deps/libretro-common/rthreads/rthreads.c

   1 /* Copyright  (C) 2010-2020 The RetroArch team
   2  *
   3  * ---------------------------------------------------------------------------------------
   4  * The following license statement only applies to this file (rthreads.c).
   5  * ---------------------------------------------------------------------------------------
   6  *
   7  * Permission is hereby granted, free of charge,
   8  * to any person obtaining a copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation the rights to
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
  11  * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  16  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  19  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 #ifdef __unix__
  24 #ifndef __sun__
  25 #define _POSIX_C_SOURCE 199309
  26 #endif
  27 #endif
  28
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include <boolean.h>
  33 #include <rthreads/rthreads.h>
  34
  35 /* with RETRO_WIN32_USE_PTHREADS, pthreads can be used even on win32. Maybe only supported in MSVC>=2005  */
  36
  37 #if defined(_WIN32) && !defined(RETRO_WIN32_USE_PTHREADS)
  38 #define USE_WIN32_THREADS
  39 #ifdef _XBOX
  40 #include <xtl.h>
  41 #else
  42 #define WIN32_LEAN_AND_MEAN
  43 #ifndef _WIN32_WINNT
  44 #define _WIN32_WINNT 0x0500 /*_WIN32_WINNT_WIN2K */
  45 #endif
  46 #include <windows.h>
  47 #include <mmsystem.h>
  48 #endif
  49 #elif defined(GEKKO)
  50 #include <ogc/lwp_watchdog.h>
  51 #include "gx_pthread.h"
  52 #elif defined(_3DS)
  53 #include "ctr_pthread.h"
  54 #else
  55 #include <pthread.h>
  56 #include <time.h>
  57 #endif
  58
  59 #if defined(VITA) || defined(BSD) || defined(ORBIS) || defined(__mips__) || defined(_3DS)
  60 #include <sys/time.h>
  61 #endif
  62
  63 #ifdef __MACH__
  64 #include <mach/clock.h>
  65 #include <mach/mach.h>
  66 #endif
  67
  68 struct thread_data
  69 {
  70    void (*func)(void*);
  71    void *userdata;
  72 };
  73
  74 struct sthread
  75 {
  76 #ifdef USE_WIN32_THREADS
  77    HANDLE thread;
  78    DWORD id;
  79 #else
  80    pthread_t id;
  81 #endif
  82 };
  83
  84 struct slock
  85 {
  86 #ifdef USE_WIN32_THREADS
  87    CRITICAL_SECTION lock;
  88 #else
  89    pthread_mutex_t lock;
  90 #endif
  91 };
  92
  93 #ifdef USE_WIN32_THREADS
  94 /* The syntax we'll use is mind-bending unless we use a struct. Plus, we might want to store more info later */
  95 /* This will be used as a linked list immplementing a queue of waiting threads */
  96 struct queue_entry
  97 {
  98    struct queue_entry *next;
  99 };
 100 #endif
 101
 102 struct scond
 103 {
 104 #ifdef USE_WIN32_THREADS
 105    /* With this implementation of scond, we don't have any way of waking
 106     * (or even identifying) specific threads
 107     * But we need to wake them in the order indicated by the queue.
 108     * This potato token will get get passed around every waiter.
 109     * The bearer can test whether he's next, and hold onto the potato if he is.
 110     * When he's done he can then put it back into play to progress
 111     * the queue further */
 112    HANDLE hot_potato;
 113
 114    /* The primary signalled event. Hot potatoes are passed until this is set. */
 115    HANDLE event;
 116
 117    /* the head of the queue; NULL if queue is empty */
 118    struct queue_entry *head;
 119
 120    /* equivalent to the queue length */
 121    int waiters;
 122
 123    /* how many waiters in the queue have been conceptually wakened by signals
 124     * (even if we haven't managed to actually wake them yet) */
 125    int wakens;
 126
 127    /* used to control access to this scond, in case the user fails */
 128    CRITICAL_SECTION cs;
 129
 130 #else
 131    pthread_cond_t cond;
 132 #endif
 133 };
 134
 135 #ifdef USE_WIN32_THREADS
 136 static DWORD CALLBACK thread_wrap(void *data_)
 137 #else
 138 static void *thread_wrap(void *data_)
 139 #endif
 140 {
 141    struct thread_data *data = (struct thread_data*)data_;
 142    if (!data)
 143            return 0;
 144    data->func(data->userdata);
 145    free(data);
 146    return 0;
 147 }
 148
 149 /**
 150  * sthread_create:
 151  * @start_routine           : thread entry callback function
 152  * @userdata                : pointer to userdata that will be made
 153  *                            available in thread entry callback function
 154  *
 155  * Create a new thread.
 156  *
 157  * Returns: pointer to new thread if successful, otherwise NULL.
 158  */
 159 sthread_t *sthread_create(void (*thread_func)(void*), void *userdata)
 160 {
 161         return sthread_create_with_priority(thread_func, userdata, 0);
 162 }
 163
 164 /* TODO/FIXME - this needs to be implemented for Switch/3DS */
 165 #if !defined(SWITCH) && !defined(USE_WIN32_THREADS) && !defined(_3DS) && !defined(GEKKO) && !defined(__HAIKU__) && !defined(EMSCRIPTEN)
 166 #define HAVE_THREAD_ATTR
 167 #endif
 168
 169 /**
 170  * sthread_create_with_priority:
 171  * @start_routine           : thread entry callback function
 172  * @userdata                : pointer to userdata that will be made
 173  *                            available in thread entry callback function
 174  * @thread_priority         : thread priority hint value from [1-100]
 175  *
 176  * Create a new thread. It is possible for the caller to give a hint
 177  * for the thread's priority from [1-100]. Any passed in @thread_priority
 178  * values that are outside of this range will cause sthread_create() to
 179  * create a new thread using the operating system's default thread
 180  * priority.
 181  *
 182  * Returns: pointer to new thread if successful, otherwise NULL.
 183  */
 184 sthread_t *sthread_create_with_priority(void (*thread_func)(void*), void *userdata, int thread_priority)
 185 {
 186 #ifdef HAVE_THREAD_ATTR
 187    pthread_attr_t thread_attr;
 188    bool thread_attr_needed  = false;
 189 #endif
 190    bool thread_created      = false;
 191    struct thread_data *data = NULL;
 192    sthread_t *thread        = (sthread_t*)malloc(sizeof(*thread));
 193
 194    if (!thread)
 195       return NULL;
 196
 197    if (!(data = (struct thread_data*)malloc(sizeof(*data))))
 198    {
 199       free(thread);
 200       return NULL;
 201    }
 202
 203    data->func               = thread_func;
 204    data->userdata           = userdata;
 205
 206    thread->id               = 0;
 207 #ifdef USE_WIN32_THREADS
 208    thread->thread           = CreateThread(NULL, 0, thread_wrap,
 209          data, 0, &thread->id);
 210    thread_created           = !!thread->thread;
 211 #else
 212 #ifdef HAVE_THREAD_ATTR
 213    pthread_attr_init(&thread_attr);
 214
 215    if ((thread_priority >= 1) && (thread_priority <= 100))
 216    {
 217       struct sched_param sp;
 218       memset(&sp, 0, sizeof(struct sched_param));
 219       sp.sched_priority = thread_priority;
 220       pthread_attr_setschedpolicy(&thread_attr, SCHED_RR);
 221       pthread_attr_setschedparam(&thread_attr, &sp);
 222
 223       thread_attr_needed = true;
 224    }
 225
 226 #if defined(VITA)
 227    pthread_attr_setstacksize(&thread_attr , 0x10000 );
 228    thread_attr_needed = true;
 229 #elif defined(__APPLE__)
 230    /* Default stack size on Apple is 512Kb;
 231     * for PS2 disc scanning and other reasons, we'd like 2MB. */
 232    pthread_attr_setstacksize(&thread_attr , 0x200000 );
 233    thread_attr_needed = true;
 234 #endif
 235
 236    if (thread_attr_needed)
 237       thread_created = pthread_create(&thread->id, &thread_attr, thread_wrap, data) == 0;
 238    else
 239       thread_created = pthread_create(&thread->id, NULL, thread_wrap, data) == 0;
 240
 241    pthread_attr_destroy(&thread_attr);
 242 #else
 243    thread_created    = pthread_create(&thread->id, NULL, thread_wrap, data) == 0;
 244 #endif
 245
 246 #endif
 247
 248    if (thread_created)
 249       return thread;
 250    free(data);
 251    free(thread);
 252    return NULL;
 253 }
 254
 255 /**
 256  * sthread_detach:
 257  * @thread                  : pointer to thread object
 258  *
 259  * Detach a thread. When a detached thread terminates, its
 260  * resources are automatically released back to the system
 261  * without the need for another thread to join with the
 262  * terminated thread.
 263  *
 264  * Returns: 0 on success, otherwise it returns a non-zero error number.
 265  */
 266 int sthread_detach(sthread_t *thread)
 267 {
 268 #ifdef USE_WIN32_THREADS
 269    CloseHandle(thread->thread);
 270    free(thread);
 271    return 0;
 272 #else
 273    int ret = pthread_detach(thread->id);
 274    free(thread);
 275    return ret;
 276 #endif
 277 }
 278
 279 /**
 280  * sthread_join:
 281  * @thread                  : pointer to thread object
 282  *
 283  * Join with a terminated thread. Waits for the thread specified by
 284  * @thread to terminate. If that thread has already terminated, then
 285  * it will return immediately. The thread specified by @thread must
 286  * be joinable.
 287  *
 288  * Returns: 0 on success, otherwise it returns a non-zero error number.
 289  */
 290 void sthread_join(sthread_t *thread)
 291 {
 292    if (!thread)
 293       return;
 294 #ifdef USE_WIN32_THREADS
 295    WaitForSingleObject(thread->thread, INFINITE);
 296    CloseHandle(thread->thread);
 297 #else
 298    pthread_join(thread->id, NULL);
 299 #endif
 300    free(thread);
 301 }
 302
 303 #if !defined(GEKKO)
 304 /**
 305  * sthread_isself:
 306  * @thread                  : pointer to thread object
 307  *
 308  * Returns: true (1) if calling thread is the specified thread
 309  */
 310 bool sthread_isself(sthread_t *thread)
 311 {
 312 #ifdef USE_WIN32_THREADS
 313    return thread ? GetCurrentThreadId() == thread->id        : false;
 314 #else
 315    return thread ? pthread_equal(pthread_self(), thread->id) : false;
 316 #endif
 317 }
 318 #endif
 319
 320 /**
 321  * slock_new:
 322  *
 323  * Create and initialize a new mutex. Must be manually
 324  * freed.
 325  *
 326  * Returns: pointer to a new mutex if successful, otherwise NULL.
 327  **/
 328 slock_t *slock_new(void)
 329 {
 330    slock_t      *lock = (slock_t*)calloc(1, sizeof(*lock));
 331    if (!lock)
 332       return NULL;
 333 #ifdef USE_WIN32_THREADS
 334    InitializeCriticalSection(&lock->lock);
 335 #else
 336    if (pthread_mutex_init(&lock->lock, NULL) != 0)
 337    {
 338       free(lock);
 339       return NULL;
 340    }
 341 #endif
 342    return lock;
 343 }
 344
 345 /**
 346  * slock_free:
 347  * @lock                    : pointer to mutex object
 348  *
 349  * Frees a mutex.
 350  **/
 351 void slock_free(slock_t *lock)
 352 {
 353    if (!lock)
 354       return;
 355
 356 #ifdef USE_WIN32_THREADS
 357    DeleteCriticalSection(&lock->lock);
 358 #else
 359    pthread_mutex_destroy(&lock->lock);
 360 #endif
 361    free(lock);
 362 }
 363
 364 /**
 365  * slock_lock:
 366  * @lock                    : pointer to mutex object
 367  *
 368  * Locks a mutex. If a mutex is already locked by
 369  * another thread, the calling thread shall block until
 370  * the mutex becomes available.
 371 **/
 372 void slock_lock(slock_t *lock)
 373 {
 374    if (!lock)
 375       return;
 376 #ifdef USE_WIN32_THREADS
 377    EnterCriticalSection(&lock->lock);
 378 #else
 379    pthread_mutex_lock(&lock->lock);
 380 #endif
 381 }
 382
 383 /**
 384  * slock_try_lock:
 385  * @lock                    : pointer to mutex object
 386  *
 387  * Attempts to lock a mutex. If a mutex is already locked by
 388  * another thread, return false.  If the lock is acquired, return true.
 389 **/
 390 bool slock_try_lock(slock_t *lock)
 391 {
 392 #ifdef USE_WIN32_THREADS
 393    return lock && TryEnterCriticalSection(&lock->lock);
 394 #else
 395    return lock && (pthread_mutex_trylock(&lock->lock) == 0);
 396 #endif
 397 }
 398
 399 /**
 400  * slock_unlock:
 401  * @lock                    : pointer to mutex object
 402  *
 403  * Unlocks a mutex.
 404  **/
 405 void slock_unlock(slock_t *lock)
 406 {
 407    if (!lock)
 408       return;
 409 #ifdef USE_WIN32_THREADS
 410    LeaveCriticalSection(&lock->lock);
 411 #else
 412    pthread_mutex_unlock(&lock->lock);
 413 #endif
 414 }
 415
 416 /**
 417  * scond_new:
 418  *
 419  * Creates and initializes a condition variable. Must
 420  * be manually freed.
 421  *
 422  * Returns: pointer to new condition variable on success,
 423  * otherwise NULL.
 424  **/
 425 scond_t *scond_new(void)
 426 {
 427    scond_t      *cond = (scond_t*)calloc(1, sizeof(*cond));
 428
 429    if (!cond)
 430       return NULL;
 431
 432 #ifdef USE_WIN32_THREADS
 433    /* This is very complex because recreating condition variable semantics
 434     * with Win32 parts is not easy.
 435     *
 436     * The main problem is that a condition variable can't be used to
 437     * "pre-wake" a thread (it will get wakened only after it's waited).
 438     *
 439     * Whereas a win32 event can pre-wake a thread (the event will be set
 440     * in advance, so a 'waiter' won't even have to wait on it).
 441     *
 442     * Keep in mind a condition variable can apparently pre-wake a thread,
 443     * insofar as spurious wakeups are always possible,
 444     * but nobody will be expecting this and it does not need to be simulated.
 445     *
 446     * Moreover, we won't be doing this, because it counts as a spurious wakeup
 447     * -- someone else with a genuine claim must get wakened, in any case.
 448     *
 449     * Therefore we choose to wake only one of the correct waiting threads.
 450     * So at the very least, we need to do something clever. But there's
 451     * bigger problems.
 452     * We don't even have a straightforward way in win32 to satisfy
 453     * pthread_cond_wait's atomicity requirement. The bulk of this
 454     * algorithm is solving that.
 455     *
 456     * Note: We might could simplify this using vista+ condition variables,
 457     * but we wanted an XP compatible solution. */
 458    if (!(cond->event      = CreateEvent(NULL, FALSE, FALSE, NULL)))
 459       goto error;
 460    if (!(cond->hot_potato = CreateEvent(NULL, FALSE, FALSE, NULL)))
 461    {
 462       CloseHandle(cond->event);
 463       goto error;
 464    }
 465
 466    InitializeCriticalSection(&cond->cs);
 467 #else
 468    if (pthread_cond_init(&cond->cond, NULL) != 0)
 469       goto error;
 470 #endif
 471
 472    return cond;
 473
 474 error:
 475    free(cond);
 476    return NULL;
 477 }
 478
 479 /**
 480  * scond_free:
 481  * @cond                    : pointer to condition variable object
 482  *
 483  * Frees a condition variable.
 484 **/
 485 void scond_free(scond_t *cond)
 486 {
 487    if (!cond)
 488       return;
 489
 490 #ifdef USE_WIN32_THREADS
 491    CloseHandle(cond->event);
 492    CloseHandle(cond->hot_potato);
 493    DeleteCriticalSection(&cond->cs);
 494 #else
 495    pthread_cond_destroy(&cond->cond);
 496 #endif
 497    free(cond);
 498 }
 499
 500 #ifdef USE_WIN32_THREADS
 501 static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds)
 502 {
 503    struct queue_entry myentry;
 504    struct queue_entry **ptr;
 505
 506 #if _WIN32_WINNT >= 0x0500 || defined(_XBOX)
 507    static LARGE_INTEGER performanceCounterFrequency;
 508    LARGE_INTEGER tsBegin;
 509    static bool first_init  = true;
 510 #else
 511    static bool beginPeriod = false;
 512    DWORD tsBegin;
 513 #endif
 514    DWORD waitResult;
 515    DWORD dwFinalTimeout = dwMilliseconds; /* Careful! in case we begin in the head,
 516                                              we don't do the hot potato stuff,
 517                                              so this timeout needs presetting. */
 518
 519    /* Reminder: `lock` is held before this is called. */
 520    /* however, someone else may have called scond_signal without the lock. soo... */
 521    EnterCriticalSection(&cond->cs);
 522
 523    /* since this library is meant for realtime game software
 524     * I have no problem setting this to 1 and forgetting about it. */
 525 #if _WIN32_WINNT >= 0x0500 || defined(_XBOX)
 526    if (first_init)
 527    {
 528       performanceCounterFrequency.QuadPart = 0;
 529       first_init = false;
 530    }
 531
 532    if (performanceCounterFrequency.QuadPart == 0)
 533       QueryPerformanceFrequency(&performanceCounterFrequency);
 534 #else
 535    if (!beginPeriod)
 536    {
 537       beginPeriod = true;
 538       timeBeginPeriod(1);
 539    }
 540 #endif
 541
 542    /* Now we can take a good timestamp for use in faking the timeout ourselves. */
 543    /* But don't bother unless we need to (to save a little time) */
 544    if (dwMilliseconds != INFINITE)
 545 #if _WIN32_WINNT >= 0x0500 || defined(_XBOX)
 546       QueryPerformanceCounter(&tsBegin);
 547 #else
 548       tsBegin = timeGetTime();
 549 #endif
 550
 551    /* add ourselves to a queue of waiting threads */
 552    ptr = &cond->head;
 553
 554    /* walk to the end of the linked list */
 555    while (*ptr)
 556       ptr       = &((*ptr)->next);
 557
 558    *ptr         = &myentry;
 559    myentry.next = NULL;
 560
 561    cond->waiters++;
 562
 563    /* now the conceptual lock release and condition block are supposed to be atomic.
 564     * we can't do that in Windows, but we can simulate the effects by using
 565     * the queue, by the following analysis:
 566     * What happens if they aren't atomic?
 567     *
 568     * 1. a signaller can rush in and signal, expecting a waiter to get it;
 569     * but the waiter wouldn't, because he isn't blocked yet.
 570     * Solution: Win32 events make this easy. The event will sit there enabled
 571     *
 572     * 2. a signaller can rush in and signal, and then turn right around and wait.
 573     * Solution: the signaller will get queued behind the waiter, who's
 574     * enqueued before he releases the mutex. */
 575
 576    /* It's my turn if I'm the head of the queue.
 577     * Check to see if it's my turn. */
 578    while (cond->head != &myentry)
 579    {
 580       /* It isn't my turn: */
 581       DWORD timeout = INFINITE;
 582
 583       /* As long as someone is even going to be able to wake up
 584        * when they receive the potato, keep it going round. */
 585       if (cond->wakens > 0)
 586          SetEvent(cond->hot_potato);
 587
 588       /* Assess the remaining timeout time */
 589       if (dwMilliseconds != INFINITE)
 590       {
 591 #if _WIN32_WINNT >= 0x0500 || defined(_XBOX)
 592          LARGE_INTEGER now;
 593          LONGLONG elapsed;
 594
 595          QueryPerformanceCounter(&now);
 596          elapsed  = now.QuadPart - tsBegin.QuadPart;
 597          elapsed *= 1000;
 598          elapsed /= performanceCounterFrequency.QuadPart;
 599 #else
 600          DWORD now     = timeGetTime();
 601          DWORD elapsed = now - tsBegin;
 602 #endif
 603
 604          /* Try one last time with a zero timeout (keeps the code simpler) */
 605          if (elapsed > dwMilliseconds)
 606             elapsed = dwMilliseconds;
 607
 608          timeout = dwMilliseconds - elapsed;
 609       }
 610
 611       /* Let someone else go */
 612       LeaveCriticalSection(&lock->lock);
 613       LeaveCriticalSection(&cond->cs);
 614
 615       /* Wait a while to catch the hot potato..
 616        * someone else should get a chance to go */
 617       /* After all, it isn't my turn (and it must be someone else's) */
 618       Sleep(0);
 619       waitResult = WaitForSingleObject(cond->hot_potato, timeout);
 620
 621       /* I should come out of here with the main lock taken */
 622       EnterCriticalSection(&lock->lock);
 623       EnterCriticalSection(&cond->cs);
 624
 625       if (waitResult == WAIT_TIMEOUT)
 626       {
 627          /* Out of time! Now, let's think about this. I do have the potato now--
 628           * maybe it's my turn, and I have the event?
 629           * If that's the case, I could proceed right now without aborting
 630           * due to timeout.
 631           *
 632           * However.. I DID wait a real long time. The caller was willing
 633           * to wait that long.
 634           *
 635           * I choose to give him one last chance with a zero timeout
 636           * in the next step
 637           */
 638          if (cond->head == &myentry)
 639          {
 640             dwFinalTimeout = 0;
 641             break;
 642          }
 643          else
 644          {
 645             /* It's not our turn and we're out of time. Give up.
 646              * Remove ourself from the queue and bail. */
 647             struct queue_entry *curr = cond->head;
 648
 649             while (curr->next != &myentry)
 650                curr = curr->next;
 651             curr->next = myentry.next;
 652             cond->waiters--;
 653             LeaveCriticalSection(&cond->cs);
 654             return false;
 655          }
 656       }
 657
 658    }
 659
 660    /* It's my turn now -- and I hold the potato */
 661
 662    /* I still have the main lock, in any case */
 663    /* I need to release it so that someone can set the event */
 664    LeaveCriticalSection(&lock->lock);
 665    LeaveCriticalSection(&cond->cs);
 666
 667    /* Wait for someone to actually signal this condition */
 668    /* We're the only waiter waiting on the event right now -- everyone else
 669     * is waiting on something different */
 670    waitResult = WaitForSingleObject(cond->event, dwFinalTimeout);
 671
 672    /* Take the main lock so we can do work. Nobody else waits on this lock
 673     * for very long, so even though it's GO TIME we won't have to wait long */
 674    EnterCriticalSection(&lock->lock);
 675    EnterCriticalSection(&cond->cs);
 676
 677    /* Remove ourselves from the queue */
 678    cond->head = myentry.next;
 679    cond->waiters--;
 680
 681    if (waitResult == WAIT_TIMEOUT)
 682    {
 683       /* Oops! ran out of time in the final wait. Just bail. */
 684       LeaveCriticalSection(&cond->cs);
 685       return false;
 686    }
 687
 688    /* If any other wakenings are pending, go ahead and set it up  */
 689    /* There may actually be no waiters. That's OK. The first waiter will come in,
 690     * find it's his turn, and immediately get the signaled event */
 691    cond->wakens--;
 692    if (cond->wakens > 0)
 693    {
 694       SetEvent(cond->event);
 695
 696       /* Progress the queue: Put the hot potato back into play. It'll be
 697        * tossed around until next in line gets it */
 698       SetEvent(cond->hot_potato);
 699    }
 700
 701    LeaveCriticalSection(&cond->cs);
 702    return true;
 703 }
 704 #endif
 705
 706 /**
 707  * scond_wait:
 708  * @cond                    : pointer to condition variable object
 709  * @lock                    : pointer to mutex object
 710  *
 711  * Block on a condition variable (i.e. wait on a condition).
 712  **/
 713 void scond_wait(scond_t *cond, slock_t *lock)
 714 {
 715 #ifdef USE_WIN32_THREADS
 716    _scond_wait_win32(cond, lock, INFINITE);
 717 #else
 718    pthread_cond_wait(&cond->cond, &lock->lock);
 719 #endif
 720 }
 721
 722 /**
 723  * scond_broadcast:
 724  * @cond                    : pointer to condition variable object
 725  *
 726  * Broadcast a condition. Unblocks all threads currently blocked
 727  * on the specified condition variable @cond.
 728  **/
 729 int scond_broadcast(scond_t *cond)
 730 {
 731 #ifdef USE_WIN32_THREADS
 732    /* Remember, we currently have mutex */
 733    if (cond->waiters != 0)
 734    {
 735       /* Awaken everything which is currently queued up */
 736       if (cond->wakens == 0)
 737          SetEvent(cond->event);
 738       cond->wakens = cond->waiters;
 739
 740       /* Since there is now at least one pending waken, the potato must be in play */
 741       SetEvent(cond->hot_potato);
 742    }
 743    return 0;
 744 #else
 745    return pthread_cond_broadcast(&cond->cond);
 746 #endif
 747 }
 748
 749 /**
 750  * scond_signal:
 751  * @cond                    : pointer to condition variable object
 752  *
 753  * Signal a condition. Unblocks at least one of the threads currently blocked
 754  * on the specified condition variable @cond.
 755  **/
 756 void scond_signal(scond_t *cond)
 757 {
 758 #ifdef USE_WIN32_THREADS
 759
 760    /* Unfortunately, pthread_cond_signal does not require that the
 761     * lock be held in advance */
 762    /* To avoid stomping on the condvar from other threads, we need
 763     * to control access to it with this */
 764    EnterCriticalSection(&cond->cs);
 765
 766    /* remember: we currently have mutex */
 767    if (cond->waiters == 0)
 768    {
 769       LeaveCriticalSection(&cond->cs);
 770       return;
 771    }
 772
 773    /* wake up the next thing in the queue */
 774    if (cond->wakens == 0)
 775       SetEvent(cond->event);
 776
 777    cond->wakens++;
 778
 779    /* The data structure is done being modified.. I think we can leave the CS now.
 780     * This would prevent some other thread from receiving the hot potato and then
 781     * immediately stalling for the critical section.
 782     * But remember, we were trying to replicate a semantic where this entire
 783     * scond_signal call was controlled (by the user) by a lock.
 784     * So in case there's trouble with this, we can move it after SetEvent() */
 785    LeaveCriticalSection(&cond->cs);
 786
 787    /* Since there is now at least one pending waken, the potato must be in play */
 788    SetEvent(cond->hot_potato);
 789
 790 #else
 791    pthread_cond_signal(&cond->cond);
 792 #endif
 793 }
 794
 795 /**
 796  * scond_wait_timeout:
 797  * @cond                    : pointer to condition variable object
 798  * @lock                    : pointer to mutex object
 799  * @timeout_us              : timeout (in microseconds)
 800  *
 801  * Try to block on a condition variable (i.e. wait on a condition) until
 802  * @timeout_us elapses.
 803  *
 804  * Returns: false (0) if timeout elapses before condition variable is
 805  * signaled or broadcast, otherwise true (1).
 806  **/
 807 bool scond_wait_timeout(scond_t *cond, slock_t *lock, int64_t timeout_us)
 808 {
 809 #ifdef USE_WIN32_THREADS
 810    /* How to convert a microsecond (us) timeout to millisecond (ms)?
 811     *
 812     * Someone asking for a 0 timeout clearly wants immediate timeout.
 813     * Someone asking for a 1 timeout clearly wants an actual timeout
 814     * of the minimum length */
 815    /* The implementation of a 0 timeout here with pthreads is sketchy.
 816     * It isn't clear what happens if pthread_cond_timedwait is called with NOW.
 817     * Moreover, it is possible that this thread gets pre-empted after the
 818     * clock_gettime but before the pthread_cond_timedwait.
 819     * In order to help smoke out problems caused by this strange usage,
 820     * let's treat a 0 timeout as always timing out.
 821     */
 822    if (timeout_us == 0)
 823       return false;
 824    else if (timeout_us < 1000)
 825       return _scond_wait_win32(cond, lock, 1);
 826    /* Someone asking for 1000 or 1001 timeout shouldn't
 827     * accidentally get 2ms. */
 828    return _scond_wait_win32(cond, lock, timeout_us / 1000);
 829 #else
 830    int64_t seconds, remainder;
 831    struct timespec now;
 832 #ifdef __MACH__
 833    /* OSX doesn't have clock_gettime. */
 834    clock_serv_t cclock;
 835    mach_timespec_t mts;
 836    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
 837    clock_get_time(cclock, &mts);
 838    mach_port_deallocate(mach_task_self(), cclock);
 839    now.tv_sec = mts.tv_sec;
 840    now.tv_nsec = mts.tv_nsec;
 841 #elif !defined(__PSL1GHT__) && defined(__PS3__)
 842    sys_time_sec_t s;
 843    sys_time_nsec_t n;
 844    sys_time_get_current_time(&s, &n);
 845    now.tv_sec            = s;
 846    now.tv_nsec           = n;
 847 #elif defined(PS2)
 848    int tickms            = ps2_clock();
 849    now.tv_sec            = tickms / 1000;
 850    now.tv_nsec           = tickms * 1000;
 851 #elif !defined(DINGUX_BETA) && (defined(__mips__) || defined(VITA) || defined(_3DS))
 852    struct timeval tm;
 853    gettimeofday(&tm, NULL);
 854    now.tv_sec            = tm.tv_sec;
 855    now.tv_nsec           = tm.tv_usec * 1000;
 856 #elif defined(RETRO_WIN32_USE_PTHREADS)
 857    _ftime64_s(&now);
 858 #elif defined(GEKKO)
 859    /* Avoid gettimeofday due to it being reported to be broken */
 860    const uint64_t tickms = gettime() / TB_TIMER_CLOCK;
 861    now.tv_sec            = tickms / 1000;
 862    now.tv_nsec           = tickms * 1000;
 863 #else
 864    clock_gettime(CLOCK_REALTIME, &now);
 865 #endif
 866
 867    seconds              = timeout_us / INT64_C(1000000);
 868    remainder            = timeout_us % INT64_C(1000000);
 869
 870    now.tv_sec          += seconds;
 871    now.tv_nsec         += remainder * INT64_C(1000);
 872
 873    if (now.tv_nsec > 1000000000)
 874    {
 875       now.tv_nsec      -= 1000000000;
 876       now.tv_sec       += 1;
 877    }
 878
 879    return (pthread_cond_timedwait(&cond->cond, &lock->lock, &now) == 0);
 880 #endif
 881 }
 882
 883 #ifdef HAVE_THREAD_STORAGE
 884 bool sthread_tls_create(sthread_tls_t *tls)
 885 {
 886 #ifdef USE_WIN32_THREADS
 887    return (*tls = TlsAlloc()) != TLS_OUT_OF_INDEXES;
 888 #else
 889    return pthread_key_create((pthread_key_t*)tls, NULL) == 0;
 890 #endif
 891 }
 892
 893 bool sthread_tls_delete(sthread_tls_t *tls)
 894 {
 895 #ifdef USE_WIN32_THREADS
 896    return TlsFree(*tls) != 0;
 897 #else
 898    return pthread_key_delete(*tls) == 0;
 899 #endif
 900 }
 901
 902 void *sthread_tls_get(sthread_tls_t *tls)
 903 {
 904 #ifdef USE_WIN32_THREADS
 905    return TlsGetValue(*tls);
 906 #else
 907    return pthread_getspecific(*tls);
 908 #endif
 909 }
 910
 911 bool sthread_tls_set(sthread_tls_t *tls, const void *data)
 912 {
 913 #ifdef USE_WIN32_THREADS
 914    return TlsSetValue(*tls, (void*)data) != 0;
 915 #else
 916    return pthread_setspecific(*tls, data) == 0;
 917 #endif
 918 }
 919 #endif
 920
 921 uintptr_t sthread_get_thread_id(sthread_t *thread)
 922 {
 923    if (thread)
 924       return (uintptr_t)thread->id;
 925    return 0;
 926 }
 927
 928 uintptr_t sthread_get_current_thread_id(void)
 929 {
 930 #ifdef USE_WIN32_THREADS
 931    return (uintptr_t)GetCurrentThreadId();
 932 #else
 933    return (uintptr_t)pthread_self();
 934 #endif
 935 }