/*****************************************************************************
* Function definitions
*****************************************************************************/
+VLC_EXPORT( void, vlc_threads_error, ( vlc_object_t *) );
VLC_EXPORT( int, __vlc_mutex_init, ( vlc_object_t *, vlc_mutex_t * ) );
+VLC_EXPORT( int, __vlc_mutex_init_recursive, ( vlc_object_t *, vlc_mutex_t * ) );
VLC_EXPORT( int, __vlc_mutex_destroy, ( const char *, int, vlc_mutex_t * ) );
VLC_EXPORT( int, __vlc_cond_init, ( vlc_object_t *, vlc_cond_t * ) );
VLC_EXPORT( int, __vlc_cond_destroy, ( const char *, int, vlc_cond_t * ) );
VLC_EXPORT( void, __vlc_thread_ready, ( vlc_object_t * ) );
VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, const char *, int ) );
+/*****************************************************************************
+ * vlc_threads_error: Signalize an error in the threading system
+ *****************************************************************************/
+#ifdef NDEBUG
+# define vlc_threads_error( P_THIS ) (void)0
+#endif
+
/*****************************************************************************
* vlc_threads_init: initialize threads system
*****************************************************************************/
#define vlc_mutex_init( P_THIS, P_MUTEX ) \
__vlc_mutex_init( VLC_OBJECT(P_THIS), P_MUTEX )
+/*****************************************************************************
+ * vlc_mutex_init: initialize a recursive mutex (Don't use it)
+ *****************************************************************************/
+#define vlc_mutex_init_recursive( P_THIS, P_MUTEX ) \
+ __vlc_mutex_init_recursive( VLC_OBJECT(P_THIS), P_MUTEX )
+
/*****************************************************************************
* vlc_mutex_lock: lock a mutex
*****************************************************************************/
#define vlc_mutex_lock( P_MUTEX ) \
__vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
-#ifdef __APPLE__
-# define CAST_PTHREAD_TO_INT(t) (unsigned long int)(uintptr_t)(void *)t
-#else
-# define CAST_PTHREAD_TO_INT(t) (unsigned long int)t
+#if defined( PTHREAD_COND_T_IN_PTHREAD_H )
+static inline unsigned long int CAST_PTHREAD_TO_INT (pthread_t th)
+{
+ union { pthread_t th; unsigned long int i; } v = { };
+ v.th = th;
+ return v.i;
+}
#endif
static inline int __vlc_mutex_lock( const char * psz_file, int i_line,
/* In case of error : */
unsigned long int i_thread = 0;
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = ( pth_mutex_acquire( &p_mutex->mutex, FALSE, NULL ) == FALSE );
-
-#elif defined( ST_INIT_IN_ST_H )
- i_result = st_mutex_lock( p_mutex->mutex );
-
-#elif defined( UNDER_CE )
+#if defined( UNDER_CE )
EnterCriticalSection( &p_mutex->csection );
i_result = 0;
errno = i_result;
}
-#elif defined( HAVE_CTHREADS_H )
- mutex_lock( p_mutex->mutex );
- i_result = 0;
-
#endif
if( i_result )
msg_Err( p_mutex->p_this,
"thread %li: mutex_lock failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
+ vlc_threads_error( p_mutex->p_this );
}
return i_result;
}
/* In case of error : */
unsigned long int i_thread = 0;
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = ( pth_mutex_release( &p_mutex->mutex ) == FALSE );
-
-#elif defined( ST_INIT_IN_ST_H )
- i_result = st_mutex_unlock( p_mutex->mutex );
-
-#elif defined( UNDER_CE )
+#if defined( UNDER_CE )
LeaveCriticalSection( &p_mutex->csection );
i_result = 0;
errno = i_result;
}
-#elif defined( HAVE_CTHREADS_H )
- mutex_unlock( p_mutex );
- i_result = 0;
-
#endif
if( i_result )
msg_Err( p_mutex->p_this,
"thread %li: mutex_unlock failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
+ vlc_threads_error( p_mutex->p_this );
}
return i_result;
/* In case of error : */
unsigned long int i_thread = 0;
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = ( pth_cond_notify( &p_condvar->cond, FALSE ) == FALSE );
-
-#elif defined( ST_INIT_IN_ST_H )
- i_result = st_cond_signal( p_condvar->cond );
-
-#elif defined( UNDER_CE )
+#if defined( UNDER_CE )
PulseEvent( p_condvar->event );
i_result = 0;
* by a mutex. This will prevent another thread from stealing the signal */
if( !p_condvar->semaphore )
{
+ /*
+ ** PulseEvent() only works if none of the waiting threads is suspended.
+ ** this is particularily problematic under a debug session.
+ ** as documented in http://support.microsoft.com/kb/q173260/
+ */
PulseEvent( p_condvar->event );
}
else if( p_condvar->i_win9x_cv == 1 )
errno = i_result;
}
-#elif defined( HAVE_CTHREADS_H )
- /* condition_signal() */
- if ( p_condvar->queue.head || p_condvar->implications )
- {
- cond_signal( (condition_t)p_condvar );
- }
- i_result = 0;
-
#endif
if( i_result )
msg_Err( p_condvar->p_this,
"thread %li: cond_signal failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
+ vlc_threads_error( p_condvar->p_this );
}
return i_result;
/* In case of error : */
unsigned long int i_thread = 0;
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = ( pth_cond_await( &p_condvar->cond, &p_mutex->mutex, NULL )
- == FALSE );
-
-#elif defined( ST_INIT_IN_ST_H )
- st_mutex_unlock( p_mutex->mutex );
- i_result = st_cond_wait( p_condvar->cond );
- st_mutex_lock( p_mutex->mutex );
-
-#elif defined( UNDER_CE )
+#if defined( UNDER_CE )
p_condvar->i_waiting_threads++;
LeaveCriticalSection( &p_mutex->csection );
WaitForSingleObject( p_condvar->event, INFINITE );
errno = i_result;
}
-#elif defined( HAVE_CTHREADS_H )
- condition_wait( (condition_t)p_condvar, (mutex_t)p_mutex );
- i_result = 0;
-
#endif
if( i_result )
msg_Err( p_condvar->p_this,
"thread %li: cond_wait failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_result );
+ vlc_threads_error( p_condvar->p_this );
}
return i_result;
int i_res;
unsigned long int i_thread = 0;
-#if defined( PTH_INIT_IN_PTH_H )
-# error Unimplemented
-#elif defined( ST_INIT_IN_ST_H )
-# error Unimplemented
-#elif defined( UNDER_CE )
+#if defined( UNDER_CE )
mtime_t delay_ms = (deadline - mdate())/1000;
DWORD result;
if( delay_ms < 0 )
- delay_ms = 0;
+ delay_ms = 0;
p_condvar->i_waiting_threads++;
LeaveCriticalSection( &p_mutex->csection );
vlc_mutex_lock( p_mutex );
i_res = (int)result;
+ if(result == WAIT_TIMEOUT)
+ return WAIT_TIMEOUT; /* this error is perfectly normal */
#elif defined( WIN32 )
DWORD result;
mtime_t delay_ms = (deadline - mdate())/1000;
if( delay_ms < 0 )
- delay_ms = 0;
+ delay_ms = 0;
if( !p_condvar->semaphore )
{
/* Wait for the gate to be open */
result = WaitForSingleObject( p_condvar->event, delay_ms );
- /* recaculate remaining delay */
- delay_ms = (deadline - mdate())/1000;
- if( delay_ms < 0 )
- delay_ms = 0;
-
/* Increase our wait count */
p_condvar->i_waiting_threads++;
LeaveCriticalSection( &p_mutex->csection );
- if( !result )
- result = WaitForSingleObject( p_condvar->semaphore, delay_ms );
+ if( !result )
+ {
+ /* recaculate remaining delay */
+ delay_ms = (deadline - mdate())/1000;
+ if( delay_ms < 0 )
+ delay_ms = 0;
+
+ result = WaitForSingleObject( p_condvar->semaphore, delay_ms );
+ }
/* Decrement and test must be atomic */
EnterCriticalSection( &p_condvar->csection );
/* Reacquire the mutex before returning. */
vlc_mutex_lock( p_mutex );
+ if(result == WAIT_TIMEOUT)
+ return WAIT_TIMEOUT; /* this error is perfectly normal */
i_res = (int)result;
errno = i_res;
}
-#elif defined( HAVE_CTHREADS_H )
-# error Unimplemented
#endif
if( i_res )
msg_Err( p_condvar->p_this,
"thread %li: cond_wait failed at %s:%d (%d:%m)",
i_thread, psz_file, i_line, i_res );
+ vlc_threads_error( p_condvar->p_this );
}
return i_res;
{
int i_ret;
-#if defined( PTH_INIT_IN_PTH_H )
- return pth_key_setdata( p_tls->handle, p_value );
-#elif defined( ST_INIT_IN_ST_H )
- return st_thread_setspecific( p_tls->handle, p_value );
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
+#if defined( HAVE_KERNEL_SCHEDULER_H )
return -1;
#elif defined( UNDER_CE ) || defined( WIN32 )
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
i_ret = pthread_setspecific( p_tls->handle, p_value );
-#elif defined( HAVE_CTHREADS_H )
- i_ret = cthread_setspecific( p_tls->handle, p_value );
#endif
return i_ret;
{
void* p_ret;
-#if defined( PTH_INIT_IN_PTH_H )
- p_ret = pth_key_getdata( p_handle->key );
-#elif defined( ST_INIT_IN_ST_H )
- p_ret = st_thread_getspecific( p_handle->key );
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
+#if defined( HAVE_KERNEL_SCHEDULER_H )
p_ret = NULL;
#elif defined( UNDER_CE ) || defined( WIN32 )
p_ret = TlsGetValue( p_tls->handle );
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
p_ret = pthread_getspecific( p_tls->handle );
-#elif defined( HAVE_CTHREADS_H )
- if ( !cthread_getspecific( p_tls->handle, &p_ret ) )
- {
- p_ret = NULL;
- }
#endif
return p_ret;
}
+# if defined (_POSIX_SPIN_LOCKS) && ((_POSIX_SPIN_LOCKS - 0) > 0)
+typedef struct
+{
+ pthread_spinlock_t spin;
+} vlc_spinlock_t;
+
+/**
+ * Initializes a spinlock.
+ */
+static inline int vlc_spin_init (vlc_spinlock_t *spin)
+{
+ return pthread_spin_init (&spin->spin, PTHREAD_PROCESS_PRIVATE);
+}
+
+/**
+ * Acquires a spinlock.
+ */
+static inline int vlc_spin_lock (vlc_spinlock_t *spin)
+{
+ return pthread_spin_lock (&spin->spin);
+}
+
+/**
+ * Releases a spinlock.
+ */
+static inline int vlc_spin_unlock (vlc_spinlock_t *spin)
+{
+ return pthread_spin_unlock (&spin->spin);
+}
+
+/**
+ * Deinitializes a spinlock.
+ */
+static inline int vlc_spin_destroy (vlc_spinlock_t *spin)
+{
+ return pthread_spin_destroy (&spin->spin);
+}
+#else
+/* Fallback to plain mutexes if spinlocks are not available */
+typedef vlc_mutex_t vlc_spinlock_t;
+
+static inline int vlc_spin_init (vlc_spinlock_t *spin)
+{
+ return __vlc_mutex_init (NULL, spin);
+}
+
+# define vlc_spin_lock vlc_mutex_lock
+# define vlc_spin_unlock vlc_mutex_unlock
+# define vlc_spin_destroy vlc_mutex_destroy
+#endif
+
/*****************************************************************************
* vlc_thread_create: create a thread
*****************************************************************************/
projects / vlc / blobdiff