02dcb2f53c62fb62a2408ebd7bd7763d99648d5a
[vlc.git] / src / misc / threads.c
1 /*****************************************************************************
2  * threads.c : threads implementation for the VideoLAN client
3  *****************************************************************************
4  * Copyright (C) 1999, 2000, 2001, 2002 VideoLAN
5  * $Id: threads.c,v 1.10 2002/07/20 18:01:43 sam Exp $
6  *
7  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
8  *          Samuel Hocevar <sam@zoy.org>
9  *          Gildas Bazin <gbazin@netcourrier.com>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
24  *****************************************************************************/
25
26 #include <vlc/vlc.h>
27
28 #define VLC_THREADS_UNINITIALIZED  0
29 #define VLC_THREADS_PENDING        1
30 #define VLC_THREADS_ERROR          2
31 #define VLC_THREADS_READY          3
32
33 /*****************************************************************************
34  * Prototype for GPROF wrapper
35  *****************************************************************************/
36 #ifdef GPROF
37 /* Wrapper function for profiling */
38 static void *      vlc_thread_wrapper ( void *p_wrapper );
39
40 #   ifdef WIN32
41
42 #       define ITIMER_REAL 1
43 #       define ITIMER_PROF 2
44
45 struct itimerval
46 {
47     struct timeval it_value;
48     struct timeval it_interval;
49 };  
50
51 int setitimer(int kind, const struct itimerval* itnew, struct itimerval* itold);
52 #   endif /* WIN32 */
53
54 typedef struct wrapper_t
55 {
56     /* Data lock access */
57     vlc_mutex_t lock;
58     vlc_cond_t  wait;
59     
60     /* Data used to spawn the real thread */
61     vlc_thread_func_t func;
62     void *p_data;
63     
64     /* Profiling timer passed to the thread */
65     struct itimerval itimer;
66     
67 } wrapper_t;
68
69 #endif /* GPROF */
70
71 /*****************************************************************************
72  * Global mutexes for lazy initialization of the threads system
73  *****************************************************************************/
74 static volatile int i_initializations = 0;
75
76 #if defined( PTH_INIT_IN_PTH_H )
77     /* Unimplemented */
78 #elif defined( ST_INIT_IN_ST_H )
79     /* Unimplemented */
80 #elif defined( WIN32 )
81     /* Unimplemented */
82 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
83     static pthread_mutex_t once_mutex = PTHREAD_MUTEX_INITIALIZER;
84 #elif defined( HAVE_CTHREADS_H )
85     /* Unimplemented */
86 #elif defined( HAVE_KERNEL_SCHEDULER_H )
87     /* Unimplemented */
88 #endif
89
90 /*****************************************************************************
91  * vlc_threads_init: initialize threads system
92  *****************************************************************************
93  * This function requires lazy initialization of a global lock in order to
94  * keep the library really thread-safe. Some architectures don't support this
95  * and thus do not guarantee the complete reentrancy.
96  *****************************************************************************/
97 int __vlc_threads_init( vlc_object_t *p_this )
98 {
99     static volatile int i_status = VLC_THREADS_UNINITIALIZED;
100     int i_ret = 0;
101
102 #if defined( PTH_INIT_IN_PTH_H )
103     /* Unimplemented */
104 #elif defined( ST_INIT_IN_ST_H )
105     /* Unimplemented */
106 #elif defined( WIN32 )
107     /* Unimplemented */
108 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
109     pthread_mutex_lock( &once_mutex );
110 #elif defined( HAVE_CTHREADS_H )
111     /* Unimplemented */
112 #elif defined( HAVE_KERNEL_SCHEDULER_H )
113     /* Unimplemented */
114 #endif
115
116     if( i_status == VLC_THREADS_UNINITIALIZED )
117     {
118         i_status = VLC_THREADS_PENDING;
119
120 #if defined( PTH_INIT_IN_PTH_H )
121         i_ret = pth_init();
122 #elif defined( ST_INIT_IN_ST_H )
123         i_ret = st_init();
124 #elif defined( WIN32 )
125         /* Unimplemented */
126 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
127         /* Unimplemented */
128 #elif defined( HAVE_CTHREADS_H )
129         /* Unimplemented */
130 #elif defined( HAVE_KERNEL_SCHEDULER_H )
131         /* Unimplemented */
132 #endif
133
134         if( i_ret )
135         {
136             i_status = VLC_THREADS_ERROR;
137         }
138         else
139         {
140             vlc_mutex_init( p_this, p_this->p_vlc->p_global_lock );
141             i_status = VLC_THREADS_READY;
142         }
143     }
144     else
145     {
146         i_ret = ( i_status == VLC_THREADS_READY );
147     }
148
149     i_initializations++;
150
151 #if defined( PTH_INIT_IN_PTH_H )
152     /* Unimplemented */
153 #elif defined( ST_INIT_IN_ST_H )
154     /* Unimplemented */
155 #elif defined( WIN32 )
156     /* Unimplemented */
157 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
158     pthread_mutex_unlock( &once_mutex );
159     return i_ret;
160 #elif defined( HAVE_CTHREADS_H )
161     /* Unimplemented */
162 #elif defined( HAVE_KERNEL_SCHEDULER_H )
163     /* Unimplemented */
164 #endif
165
166     /* Wait until the other thread has initialized the thread library */
167     while( i_status == VLC_THREADS_PENDING )
168     {
169         msleep( THREAD_SLEEP );
170     }
171
172     return i_status == VLC_THREADS_READY;
173 }
174
175 /*****************************************************************************
176  * vlc_threads_end: stop threads system
177  *****************************************************************************
178  * FIXME: This function is far from being threadsafe. We should undo exactly
179  * what we did above in vlc_threads_init.
180  *****************************************************************************/
181 int __vlc_threads_end( vlc_object_t *p_this )
182 {
183 #if defined( PTH_INIT_IN_PTH_H )
184     i_initializations--;
185     if( i_initializations == 0 )
186     {
187         return pth_kill();
188     }
189     return 0;
190
191 #elif defined( ST_INIT_IN_ST_H )
192     i_initializations--;
193     return 0;
194
195 #elif defined( WIN32 )
196     i_initializations--;
197     return 0;
198
199 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
200     pthread_mutex_lock( &once_mutex );
201     i_initializations--;
202     pthread_mutex_unlock( &once_mutex );
203     return 0;
204
205 #elif defined( HAVE_CTHREADS_H )
206     i_initializations--;
207     return 0;
208
209 #elif defined( HAVE_KERNEL_SCHEDULER_H )
210     i_initializations--;
211     return 0;
212
213 #endif
214 }
215
216 /*****************************************************************************
217  * vlc_mutex_init: initialize a mutex
218  *****************************************************************************/
219 int __vlc_mutex_init( vlc_object_t *p_this, vlc_mutex_t *p_mutex )
220 {
221 #if defined( PTH_INIT_IN_PTH_H )
222     return pth_mutex_init( p_mutex );
223
224 #elif defined( ST_INIT_IN_ST_H )
225     *p_mutex = st_mutex_new();
226     return ( *p_mutex == NULL ) ? errno : 0;
227
228 #elif defined( WIN32 )
229     /* We use mutexes on WinNT/2K/XP because we can use the SignalObjectAndWait
230      * function and have a 100% correct vlc_cond_wait() implementation.
231      * As this function is not available on Win9x, we can use the faster
232      * CriticalSections */
233     if( (GetVersion() < 0x80000000) && !p_this->p_vlc->b_fast_pthread )
234     {
235         /* We are running on NT/2K/XP, we can use SignalObjectAndWait */
236         p_mutex->mutex = CreateMutex( 0, FALSE, 0 );
237         return ( p_mutex->mutex ? 0 : 1 );
238     }
239     else
240     {
241         p_mutex->mutex = NULL;
242         InitializeCriticalSection( &p_mutex->csection );
243         return 0;
244     }
245
246 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
247 #   if defined(DEBUG) && defined(SYS_LINUX)
248     /* Create error-checking mutex to detect threads problems more easily. */
249     pthread_mutexattr_t attr;
250     int                 i_result;
251
252     pthread_mutexattr_init( &attr );
253     pthread_mutexattr_setkind_np( &attr, PTHREAD_MUTEX_ERRORCHECK_NP );
254     i_result = pthread_mutex_init( p_mutex, &attr );
255     pthread_mutexattr_destroy( &attr );
256     return( i_result );
257 #   endif
258     return pthread_mutex_init( p_mutex, NULL );
259
260 #elif defined( HAVE_CTHREADS_H )
261     mutex_init( p_mutex );
262     return 0;
263
264 #elif defined( HAVE_KERNEL_SCHEDULER_H )
265
266     /* check the arguments and whether it's already been initialized */
267     if( p_mutex == NULL )
268     {
269         return B_BAD_VALUE;
270     }
271
272     if( p_mutex->init == 9999 )
273     {
274         return EALREADY;
275     }
276
277     p_mutex->lock = create_sem( 1, "BeMutex" );
278     if( p_mutex->lock < B_NO_ERROR )
279     {
280         return( -1 );
281     }
282
283     p_mutex->init = 9999;
284     return B_OK;
285
286 #endif
287 }
288
289 /*****************************************************************************
290  * vlc_mutex_destroy: destroy a mutex, inner version
291  *****************************************************************************/
292 int __vlc_mutex_destroy( char * psz_file, int i_line, vlc_mutex_t *p_mutex )
293 {
294 #if defined( PTH_INIT_IN_PTH_H )
295     return 0;
296
297 #elif defined( ST_INIT_IN_ST_H )
298     return st_mutex_destroy( *p_mutex );
299
300 #elif defined( WIN32 )
301     if( p_mutex->mutex )
302     {
303         CloseHandle( p_mutex->mutex );
304     }
305     else
306     {
307         DeleteCriticalSection( &p_mutex->csection );
308     }
309     return 0;
310
311 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )    
312     int i_return = pthread_mutex_destroy( p_mutex );
313     if( i_return )
314     {
315 //X        intf_ErrMsg( "thread %d error: mutex_destroy failed at %s:%d (%s)",
316 //X                     pthread_self(), psz_file, i_line, strerror(i_return) );
317     }
318     return i_return;
319
320 #elif defined( HAVE_CTHREADS_H )
321     return 0;
322
323 #elif defined( HAVE_KERNEL_SCHEDULER_H )
324     if( p_mutex->init == 9999 )
325     {
326         delete_sem( p_mutex->lock );
327     }
328
329     p_mutex->init = 0;
330     return B_OK;
331
332 #endif    
333 }
334
335 /*****************************************************************************
336  * vlc_cond_init: initialize a condition
337  *****************************************************************************/
338 int __vlc_cond_init( vlc_object_t *p_this, vlc_cond_t *p_condvar )
339 {
340 #if defined( PTH_INIT_IN_PTH_H )
341     return pth_cond_init( p_condvar );
342
343 #elif defined( ST_INIT_IN_ST_H )
344     *p_condvar = st_cond_new();
345     return ( *p_condvar == NULL ) ? errno : 0;
346
347 #elif defined( WIN32 )
348     /* Initialize counter */
349     p_condvar->i_waiting_threads = 0;
350
351     if( (GetVersion() < 0x80000000) && !p_this->p_vlc->b_fast_pthread )
352     {
353         /* Create an auto-reset event and a semaphore. */
354         p_condvar->signal = CreateEvent( NULL, FALSE, FALSE, NULL );
355         p_condvar->semaphore = CreateSemaphore( NULL, 0, 0x7fffffff, NULL );
356
357         p_condvar->b_broadcast = 0;
358
359         /* We are running on NT/2K/XP, we can use SignalObjectAndWait */
360         p_condvar->SignalObjectAndWait = p_this->p_vlc->SignalObjectAndWait;
361
362         return !p_condvar->signal || !p_condvar->semaphore;
363     }
364     else
365     {
366         p_condvar->signal = NULL;
367
368         /* Create an auto-reset event and a manual-reset event. */
369         p_condvar->p_events[0] = CreateEvent( NULL, FALSE, FALSE, NULL );
370         p_condvar->p_events[1] = CreateEvent( NULL, TRUE, FALSE, NULL );
371
372         return !p_condvar->p_events[0] || !p_condvar->p_events[1];
373     }
374
375 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
376     return pthread_cond_init( p_condvar, NULL );
377
378 #elif defined( HAVE_CTHREADS_H )
379     /* condition_init() */
380     spin_lock_init( &p_condvar->lock );
381     cthread_queue_init( &p_condvar->queue );
382     p_condvar->name = 0;
383     p_condvar->implications = 0;
384
385     return 0;
386
387 #elif defined( HAVE_KERNEL_SCHEDULER_H )
388     if( !p_condvar )
389     {
390         return B_BAD_VALUE;
391     }
392
393     if( p_condvar->init == 9999 )
394     {
395         return EALREADY;
396     }
397
398     p_condvar->thread = -1;
399     p_condvar->init = 9999;
400     return 0;
401
402 #endif
403 }
404
405 /*****************************************************************************
406  * vlc_cond_destroy: destroy a condition, inner version
407  *****************************************************************************/
408 int __vlc_cond_destroy( char * psz_file, int i_line, vlc_cond_t *p_condvar )
409 {
410 #if defined( PTH_INIT_IN_PTH_H )
411     return 0;
412
413 #elif defined( ST_INIT_IN_ST_H )
414     return st_cond_destroy( *p_condvar );
415
416 #elif defined( WIN32 )
417     if( p_condvar->signal )
418     {
419         return !CloseHandle( p_condvar->signal )
420                  || !CloseHandle( p_condvar->semaphore );
421     }
422     else
423     {
424         return !CloseHandle( p_condvar->p_events[0] )
425                  || !CloseHandle( p_condvar->p_events[1] );
426     }
427
428 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
429     int i_result = pthread_cond_destroy( p_condvar );
430     if( i_result )
431     {
432 //X        intf_ErrMsg( "thread %d error: cond_destroy failed at %s:%d (%s)",
433 //X                     pthread_self(), psz_file, i_line, strerror(i_result) );
434     }
435     return i_result;
436
437 #elif defined( HAVE_CTHREADS_H )
438     return 0;
439
440 #elif defined( HAVE_KERNEL_SCHEDULER_H )
441     p_condvar->init = 0;
442     return 0;
443
444 #endif    
445 }
446
447 /*****************************************************************************
448  * vlc_thread_create: create a thread, inner version
449  *****************************************************************************/
450 int __vlc_thread_create( vlc_object_t *p_this, char * psz_file, int i_line,
451                          char *psz_name, void * ( *func ) ( void * ),
452                          vlc_bool_t b_wait )
453 {
454     int i_ret;
455
456     vlc_mutex_lock( &p_this->object_lock );
457
458 #ifdef GPROF
459     wrapper_t wrapper;
460
461     /* Initialize the wrapper structure */
462     wrapper.func = func;
463     wrapper.p_data = (void *)p_this;
464     getitimer( ITIMER_PROF, &wrapper.itimer );
465     vlc_mutex_init( p_this, &wrapper.lock );
466     vlc_cond_init( p_this, &wrapper.wait );
467     vlc_mutex_lock( &wrapper.lock );
468
469     /* Alter user-passed data so that we call the wrapper instead
470      * of the real function */
471     p_data = &wrapper;
472     func = vlc_thread_wrapper;
473 #endif
474
475 #if defined( PTH_INIT_IN_PTH_H )
476     p_this->thread_id = pth_spawn( PTH_ATTR_DEFAULT, func, (void *)p_this );
477     i_ret = 0;
478
479 #elif defined( ST_INIT_IN_ST_H )
480     p_this->thread_id = st_thread_create( func, (void *)p_this, 1, 0 );
481     i_ret = 0;
482     
483 #elif defined( WIN32 )
484     {
485         unsigned threadID;
486         /* When using the MSVCRT C library you have to use the _beginthreadex
487          * function instead of CreateThread, otherwise you'll end up with
488          * memory leaks and the signal functions not working */
489         p_this->thread_id =
490                 (HANDLE)_beginthreadex( NULL, 0, (PTHREAD_START) func, 
491                                         (void *)p_this, 0, &threadID );
492     }
493
494     i_ret = ( p_this->thread_id ? 0 : 1 );
495
496 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
497     i_ret = pthread_create( &p_this->thread_id, NULL, func, (void *)p_this );
498
499 #elif defined( HAVE_CTHREADS_H )
500     p_this->thread_id = cthread_fork( (cthread_fn_t)func, (any_t)p_this );
501     i_ret = 0;
502
503 #elif defined( HAVE_KERNEL_SCHEDULER_H )
504     p_this->thread_id = spawn_thread( (thread_func)func, psz_name,
505                                       B_NORMAL_PRIORITY, (void *)p_this );
506     i_ret = resume_thread( p_this->thread_id );
507
508 #endif
509
510 #ifdef GPROF
511     if( i_ret == 0 )
512     {
513         vlc_cond_wait( &wrapper.wait, &wrapper.lock );
514     }
515
516     vlc_mutex_unlock( &wrapper.lock );
517     vlc_mutex_destroy( &wrapper.lock );
518     vlc_cond_destroy( &wrapper.wait );
519 #endif
520
521     if( i_ret == 0 )
522     {
523         if( b_wait )
524         {
525             msg_Dbg( p_this, "waiting for thread completion" );
526             vlc_cond_wait( &p_this->object_wait, &p_this->object_lock );
527         }
528
529         p_this->b_thread = 1;
530
531         msg_Dbg( p_this, "thread %d (%s) created (%s:%d)",
532                          p_this->thread_id, psz_name, psz_file, i_line );
533
534         vlc_mutex_unlock( &p_this->object_lock );
535     }
536     else
537     {
538         msg_Err( p_this, "%s thread could not be created at %s:%d (%s)",
539                          psz_name, psz_file, i_line, strerror(i_ret) );
540         vlc_mutex_unlock( &p_this->object_lock );
541     }
542
543     return i_ret;
544 }
545
546 /*****************************************************************************
547  * vlc_thread_ready: tell the parent thread we were successfully spawned
548  *****************************************************************************/
549 void __vlc_thread_ready( vlc_object_t *p_this )
550 {
551     vlc_mutex_lock( &p_this->object_lock );
552     vlc_cond_signal( &p_this->object_wait );
553     vlc_mutex_unlock( &p_this->object_lock );
554 }
555
556 /*****************************************************************************
557  * vlc_thread_join: wait until a thread exits, inner version
558  *****************************************************************************/
559 void __vlc_thread_join( vlc_object_t *p_this, char * psz_file, int i_line )
560 {
561     int i_ret = 0;
562
563 #if defined( PTH_INIT_IN_PTH_H )
564     i_ret = pth_join( p_this->thread_id, NULL );
565
566 #elif defined( ST_INIT_IN_ST_H )
567     i_ret = st_thread_join( p_this->thread_id, NULL );
568     
569 #elif defined( WIN32 )
570     WaitForSingleObject( p_this->thread_id, INFINITE );
571
572 #elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
573     i_ret = pthread_join( p_this->thread_id, NULL );
574
575 #elif defined( HAVE_CTHREADS_H )
576     cthread_join( p_this->thread_id );
577     i_ret = 1;
578
579 #elif defined( HAVE_KERNEL_SCHEDULER_H )
580     int32 exit_value;
581     wait_for_thread( p_this->thread_id, &exit_value );
582
583 #endif
584
585     if( i_ret )
586     {
587         msg_Err( p_this, "thread_join(%d) failed at %s:%d (%s)",
588                          p_this->thread_id, psz_file, i_line, strerror(i_ret) );
589     }
590     else
591     {
592         msg_Dbg( p_this, "thread %d joined (%s:%d)",
593                          p_this->thread_id, psz_file, i_line );
594     }
595
596     p_this->b_thread = 0;
597 }
598
599 /*****************************************************************************
600  * vlc_thread_wrapper: wrapper around thread functions used when profiling.
601  *****************************************************************************/
602 #ifdef GPROF
603 static void *vlc_thread_wrapper( void *p_wrapper )
604 {
605     /* Put user data in thread-local variables */
606     void *            p_data = ((wrapper_t*)p_wrapper)->p_data;
607     vlc_thread_func_t func   = ((wrapper_t*)p_wrapper)->func;
608
609     /* Set the profile timer value */
610     setitimer( ITIMER_PROF, &((wrapper_t*)p_wrapper)->itimer, NULL );
611
612     /* Tell the calling thread that we don't need its data anymore */
613     vlc_mutex_lock( &((wrapper_t*)p_wrapper)->lock );
614     vlc_cond_signal( &((wrapper_t*)p_wrapper)->wait );
615     vlc_mutex_unlock( &((wrapper_t*)p_wrapper)->lock );
616
617     /* Call the real function */
618     return func( p_data );
619 }
620 #endif