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., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, 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 (1*1024*1024) /* 1MB */
  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     *res = (int)code;
 174     return althrd_success;
 175 }
 176
 177 int althrd_sleep(const struct timespec *ts, struct timespec* UNUSED(rem))
 178 {
 179     DWORD msec;
 180
 181     if(ts->tv_sec < 0 || ts->tv_sec >= (0x7fffffff / 1000) ||
 182        ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000)
 183         return -2;
 184
 185     msec  = (DWORD)(ts->tv_sec * 1000);
 186     msec += (DWORD)((ts->tv_nsec+999999) / 1000000);
 187     Sleep(msec);
 188
 189     return 0;
 190 }
 191
 192
 193 int almtx_init(almtx_t *mtx, int type)
 194 {
 195     if(!mtx) return althrd_error;
 196     type &= ~(almtx_recursive|almtx_timed);
 197     if(type != almtx_plain)
 198         return althrd_error;
 199
 200     InitializeCriticalSection(mtx);
 201     return althrd_success;
 202 }
 203
 204 void almtx_destroy(almtx_t *mtx)
 205 {
 206     DeleteCriticalSection(mtx);
 207 }
 208
 209 int almtx_timedlock(almtx_t *mtx, const struct timespec *ts)
 210 {
 211     int ret;
 212
 213     if(!mtx || !ts)
 214         return althrd_error;
 215
 216     while((ret=almtx_trylock(mtx)) == althrd_busy)
 217     {
 218         struct timespec now;
 219
 220         if(ts->tv_sec < 0 || ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000 ||
 221            altimespec_get(&now, AL_TIME_UTC) != AL_TIME_UTC)
 222             return althrd_error;
 223         if(now.tv_sec > ts->tv_sec || (now.tv_sec == ts->tv_sec && now.tv_nsec >= ts->tv_nsec))
 224             return althrd_timedout;
 225
 226         althrd_yield();
 227     }
 228
 229     return ret;
 230 }
 231
 232
 233 /* An associative map of uint:void* pairs. The key is the TLS index (given by
 234  * TlsAlloc), and the value is the altss_dtor_t callback. When a thread exits,
 235  * we iterate over the TLS indices for their thread-local value and call the
 236  * destructor function with it if they're both not NULL. To avoid using
 237  * DllMain, a PIMAGE_TLS_CALLBACK function pointer is placed in a ".CRT$XLx"
 238  * section (where x is a character A to Z) which will be called by the CRT.
 239  */
 240 static UIntMap TlsDestructors = UINTMAP_STATIC_INITIALIZE;
 241
 242 static void NTAPI altss_callback(void* UNUSED(handle), DWORD reason, void* UNUSED(reserved))
 243 {
 244     ALsizei i;
 245
 246     if(reason == DLL_PROCESS_DETACH)
 247     {
 248         ResetUIntMap(&TlsDestructors);
 249         return;
 250     }
 251     if(reason != DLL_THREAD_DETACH)
 252         return;
 253
 254     LockUIntMapRead(&TlsDestructors);
 255     for(i = 0;i < TlsDestructors.size;i++)
 256     {
 257         void *ptr = altss_get(TlsDestructors.array[i].key);
 258         altss_dtor_t callback = (altss_dtor_t)TlsDestructors.array[i].value;
 259         if(ptr && callback)
 260             callback(ptr);
 261     }
 262     UnlockUIntMapRead(&TlsDestructors);
 263 }
 264 #ifdef _MSC_VER
 265 #pragma section(".CRT$XLB",read)
 266 __declspec(allocate(".CRT$XLB")) PIMAGE_TLS_CALLBACK altss_callback_ = altss_callback;
 267 #elif defined(__GNUC__)
 268 PIMAGE_TLS_CALLBACK altss_callback_ __attribute__((section(".CRT$XLB"))) = altss_callback;
 269 #else
 270 #warning "No TLS callback support, thread-local contexts may leak references on poorly written applications."
 271 PIMAGE_TLS_CALLBACK altss_callback_ = altss_callback;
 272 #endif
 273
 274 int altss_create(altss_t *tss_id, altss_dtor_t callback)
 275 {
 276     DWORD key = TlsAlloc();
 277     if(key == TLS_OUT_OF_INDEXES)
 278         return althrd_error;
 279
 280     *tss_id = key;
 281     if(callback != NULL)
 282         InsertUIntMapEntry(&TlsDestructors, key, callback);
 283     return althrd_success;
 284 }
 285
 286 void altss_delete(altss_t tss_id)
 287 {
 288     RemoveUIntMapKey(&TlsDestructors, tss_id);
 289     TlsFree(tss_id);
 290 }
 291
 292
 293 int altimespec_get(struct timespec *ts, int base)
 294 {
 295     if(base == AL_TIME_UTC)
 296     {
 297         union {
 298             FILETIME ftime;
 299             ULARGE_INTEGER ulint;
 300         } systime;
 301         GetSystemTimeAsFileTime(&systime.ftime);
 302         /* FILETIME is in 100-nanosecond units, or 1/10th of a microsecond. */
 303         ts->tv_sec = systime.ulint.QuadPart/10000000;
 304         ts->tv_nsec = (systime.ulint.QuadPart%10000000) * 100;
 305         return base;
 306     }
 307
 308     return 0;
 309 }
 310
 311
 312 void alcall_once(alonce_flag *once, void (*callback)(void))
 313 {
 314     LONG ret;
 315     while((ret=InterlockedExchange(once, 1)) == 1)
 316         althrd_yield();
 317     if(ret == 0)
 318         (*callback)();
 319     InterlockedExchange(once, 2);
 320 }
 321
 322 #else
 323
 324 #include <sys/time.h>
 325 #include <unistd.h>
 326 #include <pthread.h>
 327 #ifdef HAVE_PTHREAD_NP_H
 328 #include <pthread_np.h>
 329 #endif
 330
 331
 332 extern inline int althrd_sleep(const struct timespec *ts, struct timespec *rem);
 333 extern inline void alcall_once(alonce_flag *once, void (*callback)(void));
 334
 335
 336 void althrd_setname(althrd_t thr, const char *name)
 337 {
 338 #if defined(HAVE_PTHREAD_SETNAME_NP)
 339 #if defined(__GNUC__)
 340     pthread_setname_np(thr, name);
 341 #elif defined(__APPLE__)
 342     if(althrd_equal(thr, althrd_current())
 343         pthread_setname_np(name);
 344 #endif
 345 #elif defined(HAVE_PTHREAD_SET_NAME_NP)
 346     pthread_set_name_np(thr, name);
 347 #else
 348     (void)thr;
 349     (void)name;
 350 #endif
 351 }
 352
 353
 354 typedef struct thread_cntr {
 355     althrd_start_t func;
 356     void *arg;
 357 } thread_cntr;
 358
 359 static void *althrd_starter(void *arg)
 360 {
 361     thread_cntr cntr;
 362     memcpy(&cntr, arg, sizeof(cntr));
 363     free(arg);
 364
 365     return (void*)(intptr_t)((*cntr.func)(cntr.arg));
 366 }
 367
 368
 369 int althrd_create(althrd_t *thr, althrd_start_t func, void *arg)
 370 {
 371     thread_cntr *cntr;
 372     pthread_attr_t attr;
 373
 374     cntr = malloc(sizeof(*cntr));
 375     if(!cntr) return althrd_nomem;
 376
 377     if(pthread_attr_init(&attr) != 0)
 378     {
 379         free(cntr);
 380         return althrd_error;
 381     }
 382     if(pthread_attr_setstacksize(&attr, THREAD_STACK_SIZE) != 0)
 383     {
 384         pthread_attr_destroy(&attr);
 385         free(cntr);
 386         return althrd_error;
 387     }
 388
 389     cntr->func = func;
 390     cntr->arg = arg;
 391     if(pthread_create(thr, &attr, althrd_starter, cntr) != 0)
 392     {
 393         pthread_attr_destroy(&attr);
 394         free(cntr);
 395         return althrd_error;
 396     }
 397     pthread_attr_destroy(&attr);
 398
 399     return althrd_success;
 400 }
 401
 402 int althrd_detach(althrd_t thr)
 403 {
 404     if(pthread_detach(thr) != 0)
 405         return althrd_error;
 406     return althrd_success;
 407 }
 408
 409 int althrd_join(althrd_t thr, int *res)
 410 {
 411     void *code;
 412
 413     if(!res) return althrd_error;
 414
 415     if(pthread_join(thr, &code) != 0)
 416         return althrd_error;
 417     *res = (int)(intptr_t)code;
 418     return althrd_success;
 419 }
 420
 421
 422 int almtx_init(almtx_t *mtx, int type)
 423 {
 424     int ret;
 425
 426     if(!mtx) return althrd_error;
 427     if((type&~(almtx_recursive|almtx_timed)) != 0)
 428         return althrd_error;
 429
 430     type &= ~almtx_timed;
 431     if(type == almtx_plain)
 432         ret = pthread_mutex_init(mtx, NULL);
 433     else
 434     {
 435         pthread_mutexattr_t attr;
 436
 437         ret = pthread_mutexattr_init(&attr);
 438         if(ret) return althrd_error;
 439
 440         if(type == almtx_recursive)
 441         {
 442             ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 443 #ifdef HAVE_PTHREAD_MUTEXATTR_SETKIND_NP
 444             if(ret != 0)
 445                 ret = pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE);
 446 #endif
 447         }
 448         else
 449             ret = 1;
 450         if(ret == 0)
 451             ret = pthread_mutex_init(mtx, &attr);
 452         pthread_mutexattr_destroy(&attr);
 453     }
 454     return ret ? althrd_error : althrd_success;
 455 }
 456
 457 void almtx_destroy(almtx_t *mtx)
 458 {
 459     pthread_mutex_destroy(mtx);
 460 }
 461
 462 int almtx_timedlock(almtx_t *mtx, const struct timespec *ts)
 463 {
 464     int ret;
 465
 466 #ifdef HAVE_PTHREAD_MUTEX_TIMEDLOCK
 467     ret = pthread_mutex_timedlock(mtx, ts);
 468     switch(ret)
 469     {
 470         case 0: return althrd_success;
 471         case ETIMEDOUT: return althrd_timedout;
 472         case EBUSY: return althrd_busy;
 473     }
 474     return althrd_error;
 475 #else
 476     if(!mtx || !ts)
 477         return althrd_error;
 478
 479     while((ret=almtx_trylock(mtx)) == althrd_busy)
 480     {
 481         struct timespec now;
 482
 483         if(ts->tv_sec < 0 || ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000 ||
 484            altimespec_get(&now, AL_TIME_UTC) != AL_TIME_UTC)
 485             return althrd_error;
 486         if(now.tv_sec > ts->tv_sec || (now.tv_sec == ts->tv_sec && now.tv_nsec >= ts->tv_nsec))
 487             return althrd_timedout;
 488
 489         althrd_yield();
 490     }
 491
 492     return ret;
 493 #endif
 494 }
 495
 496
 497 int altss_create(altss_t *tss_id, altss_dtor_t callback)
 498 {
 499     if(pthread_key_create(tss_id, callback) != 0)
 500         return althrd_error;
 501     return althrd_success;
 502 }
 503
 504 void altss_delete(altss_t tss_id)
 505 {
 506     pthread_key_delete(tss_id);
 507 }
 508
 509
 510 int altimespec_get(struct timespec *ts, int base)
 511 {
 512     if(base == AL_TIME_UTC)
 513     {
 514         int ret;
 515 #if _POSIX_TIMERS > 0
 516         ret = clock_gettime(CLOCK_REALTIME, ts);
 517         if(ret == 0) return base;
 518 #else /* _POSIX_TIMERS > 0 */
 519         struct timeval tv;
 520         ret = gettimeofday(&tv, NULL);
 521         if(ret == 0)
 522         {
 523             ts->tv_sec = tv.tv_sec;
 524             ts->tv_nsec = tv.tv_usec * 1000;
 525             return base;
 526         }
 527 #endif
 528     }
 529
 530     return 0;
 531 }
 532
 533 #endif
 534
 535
 536 void al_nssleep(time_t sec, long nsec)
 537 {
 538     struct timespec ts, rem;
 539     ts.tv_sec = sec;
 540     ts.tv_nsec = nsec;
 541
 542     while(althrd_sleep(&ts, &rem) == -1)
 543         ts = rem;
 544 }