Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Cosmetics on error messages
[simgrid.git] / src / xbt / xbt_os_thread.c
1 /* $Id$ */
2
3 /* xbt_os_thread -- portability layer over the pthread API                  */
4 /* Used in RL to get win/lin portability, and in SG when CONTEXT_THREAD     */
5 /* in SG, when using CONTEXT_UCONTEXT, xbt_os_thread_stub is used instead   */
6
7 /* Copyright 2006,2007 Malek Cherier, Martin Quinson          
8  * All right reserved.                                                      */
9
10 /* This program is free software; you can redistribute it and/or modify it
11  * under the terms of the license (GNU LGPL) which comes with this package. */
12
13 #include "xbt/sysdep.h"
14 #include "xbt/ex.h"
15 #include "xbt/ex_interface.h" /* We play crude games with exceptions */
16 #include "portable.h"
17 #include "xbt/xbt_os_time.h" /* Portable time facilities */
18 #include "xbt/xbt_os_thread.h" /* This module */
19 #include "xbt_modinter.h" /* Initialization/finalization of this module */
20
21 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_sync_os,xbt,"Synchronization mechanism (OS-level)");
22
23 /* ********************************* PTHREAD IMPLEMENTATION ************************************ */
24 #ifdef HAVE_PTHREAD_H
25 #include <pthread.h>
26 #include <semaphore.h>
27
28 typedef struct xbt_os_thread_ {
29    pthread_t t;
30    char *name;
31    void *param;
32    pvoid_f_pvoid_t start_routine;
33    ex_ctx_t *exception;
34 } s_xbt_os_thread_t ;
35 static xbt_os_thread_t main_thread = NULL;
36
37 /* thread-specific data containing the xbt_os_thread_t structure */
38 static pthread_key_t xbt_self_thread_key;
39 static int thread_mod_inited = 0;
40
41 /* frees the xbt_os_thread_t corresponding to the current thread */
42 static void xbt_os_thread_free_thread_data(void*d){
43    free(d);
44 }
45
46 /* callback: context fetching */
47 static ex_ctx_t *_os_thread_ex_ctx(void) {
48   return xbt_os_thread_self()->exception;
49 }
50
51 /* callback: termination */
52 static void _os_thread_ex_terminate(xbt_ex_t * e) {
53   xbt_ex_display(e);
54
55   abort();
56   /* FIXME: there should be a configuration variable to choose to kill everyone or only this one */
57 }
58
59 void xbt_os_thread_mod_init(void) {
60    int errcode;
61    
62    if (thread_mod_inited)
63      return;
64    
65    if ((errcode=pthread_key_create(&xbt_self_thread_key, NULL)))
66      THROW0(system_error,errcode,"pthread_key_create failed for xbt_self_thread_key");
67
68    main_thread=xbt_new(s_xbt_os_thread_t,1);
69    main_thread->name = (char*)"main";
70    main_thread->start_routine = NULL;
71    main_thread->param = NULL;
72    main_thread->exception = xbt_new(ex_ctx_t, 1);
73    XBT_CTX_INITIALIZE(main_thread->exception);
74
75    __xbt_ex_ctx = _os_thread_ex_ctx;
76    __xbt_ex_terminate = _os_thread_ex_terminate;
77
78    thread_mod_inited = 1;
79 }
80 void xbt_os_thread_mod_exit(void) {
81    /* FIXME: don't try to free our key on shutdown. 
82       Valgrind detects no leak if we don't, and whine if we try to */
83 //   int errcode;
84    
85 //   if ((errcode=pthread_key_delete(xbt_self_thread_key)))
86 //     THROW0(system_error,errcode,"pthread_key_delete failed for xbt_self_thread_key");
87 }
88
89 static void * wrapper_start_routine(void *s) {
90   xbt_os_thread_t t = s;   
91   int errcode;
92
93   if ((errcode=pthread_setspecific(xbt_self_thread_key,t)))
94     THROW0(system_error,errcode,
95            "pthread_setspecific failed for xbt_self_thread_key");   
96    
97   return (*(t->start_routine))(t->param);
98 }
99 xbt_os_thread_t xbt_os_thread_create(const char*name,
100                                      pvoid_f_pvoid_t start_routine,
101                                      void* param)  {
102    int errcode;
103
104    xbt_os_thread_t res_thread=xbt_new(s_xbt_os_thread_t,1);
105    res_thread->name = xbt_strdup(name);
106    res_thread->start_routine = start_routine;
107    res_thread->param = param;
108    res_thread->exception = xbt_new(ex_ctx_t, 1);
109    XBT_CTX_INITIALIZE(res_thread->exception);
110    
111    if ((errcode = pthread_create(&(res_thread->t), NULL, 
112                                  wrapper_start_routine, res_thread)))
113      THROW1(system_error,errcode, 
114             "pthread_create failed: %s",strerror(errcode));
115
116    return res_thread;
117 }
118
119 const char* xbt_os_thread_name(xbt_os_thread_t t) {
120    return t->name;
121 }
122
123 const char* xbt_os_thread_self_name(void) {
124    xbt_os_thread_t self = xbt_os_thread_self();
125    return self?self->name:"main";
126 }
127 void 
128 xbt_os_thread_join(xbt_os_thread_t thread,void ** thread_return) {
129         
130   int errcode;   
131   
132   if ((errcode = pthread_join(thread->t,thread_return)))
133     THROW1(system_error,errcode, "pthread_join failed: %s",
134            strerror(errcode));
135    if (thread->exception)
136      free(thread->exception);
137
138    if (thread == main_thread) /* just killed main thread */
139      main_thread = NULL;
140
141    free(thread);   
142 }                      
143
144 void xbt_os_thread_exit(int *retval) {
145    pthread_exit(retval);
146 }
147
148 xbt_os_thread_t xbt_os_thread_self(void) {
149   xbt_os_thread_t res;
150
151   if (!thread_mod_inited)
152     return NULL;
153   
154   res = pthread_getspecific(xbt_self_thread_key);
155   if (!res)
156     res = main_thread;
157
158   return res;
159 }
160
161 #include <sched.h>
162 void xbt_os_thread_yield(void) {
163    sched_yield();
164 }
165 void xbt_os_thread_cancel(xbt_os_thread_t t) {
166    pthread_cancel(t->t);
167 }
168 /****** mutex related functions ******/
169 typedef struct xbt_os_mutex_ {
170   /* KEEP IT IN SYNC WITH xbt_thread.c */
171    pthread_mutex_t m;
172 } s_xbt_os_mutex_t;
173
174 xbt_os_mutex_t xbt_os_mutex_init(void) {
175    xbt_os_mutex_t res = xbt_new(s_xbt_os_mutex_t,1);
176    int errcode;
177    
178    if ((errcode = pthread_mutex_init(&(res->m),NULL)))
179      THROW1(system_error,errcode,"pthread_mutex_init() failed: %s",
180             strerror(errcode));
181    
182    return res;
183 }
184
185 void xbt_os_mutex_acquire(xbt_os_mutex_t mutex) {
186    int errcode;
187    
188    if ((errcode=pthread_mutex_lock(&(mutex->m))))
189      THROW2(system_error,errcode,"pthread_mutex_lock(%p) failed: %s",
190             mutex, strerror(errcode));
191 }
192
193 void xbt_os_mutex_release(xbt_os_mutex_t mutex) {
194    int errcode;
195    
196    if ((errcode=pthread_mutex_unlock(&(mutex->m))))
197      THROW2(system_error,errcode,"pthread_mutex_unlock(%p) failed: %s",
198             mutex, strerror(errcode));
199 }
200
201 void xbt_os_mutex_destroy(xbt_os_mutex_t mutex) {
202    int errcode;
203    
204    if (!mutex) return;
205    
206    if ((errcode=pthread_mutex_destroy(&(mutex->m))))
207      THROW2(system_error,errcode,"pthread_mutex_destroy(%p) failed: %s",
208             mutex, strerror(errcode));
209    free(mutex);
210 }
211
212 /***** condition related functions *****/
213 typedef struct xbt_os_cond_ {
214   /* KEEP IT IN SYNC WITH xbt_thread.c */
215    pthread_cond_t c;
216 } s_xbt_os_cond_t;
217
218 xbt_os_cond_t xbt_os_cond_init(void) {
219    xbt_os_cond_t res = xbt_new(s_xbt_os_cond_t,1);
220    int errcode;
221    if ((errcode=pthread_cond_init(&(res->c),NULL)))
222      THROW1(system_error,errcode,"pthread_cond_init() failed: %s",
223             strerror(errcode));
224
225    return res;
226 }
227
228 void xbt_os_cond_wait(xbt_os_cond_t cond, xbt_os_mutex_t mutex) {
229    int errcode;
230    if ((errcode=pthread_cond_wait(&(cond->c),&(mutex->m))))
231      THROW3(system_error,errcode,"pthread_cond_wait(%p,%p) failed: %s",
232             cond,mutex, strerror(errcode));
233 }
234
235 #include <time.h>
236 #include <math.h>
237 void xbt_os_cond_timedwait(xbt_os_cond_t cond, xbt_os_mutex_t mutex, double delay) {
238    int errcode;
239    struct timespec ts_end;
240    double end = delay + xbt_os_time();
241    
242    if (delay < 0) {
243       xbt_os_cond_wait(cond,mutex);
244    } else {
245       ts_end.tv_sec = (time_t) floor(end);
246       ts_end.tv_nsec = (long)  ( ( end - ts_end.tv_sec) * 1000000000);
247       DEBUG3("pthread_cond_timedwait(%p,%p,%p)",&(cond->c),&(mutex->m), &ts_end);
248       switch ( (errcode=pthread_cond_timedwait(&(cond->c),&(mutex->m), &ts_end)) ) {
249        case 0:
250          return;
251        case ETIMEDOUT:
252          THROW3(timeout_error,errcode,"condition %p (mutex %p) wasn't signaled before timeout (%f)",
253                 cond,mutex, delay);
254        default:
255          THROW4(system_error,errcode,"pthread_cond_timedwait(%p,%p,%f) failed: %s",
256                 cond,mutex, delay, strerror(errcode));
257       }   
258    }
259 }
260
261 void xbt_os_cond_signal(xbt_os_cond_t cond) {
262    int errcode;
263    if ((errcode=pthread_cond_signal(&(cond->c))))
264      THROW2(system_error,errcode,"pthread_cond_signal(%p) failed: %s",
265             cond, strerror(errcode));
266 }
267          
268 void xbt_os_cond_broadcast(xbt_os_cond_t cond){
269    int errcode;
270    if ((errcode=pthread_cond_broadcast(&(cond->c))))
271      THROW2(system_error,errcode,"pthread_cond_broadcast(%p) failed: %s",
272             cond, strerror(errcode));
273 }
274 void xbt_os_cond_destroy(xbt_os_cond_t cond){
275    int errcode;
276
277    if (!cond) return;
278
279    if ((errcode=pthread_cond_destroy(&(cond->c))))
280      THROW2(system_error,errcode,"pthread_cond_destroy(%p) failed: %s",
281             cond, strerror(errcode));
282    free(cond);
283 }
284
285 void *xbt_os_thread_getparam(void) {
286    xbt_os_thread_t t = xbt_os_thread_self();
287    return t?t->param:NULL;
288 }
289
290 typedef struct xbt_os_sem_ {
291    sem_t s;
292 }s_xbt_os_sem_t ;
293
294 xbt_os_sem_t
295 xbt_os_sem_init(unsigned int value)
296 {
297         xbt_os_sem_t res = xbt_new(s_xbt_os_sem_t,1);
298         
299         if(sem_init(&(res->s),0,value) < 0)
300                 THROW1(system_error,errno,"sem_init() failed: %s",
301             strerror(errno));
302    
303    return res;
304 }
305
306 void 
307 xbt_os_sem_acquire(xbt_os_sem_t sem)
308 {
309         if(!sem)
310                 THROW0(arg_error,EINVAL,"Cannot acquire of the NULL semaphore");
311         
312         if(sem_wait(&(sem->s)) < 0)
313                 THROW1(system_error,errno,"sem_wait() failed: %s",
314             strerror(errno));            
315 }
316
317 void xbt_os_sem_timedacquire(xbt_os_sem_t sem,double timeout)
318 {
319         /* mac os x have not the sem_timedwait() function */
320         #ifndef HAVE_SEM_TIMEDWAIT
321         THROW_UNIMPLEMENTED;
322         #else
323         int errcode;
324         struct timespec ts_end;
325         double end = timeout + xbt_os_time();
326         
327         if(!sem)
328                 THROW0(arg_error,EINVAL,"Cannot acquire of the NULL semaphore");
329         
330         if (timeout < 0) 
331         {
332                 xbt_os_sem_acquire(sem);
333         } 
334         else 
335         {
336                 ts_end.tv_sec = (time_t) floor(end);
337                 ts_end.tv_nsec = (long)  ( ( end - ts_end.tv_sec) * 1000000000);
338                 DEBUG2("sem_timedwait(%p,%p)",&(sem->s),&ts_end);
339         
340                 switch ((errcode=sem_timedwait(&(sem->s),&ts_end)))
341                 {
342                         case 0:
343                         return;
344                         
345                         case ETIMEDOUT:
346                         THROW2(timeout_error,errcode,"semaphore %p wasn't signaled before timeout (%f)",sem,timeout);
347                         
348                         default:
349                         THROW3(system_error,errcode,"sem_timedwait(%p,%f) failed: %s",sem,timeout, strerror(errcode));
350                 }   
351         }
352         #endif
353 }
354
355 void 
356 xbt_os_sem_release(xbt_os_sem_t sem)
357 {
358         if(!sem)
359                 THROW0(arg_error,EINVAL,"Cannot release of the NULL semaphore");
360         
361         if(sem_post(&(sem->s)) < 0)
362                 THROW1(system_error,errno,"sem_post() failed: %s",
363             strerror(errno));            
364 }
365
366 void
367 xbt_os_sem_destroy(xbt_os_sem_t sem)
368 {
369    if(!sem)
370      return;
371             
372         if(sem_destroy(&(sem->s)) < 0)
373                 THROW1(system_error,errno,"sem_destroy() failed: %s",
374             strerror(errno));
375 }
376
377 void
378 xbt_os_sem_get_value(xbt_os_sem_t sem, int* svalue)
379 {
380         if(!sem)
381                 THROW0(arg_error,EINVAL,"Cannot get the value of the NULL semaphore");
382             
383         if(sem_getvalue(&(sem->s),svalue) < 0)
384                 THROW1(system_error,errno,"sem_getvalue() failed: %s",
385             strerror(errno));
386 }
387
388 /* ********************************* WINDOWS IMPLEMENTATION ************************************ */
389
390 #elif defined(WIN32)
391
392 #include <math.h>
393
394 typedef struct xbt_os_thread_ {
395   char *name;
396   HANDLE handle;                  /* the win thread handle        */
397   unsigned long id;               /* the win thread id            */
398   pvoid_f_pvoid_t start_routine;
399   void* param;
400 } s_xbt_os_thread_t ;
401
402 /* so we can specify the size of the stack of the threads */
403 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
404 #define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000
405 #endif
406
407 /* the default size of the stack of the threads (in bytes)*/
408 #define XBT_DEFAULT_THREAD_STACK_SIZE   4096
409
410 /* key to the TLS containing the xbt_os_thread_t structure */
411 static unsigned long xbt_self_thread_key;
412
413 void xbt_os_thread_mod_init(void) {
414    xbt_self_thread_key = TlsAlloc();
415 }
416 void xbt_os_thread_mod_exit(void) {
417    
418    if (!TlsFree(xbt_self_thread_key)) 
419      THROW0(system_error,(int)GetLastError(),"TlsFree() failed to cleanup the thread submodule");
420 }
421
422 static DWORD WINAPI  wrapper_start_routine(void *s) {
423   xbt_os_thread_t t = (xbt_os_thread_t)s;
424   void* rv;
425  
426     if(!TlsSetValue(xbt_self_thread_key,t))
427      THROW0(system_error,(int)GetLastError(),"TlsSetValue of data describing the created thread failed");
428    
429    rv = (*(t->start_routine))(t->param);
430
431    return *((DWORD*)rv);
432 }
433
434
435 xbt_os_thread_t xbt_os_thread_create(const char *name,pvoid_f_pvoid_t start_routine,
436                                void* param)  {
437    
438    xbt_os_thread_t t = xbt_new(s_xbt_os_thread_t,1);
439
440    t->name = xbt_strdup(name);
441    t->start_routine = start_routine ;
442    t->param = param;
443    
444    t->handle = CreateThread(NULL,XBT_DEFAULT_THREAD_STACK_SIZE,
445                             (LPTHREAD_START_ROUTINE)wrapper_start_routine,
446                             t,STACK_SIZE_PARAM_IS_A_RESERVATION,&(t->id));
447         
448    if(!t->handle) {
449      xbt_free(t);
450      THROW0(system_error,(int)GetLastError(),"CreateThread failed");
451    }
452    
453    return t;
454 }
455
456 const char* xbt_os_thread_name(xbt_os_thread_t t) {
457    return t->name;
458 }
459
460 const char* xbt_os_thread_self_name(void) {
461    xbt_os_thread_t t = xbt_os_thread_self();
462    return t?t->name:"main";
463 }
464
465 void 
466 xbt_os_thread_join(xbt_os_thread_t thread,void ** thread_return) {
467
468         if(WAIT_OBJECT_0 != WaitForSingleObject(thread->handle,INFINITE))  
469                 THROW0(system_error,(int)GetLastError(), "WaitForSingleObject failed");
470                 
471         if(thread_return){
472                 
473                 if(!GetExitCodeThread(thread->handle,(DWORD*)(*thread_return)))
474                         THROW0(system_error,(int)GetLastError(), "GetExitCodeThread failed");
475         }
476         
477         CloseHandle(thread->handle);
478         free(thread->name);
479         free(thread);
480 }
481
482 void xbt_os_thread_exit(int *retval) {
483    if(retval)
484         ExitThread(*retval);
485    else
486         ExitThread(0);
487 }
488
489 xbt_os_thread_t xbt_os_thread_self(void) {
490    return TlsGetValue(xbt_self_thread_key);
491 }
492
493 void *xbt_os_thread_getparam(void) {
494    xbt_os_thread_t t = xbt_os_thread_self();
495    return t->param;
496 }
497
498
499 void xbt_os_thread_yield(void) {
500     Sleep(0);
501 }
502 void xbt_os_thread_cancel(xbt_os_thread_t t) {
503    THROW_UNIMPLEMENTED;
504 }
505
506 /****** mutex related functions ******/
507 typedef struct xbt_os_mutex_ {
508   /* KEEP IT IN SYNC WITH xbt_thread.c */
509    CRITICAL_SECTION lock;   
510 } s_xbt_os_mutex_t;
511
512 xbt_os_mutex_t xbt_os_mutex_init(void) {
513    xbt_os_mutex_t res = xbt_new(s_xbt_os_mutex_t,1);
514
515    /* initialize the critical section object */
516    InitializeCriticalSection(&(res->lock));
517    
518    return res;
519 }
520
521 void xbt_os_mutex_acquire(xbt_os_mutex_t mutex) {
522
523    EnterCriticalSection(& mutex->lock);
524 }
525
526 void xbt_os_mutex_release(xbt_os_mutex_t mutex) {
527
528    LeaveCriticalSection (& mutex->lock);
529
530 }
531
532 void xbt_os_mutex_destroy(xbt_os_mutex_t mutex) {
533
534    if (!mutex) return;
535    
536    DeleteCriticalSection(& mutex->lock);                
537    free(mutex);
538 }
539
540 /***** condition related functions *****/
541  enum { /* KEEP IT IN SYNC WITH xbt_thread.c */
542     SIGNAL = 0,
543     BROADCAST = 1,
544     MAX_EVENTS = 2
545  };
546
547 typedef struct xbt_os_cond_ {
548   /* KEEP IT IN SYNC WITH xbt_thread.c */
549    HANDLE events[MAX_EVENTS];
550    
551    unsigned int waiters_count;           /* the number of waiters                        */
552    CRITICAL_SECTION waiters_count_lock;  /* protect access to waiters_count  */
553 } s_xbt_os_cond_t;
554
555 xbt_os_cond_t xbt_os_cond_init(void) {
556
557    xbt_os_cond_t res = xbt_new0(s_xbt_os_cond_t,1);
558         
559    memset(& res->waiters_count_lock,0,sizeof(CRITICAL_SECTION));
560         
561    /* initialize the critical section object */
562    InitializeCriticalSection(& res->waiters_count_lock);
563         
564    res->waiters_count = 0;
565         
566    /* Create an auto-reset event */
567    res->events[SIGNAL] = CreateEvent (NULL, FALSE, FALSE, NULL); 
568         
569    if(!res->events[SIGNAL]){
570       DeleteCriticalSection(& res->waiters_count_lock);
571       free(res);
572       THROW0(system_error,0,"CreateEvent failed for the signals");
573    }
574         
575    /* Create a manual-reset event. */
576    res->events[BROADCAST] = CreateEvent (NULL, TRUE, FALSE,NULL);
577         
578    if(!res->events[BROADCAST]){
579                 
580       DeleteCriticalSection(& res->waiters_count_lock);         
581       CloseHandle(res->events[SIGNAL]);
582       free(res); 
583       THROW0(system_error,0,"CreateEvent failed for the broadcasts");
584    }
585
586    return res;
587 }
588
589 void xbt_os_cond_wait(xbt_os_cond_t cond, xbt_os_mutex_t mutex) {
590         
591    unsigned long wait_result;
592    int is_last_waiter;
593
594    /* lock the threads counter and increment it */
595    EnterCriticalSection (& cond->waiters_count_lock);
596    cond->waiters_count++;
597    LeaveCriticalSection (& cond->waiters_count_lock);
598                 
599    /* unlock the mutex associate with the condition */
600    LeaveCriticalSection (& mutex->lock);
601         
602    /* wait for a signal (broadcast or no) */
603    wait_result = WaitForMultipleObjects (2, cond->events, FALSE, INFINITE);
604         
605    if(wait_result == WAIT_FAILED)
606      THROW0(system_error,0,"WaitForMultipleObjects failed, so we cannot wait on the condition");
607         
608    /* we have a signal lock the condition */
609    EnterCriticalSection (& cond->waiters_count_lock);
610    cond->waiters_count--;
611         
612    /* it's the last waiter or it's a broadcast ? */
613    is_last_waiter = ((wait_result == WAIT_OBJECT_0 + BROADCAST - 1) && (cond->waiters_count == 0));
614         
615    LeaveCriticalSection (& cond->waiters_count_lock);
616         
617    /* yes it's the last waiter or it's a broadcast
618     * only reset the manual event (the automatic event is reset in the WaitForMultipleObjects() function
619     * by the system. 
620     */
621    if (is_last_waiter)
622       if(!ResetEvent (cond->events[BROADCAST]))
623         THROW0(system_error,0,"ResetEvent failed");
624         
625    /* relock the mutex associated with the condition in accordance with the posix thread specification */
626    EnterCriticalSection (& mutex->lock);
627 }
628 void xbt_os_cond_timedwait(xbt_os_cond_t cond, xbt_os_mutex_t mutex, double delay) {
629    
630          unsigned long wait_result = WAIT_TIMEOUT;
631    int is_last_waiter;
632    unsigned long end = (unsigned long)(delay * 1000);
633
634
635    if (delay < 0) {
636       xbt_os_cond_wait(cond,mutex);
637    } else {
638           DEBUG3("xbt_cond_timedwait(%p,%p,%ul)",&(cond->events),&(mutex->lock),end);
639
640    /* lock the threads counter and increment it */
641    EnterCriticalSection (& cond->waiters_count_lock);
642    cond->waiters_count++;
643    LeaveCriticalSection (& cond->waiters_count_lock);
644                 
645    /* unlock the mutex associate with the condition */
646    LeaveCriticalSection (& mutex->lock);
647    /* wait for a signal (broadcast or no) */
648         
649    wait_result = WaitForMultipleObjects (2, cond->events, FALSE, end);
650         
651    switch(wait_result) {
652      case WAIT_TIMEOUT:
653         THROW3(timeout_error,GetLastError(),"condition %p (mutex %p) wasn't signaled before timeout (%f)",cond,mutex, delay);
654         case WAIT_FAILED:
655      THROW0(system_error,GetLastError(),"WaitForMultipleObjects failed, so we cannot wait on the condition");
656    }
657         
658    /* we have a signal lock the condition */
659    EnterCriticalSection (& cond->waiters_count_lock);
660    cond->waiters_count--;
661         
662    /* it's the last waiter or it's a broadcast ? */
663    is_last_waiter = ((wait_result == WAIT_OBJECT_0 + BROADCAST - 1) && (cond->waiters_count == 0));
664         
665    LeaveCriticalSection (& cond->waiters_count_lock);
666         
667    /* yes it's the last waiter or it's a broadcast
668     * only reset the manual event (the automatic event is reset in the WaitForMultipleObjects() function
669     * by the system. 
670     */
671    if (is_last_waiter)
672       if(!ResetEvent (cond->events[BROADCAST]))
673         THROW0(system_error,0,"ResetEvent failed");
674         
675    /* relock the mutex associated with the condition in accordance with the posix thread specification */
676    EnterCriticalSection (& mutex->lock);
677    }
678         /*THROW_UNIMPLEMENTED;*/
679 }
680
681 void xbt_os_cond_signal(xbt_os_cond_t cond) {
682    int have_waiters;
683
684    EnterCriticalSection (& cond->waiters_count_lock);
685    have_waiters = cond->waiters_count > 0;
686    LeaveCriticalSection (& cond->waiters_count_lock);
687         
688    if (have_waiters)
689      if(!SetEvent(cond->events[SIGNAL]))
690        THROW0(system_error,0,"SetEvent failed");
691        
692    xbt_os_thread_yield();
693 }
694
695 void xbt_os_cond_broadcast(xbt_os_cond_t cond){
696    int have_waiters;
697
698    EnterCriticalSection (& cond->waiters_count_lock);
699    have_waiters = cond->waiters_count > 0;
700    LeaveCriticalSection (& cond->waiters_count_lock);
701         
702    if (have_waiters)
703      SetEvent(cond->events[BROADCAST]);
704 }
705
706 void xbt_os_cond_destroy(xbt_os_cond_t cond){
707    int error = 0;
708    
709    if (!cond) return;
710    
711    if(!CloseHandle(cond->events[SIGNAL]))
712      error = 1;
713         
714    if(!CloseHandle(cond->events[BROADCAST]))
715      error = 1;
716         
717    DeleteCriticalSection(& cond->waiters_count_lock);
718         
719    xbt_free(cond);
720    
721    if (error)
722      THROW0(system_error,0,"Error while destroying the condition");
723 }
724
725 typedef struct xbt_os_sem_ {
726    HANDLE h;
727    unsigned int value;
728    CRITICAL_SECTION value_lock;  /* protect access to value of the semaphore  */
729 }s_xbt_os_sem_t ;
730
731 xbt_os_sem_t
732 xbt_os_sem_init(unsigned int value)
733 {
734         xbt_os_sem_t res;
735         
736         if(value > INT_MAX)
737         THROW1(arg_error,value,"Semaphore initial value too big: %ud cannot be stored as a signed int",
738             value);
739         
740         res = (xbt_os_sem_t)xbt_new0(s_xbt_os_sem_t,1);
741         
742         if(!(res->h = CreateSemaphore(NULL,value,(long)INT_MAX,NULL))) {
743                 THROW1(system_error,GetLastError(),"CreateSemaphore() failed: %s",
744             strerror(GetLastError()));
745             return NULL;
746         }
747   
748         res->value = value;
749         
750         InitializeCriticalSection(&(res->value_lock));
751    
752         return res;
753 }
754
755 void 
756 xbt_os_sem_acquire(xbt_os_sem_t sem)
757 {
758         if(!sem)
759                 THROW0(arg_error,EINVAL,"Cannot acquire the NULL semaphore");
760
761         /* wait failure */
762         if(WAIT_OBJECT_0 != WaitForSingleObject(sem->h,INFINITE))
763                 THROW1(system_error,GetLastError(),"WaitForSingleObject() failed: %s",
764                 strerror(GetLastError()));
765         EnterCriticalSection(&(sem->value_lock));
766         sem->value--;
767         LeaveCriticalSection(&(sem->value_lock));
768 }
769
770 void xbt_os_sem_timedacquire(xbt_os_sem_t sem, double timeout)
771 {
772         long seconds;
773         long milliseconds;
774         double end = timeout + xbt_os_time();
775         
776         if(!sem)
777                 THROW0(arg_error,EINVAL,"Cannot acquire the NULL semaphore");
778         
779          if (timeout < 0) 
780         {
781                 xbt_os_sem_acquire(sem);
782         } 
783         else 
784         {
785                 
786                 seconds = (long) floor(end);
787                 milliseconds = (long)( ( end - seconds) * 1000);
788                 milliseconds += (seconds * 1000);
789                 
790                 switch(WaitForSingleObject(sem->h,milliseconds))
791                 {
792                         case WAIT_OBJECT_0:
793                         EnterCriticalSection(&(sem->value_lock));
794                         sem->value--;
795                         LeaveCriticalSection(&(sem->value_lock));
796                         return;
797                 
798                         case WAIT_TIMEOUT:
799                         THROW2(timeout_error,GetLastError(),"semaphore %p wasn't signaled before timeout (%f)",sem,timeout);
800                         return;
801                 
802                         default:
803                         
804                         THROW3(system_error,GetLastError(),"WaitForSingleObject(%p,%f) failed: %s",sem,timeout, strerror(GetLastError()));
805                 }
806         }
807 }
808
809 void 
810 xbt_os_sem_release(xbt_os_sem_t sem)
811 {
812         if(!sem)
813                 THROW0(arg_error,EINVAL,"Cannot release the NULL semaphore");
814         
815         if(!ReleaseSemaphore(sem->h,1, NULL)) 
816                 THROW1(system_error,GetLastError(),"ReleaseSemaphore() failed: %s",
817                 strerror(GetLastError()));
818         EnterCriticalSection (&(sem->value_lock));
819         sem->value++;
820         LeaveCriticalSection(&(sem->value_lock));
821 }
822
823 void
824 xbt_os_sem_destroy(xbt_os_sem_t sem)
825 {
826         if(!sem) return;
827         
828         if(!CloseHandle(sem->h)) 
829                 THROW1(system_error,GetLastError(),"CloseHandle() failed: %s",
830                 strerror(GetLastError()));
831          
832          DeleteCriticalSection(&(sem->value_lock));
833                 
834          xbt_free(sem);     
835                 
836 }
837
838 void
839 xbt_os_sem_get_value(xbt_os_sem_t sem, int* svalue)
840 {
841         if(!sem)
842                 THROW0(arg_error,EINVAL,"Cannot get the value of the NULL semaphore");
843         
844         EnterCriticalSection(&(sem->value_lock));  
845         *svalue = sem->value;
846         LeaveCriticalSection(&(sem->value_lock));
847 }
848
849 #endif