* vlc_threads_funcs.h : threads implementation for the VideoLAN client
* This header provides a portable threads implementation.
*****************************************************************************
- * Copyright (C) 1999, 2002 VideoLAN
- * $Id: vlc_threads_funcs.h,v 1.2 2002/08/30 12:23:23 sam Exp $
+ * Copyright (C) 1999-2007 the VideoLAN team
+ * $Id$
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@via.ecp.fr>
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 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
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
+#if !defined( __LIBVLC__ )
+ #error You are not libvlc or one of its plugins. You cannot include this file
+#endif
+
+#ifndef _VLC_THREADFUNCS_H_
+#define _VLC_THREADFUNCS_H_
+
+#if defined( WIN32 ) && !defined ETIMEDOUT
+# define ETIMEDOUT 10060 /* This is the value in winsock.h. */
+#endif
+
/*****************************************************************************
* Function definitions
*****************************************************************************/
-VLC_EXPORT( int, __vlc_threads_init, ( vlc_object_t * ) );
-VLC_EXPORT( int, __vlc_threads_end, ( vlc_object_t * ) );
-VLC_EXPORT( int, __vlc_mutex_init, ( vlc_object_t *, vlc_mutex_t * ) );
-VLC_EXPORT( int, __vlc_mutex_destroy, ( char *, int, vlc_mutex_t * ) );
-VLC_EXPORT( int, __vlc_cond_init, ( vlc_object_t *, vlc_cond_t * ) );
-VLC_EXPORT( int, __vlc_cond_destroy, ( char *, int, vlc_cond_t * ) );
-VLC_EXPORT( int, __vlc_thread_create, ( vlc_object_t *, char *, int, char *, void * ( * ) ( void * ), int, vlc_bool_t ) );
+VLC_EXPORT( int, __vlc_mutex_init, ( vlc_mutex_t * ) );
+VLC_EXPORT( int, __vlc_mutex_init_recursive, ( vlc_mutex_t * ) );
+VLC_EXPORT( void, __vlc_mutex_destroy, ( const char *, int, vlc_mutex_t * ) );
+VLC_EXPORT( int, __vlc_cond_init, ( vlc_cond_t * ) );
+VLC_EXPORT( void, __vlc_cond_destroy, ( const char *, int, vlc_cond_t * ) );
+VLC_EXPORT( int, __vlc_threadvar_create, (vlc_threadvar_t * ) );
+VLC_EXPORT( int, __vlc_thread_create, ( vlc_object_t *, const char *, int, const char *, void * ( * ) ( void * ), int, vlc_bool_t ) );
+VLC_EXPORT( int, __vlc_thread_set_priority, ( vlc_object_t *, const char *, int, int ) );
VLC_EXPORT( void, __vlc_thread_ready, ( vlc_object_t * ) );
-VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, char *, int ) );
+VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, const char *, int ) );
/*****************************************************************************
* vlc_threads_init: initialize threads system
* vlc_mutex_init: initialize a mutex
*****************************************************************************/
#define vlc_mutex_init( P_THIS, P_MUTEX ) \
- __vlc_mutex_init( VLC_OBJECT(P_THIS), P_MUTEX )
+ __vlc_mutex_init( 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( P_MUTEX )
/*****************************************************************************
* vlc_mutex_lock: lock a mutex
#define vlc_mutex_lock( P_MUTEX ) \
__vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
-static inline int __vlc_mutex_lock( char * psz_file, int i_line,
+#if defined(LIBVLC_USE_PTHREAD)
+VLC_EXPORT(void, vlc_pthread_fatal, (const char *action, int error, const char *file, unsigned line));
+
+# define VLC_THREAD_ASSERT( action ) \
+ if (val) \
+ vlc_pthread_fatal (action, val, psz_file, i_line)
+#else
+# define VLC_THREAD_ASSERT (void)0
+#endif
+
+static inline void __vlc_mutex_lock( const char * psz_file, int i_line,
vlc_mutex_t * p_mutex )
{
- int i_result;
- /* In case of error : */
- int i_thread = -1;
- const char * psz_error = "";
-
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_mutex_acquire( &p_mutex->mutex, TRUE, NULL );
+#if defined( UNDER_CE )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-#elif defined( ST_INIT_IN_ST_H )
- i_result = st_mutex_lock( p_mutex->mutex );
+ EnterCriticalSection( &p_mutex->csection );
#elif defined( WIN32 )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
if( p_mutex->mutex )
- {
WaitForSingleObject( p_mutex->mutex, INFINITE );
- }
else
- {
EnterCriticalSection( &p_mutex->csection );
- }
- return 0;
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- i_result = pthread_mutex_lock( &p_mutex->mutex );
- if ( i_result )
- {
- i_thread = (int)pthread_self();
- psz_error = strerror(i_result);
- }
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+ acquire_sem( p_mutex->lock );
-#elif defined( HAVE_CTHREADS_H )
- mutex_lock( p_mutex->mutex );
- return 0;
+#elif defined(LIBVLC_USE_PTHREAD)
+# define vlc_assert_locked( m ) \
+ assert (pthread_mutex_lock (&((m)->mutex)) == EDEADLK)
+ int val = pthread_mutex_lock( &p_mutex->mutex );
+ VLC_THREAD_ASSERT ("locking mutex");
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( p_mutex == NULL )
- {
- i_result = B_BAD_VALUE;
- }
- else if( p_mutex->init < 2000 )
- {
- i_result = B_NO_INIT;
- }
- else
- {
- i_result = acquire_sem( p_mutex->lock );
- }
#endif
-
- if( i_result )
- {
- msg_Err( p_mutex->p_this,
- "thread %d: mutex_lock failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
- }
- return i_result;
}
+#ifndef vlc_assert_locked
+# define vlc_assert_locked( m ) (void)0
+#endif
+
/*****************************************************************************
* vlc_mutex_unlock: unlock a mutex
*****************************************************************************/
#define vlc_mutex_unlock( P_MUTEX ) \
__vlc_mutex_unlock( __FILE__, __LINE__, P_MUTEX )
-static inline int __vlc_mutex_unlock( char * psz_file, int i_line,
+static inline void __vlc_mutex_unlock( const char * psz_file, int i_line,
vlc_mutex_t *p_mutex )
{
- int i_result;
- /* In case of error : */
- int i_thread = -1;
- const char * psz_error = "";
-
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_mutex_release( &p_mutex->mutex );
+#if defined( UNDER_CE )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-#elif defined( ST_INIT_IN_ST_H )
- i_result = st_mutex_unlock( p_mutex->mutex );
+ LeaveCriticalSection( &p_mutex->csection );
#elif defined( WIN32 )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
if( p_mutex->mutex )
- {
ReleaseMutex( p_mutex->mutex );
- }
else
- {
LeaveCriticalSection( &p_mutex->csection );
- }
- return 0;
-
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- i_result = pthread_mutex_unlock( &p_mutex->mutex );
- if ( i_result )
- {
- i_thread = (int)pthread_self();
- psz_error = strerror(i_result);
- }
-
-#elif defined( HAVE_CTHREADS_H )
- mutex_unlock( p_mutex );
- return 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( p_mutex == NULL )
- {
- i_result = B_BAD_VALUE;
- }
- else if( p_mutex->init < 2000 )
- {
- i_result = B_NO_INIT;
- }
- else
- {
- release_sem( p_mutex->lock );
- return B_OK;
- }
-#endif
+ release_sem( p_mutex->lock );
- if( i_result )
- {
- msg_Err( p_mutex->p_this,
- "thread %d: mutex_unlock failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
- }
+#elif defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_mutex_unlock( &p_mutex->mutex );
+ VLC_THREAD_ASSERT ("unlocking mutex");
- return i_result;
+#endif
}
/*****************************************************************************
* vlc_cond_init: initialize a condition
*****************************************************************************/
#define vlc_cond_init( P_THIS, P_COND ) \
- __vlc_cond_init( VLC_OBJECT(P_THIS), P_COND )
+ __vlc_cond_init( P_COND )
/*****************************************************************************
* vlc_cond_signal: start a thread on condition completion
#define vlc_cond_signal( P_COND ) \
__vlc_cond_signal( __FILE__, __LINE__, P_COND )
-static inline int __vlc_cond_signal( char * psz_file, int i_line,
- vlc_cond_t *p_condvar )
+static inline void __vlc_cond_signal( const char * psz_file, int i_line,
+ vlc_cond_t *p_condvar )
{
- int i_result;
- /* In case of error : */
- int i_thread = -1;
- const char * psz_error = "";
+#if defined( UNDER_CE )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_cond_notify( &p_condvar->cond, FALSE );
-
-#elif defined( ST_INIT_IN_ST_H )
- i_result = st_cond_signal( p_condvar->cond );
+ PulseEvent( p_condvar->event );
#elif defined( WIN32 )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
/* Release one waiting thread if one is available. */
/* For this trick to work properly, the vlc_cond_signal must be surrounded
* 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 )
WaitForSingleObject( p_condvar->event, INFINITE );
}
}
- return 0;
-
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- i_result = pthread_cond_signal( &p_condvar->cond );
- if ( i_result )
- {
- i_thread = (int)pthread_self();
- psz_error = strerror(i_result);
- }
-
-#elif defined( HAVE_CTHREADS_H )
- /* condition_signal() */
- if ( p_condvar->queue.head || p_condvar->implications )
- {
- cond_signal( (condition_t)p_condvar );
- }
- return 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( p_condvar == NULL )
+ while( p_condvar->thread != -1 )
{
- i_result = B_BAD_VALUE;
- }
- else if( p_condvar->init < 2000 )
- {
- i_result = B_NO_INIT;
- }
- else
- {
- while( p_condvar->thread != -1 )
+ thread_info info;
+ if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE )
+ return;
+
+ if( info.state != B_THREAD_SUSPENDED )
+ {
+ /* The waiting thread is not suspended so it could
+ * have been interrupted beetwen the unlock and the
+ * suspend_thread line. That is why we sleep a little
+ * before retesting p_condver->thread. */
+ snooze( 10000 );
+ }
+ else
{
- thread_info info;
- if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE )
- {
- return 0;
- }
-
- if( info.state != B_THREAD_SUSPENDED )
- {
- /* The waiting thread is not suspended so it could
- * have been interrupted beetwen the unlock and the
- * suspend_thread line. That is why we sleep a little
- * before retesting p_condver->thread. */
- snooze( 10000 );
- }
- else
- {
- /* Ok, we have to wake up that thread */
- resume_thread( p_condvar->thread );
- return 0;
- }
+ /* Ok, we have to wake up that thread */
+ resume_thread( p_condvar->thread );
}
}
-#endif
- if( i_result )
- {
- msg_Err( p_condvar->p_this,
- "thread %d: cond_signal failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
- }
+#elif defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_cond_signal( &p_condvar->cond );
+ VLC_THREAD_ASSERT ("signaling condition variable");
- return i_result;
+#endif
}
/*****************************************************************************
- * vlc_cond_broadcast: start all threads waiting on condition completion
+ * vlc_cond_wait: wait until condition completion
*****************************************************************************/
-/*
- * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
- * Only works with pthreads, st, win32
- * You need to adapt it for others
- * FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
- */
-#define vlc_cond_broadcast( P_COND ) \
- __vlc_cond_broadcast( __FILE__, __LINE__, P_COND )
+#define vlc_cond_wait( P_COND, P_MUTEX ) \
+ __vlc_cond_wait( __FILE__, __LINE__, P_COND, P_MUTEX )
-static inline int __vlc_cond_broadcast( char * psz_file, int i_line,
- vlc_cond_t *p_condvar )
+static inline void __vlc_cond_wait( const char * psz_file, int i_line,
+ vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex )
{
- int i_result;
- /* In case of error : */
- int i_thread = -1;
- const char * psz_error = "";
+#if defined( UNDER_CE )
+ p_condvar->i_waiting_threads++;
+ LeaveCriticalSection( &p_mutex->csection );
+ WaitForSingleObject( p_condvar->event, INFINITE );
+ p_condvar->i_waiting_threads--;
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_cond_notify( &p_condvar->cond, FALSE );
-
-#elif defined( ST_INIT_IN_ST_H )
- i_result = st_cond_broadcast( p_condvar->cond );
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
#elif defined( WIN32 )
- /* Release all waiting threads. */
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
if( !p_condvar->semaphore )
{
- for( i = p_condvar->i_waiting_threads; i > 0; i-- )
+ /* Increase our wait count */
+ p_condvar->i_waiting_threads++;
+
+ if( p_mutex->mutex )
{
- PulseEvent( p_condvar->event );
+ /* It is only possible to atomically release the mutex and
+ * initiate the waiting on WinNT/2K/XP. Win9x doesn't have
+ * SignalObjectAndWait(). */
+ p_condvar->SignalObjectAndWait( p_mutex->mutex,
+ p_condvar->event,
+ INFINITE, FALSE );
+ }
+ else
+ {
+ LeaveCriticalSection( &p_mutex->csection );
+ WaitForSingleObject( p_condvar->event, INFINITE );
}
+
+ p_condvar->i_waiting_threads--;
}
else if( p_condvar->i_win9x_cv == 1 )
{
+ int i_waiting_threads;
+
/* Wait for the gate to be open */
WaitForSingleObject( p_condvar->event, INFINITE );
- if( p_condvar->i_waiting_threads )
- {
- /* Using a semaphore exposes us to a race condition. It is
- * possible for another thread to start waiting on the semaphore
- * just after we signaled it and thus steal the signal.
- * We have to prevent new threads from entering the cond_wait(). */
- ResetEvent( p_condvar->event );
+ /* Increase our wait count */
+ p_condvar->i_waiting_threads++;
- /* A semaphore is used here because Win9x doesn't have
- * SignalObjectAndWait() and thus a race condition exists
- * during the time we release the mutex and the time we start
- * waiting on the event (more precisely, the signal can sometimes
- * be missed by the waiting thread if we use PulseEvent()). */
- ReleaseSemaphore( p_condvar->semaphore,
- p_condvar->i_waiting_threads, 0 );
- }
+ LeaveCriticalSection( &p_mutex->csection );
+ WaitForSingleObject( p_condvar->semaphore, INFINITE );
+
+ /* Decrement and test must be atomic */
+ EnterCriticalSection( &p_condvar->csection );
+
+ /* Decrease our wait count */
+ i_waiting_threads = --p_condvar->i_waiting_threads;
+
+ LeaveCriticalSection( &p_condvar->csection );
+
+ /* Reopen the gate if we were the last waiting thread */
+ if( !i_waiting_threads )
+ SetEvent( p_condvar->event );
}
else
{
- if( p_condvar->i_waiting_threads )
- {
- ReleaseSemaphore( p_condvar->semaphore,
- p_condvar->i_waiting_threads, 0 );
+ int i_waiting_threads;
- /* Wait for the last thread to be awakened */
- WaitForSingleObject( p_condvar->event, INFINITE );
- }
- }
- return 0;
+ /* Increase our wait count */
+ p_condvar->i_waiting_threads++;
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- i_result = pthread_cond_broadcast( &p_condvar->cond );
- if ( i_result )
- {
- i_thread = (int)pthread_self();
- psz_error = strerror(i_result);
- }
+ LeaveCriticalSection( &p_mutex->csection );
+ WaitForSingleObject( p_condvar->semaphore, INFINITE );
-#elif defined( HAVE_CTHREADS_H )
- /* condition_signal() */
- if ( p_condvar->queue.head || p_condvar->implications )
- {
- cond_signal( (condition_t)p_condvar );
+ /* Decrement and test must be atomic */
+ EnterCriticalSection( &p_condvar->csection );
+
+ /* Decrease our wait count */
+ i_waiting_threads = --p_condvar->i_waiting_threads;
+
+ LeaveCriticalSection( &p_condvar->csection );
+
+ /* Signal that the last waiting thread just went through */
+ if( !i_waiting_threads )
+ SetEvent( p_condvar->event );
}
- return 0;
+
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( p_condvar == NULL )
- {
- i_result = B_BAD_VALUE;
- }
- else if( p_condvar->init < 2000 )
- {
- i_result = B_NO_INIT;
- }
- else
- {
- while( p_condvar->thread != -1 )
- {
- thread_info info;
- if( get_thread_info(p_condvar->thread, &info) == B_BAD_VALUE )
- {
- return 0;
- }
-
- if( info.state != B_THREAD_SUSPENDED )
- {
- /* The waiting thread is not suspended so it could
- * have been interrupted beetwen the unlock and the
- * suspend_thread line. That is why we sleep a little
- * before retesting p_condver->thread. */
- snooze( 10000 );
- }
- else
- {
- /* Ok, we have to wake up that thread */
- resume_thread( p_condvar->thread );
- return 0;
- }
- }
- }
-#endif
+ /* The p_condvar->thread var is initialized before the unlock because
+ * it enables to identify when the thread is interrupted beetwen the
+ * unlock line and the suspend_thread line */
+ p_condvar->thread = find_thread( NULL );
+ vlc_mutex_unlock( p_mutex );
+ suspend_thread( p_condvar->thread );
+ p_condvar->thread = -1;
- if( i_result )
- {
- msg_Err( p_condvar->p_this,
- "thread %d: cond_broadcast failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
- }
+ vlc_mutex_lock( p_mutex );
+
+#elif defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex );
+ VLC_THREAD_ASSERT ("waiting on condition");
- return i_result;
+#endif
}
+
/*****************************************************************************
- * vlc_cond_wait: wait until condition completion
+ * vlc_cond_timedwait: wait until condition completion or expiration
+ *****************************************************************************
+ * Returns 0 if object signaled, an error code in case of timeout or error.
*****************************************************************************/
-#define vlc_cond_wait( P_COND, P_MUTEX ) \
- __vlc_cond_wait( __FILE__, __LINE__, P_COND, P_MUTEX )
+#define vlc_cond_timedwait( P_COND, P_MUTEX, DEADLINE ) \
+ __vlc_cond_timedwait( __FILE__, __LINE__, P_COND, P_MUTEX, DEADLINE )
-static inline int __vlc_cond_wait( char * psz_file, int i_line,
- vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex )
+static inline int __vlc_cond_timedwait( const char * psz_file, int i_line,
+ vlc_cond_t *p_condvar,
+ vlc_mutex_t *p_mutex,
+ mtime_t deadline )
{
- int i_result;
- /* In case of error : */
- int i_thread = -1;
- const char * psz_error = "";
+#if defined( UNDER_CE )
+ mtime_t delay_ms = (deadline - mdate())/1000;
+
+ DWORD result;
+ if( delay_ms < 0 )
+ delay_ms = 0;
-#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_cond_await( &p_condvar->cond, &p_mutex->mutex, NULL );
+ p_condvar->i_waiting_threads++;
+ LeaveCriticalSection( &p_mutex->csection );
+ result = WaitForSingleObject( p_condvar->event, delay_ms );
+ p_condvar->i_waiting_threads--;
-#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 );
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
+
+ if(result == WAIT_TIMEOUT)
+ return ETIMEDOUT; /* this error is perfectly normal */
#elif defined( WIN32 )
+ VLC_UNUSED( psz_file); VLC_UNUSED( i_line );
+
+ DWORD result;
+
+ mtime_t delay_ms = (deadline - mdate())/1000;
+ if( delay_ms < 0 )
+ delay_ms = 0;
+
if( !p_condvar->semaphore )
{
/* Increase our wait count */
p_condvar->i_waiting_threads++;
- if( p_condvar->SignalObjectAndWait && p_mutex->mutex )
+ if( p_mutex->mutex )
{
/* It is only possible to atomically release the mutex and
* initiate the waiting on WinNT/2K/XP. Win9x doesn't have
* SignalObjectAndWait(). */
- p_condvar->SignalObjectAndWait( p_mutex->mutex,
+ result = p_condvar->SignalObjectAndWait( p_mutex->mutex,
p_condvar->event,
- INFINITE, FALSE );
+ delay_ms, FALSE );
}
else
{
LeaveCriticalSection( &p_mutex->csection );
- WaitForSingleObject( p_condvar->event, INFINITE );
+ result = WaitForSingleObject( p_condvar->event, delay_ms );
}
p_condvar->i_waiting_threads--;
int i_waiting_threads;
/* Wait for the gate to be open */
- WaitForSingleObject( p_condvar->event, INFINITE );
+ result = WaitForSingleObject( p_condvar->event, delay_ms );
/* Increase our wait count */
p_condvar->i_waiting_threads++;
LeaveCriticalSection( &p_mutex->csection );
- WaitForSingleObject( p_condvar->semaphore, INFINITE );
+ 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 );
p_condvar->i_waiting_threads++;
LeaveCriticalSection( &p_mutex->csection );
- WaitForSingleObject( p_condvar->semaphore, INFINITE );
+ 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 ETIMEDOUT; /* this error is perfectly normal */
- return 0;
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+# error Unimplemented
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
+#elif defined(LIBVLC_USE_PTHREAD)
+ lldiv_t d = lldiv( deadline, 1000000 );
+ struct timespec ts = { d.quot, d.rem * 1000 };
-# ifdef DEBUG
- /* In debug mode, timeout */
- struct timeval now;
- struct timespec timeout;
+ int val = pthread_cond_timedwait (&p_condvar->cond, &p_mutex->mutex, &ts);
+ if (val == ETIMEDOUT)
+ return ETIMEDOUT; /* this error is perfectly normal */
+ VLC_THREAD_ASSERT ("timed-waiting on condition");
- for( ; ; )
- {
- gettimeofday( &now, NULL );
- timeout.tv_sec = now.tv_sec + THREAD_COND_TIMEOUT;
- timeout.tv_nsec = now.tv_usec * 1000;
+#endif
- i_result = pthread_cond_timedwait( &p_condvar->cond, &p_mutex->mutex,
- &timeout );
+ return 0;
+}
- if( i_result == ETIMEDOUT )
- {
- msg_Warn( p_condvar->p_this,
- "thread %d: possible deadlock detected "
- "in cond_wait at %s:%d (%s)", pthread_self(),
- psz_file, i_line, strerror(i_result) );
- }
- else break;
- }
-# else
- i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex );
-# endif
+/*****************************************************************************
+ * vlc_cond_destroy: destroy a condition
+ *****************************************************************************/
+#define vlc_cond_destroy( P_COND ) \
+ __vlc_cond_destroy( __FILE__, __LINE__, P_COND )
- if ( i_result )
- {
- i_thread = (int)pthread_self();
- psz_error = strerror(i_result);
- }
+/*****************************************************************************
+ * vlc_threadvar_create: create a thread-local variable
+ *****************************************************************************/
+#define vlc_threadvar_create( PTHIS, P_TLS ) \
+ __vlc_threadvar_create( P_TLS )
-#elif defined( HAVE_CTHREADS_H )
- condition_wait( (condition_t)p_condvar, (mutex_t)p_mutex );
- return 0;
+/*****************************************************************************
+ * vlc_threadvar_set: create: set the value of a thread-local variable
+ *****************************************************************************/
+static inline int vlc_threadvar_set( vlc_threadvar_t * p_tls, void *p_value )
+{
+ int i_ret;
-#elif defined( HAVE_KERNEL_SCHEDULER_H )
- if( p_condvar == NULL )
- {
- i_result = B_BAD_VALUE;
- }
- else if( p_mutex == NULL )
- {
- i_result = B_BAD_VALUE;
- }
- else if( p_condvar->init < 2000 )
- {
- i_result = B_NO_INIT;
- }
+#if defined( HAVE_KERNEL_SCHEDULER_H )
+ return -1;
- /* The p_condvar->thread var is initialized before the unlock because
- * it enables to identify when the thread is interrupted beetwen the
- * unlock line and the suspend_thread line */
- p_condvar->thread = find_thread( NULL );
- vlc_mutex_unlock( p_mutex );
- suspend_thread( p_condvar->thread );
- p_condvar->thread = -1;
+#elif defined( UNDER_CE ) || defined( WIN32 )
+ i_ret = ( TlsSetValue( p_tls->handle, p_value ) != 0 );
- vlc_mutex_lock( p_mutex );
- return 0;
+#elif defined(LIBVLC_USE_PTHREAD)
+ i_ret = pthread_setspecific( p_tls->handle, p_value );
#endif
- if( i_result )
- {
- msg_Err( p_condvar->p_this,
- "thread %d: cond_wait failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
- }
-
- return i_result;
+ return i_ret;
}
/*****************************************************************************
- * vlc_cond_destroy: destroy a condition
+ * vlc_threadvar_get: create: get the value of a thread-local variable
*****************************************************************************/
-#define vlc_cond_destroy( P_COND ) \
- __vlc_cond_destroy( __FILE__, __LINE__, P_COND )
+static inline void* vlc_threadvar_get( vlc_threadvar_t * p_tls )
+{
+ void* p_ret;
+
+#if defined( HAVE_KERNEL_SCHEDULER_H )
+ p_ret = NULL;
+#elif defined( UNDER_CE ) || defined( WIN32 )
+ p_ret = TlsGetValue( p_tls->handle );
+
+#elif defined(LIBVLC_USE_PTHREAD)
+ p_ret = pthread_getspecific( p_tls->handle );
+
+#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 void vlc_spin_lock (vlc_spinlock_t *spin)
+{
+ int val = pthread_spin_lock (&spin->spin);
+ assert (val == 0);
+}
+
+/**
+ * Releases a spinlock.
+ */
+static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
+{
+ int val = pthread_spin_unlock (&spin->spin);
+ assert (val == 0);
+}
+
+/**
+ * Deinitializes a spinlock.
+ */
+static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
+{
+ int val = pthread_spin_destroy (&spin->spin);
+ assert (val == 0);
+}
+
+#elif defined( WIN32 )
+
+typedef CRITICAL_SECTION vlc_spinlock_t;
+
+/**
+ * Initializes a spinlock.
+ */
+static inline int vlc_spin_init (vlc_spinlock_t *spin)
+{
+ return !InitializeCriticalSectionAndSpinCount(spin, 4000);
+}
+
+/**
+ * Acquires a spinlock.
+ */
+static inline void vlc_spin_lock (vlc_spinlock_t *spin)
+{
+ EnterCriticalSection(spin);
+}
+
+/**
+ * Releases a spinlock.
+ */
+static inline void vlc_spin_unlock (vlc_spinlock_t *spin)
+{
+ LeaveCriticalSection(spin);
+}
+
+/**
+ * Deinitializes a spinlock.
+ */
+static inline void vlc_spin_destroy (vlc_spinlock_t *spin)
+{
+ DeleteCriticalSection(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 (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
#define vlc_thread_create( P_THIS, PSZ_NAME, FUNC, PRIORITY, WAIT ) \
__vlc_thread_create( VLC_OBJECT(P_THIS), __FILE__, __LINE__, PSZ_NAME, (void * ( * ) ( void * ))FUNC, PRIORITY, WAIT )
+/*****************************************************************************
+ * vlc_thread_set_priority: set the priority of the calling thread
+ *****************************************************************************/
+#define vlc_thread_set_priority( P_THIS, PRIORITY ) \
+ __vlc_thread_set_priority( VLC_OBJECT(P_THIS), __FILE__, __LINE__, PRIORITY )
+
/*****************************************************************************
* vlc_thread_ready: tell the parent thread we were successfully spawned
*****************************************************************************/
* vlc_thread_join: wait until a thread exits
*****************************************************************************/
#define vlc_thread_join( P_THIS ) \
- __vlc_thread_join( VLC_OBJECT(P_THIS), __FILE__, __LINE__ )
+ __vlc_thread_join( VLC_OBJECT(P_THIS), __FILE__, __LINE__ )
+
+#endif
projects / vlc / blobdiff