include/c11/threads_posix.h

   1 /*
   2  * C11 <threads.h> emulation library
   3  *
   4  * (C) Copyright yohhoy 2012.
   5  * Distributed under the Boost Software License, Version 1.0.
   6  *
   7  * Permission is hereby granted, free of charge, to any person or organization
   8  * obtaining a copy of the software and accompanying documentation covered by
   9  * this license (the "Software") to use, reproduce, display, distribute,
  10  * execute, and transmit the Software, and to prepare [[derivative work]]s of the
  11  * Software, and to permit third-parties to whom the Software is furnished to
  12  * do so, all subject to the following:
  13  *
  14  * The copyright notices in the Software and this entire statement, including
  15  * the above license grant, this restriction and the following disclaimer,
  16  * must be included in all copies of the Software, in whole or in part, and
  17  * all derivative works of the Software, unless such copies or derivative
  18  * works are solely in the form of machine-executable object code generated by
  19  * a source language processor.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
  24  * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
  25  * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
  26  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  27  * DEALINGS IN THE SOFTWARE.
  28  */
  29 #include <stdlib.h>
  30 #ifndef assert
  31 #include <assert.h>
  32 #endif
  33 #include <limits.h>
  34 #include <errno.h>
  35 #include <unistd.h>
  36 #include <sched.h>
  37 #include <stdint.h> /* for intptr_t */
  38
  39 /*
  40 Configuration macro:
  41
  42   EMULATED_THREADS_USE_NATIVE_TIMEDLOCK
  43     Use pthread_mutex_timedlock() for `mtx_timedlock()'
  44     Otherwise use mtx_trylock() + *busy loop* emulation.
  45 */
  46 #if !defined(__CYGWIN__) && !defined(__APPLE__) && !defined(__NetBSD__)
  47 #define EMULATED_THREADS_USE_NATIVE_TIMEDLOCK
  48 #endif
  49
  50
  51 #include <pthread.h>
  52
  53 /*---------------------------- macros ----------------------------*/
  54 #define ONCE_FLAG_INIT PTHREAD_ONCE_INIT
  55 #ifdef INIT_ONCE_STATIC_INIT
  56 #define TSS_DTOR_ITERATIONS PTHREAD_DESTRUCTOR_ITERATIONS
  57 #else
  58 #define TSS_DTOR_ITERATIONS 1  // assume TSS dtor MAY be called at least once.
  59 #endif
  60
  61 // FIXME: temporary non-standard hack to ease transition
  62 #define _MTX_INITIALIZER_NP PTHREAD_MUTEX_INITIALIZER
  63
  64 /*---------------------------- types ----------------------------*/
  65 typedef pthread_cond_t  cnd_t;
  66 typedef pthread_t       thrd_t;
  67 typedef pthread_key_t   tss_t;
  68 typedef pthread_mutex_t mtx_t;
  69 typedef pthread_once_t  once_flag;
  70
  71
  72 /*
  73 Implementation limits:
  74   - Conditionally emulation for "mutex with timeout"
  75     (see EMULATED_THREADS_USE_NATIVE_TIMEDLOCK macro)
  76 */
  77 struct impl_thrd_param {
  78     thrd_start_t func;
  79     void *arg;
  80 };
  81
  82 static inline void *
  83 impl_thrd_routine(void *p)
  84 {
  85     struct impl_thrd_param pack = *((struct impl_thrd_param *)p);
  86     free(p);
  87     return (void*)(intptr_t)pack.func(pack.arg);
  88 }
  89
  90
  91 /*--------------- 7.25.2 Initialization functions ---------------*/
  92 // 7.25.2.1
  93 static inline void
  94 call_once(once_flag *flag, void (*func)(void))
  95 {
  96     pthread_once(flag, func);
  97 }
  98
  99
 100 /*------------- 7.25.3 Condition variable functions -------------*/
 101 // 7.25.3.1
 102 static inline int
 103 cnd_broadcast(cnd_t *cond)
 104 {
 105     assert(cond != NULL);
 106     return (pthread_cond_broadcast(cond) == 0) ? thrd_success : thrd_error;
 107 }
 108
 109 // 7.25.3.2
 110 static inline void
 111 cnd_destroy(cnd_t *cond)
 112 {
 113     assert(cond);
 114     pthread_cond_destroy(cond);
 115 }
 116
 117 // 7.25.3.3
 118 static inline int
 119 cnd_init(cnd_t *cond)
 120 {
 121     assert(cond != NULL);
 122     return (pthread_cond_init(cond, NULL) == 0) ? thrd_success : thrd_error;
 123 }
 124
 125 // 7.25.3.4
 126 static inline int
 127 cnd_signal(cnd_t *cond)
 128 {
 129     assert(cond != NULL);
 130     return (pthread_cond_signal(cond) == 0) ? thrd_success : thrd_error;
 131 }
 132
 133 // 7.25.3.5
 134 static inline int
 135 cnd_timedwait(cnd_t *cond, mtx_t *mtx, const xtime *xt)
 136 {
 137     struct timespec abs_time;
 138     int rt;
 139
 140     assert(mtx != NULL);
 141     assert(cond != NULL);
 142     assert(xt != NULL);
 143
 144     abs_time.tv_sec = xt->sec;
 145     abs_time.tv_nsec = xt->nsec;
 146
 147     rt = pthread_cond_timedwait(cond, mtx, &abs_time);
 148     if (rt == ETIMEDOUT)
 149         return thrd_busy;
 150     return (rt == 0) ? thrd_success : thrd_error;
 151 }
 152
 153 // 7.25.3.6
 154 static inline int
 155 cnd_wait(cnd_t *cond, mtx_t *mtx)
 156 {
 157     assert(mtx != NULL);
 158     assert(cond != NULL);
 159     return (pthread_cond_wait(cond, mtx) == 0) ? thrd_success : thrd_error;
 160 }
 161
 162
 163 /*-------------------- 7.25.4 Mutex functions --------------------*/
 164 // 7.25.4.1
 165 static inline void
 166 mtx_destroy(mtx_t *mtx)
 167 {
 168     assert(mtx != NULL);
 169     pthread_mutex_destroy(mtx);
 170 }
 171
 172 /*
 173  * XXX: Workaround when building with -O0 and without pthreads link.
 174  *
 175  * In such cases constant folding and dead code elimination won't be
 176  * available, thus the compiler will always add the pthread_mutexattr*
 177  * functions into the binary. As we try to link, we'll fail as the
 178  * symbols are unresolved.
 179  *
 180  * Ideally we'll enable the optimisations locally, yet that does not
 181  * seem to work.
 182  *
 183  * So the alternative workaround is to annotate the symbols as weak.
 184  * Thus the linker will be happy and things don't clash when building
 185  * with -O1 or greater.
 186  */
 187 #ifdef HAVE_FUNC_ATTRIBUTE_WEAK
 188 __attribute__((weak))
 189 int pthread_mutexattr_init(pthread_mutexattr_t *attr);
 190
 191 __attribute__((weak))
 192 int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
 193
 194 __attribute__((weak))
 195 int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
 196 #endif
 197
 198 // 7.25.4.2
 199 static inline int
 200 mtx_init(mtx_t *mtx, int type)
 201 {
 202     pthread_mutexattr_t attr;
 203     assert(mtx != NULL);
 204     if (type != mtx_plain && type != mtx_timed && type != mtx_try
 205       && type != (mtx_plain|mtx_recursive)
 206       && type != (mtx_timed|mtx_recursive)
 207       && type != (mtx_try|mtx_recursive))
 208         return thrd_error;
 209
 210     if ((type & mtx_recursive) == 0) {
 211         pthread_mutex_init(mtx, NULL);
 212         return thrd_success;
 213     }
 214
 215     pthread_mutexattr_init(&attr);
 216     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 217     pthread_mutex_init(mtx, &attr);
 218     pthread_mutexattr_destroy(&attr);
 219     return thrd_success;
 220 }
 221
 222 // 7.25.4.3
 223 static inline int
 224 mtx_lock(mtx_t *mtx)
 225 {
 226     assert(mtx != NULL);
 227     return (pthread_mutex_lock(mtx) == 0) ? thrd_success : thrd_error;
 228 }
 229
 230 static inline int
 231 mtx_trylock(mtx_t *mtx);
 232
 233 static inline void
 234 thrd_yield(void);
 235
 236 // 7.25.4.4
 237 static inline int
 238 mtx_timedlock(mtx_t *mtx, const xtime *xt)
 239 {
 240     assert(mtx != NULL);
 241     assert(xt != NULL);
 242
 243     {
 244 #ifdef EMULATED_THREADS_USE_NATIVE_TIMEDLOCK
 245     struct timespec ts;
 246     int rt;
 247     ts.tv_sec = xt->sec;
 248     ts.tv_nsec = xt->nsec;
 249     rt = pthread_mutex_timedlock(mtx, &ts);
 250     if (rt == 0)
 251         return thrd_success;
 252     return (rt == ETIMEDOUT) ? thrd_busy : thrd_error;
 253 #else
 254     time_t expire = time(NULL);
 255     expire += xt->sec;
 256     while (mtx_trylock(mtx) != thrd_success) {
 257         time_t now = time(NULL);
 258         if (expire < now)
 259             return thrd_busy;
 260         // busy loop!
 261         thrd_yield();
 262     }
 263     return thrd_success;
 264 #endif
 265     }
 266 }
 267
 268 // 7.25.4.5
 269 static inline int
 270 mtx_trylock(mtx_t *mtx)
 271 {
 272     assert(mtx != NULL);
 273     return (pthread_mutex_trylock(mtx) == 0) ? thrd_success : thrd_busy;
 274 }
 275
 276 // 7.25.4.6
 277 static inline int
 278 mtx_unlock(mtx_t *mtx)
 279 {
 280     assert(mtx != NULL);
 281     return (pthread_mutex_unlock(mtx) == 0) ? thrd_success : thrd_error;
 282 }
 283
 284
 285 /*------------------- 7.25.5 Thread functions -------------------*/
 286 // 7.25.5.1
 287 static inline int
 288 thrd_create(thrd_t *thr, thrd_start_t func, void *arg)
 289 {
 290     struct impl_thrd_param *pack;
 291     assert(thr != NULL);
 292     pack = (struct impl_thrd_param *)malloc(sizeof(struct impl_thrd_param));
 293     if (!pack) return thrd_nomem;
 294     pack->func = func;
 295     pack->arg = arg;
 296     if (pthread_create(thr, NULL, impl_thrd_routine, pack) != 0) {
 297         free(pack);
 298         return thrd_error;
 299     }
 300     return thrd_success;
 301 }
 302
 303 // 7.25.5.2
 304 static inline thrd_t
 305 thrd_current(void)
 306 {
 307     return pthread_self();
 308 }
 309
 310 // 7.25.5.3
 311 static inline int
 312 thrd_detach(thrd_t thr)
 313 {
 314     return (pthread_detach(thr) == 0) ? thrd_success : thrd_error;
 315 }
 316
 317 // 7.25.5.4
 318 static inline int
 319 thrd_equal(thrd_t thr0, thrd_t thr1)
 320 {
 321     return pthread_equal(thr0, thr1);
 322 }
 323
 324 // 7.25.5.5
 325 static inline void
 326 thrd_exit(int res)
 327 {
 328     pthread_exit((void*)(intptr_t)res);
 329 }
 330
 331 // 7.25.5.6
 332 static inline int
 333 thrd_join(thrd_t thr, int *res)
 334 {
 335     void *code;
 336     if (pthread_join(thr, &code) != 0)
 337         return thrd_error;
 338     if (res)
 339         *res = (int)(intptr_t)code;
 340     return thrd_success;
 341 }
 342
 343 // 7.25.5.7
 344 static inline void
 345 thrd_sleep(const xtime *xt)
 346 {
 347     struct timespec req;
 348     assert(xt);
 349     req.tv_sec = xt->sec;
 350     req.tv_nsec = xt->nsec;
 351     nanosleep(&req, NULL);
 352 }
 353
 354 // 7.25.5.8
 355 static inline void
 356 thrd_yield(void)
 357 {
 358     sched_yield();
 359 }
 360
 361
 362 /*----------- 7.25.6 Thread-specific storage functions -----------*/
 363 // 7.25.6.1
 364 static inline int
 365 tss_create(tss_t *key, tss_dtor_t dtor)
 366 {
 367     assert(key != NULL);
 368     return (pthread_key_create(key, dtor) == 0) ? thrd_success : thrd_error;
 369 }
 370
 371 // 7.25.6.2
 372 static inline void
 373 tss_delete(tss_t key)
 374 {
 375     pthread_key_delete(key);
 376 }
 377
 378 // 7.25.6.3
 379 static inline void *
 380 tss_get(tss_t key)
 381 {
 382     return pthread_getspecific(key);
 383 }
 384
 385 // 7.25.6.4
 386 static inline int
 387 tss_set(tss_t key, void *val)
 388 {
 389     return (pthread_setspecific(key, val) == 0) ? thrd_success : thrd_error;
 390 }
 391
 392
 393 /*-------------------- 7.25.7 Time functions --------------------*/
 394 // 7.25.6.1
 395 static inline int
 396 xtime_get(xtime *xt, int base)
 397 {
 398     if (!xt) return 0;
 399     if (base == TIME_UTC) {
 400         xt->sec = time(NULL);
 401         xt->nsec = 0;
 402         return base;
 403     }
 404     return 0;
 405 }