* vlc_threads_funcs.h : threads implementation for the VideoLAN client
* This header provides a portable threads implementation.
*****************************************************************************
- * Copyright (C) 1999, 2002 the VideoLAN team
+ * Copyright (C) 1999-2007 the VideoLAN team
* $Id$
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
/*****************************************************************************
* 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, ( const char *, int, vlc_mutex_t * ) );
VLC_EXPORT( int, __vlc_cond_init, ( vlc_object_t *, 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_init: initialize threads system
*****************************************************************************/
#define vlc_mutex_lock( P_MUTEX ) \
__vlc_mutex_lock( __FILE__, __LINE__, P_MUTEX )
-#ifdef __APPLE__
+#if defined( __APPLE__ ) || defined( __FreeBSD__ )
# define CAST_PTHREAD_TO_INT(t) (unsigned long int)(uintptr_t)(void *)t
#else
# define CAST_PTHREAD_TO_INT(t) (unsigned long int)t
int i_result;
/* In case of error : */
unsigned long int i_thread = 0;
- const char * psz_error = "";
#if defined( PTH_INIT_IN_PTH_H )
i_result = ( pth_mutex_acquire( &p_mutex->mutex, FALSE, NULL ) == FALSE );
}
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
+# define vlc_assert_locked( m ) \
+ assert (pthread_mutex_lock (&((m)->mutex)) == EDEADLK)
+
i_result = pthread_mutex_lock( &p_mutex->mutex );
if ( i_result )
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
- psz_error = strerror(i_result);
+ errno = i_result;
}
#elif defined( HAVE_CTHREADS_H )
if( i_result )
{
msg_Err( p_mutex->p_this,
- "thread %li: mutex_lock failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
+ "thread %li: mutex_lock failed at %s:%d (%d:%m)",
+ i_thread, psz_file, i_line, i_result );
}
return i_result;
}
+#ifndef vlc_assert_locked
+# define vlc_assert_locked( m ) (void)0
+#endif
+
/*****************************************************************************
* vlc_mutex_unlock: unlock a mutex
*****************************************************************************/
int i_result;
/* In case of error : */
unsigned long int i_thread = 0;
- const char * psz_error = "";
#if defined( PTH_INIT_IN_PTH_H )
i_result = ( pth_mutex_release( &p_mutex->mutex ) == FALSE );
if ( i_result )
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
- psz_error = strerror(i_result);
+ errno = i_result;
}
#elif defined( HAVE_CTHREADS_H )
if( i_result )
{
msg_Err( p_mutex->p_this,
- "thread %li: mutex_unlock failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
+ "thread %li: mutex_unlock failed at %s:%d (%d:%m)",
+ i_thread, psz_file, i_line, i_result );
}
return i_result;
int i_result;
/* In case of error : */
unsigned long int i_thread = 0;
- const char * psz_error = "";
#if defined( PTH_INIT_IN_PTH_H )
i_result = ( pth_cond_notify( &p_condvar->cond, FALSE ) == FALSE );
* 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 )
if ( i_result )
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
- psz_error = strerror(i_result);
+ errno = i_result;
}
#elif defined( HAVE_CTHREADS_H )
if( i_result )
{
msg_Err( p_condvar->p_this,
- "thread %li: cond_signal failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
+ "thread %li: cond_signal failed at %s:%d (%d:%m)",
+ i_thread, psz_file, i_line, i_result );
}
return i_result;
int i_result;
/* In case of error : */
unsigned long int i_thread = 0;
- const char * psz_error = "";
#if defined( PTH_INIT_IN_PTH_H )
i_result = ( pth_cond_await( &p_condvar->cond, &p_mutex->mutex, NULL )
# ifdef DEBUG
/* In debug mode, timeout */
- struct timeval now;
- struct timespec timeout;
-
- gettimeofday( &now, NULL );
- timeout.tv_sec = now.tv_sec + THREAD_COND_TIMEOUT;
- timeout.tv_nsec = now.tv_usec * 1000;
+ struct timespec timeout = {
+ (mdate() / 1000000) + THREAD_COND_TIMEOUT,
+ 0 /* 1Hz precision is sufficient here :-) */
+ };
i_result = pthread_cond_timedwait( &p_condvar->cond, &p_mutex->mutex,
&timeout );
if( i_result == ETIMEDOUT )
{
+ errno = ETIMEDOUT;
msg_Dbg( p_condvar->p_this,
"thread %li: possible condition deadlock "
- "at %s:%d (%s)", CAST_PTHREAD_TO_INT(pthread_self()),
- psz_file, i_line, strerror(i_result) );
+ "at %s:%d (%m)", CAST_PTHREAD_TO_INT(pthread_self()),
+ psz_file, i_line );
i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex );
}
if ( i_result )
{
i_thread = CAST_PTHREAD_TO_INT(pthread_self());
- psz_error = strerror(i_result);
+ errno = i_result;
}
#elif defined( HAVE_CTHREADS_H )
if( i_result )
{
msg_Err( p_condvar->p_this,
- "thread %li: cond_wait failed at %s:%d (%d:%s)",
- i_thread, psz_file, i_line, i_result, psz_error );
+ "thread %li: cond_wait failed at %s:%d (%d:%m)",
+ i_thread, psz_file, i_line, i_result );
}
return i_result;
}
+
+/*****************************************************************************
+ * 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_timedwait( P_COND, P_MUTEX, DEADLINE ) \
+ __vlc_cond_timedwait( __FILE__, __LINE__, P_COND, P_MUTEX, DEADLINE )
+
+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_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 )
+ mtime_t delay_ms = (deadline - mdate())/1000;
+
+ DWORD result;
+ if( delay_ms < 0 )
+ delay_ms = 0;
+
+ p_condvar->i_waiting_threads++;
+ LeaveCriticalSection( &p_mutex->csection );
+ result = WaitForSingleObject( p_condvar->event, delay_ms );
+ p_condvar->i_waiting_threads--;
+
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
+
+ i_res = (int)result;
+
+#elif defined( WIN32 )
+ 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_mutex->mutex )
+ {
+ /* It is only possible to atomically release the mutex and
+ * initiate the waiting on WinNT/2K/XP. Win9x doesn't have
+ * SignalObjectAndWait(). */
+ result = p_condvar->SignalObjectAndWait( p_mutex->mutex,
+ p_condvar->event,
+ delay_ms, FALSE );
+ }
+ else
+ {
+ LeaveCriticalSection( &p_mutex->csection );
+ result = WaitForSingleObject( p_condvar->event, delay_ms );
+ }
+
+ p_condvar->i_waiting_threads--;
+ }
+ else if( p_condvar->i_win9x_cv == 1 )
+ {
+ int i_waiting_threads;
+
+ /* Wait for the gate to be open */
+ result = WaitForSingleObject( p_condvar->event, delay_ms );
+
+ /* Increase our wait count */
+ p_condvar->i_waiting_threads++;
+
+ LeaveCriticalSection( &p_mutex->csection );
+ 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 );
+
+ /* 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
+ {
+ int i_waiting_threads;
+
+ /* Increase our wait count */
+ p_condvar->i_waiting_threads++;
+
+ LeaveCriticalSection( &p_mutex->csection );
+ result = WaitForSingleObject( p_condvar->semaphore, delay_ms );
+
+ /* 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 );
+ }
+
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
+
+ i_res = (int)result;
+
+#elif defined( HAVE_KERNEL_SCHEDULER_H )
+# error Unimplemented
+#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
+ lldiv_t d = lldiv( deadline, 1000000 );
+ struct timespec ts = { d.quot, d.rem * 1000 };
+
+ i_res = pthread_cond_timedwait( &p_condvar->cond, &p_mutex->mutex, &ts );
+ if( i_res == ETIMEDOUT )
+ return ETIMEDOUT; /* this error is perfectly normal */
+ else
+ if ( i_res ) /* other errors = bug */
+ {
+ i_thread = CAST_PTHREAD_TO_INT(pthread_self());
+ 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 );
+ }
+
+ return i_res;
+}
+
/*****************************************************************************
* vlc_cond_destroy: destroy a condition
*****************************************************************************/