[vlc-devel] [PATCH] android: threads support
Rafaël Carré
funman at videolan.org
Thu Oct 4 20:16:02 CEST 2012
---
include/vlc_threads.h | 13 +
src/Makefile.am | 2 +-
src/android/thread.c | 988 +++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 1002 insertions(+), 1 deletion(-)
create mode 100644 src/android/thread.c
diff --git a/include/vlc_threads.h b/include/vlc_threads.h
index cc0e8b1..77ab8a5 100644
--- a/include/vlc_threads.h
+++ b/include/vlc_threads.h
@@ -42,6 +42,15 @@
# define pthread_sigmask sigprocmask
+#elif defined( __ANDROID__ ) /* pthreads without pthread_cancel() */
+
+# define LIBVLC_USE_PTHREAD 1
+
+# include <unistd.h> /* _POSIX_SPIN_LOCKS */
+# include <pthread.h>
+# include <poll.h>
+# include <semaphore.h>
+
#else /* pthreads (like Linux & BSD) */
# define LIBVLC_USE_PTHREAD 1
# define LIBVLC_USE_PTHREAD_CANCEL 1
@@ -117,7 +126,11 @@
*****************************************************************************/
#if defined (LIBVLC_USE_PTHREAD)
+# ifdef LIBVLC_USE_PTHREAD_CANCEL
typedef pthread_t vlc_thread_t;
+# else
+typedef struct vlc_thread *vlc_thread_t;
+# endif
typedef pthread_mutex_t vlc_mutex_t;
#define VLC_STATIC_MUTEX PTHREAD_MUTEX_INITIALIZER
typedef pthread_cond_t vlc_cond_t;
diff --git a/src/Makefile.am b/src/Makefile.am
index 9d1d87d..ab8c46c 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -259,9 +259,9 @@ SOURCES_libvlc_darwin = \
SOURCES_libvlc_android = \
android/dirs.c \
+ android/thread.c \
posix/filesystem.c \
posix/plugin.c \
- posix/thread.c \
posix/timer.c \
posix/linux_cpu.c \
posix/linux_specific.c \
diff --git a/src/android/thread.c b/src/android/thread.c
new file mode 100644
index 0000000..1aea7e2
--- /dev/null
+++ b/src/android/thread.c
@@ -0,0 +1,988 @@
+/*****************************************************************************
+ * thread.c : android pthread back-end for LibVLC
+ *****************************************************************************
+ * Copyright (C) 1999-2012 VLC authors and VideoLAN
+ *
+ * Authors: Jean-Marc Dressler <polux at via.ecp.fr>
+ * Samuel Hocevar <sam at zoy.org>
+ * Gildas Bazin <gbazin at 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 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 Lesser General Public License for more details.
+ *
+ * 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 <vlc_atomic.h>
+
+#include "libvlc.h"
+#include <stdarg.h>
+#include <signal.h>
+#include <errno.h>
+#include <time.h>
+#include <assert.h>
+
+#include <sys/types.h>
+#include <unistd.h> /* fsync() */
+#include <pthread.h>
+#include <sched.h>
+
+#include <android/log.h>
+#include <sys/syscall.h> /* __NR_gettid */
+
+# warning Monotonic clock not available. Expect timing issues.
+
+#undef assert
+#define assert(x) do { \
+ if (unlikely(!x)) { \
+ __android_log_print(ANDROID_LOG_ERROR, "vlc", "assert failed %s:%d: %s", \
+ __FILE__, __LINE__, #x \
+ ); \
+ abort(); \
+ } \
+} while(0)
+
+static struct timespec mtime_to_ts (mtime_t date)
+{
+ lldiv_t d = lldiv (date, CLOCK_FREQ);
+ struct timespec ts = { d.quot, d.rem * (1000000000 / CLOCK_FREQ) };
+
+ return ts;
+}
+
+#ifndef NDEBUG
+/**
+ * Reports a fatal error from the threading layer, for debugging purposes.
+ */
+static void
+vlc_thread_fatal (const char *action, int error,
+ const char *function, const char *file, unsigned line)
+{
+ int canc = vlc_savecancel ();
+ __android_log_print(ANDROID_LOG_ERROR, "vlc",
+ "LibVLC fatal error %s (%d) in thread %d ",
+ action, error, syscall (__NR_gettid));
+ fprintf (stderr, "at %s:%u in %s\n", file, line, function);
+ fflush (stderr); /* needed before switch to low-level I/O */
+ fsync (2);
+
+ /* Sometimes strerror_r() crashes too, so make sure we print an error
+ * message before we invoke it */
+ char buf[1000];
+ const char *msg;
+
+ switch (strerror_r (error, buf, sizeof (buf)))
+ {
+ case 0:
+ msg = buf;
+ break;
+ case ERANGE: /* should never happen */
+ msg = "unknown (too big to display)";
+ break;
+ default:
+ msg = "unknown (invalid error number)";
+ break;
+ }
+ fprintf (stderr, " Error message: %s\n", msg);
+ fflush (stderr);
+
+ vlc_restorecancel (canc);
+ abort ();
+}
+
+# define VLC_THREAD_ASSERT( action ) \
+ if (unlikely(val)) \
+ vlc_thread_fatal (action, val, __func__, __FILE__, __LINE__)
+#else
+# define VLC_THREAD_ASSERT( action ) ((void)val)
+#endif
+
+/**
+ * Initializes a fast mutex.
+ */
+void vlc_mutex_init( vlc_mutex_t *p_mutex )
+{
+ pthread_mutexattr_t attr;
+
+ if (unlikely(pthread_mutexattr_init (&attr)))
+ abort();
+#ifdef NDEBUG
+ pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_DEFAULT);
+#else
+ pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK);
+#endif
+ if (unlikely(pthread_mutex_init (p_mutex, &attr)))
+ abort();
+ pthread_mutexattr_destroy( &attr );
+}
+
+/**
+ * Initializes a recursive mutex.
+ * \warning This is strongly discouraged. Please use normal mutexes.
+ */
+void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
+{
+ pthread_mutexattr_t attr;
+
+ if (unlikely(pthread_mutexattr_init (&attr)))
+ abort();
+ pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
+ if (unlikely(pthread_mutex_init (p_mutex, &attr)))
+ abort();
+ pthread_mutexattr_destroy( &attr );
+}
+
+
+/**
+ * Destroys a mutex. The mutex must not be locked.
+ *
+ * @param p_mutex mutex to destroy
+ * @return always succeeds
+ */
+void vlc_mutex_destroy (vlc_mutex_t *p_mutex)
+{
+ int val = pthread_mutex_destroy( p_mutex );
+ VLC_THREAD_ASSERT ("destroying mutex");
+}
+
+#ifndef NDEBUG
+# ifdef HAVE_VALGRIND_VALGRIND_H
+# include <valgrind/valgrind.h>
+# else
+# define RUNNING_ON_VALGRIND (0)
+# endif
+
+/**
+ * Asserts that a mutex is locked by the calling thread.
+ */
+void vlc_assert_locked (vlc_mutex_t *p_mutex)
+{
+ if (RUNNING_ON_VALGRIND > 0)
+ return;
+ assert (pthread_mutex_lock (p_mutex) == EDEADLK);
+}
+#endif
+
+/**
+ * Acquires a mutex. If needed, waits for any other thread to release it.
+ * Beware of deadlocks when locking multiple mutexes at the same time,
+ * or when using mutexes from callbacks.
+ * This function is not a cancellation-point.
+ *
+ * @param p_mutex mutex initialized with vlc_mutex_init() or
+ * vlc_mutex_init_recursive()
+ */
+void vlc_mutex_lock (vlc_mutex_t *p_mutex)
+{
+ int val = pthread_mutex_lock( p_mutex );
+ VLC_THREAD_ASSERT ("locking mutex");
+}
+
+/**
+ * Acquires a mutex if and only if it is not currently held by another thread.
+ * This function never sleeps and can be used in delay-critical code paths.
+ * This function is not a cancellation-point.
+ *
+ * <b>Beware</b>: If this function fails, then the mutex is held... by another
+ * thread. The calling thread must deal with the error appropriately. That
+ * typically implies postponing the operations that would have required the
+ * mutex. If the thread cannot defer those operations, then it must use
+ * vlc_mutex_lock(). If in doubt, use vlc_mutex_lock() instead.
+ *
+ * @param p_mutex mutex initialized with vlc_mutex_init() or
+ * vlc_mutex_init_recursive()
+ * @return 0 if the mutex could be acquired, an error code otherwise.
+ */
+int vlc_mutex_trylock (vlc_mutex_t *p_mutex)
+{
+ int val = pthread_mutex_trylock( p_mutex );
+
+ if (val != EBUSY)
+ VLC_THREAD_ASSERT ("locking mutex");
+ return val;
+}
+
+/**
+ * Releases a mutex (or crashes if the mutex is not locked by the caller).
+ * @param p_mutex mutex locked with vlc_mutex_lock().
+ */
+void vlc_mutex_unlock (vlc_mutex_t *p_mutex)
+{
+ int val = pthread_mutex_unlock( p_mutex );
+ VLC_THREAD_ASSERT ("unlocking mutex");
+}
+
+struct vlc_thread
+{
+ pthread_t thread;
+ pthread_cond_t *cond; /// Non-null if thread waiting on cond
+ pthread_mutex_t *lock ; /// Non-null if thread waiting on cond
+ vlc_cleanup_t *cleaners;
+
+ void *(*entry)(void*);
+ void *data;
+
+ bool killable;
+ bool killed;
+ bool finished;
+};
+
+static pthread_key_t thread_key = 0;
+
+static void threads_init(void) __attribute__((__constructor__));
+static void threads_init(void)
+{
+ static struct vlc_thread main_thread = {
+ .cond = NULL,
+ .lock = NULL,
+ .cleaners = NULL,
+ .killable = false,
+ .killed = false,
+ .finished = false,
+ .entry = NULL,
+ .data = NULL,
+ };
+
+ main_thread.thread = pthread_self();
+ pthread_key_create(&thread_key, NULL);
+ if (unlikely(pthread_setspecific(thread_key, &main_thread)))
+ abort();
+}
+
+static void threads_deinit(void) __attribute__((__destructor__));
+static void threads_deinit(void)
+{
+ pthread_key_delete(thread_key);
+}
+
+static void *andro_Thread(void *data)
+{
+ vlc_thread_t thread = data;
+ if (unlikely(pthread_setspecific(thread_key, thread)))
+ abort();
+ void *ret = thread->entry(thread->data);
+ thread->finished = true;
+ return ret;
+}
+
+/**
+ * Initializes a condition variable.
+ */
+void vlc_cond_init (vlc_cond_t *p_condvar)
+{
+ pthread_condattr_t attr;
+
+ if (unlikely(pthread_condattr_init (&attr)))
+ abort ();
+ if (unlikely(pthread_cond_init (p_condvar, &attr)))
+ abort ();
+ pthread_condattr_destroy (&attr);
+}
+
+/**
+ * Initializes a condition variable.
+ * Contrary to vlc_cond_init(), the wall clock will be used as a reference for
+ * the vlc_cond_timedwait() time-out parameter.
+ */
+void vlc_cond_init_daytime (vlc_cond_t *p_condvar)
+{
+ if (unlikely(pthread_cond_init (p_condvar, NULL)))
+ abort ();
+}
+
+/**
+ * Destroys a condition variable. No threads shall be waiting or signaling the
+ * condition.
+ * @param p_condvar condition variable to destroy
+ */
+void vlc_cond_destroy (vlc_cond_t *p_condvar)
+{
+ int val = pthread_cond_destroy( p_condvar );
+ VLC_THREAD_ASSERT ("destroying condition");
+}
+
+/**
+ * Wakes up one thread waiting on a condition variable, if any.
+ * @param p_condvar condition variable
+ */
+void vlc_cond_signal (vlc_cond_t *p_condvar)
+{
+ int val = pthread_cond_signal( p_condvar );
+ VLC_THREAD_ASSERT ("signaling condition variable");
+}
+
+/**
+ * Wakes up all threads (if any) waiting on a condition variable.
+ * @param p_cond condition variable
+ */
+void vlc_cond_broadcast (vlc_cond_t *p_condvar)
+{
+ pthread_cond_broadcast (p_condvar);
+}
+
+/**
+ * Waits for a condition variable. The calling thread will be suspended until
+ * another thread calls vlc_cond_signal() or vlc_cond_broadcast() on the same
+ * condition variable, the thread is cancelled with vlc_cancel(), or the
+ * system causes a "spurious" unsolicited wake-up.
+ *
+ * A mutex is needed to wait on a condition variable. It must <b>not</b> be
+ * a recursive mutex. Although it is possible to use the same mutex for
+ * multiple condition, it is not valid to use different mutexes for the same
+ * condition variable at the same time from different threads.
+ *
+ * In case of thread cancellation, the mutex is always locked before
+ * cancellation proceeds.
+ *
+ * The canonical way to use a condition variable to wait for event foobar is:
+ @code
+ vlc_mutex_lock (&lock);
+ mutex_cleanup_push (&lock); // release the mutex in case of cancellation
+
+ while (!foobar)
+ vlc_cond_wait (&wait, &lock);
+
+ --- foobar is now true, do something about it here --
+
+ vlc_cleanup_run (); // release the mutex
+ @endcode
+ *
+ * @param p_condvar condition variable to wait on
+ * @param p_mutex mutex which is unlocked while waiting,
+ * then locked again when waking up.
+ * @param deadline <b>absolute</b> timeout
+ */
+void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
+{
+ vlc_thread_t thread = pthread_getspecific(thread_key);
+
+ if (thread) {
+ vlc_testcancel();
+ thread->cond = p_condvar;
+ thread->lock = p_mutex;
+ }
+
+ int val = pthread_cond_wait( p_condvar, p_mutex );
+
+ if (thread) {
+ thread->cond = NULL;
+ thread->lock = NULL;
+ vlc_testcancel();
+ }
+
+ VLC_THREAD_ASSERT ("waiting on condition");
+}
+
+/**
+ * Waits for a condition variable up to a certain date.
+ * This works like vlc_cond_wait(), except for the additional time-out.
+ *
+ * If the variable was initialized with vlc_cond_init(), the timeout has the
+ * same arbitrary origin as mdate(). If the variable was initialized with
+ * vlc_cond_init_daytime(), the timeout is expressed from the Unix epoch.
+ *
+ * @param p_condvar condition variable to wait on
+ * @param p_mutex mutex which is unlocked while waiting,
+ * then locked again when waking up.
+ * @param deadline <b>absolute</b> timeout
+ *
+ * @return 0 if the condition was signaled, an error code in case of timeout.
+ */
+int vlc_cond_timedwait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
+ mtime_t deadline)
+{
+ vlc_thread_t thread = pthread_getspecific(thread_key);
+ struct timespec ts = mtime_to_ts (deadline);
+
+ if (thread) {
+ vlc_testcancel();
+ thread->cond = p_condvar;
+ thread->lock = p_mutex;
+ }
+
+ int val = pthread_cond_timedwait (p_condvar, p_mutex, &ts);
+ if (val != ETIMEDOUT)
+ VLC_THREAD_ASSERT ("timed-waiting on condition");
+
+ if (thread) {
+ thread->cond = NULL;
+ thread->lock = NULL;
+ vlc_testcancel();
+ }
+
+ return val;
+}
+
+/**
+ * Initializes a semaphore.
+ */
+void vlc_sem_init (vlc_sem_t *sem, unsigned value)
+{
+#if defined(__APPLE__)
+ if (unlikely(semaphore_create(mach_task_self(), sem, SYNC_POLICY_FIFO, value) != KERN_SUCCESS))
+ abort ();
+#else
+ if (unlikely(sem_init (sem, 0, value)))
+ abort ();
+#endif
+}
+
+/**
+ * Destroys a semaphore.
+ */
+void vlc_sem_destroy (vlc_sem_t *sem)
+{
+ int val;
+
+#if defined(__APPLE__)
+ if (likely(semaphore_destroy(mach_task_self(), *sem) == KERN_SUCCESS))
+ return;
+
+ val = EINVAL;
+#else
+ if (likely(sem_destroy (sem) == 0))
+ return;
+
+ val = errno;
+#endif
+
+ VLC_THREAD_ASSERT ("destroying semaphore");
+}
+
+/**
+ * Increments the value of a semaphore.
+ * @return 0 on success, EOVERFLOW in case of integer overflow
+ */
+int vlc_sem_post (vlc_sem_t *sem)
+{
+ int val;
+
+#if defined(__APPLE__)
+ if (likely(semaphore_signal(*sem) == KERN_SUCCESS))
+ return 0;
+
+ val = EINVAL;
+#else
+ if (likely(sem_post (sem) == 0))
+ return 0;
+
+ val = errno;
+#endif
+
+ if (unlikely(val != EOVERFLOW))
+ VLC_THREAD_ASSERT ("unlocking semaphore");
+ return val;
+}
+
+/**
+ * Atomically wait for the semaphore to become non-zero (if needed),
+ * then decrements it.
+ */
+void vlc_sem_wait (vlc_sem_t *sem)
+{
+ int val;
+
+#if defined(__APPLE__)
+ if (likely(semaphore_wait(*sem) == KERN_SUCCESS))
+ return;
+
+ val = EINVAL;
+#else
+ do {
+ vlc_testcancel();
+ struct timespec t = mtime_to_ts (mdate());
+ t.tv_nsec += 10 * 1000 * 1000;
+ if (likely(sem_timedwait (sem, &t) == 0))
+ return;
+ val = errno;
+ } while (val == EINTR || val == ETIMEDOUT);
+#endif
+
+ VLC_THREAD_ASSERT ("locking semaphore");
+}
+
+/**
+ * Initializes a read/write lock.
+ */
+void vlc_rwlock_init (vlc_rwlock_t *lock)
+{
+ if (unlikely(pthread_rwlock_init (lock, NULL)))
+ abort ();
+}
+
+/**
+ * Destroys an initialized unused read/write lock.
+ */
+void vlc_rwlock_destroy (vlc_rwlock_t *lock)
+{
+ int val = pthread_rwlock_destroy (lock);
+ VLC_THREAD_ASSERT ("destroying R/W lock");
+}
+
+/**
+ * Acquires a read/write lock for reading. Recursion is allowed.
+ * @note This function may be a point of cancellation.
+ */
+void vlc_rwlock_rdlock (vlc_rwlock_t *lock)
+{
+ int val = pthread_rwlock_rdlock (lock);
+ VLC_THREAD_ASSERT ("acquiring R/W lock for reading");
+}
+
+/**
+ * Acquires a read/write lock for writing. Recursion is not allowed.
+ * @note This function may be a point of cancellation.
+ */
+void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
+{
+ int val = pthread_rwlock_wrlock (lock);
+ VLC_THREAD_ASSERT ("acquiring R/W lock for writing");
+}
+
+/**
+ * Releases a read/write lock.
+ */
+void vlc_rwlock_unlock (vlc_rwlock_t *lock)
+{
+ int val = pthread_rwlock_unlock (lock);
+ VLC_THREAD_ASSERT ("releasing R/W lock");
+}
+
+/**
+ * Allocates a thread-specific variable.
+ * @param key where to store the thread-specific variable handle
+ * @param destr a destruction callback. It is called whenever a thread exits
+ * and the thread-specific variable has a non-NULL value.
+ * @return 0 on success, a system error code otherwise. This function can
+ * actually fail because there is a fixed limit on the number of
+ * thread-specific variable in a process on most systems.
+ */
+int vlc_threadvar_create (vlc_threadvar_t *key, void (*destr) (void *))
+{
+ return pthread_key_create (key, destr);
+}
+
+void vlc_threadvar_delete (vlc_threadvar_t *p_tls)
+{
+ pthread_key_delete (*p_tls);
+}
+
+/**
+ * Sets a thread-specific variable.
+ * @param key thread-local variable key (created with vlc_threadvar_create())
+ * @param value new value for the variable for the calling thread
+ * @return 0 on success, a system error code otherwise.
+ */
+int vlc_threadvar_set (vlc_threadvar_t key, void *value)
+{
+ return pthread_setspecific (key, value);
+}
+
+/**
+ * Gets the value of a thread-local variable for the calling thread.
+ * This function cannot fail.
+ * @return the value associated with the given variable for the calling
+ * or NULL if there is no value.
+ */
+void *vlc_threadvar_get (vlc_threadvar_t key)
+{
+ return pthread_getspecific (key);
+}
+
+static bool rt_priorities = false;
+static int rt_offset;
+
+void vlc_threads_setup (libvlc_int_t *p_libvlc)
+{
+ static vlc_mutex_t lock = VLC_STATIC_MUTEX;
+ static bool initialized = false;
+
+ vlc_mutex_lock (&lock);
+ /* Initializes real-time priorities before any thread is created,
+ * just once per process. */
+ if (!initialized)
+ {
+#ifndef __APPLE__
+ if (var_InheritBool (p_libvlc, "rt-priority"))
+#endif
+ {
+ rt_offset = var_InheritInteger (p_libvlc, "rt-offset");
+ rt_priorities = true;
+ }
+ initialized = true;
+ }
+ vlc_mutex_unlock (&lock);
+}
+
+
+static int vlc_clone_attr (vlc_thread_t *th, pthread_attr_t *attr,
+ void *(*entry) (void *), void *data, int priority)
+{
+ int ret;
+
+ /* Block the signals that signals interface plugin handles.
+ * If the LibVLC caller wants to handle some signals by itself, it should
+ * block these before whenever invoking LibVLC. And it must obviously not
+ * start the VLC signals interface plugin.
+ *
+ * LibVLC will normally ignore any interruption caused by an asynchronous
+ * signal during a system call. But there may well be some buggy cases
+ * where it fails to handle EINTR (bug reports welcome). Some underlying
+ * libraries might also not handle EINTR properly.
+ */
+ sigset_t oldset;
+ {
+ sigset_t set;
+ sigemptyset (&set);
+ sigdelset (&set, SIGHUP);
+ sigaddset (&set, SIGINT);
+ sigaddset (&set, SIGQUIT);
+ sigaddset (&set, SIGTERM);
+
+ sigaddset (&set, SIGPIPE); /* We don't want this one, really! */
+ pthread_sigmask (SIG_BLOCK, &set, &oldset);
+ }
+
+ (void) priority;
+
+ /* The thread stack size.
+ * The lower the value, the less address space per thread, the highest
+ * maximum simultaneous threads per process. Too low values will cause
+ * stack overflows and weird crashes. Set with caution. Also keep in mind
+ * that 64-bits platforms consume more stack than 32-bits one.
+ *
+ * Thanks to on-demand paging, thread stack size only affects address space
+ * consumption. In terms of memory, threads only use what they need
+ * (rounded up to the page boundary).
+ *
+ * For example, on Linux i386, the default is 2 mega-bytes, which supports
+ * about 320 threads per processes. */
+#define VLC_STACKSIZE (128 * sizeof (void *) * 1024)
+
+#ifdef VLC_STACKSIZE
+ ret = pthread_attr_setstacksize (attr, VLC_STACKSIZE);
+ assert (ret == 0); /* fails iif VLC_STACKSIZE is invalid */
+#endif
+
+ vlc_thread_t thread = malloc (sizeof (*thread));
+ if (unlikely(thread == NULL))
+ return ENOMEM;
+
+ thread->killable = true;
+ thread->killed = false;
+ thread->finished = false,
+ thread->cond = NULL;
+ thread->lock = NULL;
+ thread->cleaners = NULL;
+ thread->entry = entry;
+ thread->data = data;
+
+ *th = thread;
+ ret = pthread_create (&thread->thread, attr, andro_Thread, thread);
+
+ pthread_sigmask (SIG_SETMASK, &oldset, NULL);
+ pthread_attr_destroy (attr);
+ return ret;
+}
+
+/**
+ * Creates and starts new thread.
+ *
+ * The thread must be <i>joined</i> with vlc_join() to reclaim resources
+ * when it is not needed anymore.
+ *
+ * @param th [OUT] pointer to write the handle of the created thread to
+ * (mandatory, must be non-NULL)
+ * @param entry entry point for the thread
+ * @param data data parameter given to the entry point
+ * @param priority thread priority value
+ * @return 0 on success, a standard error code on error.
+ */
+int vlc_clone (vlc_thread_t *th, void *(*entry) (void *), void *data,
+ int priority)
+{
+ pthread_attr_t attr;
+
+ pthread_attr_init (&attr);
+ return vlc_clone_attr (th, &attr, entry, data, priority);
+}
+
+/**
+ * Waits for a thread to complete (if needed), then destroys it.
+ * This is a cancellation point; in case of cancellation, the join does _not_
+ * occur.
+ * @warning
+ * A thread cannot join itself (normally VLC will abort if this is attempted).
+ * Also, a detached thread <b>cannot</b> be joined.
+ *
+ * @param handle thread handle
+ * @param p_result [OUT] pointer to write the thread return value or NULL
+ */
+void vlc_join (vlc_thread_t handle, void **result)
+{
+ do {
+ vlc_testcancel();
+ msleep(CLOCK_FREQ / 100);
+ } while (!handle->finished);
+
+ int val = pthread_join (handle->thread, result);
+ VLC_THREAD_ASSERT ("joining thread");
+ free(handle);
+}
+
+/**
+ * Creates and starts new detached thread.
+ * A detached thread cannot be joined. Its resources will be automatically
+ * released whenever the thread exits (in particular, its call stack will be
+ * reclaimed).
+ *
+ * Detached thread are particularly useful when some work needs to be done
+ * asynchronously, that is likely to be completed much earlier than the thread
+ * can practically be joined. In this case, thread detach can spare memory.
+ *
+ * A detached thread may be cancelled, so as to expedite its termination.
+ * Be extremely careful if you do this: while a normal joinable thread can
+ * safely be cancelled after it has already exited, cancelling an already
+ * exited detached thread is undefined: The thread handle would is destroyed
+ * immediately when the detached thread exits. So you need to ensure that the
+ * detached thread is still running before cancellation is attempted.
+ *
+ * @warning Care must be taken that any resources used by the detached thread
+ * remains valid until the thread completes.
+ *
+ * @note A detached thread must eventually exit just like another other
+ * thread. In practice, LibVLC will wait for detached threads to exit before
+ * it unloads the plugins.
+ *
+ * @param th [OUT] pointer to hold the thread handle, or NULL
+ * @param entry entry point for the thread
+ * @param data data parameter given to the entry point
+ * @param priority thread priority value
+ * @return 0 on success, a standard error code on error.
+ */
+int vlc_clone_detach (vlc_thread_t *th, void *(*entry) (void *), void *data,
+ int priority)
+{
+ vlc_thread_t dummy;
+ pthread_attr_t attr;
+
+ if (th == NULL)
+ th = &dummy;
+
+ pthread_attr_init (&attr);
+ pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+ return vlc_clone_attr (th, &attr, entry, data, priority);
+}
+
+int vlc_set_priority (vlc_thread_t th, int priority)
+{
+ (void) th; (void) priority;
+ return VLC_SUCCESS;
+}
+
+/**
+ * Marks a thread as cancelled. Next time the target thread reaches a
+ * cancellation point (while not having disabled cancellation), it will
+ * run its cancellation cleanup handler, the thread variable destructors, and
+ * terminate. vlc_join() must be used afterward regardless of a thread being
+ * cancelled or not.
+ */
+void vlc_cancel (vlc_thread_t thread_id)
+{
+ bool self = thread_id == pthread_getspecific(thread_key);
+
+ thread_id->killed = true;
+ if (!thread_id->killable)
+ return;
+
+ vlc_mutex_t *lock = thread_id->lock;
+
+ if (lock) {
+ if (!self)
+ vlc_mutex_lock(lock);
+ if (thread_id->cond)
+ pthread_cond_broadcast(thread_id->cond);
+ if (!self)
+ vlc_mutex_unlock(lock);
+ }
+
+ if (self)
+ vlc_testcancel();
+}
+
+/**
+ * Save the current cancellation state (enabled or disabled), then disable
+ * cancellation for the calling thread.
+ * This function must be called before entering a piece of code that is not
+ * cancellation-safe, unless it can be proven that the calling thread will not
+ * be cancelled.
+ * @return Previous cancellation state (opaque value for vlc_restorecancel()).
+ */
+int vlc_savecancel (void)
+{
+ vlc_thread_t thread = pthread_getspecific(thread_key);
+ if (!thread) /* not created by VLC, can't be cancelled */
+ return true;
+
+ int oldstate = thread->killable;
+ thread->killable = false;
+ return oldstate;
+}
+
+/**
+ * Restore the cancellation state for the calling thread.
+ * @param state previous state as returned by vlc_savecancel().
+ * @return Nothing, always succeeds.
+ */
+void vlc_restorecancel (int state)
+{
+ vlc_thread_t thread = pthread_getspecific(thread_key);
+ if (!thread) /* not created by VLC, can't be cancelled */
+ return;
+
+ int val = thread->killable != false;
+ VLC_THREAD_ASSERT("restoring cancellation while not disabled");
+ thread->killable = state;
+}
+
+/**
+ * Issues an explicit deferred cancellation point.
+ * This has no effect if thread cancellation is disabled.
+ * This can be called when there is a rather slow non-sleeping operation.
+ * This is also used to force a cancellation point in a function that would
+ * otherwise "not always" be a one (block_FifoGet() is an example).
+ */
+void vlc_testcancel (void)
+{
+ vlc_thread_t thread = pthread_getspecific(thread_key);
+ if (!thread) /* not created by VLC, can't be cancelled */
+ return;
+ if (!thread->killable || !thread->killed)
+ return;
+
+ for (vlc_cleanup_t *p = thread->cleaners; p != NULL; p = p->next)
+ p->proc (p->data);
+
+ thread->finished = true;
+ pthread_exit(NULL);
+}
+
+void vlc_control_cancel (int cmd, ...)
+{
+ vlc_thread_t thread = pthread_getspecific(thread_key);
+ if (!thread) /* not created by VLC, can't be cancelled */
+ return;
+ /* NOTE: This function only modifies thread-specific data, so there is no
+ * need to lock anything. */
+ va_list ap;
+
+ va_start (ap, cmd);
+ switch (cmd)
+ {
+ case VLC_CLEANUP_PUSH:
+ {
+ /* cleaner is a pointer to the caller stack, no need to allocate
+ * and copy anything. As a nice side effect, this cannot fail. */
+ vlc_cleanup_t *cleaner = va_arg (ap, vlc_cleanup_t *);
+ cleaner->next = thread->cleaners;
+ thread->cleaners = cleaner;
+ break;
+ }
+
+ case VLC_CLEANUP_POP:
+ {
+ thread->cleaners = thread->cleaners->next;
+ break;
+ }
+ }
+ va_end (ap);
+}
+
+/**
+ * Precision monotonic clock.
+ *
+ * In principles, the clock has a precision of 1 MHz. But the actual resolution
+ * may be much lower, especially when it comes to sleeping with mwait() or
+ * msleep(). Most general-purpose operating systems provide a resolution of
+ * only 100 to 1000 Hz.
+ *
+ * @warning The origin date (time value "zero") is not specified. It is
+ * typically the time the kernel started, but this is platform-dependent.
+ * If you need wall clock time, use gettimeofday() instead.
+ *
+ * @return a timestamp in microseconds.
+ */
+mtime_t mdate (void)
+{
+ struct timespec ts;
+
+ if (unlikely(clock_gettime (CLOCK_REALTIME, &ts) != 0))
+ abort ();
+
+ return (INT64_C(1000000) * ts.tv_sec) + (ts.tv_nsec / 1000);
+}
+
+#undef mwait
+/**
+ * Waits until a deadline (possibly later due to OS scheduling).
+ * @param deadline timestamp to wait for (see mdate())
+ */
+void mwait (mtime_t deadline)
+{
+ deadline -= mdate ();
+ if (deadline > 0)
+ msleep (deadline);
+}
+
+#undef msleep
+/**
+ * Waits for an interval of time.
+ * @param delay how long to wait (in microseconds)
+ */
+void msleep (mtime_t delay)
+{
+ struct timespec ts = mtime_to_ts (delay);
+
+ vlc_testcancel();
+ for (;;) {
+ struct timespec t = { 0, 10 * 1000 * 1000 };
+ if (ts.tv_sec <= 0 && t.tv_nsec > ts.tv_nsec)
+ t.tv_nsec = ts.tv_nsec;
+ while (nanosleep (&t, &t) == -1) {
+ vlc_testcancel();
+ assert (errno == EINTR);
+ }
+
+ ts.tv_nsec -= 10 * 1000 * 1000;
+ if (ts.tv_nsec < 0) {
+ if (--ts.tv_sec < 0)
+ return;
+ ts.tv_nsec += 1000 * 1000 * 1000;
+ }
+ }
+}
+
+/**
+ * Count CPUs.
+ * @return number of available (logical) CPUs.
+ */
+unsigned vlc_GetCPUCount(void)
+{
+ return sysconf(_SC_NPROCESSORS_CONF);
+}
--
1.7.10.4
More information about the vlc-devel
mailing list