* 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.4 2002/10/03 17:01:59 gbazin Exp $
+ * Copyright (C) 1999, 2002 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
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_thread_set_priority, ( vlc_object_t *, char *, int, int ) );
VLC_EXPORT( void, __vlc_thread_ready, ( vlc_object_t * ) );
VLC_EXPORT( void, __vlc_thread_join, ( vlc_object_t *, char *, int ) );
+
/*****************************************************************************
* vlc_threads_init: initialize threads system
*****************************************************************************/
const char * psz_error = "";
#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_mutex_acquire( &p_mutex->mutex, TRUE, NULL );
+ 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 )
+ EnterCriticalSection( &p_mutex->csection );
+ i_result = 0;
+
#elif defined( WIN32 )
if( p_mutex->mutex )
{
{
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_CTHREADS_H )
- mutex_lock( p_mutex->mutex );
- return 0;
+ i_result = 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_mutex == NULL )
{
i_result = acquire_sem( p_mutex->lock );
}
+
+#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_CTHREADS_H )
+ mutex_lock( p_mutex->mutex );
+ i_result = 0;
+
#endif
if( i_result )
{
msg_Err( p_mutex->p_this,
- "thread %d: mutex_lock failed at %s:%d (%d:%s)",
+ "thread %u: mutex_lock failed at %s:%d (%d:%s)",
i_thread, psz_file, i_line, i_result, psz_error );
}
return i_result;
const char * psz_error = "";
#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_mutex_release( &p_mutex->mutex );
+ 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 )
+ LeaveCriticalSection( &p_mutex->csection );
+ i_result = 0;
+
#elif defined( WIN32 )
if( p_mutex->mutex )
{
{
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;
+ i_result = 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_mutex == NULL )
release_sem( p_mutex->lock );
return B_OK;
}
+
+#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 );
+ i_result = 0;
+
#endif
if( i_result )
{
msg_Err( p_mutex->p_this,
- "thread %d: mutex_unlock failed at %s:%d (%d:%s)",
+ "thread %u: mutex_unlock failed at %s:%d (%d:%s)",
i_thread, psz_file, i_line, i_result, psz_error );
}
const char * psz_error = "";
#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_cond_notify( &p_condvar->cond, FALSE );
+ 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 )
+ PulseEvent( p_condvar->event );
+ i_result = 0;
+
#elif defined( WIN32 )
/* Release one waiting thread if one is available. */
/* For this trick to work properly, the vlc_cond_signal must be surrounded
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;
+ i_result = 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_condvar == NULL )
return 0;
}
}
+ i_result = 0;
}
-#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 );
- }
-
- return i_result;
-}
-
-/*****************************************************************************
- * vlc_cond_broadcast: start all threads waiting on 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 )
-
-static inline int __vlc_cond_broadcast( 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( 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 );
-
-#elif defined( WIN32 )
- int i;
-
- /* Release all waiting threads. */
- if( !p_condvar->semaphore )
- {
- for( i = p_condvar->i_waiting_threads; i > 0; i-- )
- {
- PulseEvent( p_condvar->event );
- }
- }
- else if( p_condvar->i_win9x_cv == 1 )
- {
- /* 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 );
-
- /* 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 );
- }
- }
- else
- {
- if( p_condvar->i_waiting_threads )
- {
- ReleaseSemaphore( p_condvar->semaphore,
- p_condvar->i_waiting_threads, 0 );
-
- /* Wait for the last thread to be awakened */
- WaitForSingleObject( p_condvar->event, INFINITE );
- }
- }
- return 0;
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- i_result = pthread_cond_broadcast( &p_condvar->cond );
+ i_result = pthread_cond_signal( &p_condvar->cond );
if ( i_result )
{
i_thread = (int)pthread_self();
{
cond_signal( (condition_t)p_condvar );
}
- return 0;
+ i_result = 0;
-#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
if( i_result )
{
msg_Err( p_condvar->p_this,
- "thread %d: cond_broadcast failed at %s:%d (%d:%s)",
+ "thread %u: cond_signal failed at %s:%d (%d:%s)",
i_thread, psz_file, i_line, i_result, psz_error );
}
const char * psz_error = "";
#if defined( PTH_INIT_IN_PTH_H )
- i_result = pth_cond_await( &p_condvar->cond, &p_mutex->mutex, NULL );
+ 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 )
+ p_condvar->i_waiting_threads++;
+ LeaveCriticalSection( &p_mutex->csection );
+ WaitForSingleObject( p_condvar->event, INFINITE );
+ p_condvar->i_waiting_threads--;
+
+ /* Reacquire the mutex before returning. */
+ vlc_mutex_lock( p_mutex );
+
+ i_result = 0;
+
#elif defined( WIN32 )
if( !p_condvar->semaphore )
{
/* Reacquire the mutex before returning. */
vlc_mutex_lock( p_mutex );
- return 0;
-
-#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
-
-# ifdef DEBUG
- /* In debug mode, timeout */
- struct timeval now;
- struct timespec timeout;
-
- for( ; ; )
- {
- gettimeofday( &now, NULL );
- timeout.tv_sec = now.tv_sec + THREAD_COND_TIMEOUT;
- timeout.tv_nsec = now.tv_usec * 1000;
-
- i_result = pthread_cond_timedwait( &p_condvar->cond, &p_mutex->mutex,
- &timeout );
-
- 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
-
- if ( i_result )
- {
- i_thread = (int)pthread_self();
- psz_error = strerror(i_result);
- }
-
-#elif defined( HAVE_CTHREADS_H )
- condition_wait( (condition_t)p_condvar, (mutex_t)p_mutex );
- return 0;
+ i_result = 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
if( p_condvar == NULL )
p_condvar->thread = -1;
vlc_mutex_lock( p_mutex );
- return 0;
+ i_result = 0;
+
+#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
+
+# 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;
+
+ i_result = pthread_cond_timedwait( &p_condvar->cond, &p_mutex->mutex,
+ &timeout );
+
+ if( i_result == ETIMEDOUT )
+ {
+ /* People keep pissing me off with this. --Meuuh */
+ msg_Dbg( p_condvar->p_this,
+ "thread %u: secret message triggered "
+ "at %s:%d (%s)", (int)pthread_self(),
+ psz_file, i_line, strerror(i_result) );
+
+ i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex );
+ }
+
+# else
+ i_result = pthread_cond_wait( &p_condvar->cond, &p_mutex->mutex );
+# endif
+
+ if ( i_result )
+ {
+ i_thread = (int)pthread_self();
+ psz_error = strerror(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 %d: cond_wait failed at %s:%d (%d:%s)",
+ "thread %u: cond_wait failed at %s:%d (%d:%s)",
i_thread, psz_file, i_line, i_result, psz_error );
}
#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__ )
projects / vlc / blobdiff