Logo AND Algorithmique Numérique Distribuée

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