Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix sem_init testing.
[simgrid.git] / src / xbt / xbt_os_thread.c
1 /* xbt_os_thread -- portability layer over the pthread API                  */
2 /* Used in RL to get win/lin portability, and in SG when CONTEXT_THREAD     */
3 /* in SG, when using CONTEXT_UCONTEXT, xbt_os_thread_stub is used instead   */
4
5 /* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
6  * All rights reserved.                                                     */
7
8 /* This program is free software; you can redistribute it and/or modify it
9  * under the terms of the license (GNU LGPL) which comes with this package. */
10
11 #include "xbt/sysdep.h"
12 #include "xbt/ex.h"
13 #include "xbt/ex_interface.h"   /* We play crude games with exceptions */
14 #include "portable.h"
15 #include "xbt/xbt_os_time.h"    /* Portable time facilities */
16 #include "xbt/xbt_os_thread.h"  /* This module */
17 #include "xbt_modinter.h"       /* Initialization/finalization of this module */
18
19 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_sync_os, xbt,
20                                 "Synchronization mechanism (OS-level)");
21
22 /* ********************************* PTHREAD IMPLEMENTATION ************************************ */
23 #ifdef HAVE_PTHREAD_H
24
25 #include <pthread.h>
26 #include <semaphore.h>
27
28 #ifdef HAVE_MUTEX_TIMEDLOCK
29 /* redefine the function header since we fail to get this from system headers on amd (at least) */
30 int pthread_mutex_timedlock(pthread_mutex_t * mutex,
31                             const struct timespec *abs_timeout);
32 #endif
33
34
35 /* use named sempahore when sem_init() does not work */
36 #ifndef HAVE_SEM_INIT
37 static int next_sem_ID = 0;
38 static xbt_os_mutex_t next_sem_ID_lock;
39 #endif
40
41 typedef struct xbt_os_thread_ {
42   pthread_t t;
43   char *name;
44   void *param;
45   pvoid_f_pvoid_t start_routine;
46   ex_ctx_t *exception;
47 } s_xbt_os_thread_t;
48 static xbt_os_thread_t main_thread = NULL;
49
50 /* thread-specific data containing the xbt_os_thread_t structure */
51 static pthread_key_t xbt_self_thread_key;
52 static int thread_mod_inited = 0;
53
54 /* frees the xbt_os_thread_t corresponding to the current thread */
55 static void xbt_os_thread_free_thread_data(void *d)
56 {
57   free(d);
58 }
59
60 /* callback: context fetching */
61 static ex_ctx_t *_os_thread_ex_ctx(void)
62 {
63   return xbt_os_thread_self()->exception;
64 }
65
66 /* callback: termination */
67 static void _os_thread_ex_terminate(xbt_ex_t * e)
68 {
69   xbt_ex_display(e);
70
71   abort();
72   /* FIXME: there should be a configuration variable to choose to kill everyone or only this one */
73 }
74
75 void xbt_os_thread_mod_preinit(void)
76 {
77   int errcode;
78
79   if (thread_mod_inited)
80     return;
81
82   if ((errcode = pthread_key_create(&xbt_self_thread_key, NULL)))
83     THROW0(system_error, errcode,
84            "pthread_key_create failed for xbt_self_thread_key");
85
86   main_thread = xbt_new(s_xbt_os_thread_t, 1);
87   main_thread->name = (char *) "main";
88   main_thread->start_routine = NULL;
89   main_thread->param = NULL;
90   main_thread->exception = xbt_new(ex_ctx_t, 1);
91   XBT_CTX_INITIALIZE(main_thread->exception);
92
93   __xbt_ex_ctx = _os_thread_ex_ctx;
94   __xbt_ex_terminate = _os_thread_ex_terminate;
95
96   thread_mod_inited = 1;
97
98 #ifndef HAVE_SEM_INIT
99   next_sem_ID_lock = xbt_os_mutex_init();
100 #endif
101
102 }
103
104 void xbt_os_thread_mod_postexit(void)
105 {
106   /* FIXME: don't try to free our key on shutdown.
107      Valgrind detects no leak if we don't, and whine if we try to */
108   //   int errcode;
109
110   //   if ((errcode=pthread_key_delete(xbt_self_thread_key)))
111   //     THROW0(system_error,errcode,"pthread_key_delete failed for xbt_self_thread_key");
112   free(main_thread->exception);
113   free(main_thread);
114   main_thread = NULL;
115   thread_mod_inited = 0;
116 #ifndef HAVE_SEM_INIT
117   xbt_os_mutex_destroy(next_sem_ID_lock);
118 #endif
119
120   /* Restore the default exception setup */
121   __xbt_ex_ctx = &__xbt_ex_ctx_default;
122   __xbt_ex_terminate = &__xbt_ex_terminate_default;
123 }
124
125 int xbt_os_thread_atfork(void (*prepare)(void),
126                          void (*parent)(void), void (*child)(void))
127 {
128   return pthread_atfork(prepare, parent, child);
129 }
130
131 static void *wrapper_start_routine(void *s)
132 {
133   xbt_os_thread_t t = s;
134   int errcode;
135
136   if ((errcode = pthread_setspecific(xbt_self_thread_key, t)))
137     THROW0(system_error, errcode,
138            "pthread_setspecific failed for xbt_self_thread_key");
139
140   return (*(t->start_routine)) (t->param);
141 }
142
143 xbt_os_thread_t xbt_os_thread_create(const char *name,
144                                      pvoid_f_pvoid_t start_routine,
145                                      void *param)
146 {
147   int errcode;
148
149   xbt_os_thread_t res_thread = xbt_new(s_xbt_os_thread_t, 1);
150   res_thread->name = xbt_strdup(name);
151   res_thread->start_routine = start_routine;
152   res_thread->param = param;
153   res_thread->exception = xbt_new(ex_ctx_t, 1);
154   XBT_CTX_INITIALIZE(res_thread->exception);
155
156   if ((errcode = pthread_create(&(res_thread->t), NULL,
157                                 wrapper_start_routine, res_thread)))
158     THROW1(system_error, errcode,
159            "pthread_create failed: %s", strerror(errcode));
160
161   return res_thread;
162 }
163
164 const char *xbt_os_thread_name(xbt_os_thread_t t)
165 {
166   return t->name;
167 }
168
169 const char *xbt_os_thread_self_name(void)
170 {
171   xbt_os_thread_t me = xbt_os_thread_self();
172   return me ? me->name : "main";
173 }
174
175 void xbt_os_thread_join(xbt_os_thread_t thread, void **thread_return)
176 {
177
178   int errcode;
179
180   if ((errcode = pthread_join(thread->t, thread_return)))
181     THROW1(system_error, errcode, "pthread_join failed: %s",
182            strerror(errcode));
183   if (thread->exception)
184     free(thread->exception);
185
186   if (thread->name)
187     free(thread->name);
188
189   if (thread == main_thread)    /* just killed main thread */
190     main_thread = NULL;
191
192   free(thread);
193 }
194
195 void xbt_os_thread_exit(int *retval)
196 {
197   pthread_exit(retval);
198 }
199
200 xbt_os_thread_t xbt_os_thread_self(void)
201 {
202   xbt_os_thread_t res;
203
204   if (!thread_mod_inited)
205     return NULL;
206
207   res = pthread_getspecific(xbt_self_thread_key);
208   if (!res)
209     res = main_thread;
210
211   return res;
212 }
213
214 #include <sched.h>
215 void xbt_os_thread_yield(void)
216 {
217   sched_yield();
218 }
219
220 void xbt_os_thread_cancel(xbt_os_thread_t t)
221 {
222   pthread_cancel(t->t);
223 }
224
225 /****** mutex related functions ******/
226 typedef struct xbt_os_mutex_ {
227   /* KEEP IT IN SYNC WITH xbt_thread.c */
228   pthread_mutex_t m;
229 } s_xbt_os_mutex_t;
230
231 #include <time.h>
232 #include <math.h>
233
234 xbt_os_mutex_t xbt_os_mutex_init(void)
235 {
236   xbt_os_mutex_t res = xbt_new(s_xbt_os_mutex_t, 1);
237   int errcode;
238
239   if ((errcode = pthread_mutex_init(&(res->m), NULL)))
240     THROW1(system_error, errcode, "pthread_mutex_init() failed: %s",
241            strerror(errcode));
242
243   return res;
244 }
245
246 void xbt_os_mutex_acquire(xbt_os_mutex_t mutex)
247 {
248   int errcode;
249
250   if ((errcode = pthread_mutex_lock(&(mutex->m))))
251     THROW2(system_error, errcode, "pthread_mutex_lock(%p) failed: %s",
252            mutex, strerror(errcode));
253 }
254
255
256 void xbt_os_mutex_timedacquire(xbt_os_mutex_t mutex, double delay)
257 {
258   int errcode;
259
260   if (delay < 0) {
261     xbt_os_mutex_acquire(mutex);
262
263   } else if (delay == 0) {
264     errcode = pthread_mutex_trylock(&(mutex->m));
265
266     switch (errcode) {
267     case 0:
268       return;
269     case ETIMEDOUT:
270       THROW1(timeout_error, 0, "mutex %p not ready", mutex);
271     default:
272       THROW2(system_error, errcode,
273              "xbt_mutex_timedacquire(%p) failed: %s", mutex,
274              strerror(errcode));
275     }
276
277
278   } else {
279
280 #ifdef HAVE_MUTEX_TIMEDLOCK
281     struct timespec ts_end;
282     double end = delay + xbt_os_time();
283
284     ts_end.tv_sec = (time_t) floor(end);
285     ts_end.tv_nsec = (long) ((end - ts_end.tv_sec) * 1000000000);
286     DEBUG2("pthread_mutex_timedlock(%p,%p)", &(mutex->m), &ts_end);
287
288     errcode = pthread_mutex_timedlock(&(mutex->m), &ts_end);
289
290 #else                           /* Well, let's reimplement it since those lazy libc dudes didn't */
291     double start = xbt_os_time();
292     do {
293       errcode = pthread_mutex_trylock(&(mutex->m));
294       if (errcode == EBUSY)
295         xbt_os_thread_yield();
296     } while (errcode == EBUSY && xbt_os_time() - start < delay);
297
298     if (errcode == EBUSY)
299       errcode = ETIMEDOUT;
300
301 #endif                          /* HAVE_MUTEX_TIMEDLOCK */
302
303     switch (errcode) {
304     case 0:
305       return;
306
307     case ETIMEDOUT:
308       THROW2(timeout_error, delay,
309              "mutex %p wasn't signaled before timeout (%f)", mutex, delay);
310
311     default:
312       THROW3(system_error, errcode,
313              "pthread_mutex_timedlock(%p,%f) failed: %s", mutex, delay,
314              strerror(errcode));
315     }
316   }
317 }
318
319 void xbt_os_mutex_release(xbt_os_mutex_t mutex)
320 {
321   int errcode;
322
323   if ((errcode = pthread_mutex_unlock(&(mutex->m))))
324     THROW2(system_error, errcode, "pthread_mutex_unlock(%p) failed: %s",
325            mutex, strerror(errcode));
326 }
327
328 void xbt_os_mutex_destroy(xbt_os_mutex_t mutex)
329 {
330   int errcode;
331
332   if (!mutex)
333     return;
334
335   if ((errcode = pthread_mutex_destroy(&(mutex->m))))
336     THROW2(system_error, errcode, "pthread_mutex_destroy(%p) failed: %s",
337            mutex, strerror(errcode));
338   free(mutex);
339 }
340
341 /***** condition related functions *****/
342 typedef struct xbt_os_cond_ {
343   /* KEEP IT IN SYNC WITH xbt_thread.c */
344   pthread_cond_t c;
345 } s_xbt_os_cond_t;
346
347 xbt_os_cond_t xbt_os_cond_init(void)
348 {
349   xbt_os_cond_t res = xbt_new(s_xbt_os_cond_t, 1);
350   int errcode;
351   if ((errcode = pthread_cond_init(&(res->c), NULL)))
352     THROW1(system_error, errcode, "pthread_cond_init() failed: %s",
353            strerror(errcode));
354
355   return res;
356 }
357
358 void xbt_os_cond_wait(xbt_os_cond_t cond, xbt_os_mutex_t mutex)
359 {
360   int errcode;
361   if ((errcode = pthread_cond_wait(&(cond->c), &(mutex->m))))
362     THROW3(system_error, errcode, "pthread_cond_wait(%p,%p) failed: %s",
363            cond, mutex, strerror(errcode));
364 }
365
366
367 void xbt_os_cond_timedwait(xbt_os_cond_t cond, xbt_os_mutex_t mutex,
368                            double delay)
369 {
370   int errcode;
371   struct timespec ts_end;
372   double end = delay + xbt_os_time();
373
374   if (delay < 0) {
375     xbt_os_cond_wait(cond, mutex);
376   } else {
377     ts_end.tv_sec = (time_t) floor(end);
378     ts_end.tv_nsec = (long) ((end - ts_end.tv_sec) * 1000000000);
379     DEBUG3("pthread_cond_timedwait(%p,%p,%p)", &(cond->c), &(mutex->m),
380            &ts_end);
381     switch ((errcode =
382              pthread_cond_timedwait(&(cond->c), &(mutex->m), &ts_end))) {
383     case 0:
384       return;
385     case ETIMEDOUT:
386       THROW3(timeout_error, errcode,
387              "condition %p (mutex %p) wasn't signaled before timeout (%f)",
388              cond, mutex, delay);
389     default:
390       THROW4(system_error, errcode,
391              "pthread_cond_timedwait(%p,%p,%f) failed: %s", cond, mutex,
392              delay, strerror(errcode));
393     }
394   }
395 }
396
397 void xbt_os_cond_signal(xbt_os_cond_t cond)
398 {
399   int errcode;
400   if ((errcode = pthread_cond_signal(&(cond->c))))
401     THROW2(system_error, errcode, "pthread_cond_signal(%p) failed: %s",
402            cond, strerror(errcode));
403 }
404
405 void xbt_os_cond_broadcast(xbt_os_cond_t cond)
406 {
407   int errcode;
408   if ((errcode = pthread_cond_broadcast(&(cond->c))))
409     THROW2(system_error, errcode, "pthread_cond_broadcast(%p) failed: %s",
410            cond, strerror(errcode));
411 }
412
413 void xbt_os_cond_destroy(xbt_os_cond_t cond)
414 {
415   int errcode;
416
417   if (!cond)
418     return;
419
420   if ((errcode = pthread_cond_destroy(&(cond->c))))
421     THROW2(system_error, errcode, "pthread_cond_destroy(%p) failed: %s",
422            cond, strerror(errcode));
423   free(cond);
424 }
425
426 void *xbt_os_thread_getparam(void)
427 {
428   xbt_os_thread_t t = xbt_os_thread_self();
429   return t ? t->param : NULL;
430 }
431
432 typedef struct xbt_os_sem_ {
433 #ifndef HAVE_SEM_INIT
434   char *name;
435 #endif
436   sem_t s;
437   sem_t *ps;
438 } s_xbt_os_sem_t;
439
440 #ifndef SEM_FAILED
441 #define SEM_FAILED (-1)
442 #endif
443
444 xbt_os_sem_t xbt_os_sem_init(unsigned int value)
445 {
446   xbt_os_sem_t res = xbt_new(s_xbt_os_sem_t, 1);
447
448   /* On some systems (MAC OS X), only the stub of sem_init is to be found.
449    * Any attempt to use it leads to ENOSYS (function not implemented).
450    * If such a prehistoric system is detected, do the job with sem_open instead
451    */
452 #ifdef HAVE_SEM_INIT
453   if (sem_init(&(res->s), 0, value) != 0)
454     THROW1(system_error, errno, "sem_init() failed: %s", strerror(errno));
455   res->ps = &(res->s);
456
457 #else                           /* damn, no sem_init(). Reimplement it */
458
459   xbt_os_mutex_acquire(next_sem_ID_lock);
460   res->name = bprintf("/%d.%d", (*xbt_getpid) (), ++next_sem_ID);
461   xbt_os_mutex_release(next_sem_ID_lock);
462
463   res->ps = sem_open(res->name, O_CREAT, 0644, value);
464   if ((res->ps == (sem_t *) SEM_FAILED) && (errno == ENAMETOOLONG)) {
465     /* Old darwins only allow 13 chars. Did you create *that* amount of semaphores? */
466     res->name[13] = '\0';
467     res->ps = sem_open(res->name, O_CREAT, 0644, 1);
468   }
469   if ((res->ps == (sem_t *) SEM_FAILED))
470     THROW1(system_error, errno, "sem_open() failed: %s", strerror(errno));
471
472   /* Remove the name from the semaphore namespace: we never join on it */
473   if (sem_unlink(res->name) < 0)
474     THROW1(system_error, errno, "sem_unlink() failed: %s",
475            strerror(errno));
476
477 #endif
478
479   return res;
480 }
481
482 void xbt_os_sem_acquire(xbt_os_sem_t sem)
483 {
484   if (!sem)
485     THROW0(arg_error, EINVAL, "Cannot acquire of the NULL semaphore");
486   if (sem_wait(sem->ps) < 0)
487     THROW1(system_error, errno, "sem_wait() failed: %s", strerror(errno));
488 }
489
490 void xbt_os_sem_timedacquire(xbt_os_sem_t sem, double delay)
491 {
492   int errcode;
493
494   if (!sem)
495     THROW0(arg_error, EINVAL, "Cannot acquire of the NULL semaphore");
496
497   if (delay < 0) {
498     xbt_os_sem_acquire(sem);
499   } else if (delay == 0) {
500     errcode = sem_trywait(sem->ps);
501
502     switch (errcode) {
503     case 0:
504       return;
505     case ETIMEDOUT:
506       THROW1(timeout_error, 0, "semaphore %p not ready", sem);
507     default:
508       THROW2(system_error, errcode,
509              "xbt_os_sem_timedacquire(%p) failed: %s", sem,
510              strerror(errcode));
511     }
512
513   } else {
514 #ifdef HAVE_SEM_WAIT
515     struct timespec ts_end;
516     double end = delay + xbt_os_time();
517
518     ts_end.tv_sec = (time_t) floor(end);
519     ts_end.tv_nsec = (long) ((end - ts_end.tv_sec) * 1000000000);
520     DEBUG2("sem_timedwait(%p,%p)", sem->ps, &ts_end);
521     errcode = sem_timedwait(sem->s, &ts_end);
522
523 #else                           /* Okay, reimplement this function then */
524     double start = xbt_os_time();
525     do {
526       errcode = sem_trywait(sem->ps);
527       if (errcode == EBUSY)
528         xbt_os_thread_yield();
529     } while (errcode == EBUSY && xbt_os_time() - start < delay);
530
531     if (errcode == EBUSY)
532       errcode = ETIMEDOUT;
533 #endif
534
535     switch (errcode) {
536     case 0:
537       return;
538
539     case ETIMEDOUT:
540       THROW2(timeout_error, delay,
541              "semaphore %p wasn't signaled before timeout (%f)", sem,
542              delay);
543
544     default:
545       THROW3(system_error, errcode, "sem_timedwait(%p,%f) failed: %s", sem,
546              delay, strerror(errcode));
547     }
548   }
549 }
550
551 void xbt_os_sem_release(xbt_os_sem_t sem)
552 {
553   if (!sem)
554     THROW0(arg_error, EINVAL, "Cannot release of the NULL semaphore");
555
556   if (sem_post(sem->ps) < 0)
557     THROW1(system_error, errno, "sem_post() failed: %s", strerror(errno));
558 }
559
560 void xbt_os_sem_destroy(xbt_os_sem_t sem)
561 {
562   if (!sem)
563     THROW0(arg_error, EINVAL, "Cannot destroy the NULL sempahore");
564
565 #ifdef HAVE_SEM_INIT
566   if (sem_destroy(sem->ps) < 0)
567     THROW1(system_error, errno, "sem_destroy() failed: %s",
568            strerror(errno));
569 #else
570   if (sem_close(sem->ps) < 0)
571     THROW1(system_error, errno, "sem_close() failed: %s", strerror(errno));
572   xbt_free(sem->name);
573
574 #endif
575   xbt_free(sem);
576 }
577
578 void xbt_os_sem_get_value(xbt_os_sem_t sem, int *svalue)
579 {
580   if (!sem)
581     THROW0(arg_error, EINVAL,
582            "Cannot get the value of the NULL semaphore");
583
584   if (sem_getvalue(&(sem->s), svalue) < 0)
585     THROW1(system_error, errno, "sem_getvalue() failed: %s",
586            strerror(errno));
587 }
588
589 /* ********************************* WINDOWS IMPLEMENTATION ************************************ */
590
591 #elif defined(_XBT_WIN32)
592
593 #include <math.h>
594
595 typedef struct xbt_os_thread_ {
596   char *name;
597   HANDLE handle;                /* the win thread handle        */
598   unsigned long id;             /* the win thread id            */
599   pvoid_f_pvoid_t start_routine;
600   void *param;
601 } s_xbt_os_thread_t;
602
603 /* so we can specify the size of the stack of the threads */
604 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
605 #define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000
606 #endif
607
608 /* the default size of the stack of the threads (in bytes)*/
609 #define XBT_DEFAULT_THREAD_STACK_SIZE   4096
610
611 /* key to the TLS containing the xbt_os_thread_t structure */
612 static unsigned long xbt_self_thread_key;
613
614 void xbt_os_thread_mod_preinit(void)
615 {
616   xbt_self_thread_key = TlsAlloc();
617 }
618
619 void xbt_os_thread_mod_postexit(void)
620 {
621
622   if (!TlsFree(xbt_self_thread_key))
623     THROW0(system_error, (int) GetLastError(),
624            "TlsFree() failed to cleanup the thread submodule");
625 }
626
627 int xbt_os_thread_atfork(void (*prepare)(void),
628                          void (*parent)(void), void (*child)(void))
629 {
630   return 0;
631 }
632
633 static DWORD WINAPI wrapper_start_routine(void *s)
634 {
635   xbt_os_thread_t t = (xbt_os_thread_t) s;
636   DWORD *rv;
637
638   if (!TlsSetValue(xbt_self_thread_key, t))
639     THROW0(system_error, (int) GetLastError(),
640            "TlsSetValue of data describing the created thread failed");
641
642   rv = (DWORD *) ((t->start_routine) (t->param));
643
644   return rv ? *rv : 0;
645
646 }
647
648
649 xbt_os_thread_t xbt_os_thread_create(const char *name,
650                                      pvoid_f_pvoid_t start_routine,
651                                      void *param)
652 {
653
654   xbt_os_thread_t t = xbt_new(s_xbt_os_thread_t, 1);
655
656   t->name = xbt_strdup(name);
657   t->start_routine = start_routine;
658   t->param = param;
659
660   t->handle = CreateThread(NULL, XBT_DEFAULT_THREAD_STACK_SIZE,
661                            (LPTHREAD_START_ROUTINE) wrapper_start_routine,
662                            t, STACK_SIZE_PARAM_IS_A_RESERVATION, &(t->id));
663
664   if (!t->handle) {
665     xbt_free(t);
666     THROW0(system_error, (int) GetLastError(), "CreateThread failed");
667   }
668
669   return t;
670 }
671
672 const char *xbt_os_thread_name(xbt_os_thread_t t)
673 {
674   return t->name;
675 }
676
677 const char *xbt_os_thread_self_name(void)
678 {
679   xbt_os_thread_t t = xbt_os_thread_self();
680   return t ? t->name : "main";
681 }
682
683 void xbt_os_thread_join(xbt_os_thread_t thread, void **thread_return)
684 {
685
686   if (WAIT_OBJECT_0 != WaitForSingleObject(thread->handle, INFINITE))
687     THROW0(system_error, (int) GetLastError(),
688            "WaitForSingleObject failed");
689
690   if (thread_return) {
691
692     if (!GetExitCodeThread(thread->handle, (DWORD *) (*thread_return)))
693       THROW0(system_error, (int) GetLastError(),
694              "GetExitCodeThread failed");
695   }
696
697   CloseHandle(thread->handle);
698
699   if (thread->name)
700     free(thread->name);
701
702   free(thread);
703 }
704
705 void xbt_os_thread_exit(int *retval)
706 {
707   if (retval)
708     ExitThread(*retval);
709   else
710     ExitThread(0);
711 }
712
713 xbt_os_thread_t xbt_os_thread_self(void)
714 {
715   return TlsGetValue(xbt_self_thread_key);
716 }
717
718 void *xbt_os_thread_getparam(void)
719 {
720   xbt_os_thread_t t = xbt_os_thread_self();
721   return t->param;
722 }
723
724
725 void xbt_os_thread_yield(void)
726 {
727   Sleep(0);
728 }
729
730 void xbt_os_thread_cancel(xbt_os_thread_t t)
731 {
732   if (!TerminateThread(t->handle, 0))
733     THROW0(system_error, (int) GetLastError(), "TerminateThread failed");
734 }
735
736 /****** mutex related functions ******/
737 typedef struct xbt_os_mutex_ {
738   /* KEEP IT IN SYNC WITH xbt_thread.c */
739   CRITICAL_SECTION lock;
740 } s_xbt_os_mutex_t;
741
742 xbt_os_mutex_t xbt_os_mutex_init(void)
743 {
744   xbt_os_mutex_t res = xbt_new(s_xbt_os_mutex_t, 1);
745
746   /* initialize the critical section object */
747   InitializeCriticalSection(&(res->lock));
748
749   return res;
750 }
751
752 void xbt_os_mutex_acquire(xbt_os_mutex_t mutex)
753 {
754   EnterCriticalSection(&mutex->lock);
755 }
756
757 void xbt_os_mutex_timedacquire(xbt_os_mutex_t mutex, double delay)
758 {
759   THROW_UNIMPLEMENTED;
760 }
761
762 void xbt_os_mutex_release(xbt_os_mutex_t mutex)
763 {
764
765   LeaveCriticalSection(&mutex->lock);
766
767 }
768
769 void xbt_os_mutex_destroy(xbt_os_mutex_t mutex)
770 {
771
772   if (!mutex)
773     return;
774
775   DeleteCriticalSection(&mutex->lock);
776   free(mutex);
777 }
778
779 /***** condition related functions *****/
780 enum {                          /* KEEP IT IN SYNC WITH xbt_thread.c */
781   SIGNAL = 0,
782   BROADCAST = 1,
783   MAX_EVENTS = 2
784 };
785
786 typedef struct xbt_os_cond_ {
787   /* KEEP IT IN SYNC WITH xbt_thread.c */
788   HANDLE events[MAX_EVENTS];
789
790   unsigned int waiters_count;   /* the number of waiters                        */
791   CRITICAL_SECTION waiters_count_lock;  /* protect access to waiters_count  */
792 } s_xbt_os_cond_t;
793
794 xbt_os_cond_t xbt_os_cond_init(void)
795 {
796
797   xbt_os_cond_t res = xbt_new0(s_xbt_os_cond_t, 1);
798
799   memset(&res->waiters_count_lock, 0, sizeof(CRITICAL_SECTION));
800
801   /* initialize the critical section object */
802   InitializeCriticalSection(&res->waiters_count_lock);
803
804   res->waiters_count = 0;
805
806   /* Create an auto-reset event */
807   res->events[SIGNAL] = CreateEvent(NULL, FALSE, FALSE, NULL);
808
809   if (!res->events[SIGNAL]) {
810     DeleteCriticalSection(&res->waiters_count_lock);
811     free(res);
812     THROW0(system_error, 0, "CreateEvent failed for the signals");
813   }
814
815   /* Create a manual-reset event. */
816   res->events[BROADCAST] = CreateEvent(NULL, TRUE, FALSE, NULL);
817
818   if (!res->events[BROADCAST]) {
819
820     DeleteCriticalSection(&res->waiters_count_lock);
821     CloseHandle(res->events[SIGNAL]);
822     free(res);
823     THROW0(system_error, 0, "CreateEvent failed for the broadcasts");
824   }
825
826   return res;
827 }
828
829 void xbt_os_cond_wait(xbt_os_cond_t cond, xbt_os_mutex_t mutex)
830 {
831
832   unsigned long wait_result;
833   int is_last_waiter;
834
835   /* lock the threads counter and increment it */
836   EnterCriticalSection(&cond->waiters_count_lock);
837   cond->waiters_count++;
838   LeaveCriticalSection(&cond->waiters_count_lock);
839
840   /* unlock the mutex associate with the condition */
841   LeaveCriticalSection(&mutex->lock);
842
843   /* wait for a signal (broadcast or no) */
844   wait_result = WaitForMultipleObjects(2, cond->events, FALSE, INFINITE);
845
846   if (wait_result == WAIT_FAILED)
847     THROW0(system_error, 0,
848            "WaitForMultipleObjects failed, so we cannot wait on the condition");
849
850   /* we have a signal lock the condition */
851   EnterCriticalSection(&cond->waiters_count_lock);
852   cond->waiters_count--;
853
854   /* it's the last waiter or it's a broadcast ? */
855   is_last_waiter = ((wait_result == WAIT_OBJECT_0 + BROADCAST - 1)
856                     && (cond->waiters_count == 0));
857
858   LeaveCriticalSection(&cond->waiters_count_lock);
859
860   /* yes it's the last waiter or it's a broadcast
861    * only reset the manual event (the automatic event is reset in the WaitForMultipleObjects() function
862    * by the system.
863    */
864   if (is_last_waiter)
865     if (!ResetEvent(cond->events[BROADCAST]))
866       THROW0(system_error, 0, "ResetEvent failed");
867
868   /* relock the mutex associated with the condition in accordance with the posix thread specification */
869   EnterCriticalSection(&mutex->lock);
870 }
871
872 void xbt_os_cond_timedwait(xbt_os_cond_t cond, xbt_os_mutex_t mutex,
873                            double delay)
874 {
875
876   unsigned long wait_result = WAIT_TIMEOUT;
877   int is_last_waiter;
878   unsigned long end = (unsigned long) (delay * 1000);
879
880
881   if (delay < 0) {
882     xbt_os_cond_wait(cond, mutex);
883   } else {
884     DEBUG3("xbt_cond_timedwait(%p,%p,%lu)", &(cond->events),
885            &(mutex->lock), end);
886
887     /* lock the threads counter and increment it */
888     EnterCriticalSection(&cond->waiters_count_lock);
889     cond->waiters_count++;
890     LeaveCriticalSection(&cond->waiters_count_lock);
891
892     /* unlock the mutex associate with the condition */
893     LeaveCriticalSection(&mutex->lock);
894     /* wait for a signal (broadcast or no) */
895
896     wait_result = WaitForMultipleObjects(2, cond->events, FALSE, end);
897
898     switch (wait_result) {
899     case WAIT_TIMEOUT:
900       THROW3(timeout_error, GetLastError(),
901              "condition %p (mutex %p) wasn't signaled before timeout (%f)",
902              cond, mutex, delay);
903     case WAIT_FAILED:
904       THROW0(system_error, GetLastError(),
905              "WaitForMultipleObjects failed, so we cannot wait on the condition");
906     }
907
908     /* we have a signal lock the condition */
909     EnterCriticalSection(&cond->waiters_count_lock);
910     cond->waiters_count--;
911
912     /* it's the last waiter or it's a broadcast ? */
913     is_last_waiter = ((wait_result == WAIT_OBJECT_0 + BROADCAST - 1)
914                       && (cond->waiters_count == 0));
915
916     LeaveCriticalSection(&cond->waiters_count_lock);
917
918     /* yes it's the last waiter or it's a broadcast
919      * only reset the manual event (the automatic event is reset in the WaitForMultipleObjects() function
920      * by the system.
921      */
922     if (is_last_waiter)
923       if (!ResetEvent(cond->events[BROADCAST]))
924         THROW0(system_error, 0, "ResetEvent failed");
925
926     /* relock the mutex associated with the condition in accordance with the posix thread specification */
927     EnterCriticalSection(&mutex->lock);
928   }
929   /*THROW_UNIMPLEMENTED; */
930 }
931
932 void xbt_os_cond_signal(xbt_os_cond_t cond)
933 {
934   int have_waiters;
935
936   EnterCriticalSection(&cond->waiters_count_lock);
937   have_waiters = cond->waiters_count > 0;
938   LeaveCriticalSection(&cond->waiters_count_lock);
939
940   if (have_waiters)
941     if (!SetEvent(cond->events[SIGNAL]))
942       THROW0(system_error, 0, "SetEvent failed");
943
944   xbt_os_thread_yield();
945 }
946
947 void xbt_os_cond_broadcast(xbt_os_cond_t cond)
948 {
949   int have_waiters;
950
951   EnterCriticalSection(&cond->waiters_count_lock);
952   have_waiters = cond->waiters_count > 0;
953   LeaveCriticalSection(&cond->waiters_count_lock);
954
955   if (have_waiters)
956     SetEvent(cond->events[BROADCAST]);
957 }
958
959 void xbt_os_cond_destroy(xbt_os_cond_t cond)
960 {
961   int error = 0;
962
963   if (!cond)
964     return;
965
966   if (!CloseHandle(cond->events[SIGNAL]))
967     error = 1;
968
969   if (!CloseHandle(cond->events[BROADCAST]))
970     error = 1;
971
972   DeleteCriticalSection(&cond->waiters_count_lock);
973
974   xbt_free(cond);
975
976   if (error)
977     THROW0(system_error, 0, "Error while destroying the condition");
978 }
979
980 typedef struct xbt_os_sem_ {
981   HANDLE h;
982   unsigned int value;
983   CRITICAL_SECTION value_lock;  /* protect access to value of the semaphore  */
984 } s_xbt_os_sem_t;
985
986 #ifndef INT_MAX
987 # define INT_MAX 32767          /* let's be safe by underestimating this value: this is for 16bits only */
988 #endif
989
990 xbt_os_sem_t xbt_os_sem_init(unsigned int value)
991 {
992   xbt_os_sem_t res;
993
994   if (value > INT_MAX)
995     THROW1(arg_error, value,
996            "Semaphore initial value too big: %ud cannot be stored as a signed int",
997            value);
998
999   res = (xbt_os_sem_t) xbt_new0(s_xbt_os_sem_t, 1);
1000
1001   if (!(res->h = CreateSemaphore(NULL, value, (long) INT_MAX, NULL))) {
1002     THROW1(system_error, GetLastError(), "CreateSemaphore() failed: %s",
1003            strerror(GetLastError()));
1004     return NULL;
1005   }
1006
1007   res->value = value;
1008
1009   InitializeCriticalSection(&(res->value_lock));
1010
1011   return res;
1012 }
1013
1014 void xbt_os_sem_acquire(xbt_os_sem_t sem)
1015 {
1016   if (!sem)
1017     THROW0(arg_error, EINVAL, "Cannot acquire the NULL semaphore");
1018
1019   /* wait failure */
1020   if (WAIT_OBJECT_0 != WaitForSingleObject(sem->h, INFINITE))
1021     THROW1(system_error, GetLastError(),
1022            "WaitForSingleObject() failed: %s", strerror(GetLastError()));
1023   EnterCriticalSection(&(sem->value_lock));
1024   sem->value--;
1025   LeaveCriticalSection(&(sem->value_lock));
1026 }
1027
1028 void xbt_os_sem_timedacquire(xbt_os_sem_t sem, double timeout)
1029 {
1030   long seconds;
1031   long milliseconds;
1032   double end = timeout + xbt_os_time();
1033
1034   if (!sem)
1035     THROW0(arg_error, EINVAL, "Cannot acquire the NULL semaphore");
1036
1037   if (timeout < 0) {
1038     xbt_os_sem_acquire(sem);
1039   } else {                      /* timeout can be zero <-> try acquire ) */
1040
1041
1042     seconds = (long) floor(end);
1043     milliseconds = (long) ((end - seconds) * 1000);
1044     milliseconds += (seconds * 1000);
1045
1046     switch (WaitForSingleObject(sem->h, milliseconds)) {
1047     case WAIT_OBJECT_0:
1048       EnterCriticalSection(&(sem->value_lock));
1049       sem->value--;
1050       LeaveCriticalSection(&(sem->value_lock));
1051       return;
1052
1053     case WAIT_TIMEOUT:
1054       THROW2(timeout_error, GetLastError(),
1055              "semaphore %p wasn't signaled before timeout (%f)", sem,
1056              timeout);
1057       return;
1058
1059     default:
1060       THROW3(system_error, GetLastError(),
1061              "WaitForSingleObject(%p,%f) failed: %s", sem, timeout,
1062              strerror(GetLastError()));
1063     }
1064   }
1065 }
1066
1067 void xbt_os_sem_release(xbt_os_sem_t sem)
1068 {
1069   if (!sem)
1070     THROW0(arg_error, EINVAL, "Cannot release the NULL semaphore");
1071
1072   if (!ReleaseSemaphore(sem->h, 1, NULL))
1073     THROW1(system_error, GetLastError(), "ReleaseSemaphore() failed: %s",
1074            strerror(GetLastError()));
1075   EnterCriticalSection(&(sem->value_lock));
1076   sem->value++;
1077   LeaveCriticalSection(&(sem->value_lock));
1078 }
1079
1080 void xbt_os_sem_destroy(xbt_os_sem_t sem)
1081 {
1082   if (!sem)
1083     THROW0(arg_error, EINVAL, "Cannot destroy the NULL semaphore");
1084
1085   if (!CloseHandle(sem->h))
1086     THROW1(system_error, GetLastError(), "CloseHandle() failed: %s",
1087            strerror(GetLastError()));
1088
1089   DeleteCriticalSection(&(sem->value_lock));
1090
1091   xbt_free(sem);
1092
1093 }
1094
1095 void xbt_os_sem_get_value(xbt_os_sem_t sem, int *svalue)
1096 {
1097   if (!sem)
1098     THROW0(arg_error, EINVAL,
1099            "Cannot get the value of the NULL semaphore");
1100
1101   EnterCriticalSection(&(sem->value_lock));
1102   *svalue = sem->value;
1103   LeaveCriticalSection(&(sem->value_lock));
1104 }
1105
1106 #endif