[vlc-devel] [PATCH] android: threads support
Rémi Denis-Courmont
remi at remlab.net
Thu Oct 4 21:42:40 CEST 2012
Le jeudi 4 octobre 2012 21:16:02, Rafaël Carré a écrit :
> ---
> 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() */
That comment is a tad abusive. Like NaCl-newlib, Android does not have
pthreads. Clock selection is done differently and cancellation is not optional
in pthreads.
> +# 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.
I don't know nor care about older versions but Android 4.x definitely has
monotonic clock support, including condition variables.
> +
> +#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)
Undefining standard macros is pretty much never a good idea.
> +
> +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.
> + */
Duplicated documentation is a bad idea. It will confuse Doxygen, and we do not
know which version will be used.
> +static void
> +vlc_thread_fatal (const char *action, int error,
> + const char *function, const char *file, unsigned line)
> +{
> + int canc = vlc_savecancel ();
That should not be needed since Android does not support cancellation.
> + __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();
This function cannot fail on Android. The if() is redundant IMHO.
(In fact, it cannot fail on any Linux run-time that I know. But it might fail
on some arcane POSIX systems, hence the abort()s in src/posix/.)
> +#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();
Same here, if I am not mistaken and further.
> + 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
Are there really versions of the SDK with valgrind.h and versions without it?
This seems likely redundant.
> +
> +/**
> + * 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);
> +}
If __thread is supported, it would be far simpler.
> +
> +static void *andro_Thread(void *data)
> +{
> + vlc_thread_t thread = data;
> + if (unlikely(pthread_setspecific(thread_key, thread)))
> + abort();
Failure should be impossible, thus I suggest an assertion.
> + 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 ();
This is pointless. Use NULL.
> + 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)
This is not going to interoperate with cancellation. I think the generic VLC
semaphore implementation should be used instead. You are in luck; I split it a
few weeks ago.
This comment also applies to read/write locks.
> +{
> +#if defined(__APPLE__)
Android on Darwin, really?
> + 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;
Are RT priorities even available to applications on Android?
> + }
> + 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.
> + */
This comment is stale (there is no signal plugin). That is one reason why I do
not like to duplicate documentation and comments.
> + 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. */
Not very relevant comment.
> +#define VLC_STACKSIZE (128 * sizeof (void *) * 1024)
It should probably be smaller on Android. There is no gettext, is there?
> +
> +#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);
Better than nothing, but it will waste precious µWh.
> +
> + 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;
I fail to grasp where the memory barriers are.
> +
> + if (lock) {
> + if (!self)
> + vlc_mutex_lock(lock);
I don't see what warrants that the mutex still exists at this point.
> + if (thread_id->cond)
> + pthread_cond_broadcast(thread_id->cond);
> + if (!self)
> + vlc_mutex_unlock(lock);
> + }
> +
> + if (self)
> + vlc_testcancel();
No, vlc_cancel() is not a cancellation point.
> +}
> +
> +/**
> + * 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);
Why don't you just call pthread_exit() and let bionic run the handlers?
> +
> + 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);
> +}
--
Rémi Denis-Courmont
http://www.remlab.net/
More information about the vlc-devel
mailing list