src/xbt/xbt_os_thread.c

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