/*****************************************************************************
- * threads.c : threads implementation for the VideoLAN client
+ * threads.c: LibVLC generic thread support
*****************************************************************************
- * Copyright (C) 1999-2008 the VideoLAN team
- * $Id$
+ * Copyright (C) 2009-2012 Rémi Denis-Courmont
*
- * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
- * Samuel Hocevar <sam@zoy.org>
- * Gildas Bazin <gbazin@netcourrier.com>
- * Clément Sténac
- * Rémi Denis-Courmont
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
*
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
-#include <vlc_common.h>
#include <assert.h>
+#include <vlc_common.h>
+
/*** Global locks ***/
void vlc_global_mutex (unsigned n, bool acquire)
VLC_STATIC_MUTEX,
VLC_STATIC_MUTEX,
VLC_STATIC_MUTEX,
+ VLC_STATIC_MUTEX,
+ VLC_STATIC_MUTEX,
};
+ static_assert (VLC_MAX_MUTEX == (sizeof (locks) / sizeof (locks[0])),
+ "Wrong number of global mutexes");
assert (n < (sizeof (locks) / sizeof (locks[0])));
- vlc_mutex_t *lock = locks + n;
+ vlc_mutex_t *lock = locks + n;
if (acquire)
vlc_mutex_lock (lock);
else
vlc_mutex_unlock (lock);
+}
+
+#ifdef LIBVLC_NEED_RWLOCK
+/*** Generic read/write locks ***/
+#include <stdlib.h>
+#include <limits.h>
+/* NOTE:
+ * lock->state is a signed long integer:
+ * - The sign bit is set when the lock is held for writing.
+ * - The other bits code the number of times the lock is held for reading.
+ * Consequently:
+ * - The value is negative if and only if the lock is held for writing.
+ * - The value is zero if and only if the lock is not held at all.
+ */
+#define READER_MASK LONG_MAX
+#define WRITER_BIT LONG_MIN
+
+void vlc_rwlock_init (vlc_rwlock_t *lock)
+{
+ vlc_mutex_init (&lock->mutex);
+ vlc_cond_init (&lock->wait);
+ lock->state = 0;
+}
+
+void vlc_rwlock_destroy (vlc_rwlock_t *lock)
+{
+ vlc_cond_destroy (&lock->wait);
+ vlc_mutex_destroy (&lock->mutex);
+}
+
+void vlc_rwlock_rdlock (vlc_rwlock_t *lock)
+{
+ vlc_mutex_lock (&lock->mutex);
+ /* Recursive read-locking is allowed.
+ * Ensure that there is no active writer. */
+ while (lock->state < 0)
+ {
+ assert (lock->state == WRITER_BIT);
+ mutex_cleanup_push (&lock->mutex);
+ vlc_cond_wait (&lock->wait, &lock->mutex);
+ vlc_cleanup_pop ();
+ }
+ if (unlikely(lock->state >= READER_MASK))
+ abort (); /* An overflow is certainly a recursion bug. */
+ lock->state++;
+ vlc_mutex_unlock (&lock->mutex);
+}
+
+void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
+{
+ vlc_mutex_lock (&lock->mutex);
+ /* Wait until nobody owns the lock in any way. */
+ while (lock->state != 0)
+ {
+ mutex_cleanup_push (&lock->mutex);
+ vlc_cond_wait (&lock->wait, &lock->mutex);
+ vlc_cleanup_pop ();
+ }
+ lock->state = WRITER_BIT;
+ vlc_mutex_unlock (&lock->mutex);
+}
+
+void vlc_rwlock_unlock (vlc_rwlock_t *lock)
+{
+ vlc_mutex_lock (&lock->mutex);
+ if (lock->state < 0)
+ { /* Write unlock */
+ assert (lock->state == WRITER_BIT);
+ /* Let reader and writer compete. OS scheduler decides who wins. */
+ lock->state = 0;
+ vlc_cond_broadcast (&lock->wait);
+ }
+ else
+ { /* Read unlock */
+ assert (lock->state > 0);
+ /* If there are no readers left, wake up one pending writer. */
+ if (--lock->state == 0)
+ vlc_cond_signal (&lock->wait);
+ }
+ vlc_mutex_unlock (&lock->mutex);
+}
+#endif /* LIBVLC_NEED_RWLOCK */
+
+#ifdef LIBVLC_NEED_SEMAPHORE
+/*** Generic semaphores ***/
+#include <limits.h>
+#include <errno.h>
+
+void vlc_sem_init (vlc_sem_t *sem, unsigned value)
+{
+ vlc_mutex_init (&sem->lock);
+ vlc_cond_init (&sem->wait);
+ sem->value = value;
+}
- /* Compile-time assertion ;-) */
- char enough_locks[(sizeof (locks) / sizeof (locks[0])) - VLC_MAX_MUTEX];
- (void) enough_locks;
+void vlc_sem_destroy (vlc_sem_t *sem)
+{
+ vlc_cond_destroy (&sem->wait);
+ vlc_mutex_destroy (&sem->lock);
+}
+
+int vlc_sem_post (vlc_sem_t *sem)
+{
+ int ret = 0;
+
+ vlc_mutex_lock (&sem->lock);
+ if (likely(sem->value != UINT_MAX))
+ sem->value++;
+ else
+ ret = EOVERFLOW;
+ vlc_mutex_unlock (&sem->lock);
+ vlc_cond_signal (&sem->wait);
+
+ return ret;
+}
+
+void vlc_sem_wait (vlc_sem_t *sem)
+{
+ vlc_mutex_lock (&sem->lock);
+ mutex_cleanup_push (&sem->lock);
+ while (!sem->value)
+ vlc_cond_wait (&sem->wait, &sem->lock);
+ sem->value--;
+ vlc_cleanup_run ();
}
+#endif /* LIBVLC_NEED_SEMAPHORE */