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