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