common/threads.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "threads.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <errno.h>
  28
  29 #include "uintmap.h"
  30
  31
  32 extern inline althrd_t althrd_current(void);
  33 extern inline int althrd_equal(althrd_t thr0, althrd_t thr1);
  34 extern inline void althrd_exit(int res);
  35 extern inline void althrd_yield(void);
  36
  37 extern inline int almtx_lock(almtx_t *mtx);
  38 extern inline int almtx_unlock(almtx_t *mtx);
  39 extern inline int almtx_trylock(almtx_t *mtx);
  40
  41 extern inline void *altss_get(altss_t tss_id);
  42 extern inline int altss_set(altss_t tss_id, void *val);
  43
  44
  45 #ifndef UNUSED
  46 #if defined(__cplusplus)
  47 #define UNUSED(x)
  48 #elif defined(__GNUC__)
  49 #define UNUSED(x) UNUSED_##x __attribute__((unused))
  50 #elif defined(__LCLINT__)
  51 #define UNUSED(x) /*@unused@*/ x
  52 #else
  53 #define UNUSED(x) x
  54 #endif
  55 #endif
  56
  57
  58 #define THREAD_STACK_SIZE (2*1024*1024) /* 2MB */
  59
  60 #ifdef _WIN32
  61
  62 #define WIN32_LEAN_AND_MEAN
  63 #include <windows.h>
  64 #include <mmsystem.h>
  65
  66
  67 void althrd_setname(althrd_t thr, const char *name)
  68 {
  69 #if defined(_MSC_VER)
  70 #define MS_VC_EXCEPTION 0x406D1388
  71 #pragma pack(push,8)
  72     struct {
  73         DWORD dwType;     // Must be 0x1000.
  74         LPCSTR szName;    // Pointer to name (in user addr space).
  75         DWORD dwThreadID; // Thread ID (-1=caller thread).
  76         DWORD dwFlags;    // Reserved for future use, must be zero.
  77     } info;
  78 #pragma pack(pop)
  79     info.dwType = 0x1000;
  80     info.szName = name;
  81     info.dwThreadID = thr;
  82     info.dwFlags = 0;
  83
  84     __try {
  85         RaiseException(MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info);
  86     }
  87     __except(EXCEPTION_CONTINUE_EXECUTION) {
  88     }
  89 #undef MS_VC_EXCEPTION
  90 #else
  91     (void)thr;
  92     (void)name;
  93 #endif
  94 }
  95
  96
  97 static UIntMap ThrdIdHandle = UINTMAP_STATIC_INITIALIZE;
  98
  99 static void NTAPI althrd_callback(void* UNUSED(handle), DWORD reason, void* UNUSED(reserved))
 100 {
 101     if(reason == DLL_PROCESS_DETACH)
 102         ResetUIntMap(&ThrdIdHandle);
 103 }
 104 #ifdef _MSC_VER
 105 #pragma section(".CRT$XLC",read)
 106 __declspec(allocate(".CRT$XLC")) PIMAGE_TLS_CALLBACK althrd_callback_ = althrd_callback;
 107 #elif defined(__GNUC__)
 108 PIMAGE_TLS_CALLBACK althrd_callback_ __attribute__((section(".CRT$XLC"))) = althrd_callback;
 109 #else
 110 PIMAGE_TLS_CALLBACK althrd_callback_ = althrd_callback;
 111 #endif
 112
 113
 114 typedef struct thread_cntr {
 115     althrd_start_t func;
 116     void *arg;
 117 } thread_cntr;
 118
 119 static DWORD WINAPI althrd_starter(void *arg)
 120 {
 121     thread_cntr cntr;
 122     memcpy(&cntr, arg, sizeof(cntr));
 123     free(arg);
 124
 125     return (DWORD)((*cntr.func)(cntr.arg));
 126 }
 127
 128
 129 int althrd_create(althrd_t *thr, althrd_start_t func, void *arg)
 130 {
 131     thread_cntr *cntr;
 132     DWORD thrid;
 133     HANDLE hdl;
 134
 135     cntr = malloc(sizeof(*cntr));
 136     if(!cntr) return althrd_nomem;
 137
 138     cntr->func = func;
 139     cntr->arg = arg;
 140
 141     hdl = CreateThread(NULL, THREAD_STACK_SIZE, althrd_starter, cntr, 0, &thrid);
 142     if(!hdl)
 143     {
 144         free(cntr);
 145         return althrd_error;
 146     }
 147     InsertUIntMapEntry(&ThrdIdHandle, thrid, hdl);
 148
 149     *thr = thrid;
 150     return althrd_success;
 151 }
 152
 153 int althrd_detach(althrd_t thr)
 154 {
 155     HANDLE hdl = RemoveUIntMapKey(&ThrdIdHandle, thr);
 156     if(!hdl) return althrd_error;
 157
 158     CloseHandle(hdl);
 159     return althrd_success;
 160 }
 161
 162 int althrd_join(althrd_t thr, int *res)
 163 {
 164     DWORD code;
 165
 166     HANDLE hdl = RemoveUIntMapKey(&ThrdIdHandle, thr);
 167     if(!hdl) return althrd_error;
 168
 169     WaitForSingleObject(hdl, INFINITE);
 170     GetExitCodeThread(hdl, &code);
 171     CloseHandle(hdl);
 172
 173     if(res != NULL)
 174         *res = (int)code;
 175     return althrd_success;
 176 }
 177
 178 int althrd_sleep(const struct timespec *ts, struct timespec* UNUSED(rem))
 179 {
 180     DWORD msec;
 181
 182     if(ts->tv_sec < 0 || ts->tv_sec >= (0x7fffffff / 1000) ||
 183        ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000)
 184         return -2;
 185
 186     msec  = (DWORD)(ts->tv_sec * 1000);
 187     msec += (DWORD)((ts->tv_nsec+999999) / 1000000);
 188     Sleep(msec);
 189
 190     return 0;
 191 }
 192
 193
 194 int almtx_init(almtx_t *mtx, int type)
 195 {
 196     if(!mtx) return althrd_error;
 197
 198     type &= ~almtx_recursive;
 199     if(type != almtx_plain)
 200         return althrd_error;
 201
 202     InitializeCriticalSection(mtx);
 203     return althrd_success;
 204 }
 205
 206 void almtx_destroy(almtx_t *mtx)
 207 {
 208     DeleteCriticalSection(mtx);
 209 }
 210
 211 int almtx_timedlock(almtx_t* UNUSED(mtx), const struct timespec* UNUSED(ts))
 212 {
 213     /* Windows CRITICAL_SECTIONs don't seem to have a timedlock method. */
 214     return althrd_error;
 215 }
 216
 217 #if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0600
 218 int alcnd_init(alcnd_t *cond)
 219 {
 220     InitializeConditionVariable(cond);
 221     return althrd_success;
 222 }
 223
 224 int alcnd_signal(alcnd_t *cond)
 225 {
 226     WakeConditionVariable(cond);
 227     return althrd_success;
 228 }
 229
 230 int alcnd_broadcast(alcnd_t *cond)
 231 {
 232     WakeAllConditionVariable(cond);
 233     return althrd_success;
 234 }
 235
 236 int alcnd_wait(alcnd_t *cond, almtx_t *mtx)
 237 {
 238     if(SleepConditionVariableCS(cond, mtx, INFINITE) != 0)
 239         return althrd_success;
 240     return althrd_error;
 241 }
 242
 243 int alcnd_timedwait(alcnd_t *cond, almtx_t *mtx, const struct timespec *time_point)
 244 {
 245     struct timespec curtime;
 246     DWORD sleeptime;
 247
 248     if(altimespec_get(&curtime, AL_TIME_UTC) != AL_TIME_UTC)
 249         return althrd_error;
 250
 251     if(curtime.tv_sec > time_point->tv_sec || (curtime.tv_sec == time_point->tv_sec &&
 252                                                curtime.tv_nsec >= time_point->tv_nsec))
 253     {
 254         if(SleepConditionVariableCS(cond, mtx, 0) != 0)
 255             return althrd_success;
 256     }
 257     else
 258     {
 259         sleeptime  = (time_point->tv_nsec - curtime.tv_nsec + 999999)/1000000;
 260         sleeptime += (DWORD)(time_point->tv_sec - curtime.tv_sec)*1000;
 261         if(SleepConditionVariableCS(cond, mtx, sleeptime) != 0)
 262             return althrd_success;
 263     }
 264     return (GetLastError()==ERROR_TIMEOUT) ? althrd_timedout : althrd_error;
 265 }
 266
 267 void alcnd_destroy(alcnd_t* UNUSED(cond))
 268 {
 269     /* Nothing to delete? */
 270 }
 271
 272 #else
 273
 274 /* WARNING: This is a rather poor implementation of condition variables, with
 275  * known problems. However, it's simple, efficient, and good enough for now to
 276  * not require Vista. Based on "Strategies for Implementing POSIX Condition
 277  * Variables" by Douglas C. Schmidt and Irfan Pyarali:
 278  * http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
 279  */
 280 /* A better solution may be using Wine's implementation. It requires internals
 281  * (NtCreateKeyedEvent, NtReleaseKeyedEvent, and NtWaitForKeyedEvent) from
 282  * ntdll, and implemention of exchange and compare-exchange for RefCounts.
 283  */
 284
 285 typedef struct {
 286     RefCount wait_count;
 287
 288     HANDLE events[2];
 289 } _int_alcnd_t;
 290 enum {
 291     SIGNAL = 0,
 292     BROADCAST = 1
 293 };
 294
 295 int alcnd_init(alcnd_t *cond)
 296 {
 297     _int_alcnd_t *icond = calloc(1, sizeof(*icond));
 298     if(!icond) return althrd_nomem;
 299
 300     InitRef(&icond->wait_count, 0);
 301
 302     icond->events[SIGNAL] = CreateEventW(NULL, FALSE, FALSE, NULL);
 303     icond->events[BROADCAST] = CreateEventW(NULL, TRUE, FALSE, NULL);
 304     if(!icond->events[SIGNAL] || !icond->events[BROADCAST])
 305     {
 306         if(icond->events[SIGNAL])
 307             CloseHandle(icond->events[SIGNAL]);
 308         if(icond->events[BROADCAST])
 309             CloseHandle(icond->events[BROADCAST]);
 310         free(icond);
 311         return althrd_error;
 312     }
 313
 314     cond->Ptr = icond;
 315     return althrd_success;
 316 }
 317
 318 int alcnd_signal(alcnd_t *cond)
 319 {
 320     _int_alcnd_t *icond = cond->Ptr;
 321     if(ReadRef(&icond->wait_count) > 0)
 322         SetEvent(icond->events[SIGNAL]);
 323     return althrd_success;
 324 }
 325
 326 int alcnd_broadcast(alcnd_t *cond)
 327 {
 328     _int_alcnd_t *icond = cond->Ptr;
 329     if(ReadRef(&icond->wait_count) > 0)
 330         SetEvent(icond->events[BROADCAST]);
 331     return althrd_success;
 332 }
 333
 334 int alcnd_wait(alcnd_t *cond, almtx_t *mtx)
 335 {
 336     _int_alcnd_t *icond = cond->Ptr;
 337     int res;
 338
 339     IncrementRef(&icond->wait_count);
 340     LeaveCriticalSection(mtx);
 341
 342     res = WaitForMultipleObjects(2, icond->events, FALSE, INFINITE);
 343
 344     if(DecrementRef(&icond->wait_count) == 0 && res == WAIT_OBJECT_0+BROADCAST)
 345         ResetEvent(icond->events[BROADCAST]);
 346     EnterCriticalSection(mtx);
 347
 348     return althrd_success;
 349 }
 350
 351 int alcnd_timedwait(alcnd_t *cond, almtx_t *mtx, const struct timespec *time_point)
 352 {
 353     _int_alcnd_t *icond = cond->Ptr;
 354     struct timespec curtime;
 355     DWORD sleeptime;
 356     int res;
 357
 358     if(altimespec_get(&curtime, AL_TIME_UTC) != AL_TIME_UTC)
 359         return althrd_error;
 360
 361     if(curtime.tv_sec > time_point->tv_sec || (curtime.tv_sec == time_point->tv_sec &&
 362                                                curtime.tv_nsec >= time_point->tv_nsec))
 363         sleeptime = 0;
 364     else
 365     {
 366         sleeptime  = (time_point->tv_nsec - curtime.tv_nsec + 999999)/1000000;
 367         sleeptime += (DWORD)(time_point->tv_sec - curtime.tv_sec)*1000;
 368     }
 369
 370     IncrementRef(&icond->wait_count);
 371     LeaveCriticalSection(mtx);
 372
 373     res = WaitForMultipleObjects(2, icond->events, FALSE, sleeptime);
 374
 375     if(DecrementRef(&icond->wait_count) == 0 && res == WAIT_OBJECT_0+BROADCAST)
 376         ResetEvent(icond->events[BROADCAST]);
 377     EnterCriticalSection(mtx);
 378
 379     return (res == WAIT_TIMEOUT) ? althrd_timedout : althrd_success;
 380 }
 381
 382 void alcnd_destroy(alcnd_t *cond)
 383 {
 384     _int_alcnd_t *icond = cond->Ptr;
 385     CloseHandle(icond->events[SIGNAL]);
 386     CloseHandle(icond->events[BROADCAST]);
 387     free(icond);
 388 }
 389 #endif /* defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0600 */
 390
 391
 392 /* An associative map of uint:void* pairs. The key is the TLS index (given by
 393  * TlsAlloc), and the value is the altss_dtor_t callback. When a thread exits,
 394  * we iterate over the TLS indices for their thread-local value and call the
 395  * destructor function with it if they're both not NULL. To avoid using
 396  * DllMain, a PIMAGE_TLS_CALLBACK function pointer is placed in a ".CRT$XLx"
 397  * section (where x is a character A to Z) which will be called by the CRT.
 398  */
 399 static UIntMap TlsDestructors = UINTMAP_STATIC_INITIALIZE;
 400
 401 static void NTAPI altss_callback(void* UNUSED(handle), DWORD reason, void* UNUSED(reserved))
 402 {
 403     ALsizei i;
 404
 405     if(reason == DLL_PROCESS_DETACH)
 406     {
 407         ResetUIntMap(&TlsDestructors);
 408         return;
 409     }
 410     if(reason != DLL_THREAD_DETACH)
 411         return;
 412
 413     LockUIntMapRead(&TlsDestructors);
 414     for(i = 0;i < TlsDestructors.size;i++)
 415     {
 416         void *ptr = altss_get(TlsDestructors.keys[i]);
 417         altss_dtor_t callback = (altss_dtor_t)TlsDestructors.values[i];
 418         if(ptr && callback)
 419             callback(ptr);
 420     }
 421     UnlockUIntMapRead(&TlsDestructors);
 422 }
 423 #ifdef _MSC_VER
 424 #pragma section(".CRT$XLB",read)
 425 __declspec(allocate(".CRT$XLB")) PIMAGE_TLS_CALLBACK altss_callback_ = altss_callback;
 426 #elif defined(__GNUC__)
 427 PIMAGE_TLS_CALLBACK altss_callback_ __attribute__((section(".CRT$XLB"))) = altss_callback;
 428 #else
 429 #warning "No TLS callback support, thread-local contexts may leak references on poorly written applications."
 430 PIMAGE_TLS_CALLBACK altss_callback_ = altss_callback;
 431 #endif
 432
 433 int altss_create(altss_t *tss_id, altss_dtor_t callback)
 434 {
 435     DWORD key = TlsAlloc();
 436     if(key == TLS_OUT_OF_INDEXES)
 437         return althrd_error;
 438
 439     *tss_id = key;
 440     if(callback != NULL)
 441         InsertUIntMapEntry(&TlsDestructors, key, callback);
 442     return althrd_success;
 443 }
 444
 445 void altss_delete(altss_t tss_id)
 446 {
 447     RemoveUIntMapKey(&TlsDestructors, tss_id);
 448     TlsFree(tss_id);
 449 }
 450
 451
 452 int altimespec_get(struct timespec *ts, int base)
 453 {
 454     static_assert(sizeof(FILETIME) == sizeof(ULARGE_INTEGER),
 455                   "Size of FILETIME does not match ULARGE_INTEGER");
 456     if(base == AL_TIME_UTC)
 457     {
 458         union {
 459             FILETIME ftime;
 460             ULARGE_INTEGER ulint;
 461         } systime;
 462         GetSystemTimeAsFileTime(&systime.ftime);
 463         /* FILETIME is in 100-nanosecond units, or 1/10th of a microsecond. */
 464         ts->tv_sec = systime.ulint.QuadPart/10000000;
 465         ts->tv_nsec = (systime.ulint.QuadPart%10000000) * 100;
 466         return base;
 467     }
 468
 469     return 0;
 470 }
 471
 472
 473 void alcall_once(alonce_flag *once, void (*callback)(void))
 474 {
 475     LONG ret;
 476     while((ret=InterlockedExchange(once, 1)) == 1)
 477         althrd_yield();
 478     if(ret == 0)
 479         (*callback)();
 480     InterlockedExchange(once, 2);
 481 }
 482
 483 #else
 484
 485 #include <sys/time.h>
 486 #include <unistd.h>
 487 #include <pthread.h>
 488 #ifdef HAVE_PTHREAD_NP_H
 489 #include <pthread_np.h>
 490 #endif
 491
 492
 493 extern inline int althrd_sleep(const struct timespec *ts, struct timespec *rem);
 494 extern inline void alcall_once(alonce_flag *once, void (*callback)(void));
 495
 496
 497 void althrd_setname(althrd_t thr, const char *name)
 498 {
 499 #if defined(HAVE_PTHREAD_SETNAME_NP)
 500 #if defined(PTHREAD_SETNAME_NP_ONE_PARAM)
 501     if(althrd_equal(thr, althrd_current()))
 502         pthread_setname_np(name);
 503 #else
 504     pthread_setname_np(thr, name);
 505 #endif
 506 #elif defined(HAVE_PTHREAD_SET_NAME_NP)
 507     pthread_set_name_np(thr, name);
 508 #else
 509     (void)thr;
 510     (void)name;
 511 #endif
 512 }
 513
 514
 515 typedef struct thread_cntr {
 516     althrd_start_t func;
 517     void *arg;
 518 } thread_cntr;
 519
 520 static void *althrd_starter(void *arg)
 521 {
 522     thread_cntr cntr;
 523     memcpy(&cntr, arg, sizeof(cntr));
 524     free(arg);
 525
 526     return (void*)(intptr_t)((*cntr.func)(cntr.arg));
 527 }
 528
 529
 530 int althrd_create(althrd_t *thr, althrd_start_t func, void *arg)
 531 {
 532     thread_cntr *cntr;
 533     pthread_attr_t attr;
 534     size_t stackmult = 1;
 535     int err;
 536
 537     cntr = malloc(sizeof(*cntr));
 538     if(!cntr) return althrd_nomem;
 539
 540     if(pthread_attr_init(&attr) != 0)
 541     {
 542         free(cntr);
 543         return althrd_error;
 544     }
 545 retry_stacksize:
 546     if(pthread_attr_setstacksize(&attr, THREAD_STACK_SIZE*stackmult) != 0)
 547     {
 548         pthread_attr_destroy(&attr);
 549         free(cntr);
 550         return althrd_error;
 551     }
 552
 553     cntr->func = func;
 554     cntr->arg = arg;
 555     if((err=pthread_create(thr, &attr, althrd_starter, cntr)) == 0)
 556     {
 557         pthread_attr_destroy(&attr);
 558         return althrd_success;
 559     }
 560
 561     if(err == EINVAL)
 562     {
 563         /* If an invalid stack size, try increasing it (limit x4, 8MB). */
 564         if(stackmult < 4)
 565         {
 566             stackmult *= 2;
 567             goto retry_stacksize;
 568         }
 569         /* If still nothing, try defaults and hope they're good enough. */
 570         if(pthread_create(thr, NULL, althrd_starter, cntr) == 0)
 571         {
 572             pthread_attr_destroy(&attr);
 573             return althrd_success;
 574         }
 575     }
 576     pthread_attr_destroy(&attr);
 577     free(cntr);
 578     return althrd_error;
 579 }
 580
 581 int althrd_detach(althrd_t thr)
 582 {
 583     if(pthread_detach(thr) != 0)
 584         return althrd_error;
 585     return althrd_success;
 586 }
 587
 588 int althrd_join(althrd_t thr, int *res)
 589 {
 590     void *code;
 591
 592     if(pthread_join(thr, &code) != 0)
 593         return althrd_error;
 594     if(res != NULL)
 595         *res = (int)(intptr_t)code;
 596     return althrd_success;
 597 }
 598
 599
 600 int almtx_init(almtx_t *mtx, int type)
 601 {
 602     int ret;
 603
 604     if(!mtx) return althrd_error;
 605 #ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
 606     if((type&~(almtx_recursive|almtx_timed)) != 0)
 607         return althrd_error;
 608 #else
 609     if((type&~almtx_recursive) != 0)
 610         return althrd_error;
 611 #endif
 612
 613     type &= ~almtx_timed;
 614     if(type == almtx_plain)
 615         ret = pthread_mutex_init(mtx, NULL);
 616     else
 617     {
 618         pthread_mutexattr_t attr;
 619
 620         ret = pthread_mutexattr_init(&attr);
 621         if(ret) return althrd_error;
 622
 623         if(type == almtx_recursive)
 624         {
 625             ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 626 #ifdef HAVE_PTHREAD_MUTEXATTR_SETKIND_NP
 627             if(ret != 0)
 628                 ret = pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE);
 629 #endif
 630         }
 631         else
 632             ret = 1;
 633         if(ret == 0)
 634             ret = pthread_mutex_init(mtx, &attr);
 635         pthread_mutexattr_destroy(&attr);
 636     }
 637     return ret ? althrd_error : althrd_success;
 638 }
 639
 640 void almtx_destroy(almtx_t *mtx)
 641 {
 642     pthread_mutex_destroy(mtx);
 643 }
 644
 645 int almtx_timedlock(almtx_t *mtx, const struct timespec *ts)
 646 {
 647 #ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
 648     int ret = pthread_mutex_timedlock(mtx, ts);
 649     switch(ret)
 650     {
 651         case 0: return althrd_success;
 652         case ETIMEDOUT: return althrd_timedout;
 653         case EBUSY: return althrd_busy;
 654     }
 655 #endif
 656     return althrd_error;
 657 }
 658
 659 int alcnd_init(alcnd_t *cond)
 660 {
 661     if(pthread_cond_init(cond, NULL) == 0)
 662         return althrd_success;
 663     return althrd_error;
 664 }
 665
 666 int alcnd_signal(alcnd_t *cond)
 667 {
 668     if(pthread_cond_signal(cond) == 0)
 669         return althrd_success;
 670     return althrd_error;
 671 }
 672
 673 int alcnd_broadcast(alcnd_t *cond)
 674 {
 675     if(pthread_cond_broadcast(cond) == 0)
 676         return althrd_success;
 677     return althrd_error;
 678 }
 679
 680 int alcnd_wait(alcnd_t *cond, almtx_t *mtx)
 681 {
 682     if(pthread_cond_wait(cond, mtx) == 0)
 683         return althrd_success;
 684     return althrd_error;
 685 }
 686
 687 int alcnd_timedwait(alcnd_t *cond, almtx_t *mtx, const struct timespec *time_point)
 688 {
 689     if(pthread_cond_timedwait(cond, mtx, time_point) == 0)
 690         return althrd_success;
 691     return althrd_error;
 692 }
 693
 694 void alcnd_destroy(alcnd_t *cond)
 695 {
 696     pthread_cond_destroy(cond);
 697 }
 698
 699
 700 int altss_create(altss_t *tss_id, altss_dtor_t callback)
 701 {
 702     if(pthread_key_create(tss_id, callback) != 0)
 703         return althrd_error;
 704     return althrd_success;
 705 }
 706
 707 void altss_delete(altss_t tss_id)
 708 {
 709     pthread_key_delete(tss_id);
 710 }
 711
 712
 713 int altimespec_get(struct timespec *ts, int base)
 714 {
 715     if(base == AL_TIME_UTC)
 716     {
 717         int ret;
 718 #if _POSIX_TIMERS > 0
 719         ret = clock_gettime(CLOCK_REALTIME, ts);
 720         if(ret == 0) return base;
 721 #else /* _POSIX_TIMERS > 0 */
 722         struct timeval tv;
 723         ret = gettimeofday(&tv, NULL);
 724         if(ret == 0)
 725         {
 726             ts->tv_sec = tv.tv_sec;
 727             ts->tv_nsec = tv.tv_usec * 1000;
 728             return base;
 729         }
 730 #endif
 731     }
 732
 733     return 0;
 734 }
 735
 736 #endif
 737
 738
 739 void al_nssleep(unsigned long nsec)
 740 {
 741     struct timespec ts, rem;
 742     ts.tv_sec = nsec / 1000000000ul;
 743     ts.tv_nsec = nsec % 1000000000ul;
 744
 745     while(althrd_sleep(&ts, &rem) == -1)
 746         ts = rem;
 747 }