libphobos/libdruntime/core/sys/posix/pthread.d

   1 /**
   2  * D header file for POSIX.
   3  *
   4  * Copyright: Copyright Sean Kelly 2005 - 2009.
   5  * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
   6  * Authors:   Sean Kelly, Alex Rønne Petersen
   7  * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
   8  */
   9
  10 /*          Copyright Sean Kelly 2005 - 2009.
  11  * Distributed under the Boost Software License, Version 1.0.
  12  *    (See accompanying file LICENSE or copy at
  13  *          http://www.boost.org/LICENSE_1_0.txt)
  14  */
  15 module core.sys.posix.pthread;
  16
  17 private import core.sys.posix.config;
  18 public import core.sys.posix.sys.types;
  19 public import core.sys.posix.sched;
  20 public import core.sys.posix.time;
  21
  22 import core.stdc.stdint;
  23
  24 version (OSX)
  25     version = Darwin;
  26 else version (iOS)
  27     version = Darwin;
  28 else version (TVOS)
  29     version = Darwin;
  30 else version (WatchOS)
  31     version = Darwin;
  32
  33 version (Posix):
  34 extern (C)
  35 nothrow:
  36
  37 //
  38 // Required
  39 //
  40 /*
  41 PTHREAD_CANCEL_ASYNCHRONOUS
  42 PTHREAD_CANCEL_ENABLE
  43 PTHREAD_CANCEL_DEFERRED
  44 PTHREAD_CANCEL_DISABLE
  45 PTHREAD_CANCELED
  46 PTHREAD_COND_INITIALIZER
  47 PTHREAD_CREATE_DETACHED
  48 PTHREAD_CREATE_JOINABLE
  49 PTHREAD_EXPLICIT_SCHED
  50 PTHREAD_INHERIT_SCHED
  51 PTHREAD_MUTEX_INITIALIZER
  52 PTHREAD_ONCE_INIT
  53 PTHREAD_PROCESS_SHARED
  54 PTHREAD_PROCESS_PRIVATE
  55
  56 int pthread_atfork(void function(), void function(), void function());
  57 int pthread_attr_destroy(pthread_attr_t*);
  58 int pthread_attr_getdetachstate(in pthread_attr_t*, int*);
  59 int pthread_attr_getschedparam(in pthread_attr_t*, sched_param*);
  60 int pthread_attr_init(pthread_attr_t*);
  61 int pthread_attr_setdetachstate(pthread_attr_t*, int);
  62 int pthread_attr_setschedparam(in pthread_attr_t*, sched_param*);
  63 int pthread_cancel(pthread_t);
  64 void pthread_cleanup_push(void function(void*), void*);
  65 void pthread_cleanup_pop(int);
  66 int pthread_cond_broadcast(pthread_cond_t*);
  67 int pthread_cond_destroy(pthread_cond_t*);
  68 int pthread_cond_init(in pthread_cond_t*, pthread_condattr_t*);
  69 int pthread_cond_signal(pthread_cond_t*);
  70 int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, in timespec*);
  71 int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
  72 int pthread_condattr_destroy(pthread_condattr_t*);
  73 int pthread_condattr_init(pthread_condattr_t*);
  74 int pthread_create(pthread_t*, in pthread_attr_t*, void* function(void*), void*);
  75 int pthread_detach(pthread_t);
  76 int pthread_equal(pthread_t, pthread_t);
  77 void pthread_exit(void*);
  78 void* pthread_getspecific(pthread_key_t);
  79 int pthread_join(pthread_t, void**);
  80 int pthread_key_create(pthread_key_t*, void function(void*));
  81 int pthread_key_delete(pthread_key_t);
  82 int pthread_mutex_destroy(pthread_mutex_t*);
  83 int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*);
  84 int pthread_mutex_lock(pthread_mutex_t*);
  85 int pthread_mutex_trylock(pthread_mutex_t*);
  86 int pthread_mutex_unlock(pthread_mutex_t*);
  87 int pthread_mutexattr_destroy(pthread_mutexattr_t*);
  88 int pthread_mutexattr_init(pthread_mutexattr_t*);
  89 int pthread_once(pthread_once_t*, void function());
  90 int pthread_rwlock_destroy(pthread_rwlock_t*);
  91 int pthread_rwlock_init(pthread_rwlock_t*, in pthread_rwlockattr_t*);
  92 int pthread_rwlock_rdlock(pthread_rwlock_t*);
  93 int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
  94 int pthread_rwlock_trywrlock(pthread_rwlock_t*);
  95 int pthread_rwlock_unlock(pthread_rwlock_t*);
  96 int pthread_rwlock_wrlock(pthread_rwlock_t*);
  97 int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
  98 int pthread_rwlockattr_init(pthread_rwlockattr_t*);
  99 pthread_t pthread_self();
 100 int pthread_setcancelstate(int, int*);
 101 int pthread_setcanceltype(int, int*);
 102 int pthread_setspecific(pthread_key_t, in void*);
 103 void pthread_testcancel();
 104 */
 105 version (CRuntime_Glibc)
 106 {
 107     enum
 108     {
 109         PTHREAD_CANCEL_ENABLE,
 110         PTHREAD_CANCEL_DISABLE
 111     }
 112
 113     enum
 114     {
 115         PTHREAD_CANCEL_DEFERRED,
 116         PTHREAD_CANCEL_ASYNCHRONOUS
 117     }
 118
 119     enum PTHREAD_CANCELED = cast(void*) -1;
 120
 121     //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 };
 122
 123     enum
 124     {
 125         PTHREAD_CREATE_JOINABLE,
 126         PTHREAD_CREATE_DETACHED
 127     }
 128
 129     enum
 130     {
 131         PTHREAD_INHERIT_SCHED,
 132         PTHREAD_EXPLICIT_SCHED
 133     }
 134
 135     enum PTHREAD_MUTEX_INITIALIZER  = pthread_mutex_t.init;
 136     enum PTHREAD_ONCE_INIT          = pthread_once_t.init;
 137
 138     enum
 139     {
 140         PTHREAD_PROCESS_PRIVATE,
 141         PTHREAD_PROCESS_SHARED
 142     }
 143 }
 144 else version (Darwin)
 145 {
 146     enum
 147     {
 148         PTHREAD_CANCEL_ENABLE   = 1,
 149         PTHREAD_CANCEL_DISABLE  = 0
 150     }
 151
 152     enum
 153     {
 154         PTHREAD_CANCEL_DEFERRED     = 2,
 155         PTHREAD_CANCEL_ASYNCHRONOUS = 0
 156     }
 157
 158     enum PTHREAD_CANCELED = cast(void*) -1;
 159
 160     //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 };
 161
 162     enum
 163     {
 164         PTHREAD_CREATE_JOINABLE = 1,
 165         PTHREAD_CREATE_DETACHED = 2
 166     }
 167
 168     enum
 169     {
 170         PTHREAD_INHERIT_SCHED   = 1,
 171         PTHREAD_EXPLICIT_SCHED  = 2
 172     }
 173
 174     enum PTHREAD_MUTEX_INITIALIZER  = pthread_mutex_t(0x32AAABA7);
 175     enum PTHREAD_ONCE_INIT          = pthread_once_t(0x30b1bcba);
 176
 177     enum
 178     {
 179         PTHREAD_PROCESS_PRIVATE = 2,
 180         PTHREAD_PROCESS_SHARED  = 1
 181     }
 182 }
 183 else version (FreeBSD)
 184 {
 185     enum
 186     {
 187         PTHREAD_DETACHED            = 0x1,
 188         PTHREAD_INHERIT_SCHED       = 0x4,
 189         PTHREAD_NOFLOAT             = 0x8,
 190
 191         PTHREAD_CREATE_DETACHED     = PTHREAD_DETACHED,
 192         PTHREAD_CREATE_JOINABLE     = 0,
 193         PTHREAD_EXPLICIT_SCHED      = 0,
 194     }
 195
 196     enum
 197     {
 198         PTHREAD_PROCESS_PRIVATE     = 0,
 199         PTHREAD_PROCESS_SHARED      = 1,
 200     }
 201
 202     enum
 203     {
 204         PTHREAD_CANCEL_ENABLE       = 0,
 205         PTHREAD_CANCEL_DISABLE      = 1,
 206         PTHREAD_CANCEL_DEFERRED     = 0,
 207         PTHREAD_CANCEL_ASYNCHRONOUS = 2,
 208     }
 209
 210     enum PTHREAD_CANCELED = cast(void*) -1;
 211
 212     enum PTHREAD_NEEDS_INIT = 0;
 213     enum PTHREAD_DONE_INIT  = 1;
 214
 215     enum PTHREAD_MUTEX_INITIALIZER              = null;
 216     enum PTHREAD_ONCE_INIT                      = null;
 217     enum PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP  = null;
 218     enum PTHREAD_COND_INITIALIZER               = null;
 219     enum PTHREAD_RWLOCK_INITIALIZER             = null;
 220 }
 221 else version (NetBSD)
 222 {
 223     enum PRI_NONE = -1;
 224     enum
 225     {
 226         PTHREAD_INHERIT_SCHED       = 0x0,
 227
 228         PTHREAD_CREATE_DETACHED     = 1,
 229         PTHREAD_CREATE_JOINABLE     = 0,
 230         PTHREAD_EXPLICIT_SCHED      = 1,
 231     }
 232
 233     enum
 234     {
 235         PTHREAD_PROCESS_PRIVATE     = 0,
 236         PTHREAD_PROCESS_SHARED      = 1,
 237     }
 238
 239     enum
 240     {
 241         PTHREAD_CANCEL_ENABLE       = 0,
 242         PTHREAD_CANCEL_DISABLE      = 1,
 243         PTHREAD_CANCEL_DEFERRED     = 0,
 244         PTHREAD_CANCEL_ASYNCHRONOUS = 1,
 245     }
 246
 247     enum PTHREAD_CANCELED = cast(void*) 1;
 248
 249     enum PTHREAD_DONE_INIT  = 1;
 250
 251     enum PTHREAD_MUTEX_INITIALIZER              = pthread_mutex_t(0x33330003);
 252
 253     enum PTHREAD_ONCE_INIT                      = pthread_once_t(PTHREAD_MUTEX_INITIALIZER);
 254     enum PTHREAD_COND_INITIALIZER               = pthread_cond_t(0x55550005);
 255     enum PTHREAD_RWLOCK_INITIALIZER             = pthread_rwlock_t(0x99990009);
 256 }
 257 else version (OpenBSD)
 258 {
 259     enum
 260     {
 261         PTHREAD_DETACHED            = 0x1,
 262         PTHREAD_INHERIT_SCHED       = 0x4,
 263         PTHREAD_NOFLOAT             = 0x8,
 264
 265         PTHREAD_CREATE_DETACHED     = PTHREAD_DETACHED,
 266         PTHREAD_CREATE_JOINABLE     = 0,
 267         PTHREAD_EXPLICIT_SCHED      = 0,
 268     }
 269
 270     enum
 271     {
 272         PTHREAD_PROCESS_PRIVATE     = 0,
 273         PTHREAD_PROCESS_SHARED      = 1,
 274     }
 275
 276     enum
 277     {
 278         PTHREAD_CANCEL_ENABLE       = 0,
 279         PTHREAD_CANCEL_DISABLE      = 1,
 280         PTHREAD_CANCEL_DEFERRED     = 0,
 281         PTHREAD_CANCEL_ASYNCHRONOUS = 2,
 282     }
 283
 284     enum PTHREAD_CANCELED = cast(void*) 1;
 285
 286     enum
 287     {
 288         PTHREAD_NEEDS_INIT = 0,
 289         PTHREAD_DONE_INIT  = 1,
 290     }
 291
 292     enum PTHREAD_MUTEX_INITIALIZER              = null;
 293     //enum PTHREAD_ONCE_INIT                      = { PTHREAD_NEEDS_INIT, PTHREAD_MUTEX_INITIALIZER };
 294     enum PTHREAD_COND_INITIALIZER               = null;
 295     enum PTHREAD_RWLOCK_INITIALIZER             = null;
 296 }
 297 else version (DragonFlyBSD)
 298 {
 299     enum
 300     {
 301         PTHREAD_DETACHED            = 0x1,
 302         //PTHREAD_SCOPE_SYSTEM        = 0x2,    // defined below
 303         PTHREAD_INHERIT_SCHED       = 0x4,
 304         PTHREAD_NOFLOAT             = 0x8,
 305
 306         PTHREAD_CREATE_DETACHED     = PTHREAD_DETACHED,
 307         PTHREAD_CREATE_JOINABLE     = 0,
 308         //PTHREAD_SCOPE_PROCESS       = 0,      // defined below
 309         PTHREAD_EXPLICIT_SCHED      = 0,
 310     }
 311
 312     enum
 313     {
 314         PTHREAD_PROCESS_PRIVATE     = 0,
 315         PTHREAD_PROCESS_SHARED      = 1,
 316     }
 317
 318     enum
 319     {
 320         PTHREAD_CANCEL_ENABLE       = 0,
 321         PTHREAD_CANCEL_DISABLE      = 1,
 322         PTHREAD_CANCEL_DEFERRED     = 0,
 323         PTHREAD_CANCEL_ASYNCHRONOUS = 2,
 324     }
 325
 326     enum PTHREAD_CANCELED = cast(void*) -1;
 327
 328     enum PTHREAD_NEEDS_INIT = 0;
 329     enum PTHREAD_DONE_INIT  = 1;
 330
 331     enum PTHREAD_MUTEX_INITIALIZER              = null;
 332     //enum PTHREAD_ONCE_INIT                      = { PTHREAD_NEEDS_INIT, NULL };
 333     enum PTHREAD_ONCE_INIT                      = pthread_once_t.init;;
 334     enum PTHREAD_COND_INITIALIZER               = null;
 335     enum PTHREAD_RWLOCK_INITIALIZER             = null;
 336 }
 337 else version (Solaris)
 338 {
 339     enum
 340     {
 341         PTHREAD_INHERIT_SCHED = 0x01,
 342         PTHREAD_NOFLOAT = 0x08,
 343         PTHREAD_CREATE_DETACHED = 0x40,
 344         PTHREAD_CREATE_JOINABLE = 0x00,
 345         PTHREAD_EXPLICIT_SCHED = 0x00,
 346     }
 347
 348     enum
 349     {
 350         PTHREAD_PROCESS_PRIVATE = 0,
 351         PTHREAD_PROCESS_SHARED = 1,
 352     }
 353
 354     enum
 355     {
 356         PTHREAD_CANCEL_ENABLE = 0,
 357         PTHREAD_CANCEL_DISABLE = 1,
 358         PTHREAD_CANCEL_DEFERRED = 0,
 359         PTHREAD_CANCEL_ASYNCHRONOUS = 2,
 360     }
 361
 362     enum PTHREAD_CANCELED = cast(void*)-19;
 363
 364     enum PTHREAD_MUTEX_INITIALIZER  = pthread_mutex_t.init;
 365     enum PTHREAD_ONCE_INIT          = pthread_once_t.init;
 366 }
 367 else version (CRuntime_Bionic)
 368 {
 369     enum
 370     {
 371         PTHREAD_CREATE_JOINABLE,
 372         PTHREAD_CREATE_DETACHED
 373     }
 374
 375     enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t.init;
 376     enum PTHREAD_ONCE_INIT         = pthread_once_t.init;
 377
 378     enum
 379     {
 380         PTHREAD_PROCESS_PRIVATE,
 381         PTHREAD_PROCESS_SHARED
 382     }
 383 }
 384 else version (CRuntime_Musl)
 385 {
 386     enum
 387     {
 388         PTHREAD_CREATE_JOINABLE = 0,
 389         PTHREAD_CREATE_DETACHED = 1
 390     }
 391
 392     enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t.init;
 393     enum PTHREAD_ONCE_INIT = pthread_once_t.init;
 394
 395     enum
 396     {
 397         PTHREAD_PROCESS_PRIVATE = 0,
 398         PTHREAD_PROCESS_SHARED = 1
 399     }
 400 }
 401 else version (CRuntime_UClibc)
 402 {
 403     enum
 404     {
 405         PTHREAD_CANCEL_ENABLE,
 406         PTHREAD_CANCEL_DISABLE
 407     }
 408
 409     enum
 410     {
 411         PTHREAD_CANCEL_DEFERRED,
 412         PTHREAD_CANCEL_ASYNCHRONOUS
 413     }
 414
 415     enum PTHREAD_CANCELED   = cast(void*) -1;
 416
 417     enum PTHREAD_MUTEX_INITIALIZER  = pthread_mutex_t.init;
 418     enum PTHREAD_ONCE_INIT          = pthread_once_t.init;
 419
 420     enum
 421     {
 422         PTHREAD_CREATE_JOINABLE,
 423         PTHREAD_CREATE_DETACHED
 424     }
 425
 426     enum
 427     {
 428         PTHREAD_INHERIT_SCHED,
 429         PTHREAD_EXPLICIT_SCHED
 430     }
 431
 432     enum
 433     {
 434         PTHREAD_PROCESS_PRIVATE,
 435         PTHREAD_PROCESS_SHARED
 436     }
 437 }
 438 else
 439 {
 440     static assert(false, "Unsupported platform");
 441 }
 442
 443 int pthread_atfork(void function(), void function(), void function());
 444 @nogc {
 445     int pthread_atfork(void function() @nogc, void function() @nogc, void function() @nogc);
 446     int pthread_attr_destroy(pthread_attr_t*);
 447     int pthread_attr_getdetachstate(in pthread_attr_t*, int*);
 448     int pthread_attr_getschedparam(in pthread_attr_t*, sched_param*);
 449     int pthread_attr_init(pthread_attr_t*);
 450     int pthread_attr_setdetachstate(pthread_attr_t*, int);
 451     int pthread_attr_setschedparam(in pthread_attr_t*, sched_param*);
 452     int pthread_cancel(pthread_t);
 453 }
 454
 455 alias void function(void*) _pthread_cleanup_routine;
 456 alias void function(void*) @nogc _pthread_cleanup_routine_nogc;
 457 version (CRuntime_Glibc)
 458 {
 459     struct _pthread_cleanup_buffer
 460     {
 461         _pthread_cleanup_routine    __routine;
 462         void*                       __arg;
 463         int                         __canceltype;
 464         _pthread_cleanup_buffer*    __prev;
 465     }
 466
 467     void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine, void*);
 468     void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine_nogc, void*) @nogc;
 469     void _pthread_cleanup_pop(_pthread_cleanup_buffer*, int);
 470
 471     struct pthread_cleanup
 472     {
 473         _pthread_cleanup_buffer buffer = void;
 474
 475         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 476         {
 477             _pthread_cleanup_push( &buffer, routine, arg );
 478         }
 479
 480         extern (D) void pop()( int execute )
 481         {
 482             _pthread_cleanup_pop( &buffer, execute );
 483         }
 484     }
 485 }
 486 else version (Darwin)
 487 {
 488     struct _pthread_cleanup_buffer
 489     {
 490         _pthread_cleanup_routine    __routine;
 491         void*                       __arg;
 492         _pthread_cleanup_buffer*    __next;
 493     }
 494
 495     struct pthread_cleanup
 496     {
 497         _pthread_cleanup_buffer buffer = void;
 498
 499         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 500         {
 501             pthread_t self       = pthread_self();
 502             buffer.__routine     = routine;
 503             buffer.__arg         = arg;
 504             buffer.__next        = cast(_pthread_cleanup_buffer*) self.__cleanup_stack;
 505             self.__cleanup_stack = cast(pthread_handler_rec*) &buffer;
 506         }
 507
 508         extern (D) void pop()( int execute )
 509         {
 510             pthread_t self       = pthread_self();
 511             self.__cleanup_stack = cast(pthread_handler_rec*) buffer.__next;
 512             if ( execute )
 513             {
 514                 buffer.__routine( buffer.__arg );
 515             }
 516         }
 517     }
 518 }
 519 else version (FreeBSD)
 520 {
 521     struct _pthread_cleanup_info
 522     {
 523         uintptr_t[8]    pthread_cleanup_pad;
 524     }
 525
 526     struct pthread_cleanup
 527     {
 528         _pthread_cleanup_info __cleanup_info__ = void;
 529
 530         extern (D) void push(F: _pthread_cleanup_routine)(F cleanup_routine, void* cleanup_arg )
 531         {
 532             __pthread_cleanup_push_imp( cleanup_routine, cleanup_arg, &__cleanup_info__ );
 533         }
 534
 535         extern (D) void pop()( int execute )
 536         {
 537             __pthread_cleanup_pop_imp( execute );
 538         }
 539     }
 540
 541     void __pthread_cleanup_push_imp(_pthread_cleanup_routine, void*, _pthread_cleanup_info*);
 542     void __pthread_cleanup_push_imp(_pthread_cleanup_routine_nogc, void*, _pthread_cleanup_info*) @nogc;
 543     void __pthread_cleanup_pop_imp(int);
 544 }
 545 else version (DragonFlyBSD)
 546 {
 547     struct _pthread_cleanup_info
 548     {
 549         uintptr_t[8]    pthread_cleanup_pad;
 550     }
 551
 552     struct pthread_cleanup
 553     {
 554         _pthread_cleanup_info __cleanup_info__ = void;
 555
 556         extern (D) void push()( _pthread_cleanup_routine cleanup_routine, void* cleanup_arg )
 557         {
 558             _pthread_cleanup_push( cleanup_routine, cleanup_arg, &__cleanup_info__ );
 559         }
 560
 561         extern (D) void pop()( int execute )
 562         {
 563             _pthread_cleanup_pop( execute );
 564         }
 565     }
 566
 567     void _pthread_cleanup_push(_pthread_cleanup_routine, void*, _pthread_cleanup_info*);
 568     void _pthread_cleanup_pop(int);
 569 }
 570 else version (NetBSD)
 571 {
 572     struct _pthread_cleanup_store
 573     {
 574         void*[4]    pthread_cleanup_pad;
 575     }
 576
 577     struct pthread_cleanup
 578     {
 579         _pthread_cleanup_store __cleanup_info__ = void;
 580
 581         extern (D) void push()( _pthread_cleanup_routine cleanup_routine, void* cleanup_arg )
 582         {
 583             pthread__cleanup_push( cleanup_routine, cleanup_arg, &__cleanup_info__ );
 584         }
 585
 586         extern (D) void pop()( int execute )
 587         {
 588             pthread__cleanup_pop( execute, &__cleanup_info__ );
 589         }
 590     }
 591
 592     void pthread__cleanup_push(_pthread_cleanup_routine, void*, void*);
 593     void pthread__cleanup_pop(int, void *);
 594 }
 595 else version (OpenBSD)
 596 {
 597     void pthread_cleanup_push(void function(void*), void*);
 598     void pthread_cleanup_pop(int);
 599 }
 600 else version (Solaris)
 601 {
 602     caddr_t _getfp();
 603
 604     struct _pthread_cleanup_info
 605     {
 606         uintptr_t[4] pthread_cleanup_pad;
 607     }
 608
 609     struct pthread_cleanup
 610     {
 611         _pthread_cleanup_info __cleanup_info__ = void;
 612
 613         extern (D) void push(F: _pthread_cleanup_routine)(F cleanup_routine, void* cleanup_arg)
 614         {
 615             __pthread_cleanup_push(cleanup_routine, cleanup_arg, _getfp(), &__cleanup_info__);
 616         }
 617
 618         extern (D) void pop()(int execute)
 619         {
 620             __pthread_cleanup_pop(execute, &__cleanup_info__);
 621         }
 622     }
 623
 624     void __pthread_cleanup_push(_pthread_cleanup_routine, void*, caddr_t, _pthread_cleanup_info*);
 625     void __pthread_cleanup_push(_pthread_cleanup_routine_nogc, void*, caddr_t, _pthread_cleanup_info*) @nogc;
 626     void __pthread_cleanup_pop(int, _pthread_cleanup_info*);
 627 }
 628 else version (CRuntime_Bionic)
 629 {
 630     struct __pthread_cleanup_t
 631     {
 632         __pthread_cleanup_t*     __cleanup_prev;
 633         _pthread_cleanup_routine __cleanup_routine;
 634         void*                    __cleanup_arg;
 635     }
 636
 637     void __pthread_cleanup_push(__pthread_cleanup_t*, _pthread_cleanup_routine, void*);
 638     void __pthread_cleanup_push(__pthread_cleanup_t*, _pthread_cleanup_routine_nogc, void*) @nogc;
 639     void __pthread_cleanup_pop(__pthread_cleanup_t*, int);
 640
 641     struct pthread_cleanup
 642     {
 643         __pthread_cleanup_t __cleanup = void;
 644
 645         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 646         {
 647             __pthread_cleanup_push( &__cleanup, routine, arg );
 648         }
 649
 650         extern (D) void pop()( int execute )
 651         {
 652             __pthread_cleanup_pop( &__cleanup, execute );
 653         }
 654     }
 655 }
 656 else version (CRuntime_Musl)
 657 {
 658     struct __ptcb {
 659         _pthread_cleanup_routine f;
 660         void* __x;
 661         __ptcb* __next;
 662     }
 663     void _pthread_cleanup_push(__ptcb*, _pthread_cleanup_routine, void*);
 664     void _pthread_cleanup_pop(__ptcb*, int);
 665
 666     struct pthread_cleanup
 667     {
 668         __ptcb __cleanup = void;
 669
 670         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 671         {
 672             _pthread_cleanup_push( &__cleanup, routine, arg );
 673         }
 674
 675         extern (D) void pop()( int execute )
 676         {
 677             _pthread_cleanup_pop( &__cleanup, execute );
 678         }
 679     }
 680 }
 681 else version (CRuntime_UClibc)
 682 {
 683     struct _pthread_cleanup_buffer
 684     {
 685         _pthread_cleanup_routine    __routine;
 686         void*                       __arg;
 687         int                         __canceltype;
 688         _pthread_cleanup_buffer*    __prev;
 689     }
 690
 691     void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine, void*);
 692     void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine_nogc, void*) @nogc;
 693     void _pthread_cleanup_pop(_pthread_cleanup_buffer*, int);
 694
 695     struct pthread_cleanup
 696     {
 697         _pthread_cleanup_buffer buffer = void;
 698
 699         extern (D) void push(F: _pthread_cleanup_routine)(F routine, void* arg )
 700         {
 701             _pthread_cleanup_push( &buffer, routine, arg );
 702         }
 703
 704         extern (D) void pop()( int execute )
 705         {
 706             _pthread_cleanup_pop( &buffer, execute );
 707         }
 708     }
 709 }
 710 else
 711 {
 712     static assert(false, "Unsupported platform");
 713 }
 714
 715 @nogc:
 716
 717 int pthread_cond_broadcast(pthread_cond_t*);
 718 int pthread_cond_destroy(pthread_cond_t*);
 719 int pthread_cond_init(in pthread_cond_t*, pthread_condattr_t*) @trusted;
 720 int pthread_cond_signal(pthread_cond_t*);
 721 int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, in timespec*);
 722 int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
 723 int pthread_condattr_destroy(pthread_condattr_t*);
 724 int pthread_condattr_init(pthread_condattr_t*);
 725 int pthread_create(pthread_t*, in pthread_attr_t*, void* function(void*), void*);
 726 int pthread_detach(pthread_t);
 727 int pthread_equal(pthread_t, pthread_t);
 728 void pthread_exit(void*);
 729 void* pthread_getspecific(pthread_key_t);
 730 int pthread_join(pthread_t, void**);
 731 int pthread_key_create(pthread_key_t*, void function(void*));
 732 int pthread_key_delete(pthread_key_t);
 733 int pthread_mutex_destroy(pthread_mutex_t*);
 734 int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*) @trusted;
 735 int pthread_mutex_lock(pthread_mutex_t*);
 736 int pthread_mutex_lock(shared(pthread_mutex_t)*);
 737 int pthread_mutex_trylock(pthread_mutex_t*);
 738 int pthread_mutex_trylock(shared(pthread_mutex_t)*);
 739 int pthread_mutex_unlock(pthread_mutex_t*);
 740 int pthread_mutex_unlock(shared(pthread_mutex_t)*);
 741 int pthread_mutexattr_destroy(pthread_mutexattr_t*);
 742 int pthread_mutexattr_init(pthread_mutexattr_t*) @trusted;
 743 int pthread_once(pthread_once_t*, void function());
 744 int pthread_rwlock_destroy(pthread_rwlock_t*);
 745 int pthread_rwlock_init(pthread_rwlock_t*, in pthread_rwlockattr_t*);
 746 int pthread_rwlock_rdlock(pthread_rwlock_t*);
 747 int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
 748 int pthread_rwlock_trywrlock(pthread_rwlock_t*);
 749 int pthread_rwlock_unlock(pthread_rwlock_t*);
 750 int pthread_rwlock_wrlock(pthread_rwlock_t*);
 751 int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
 752 int pthread_rwlockattr_init(pthread_rwlockattr_t*);
 753 pthread_t pthread_self();
 754 int pthread_setcancelstate(int, int*);
 755 int pthread_setcanceltype(int, int*);
 756 int pthread_setspecific(pthread_key_t, in void*);
 757 void pthread_testcancel();
 758
 759 //
 760 // Barrier (BAR)
 761 //
 762 /*
 763 PTHREAD_BARRIER_SERIAL_THREAD
 764
 765 int pthread_barrier_destroy(pthread_barrier_t*);
 766 int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
 767 int pthread_barrier_wait(pthread_barrier_t*);
 768 int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 769 int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*); (BAR|TSH)
 770 int pthread_barrierattr_init(pthread_barrierattr_t*);
 771 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); (BAR|TSH)
 772 */
 773
 774 version (CRuntime_Glibc)
 775 {
 776     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 777
 778     int pthread_barrier_destroy(pthread_barrier_t*);
 779     int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
 780     int pthread_barrier_wait(pthread_barrier_t*);
 781     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 782     int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
 783     int pthread_barrierattr_init(pthread_barrierattr_t*);
 784     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 785 }
 786 else version (FreeBSD)
 787 {
 788     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 789
 790     int pthread_barrier_destroy(pthread_barrier_t*);
 791     int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
 792     int pthread_barrier_wait(pthread_barrier_t*);
 793     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 794     int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
 795     int pthread_barrierattr_init(pthread_barrierattr_t*);
 796     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 797 }
 798 else version (DragonFlyBSD)
 799 {
 800     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 801     enum PTHREAD_KEYS_MAX              = 256;
 802     enum PTHREAD_STACK_MIN             = 16384;
 803     enum PTHREAD_THREADS_MAX           = c_ulong.max;
 804
 805     int pthread_barrier_destroy(pthread_barrier_t*);
 806     int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
 807     int pthread_barrier_wait(pthread_barrier_t*);
 808     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 809     int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
 810     int pthread_barrierattr_init(pthread_barrierattr_t*);
 811     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 812 }
 813 else version (NetBSD)
 814 {
 815     enum PTHREAD_BARRIER_SERIAL_THREAD = 1234567;
 816
 817     int pthread_barrier_destroy(pthread_barrier_t*);
 818     int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
 819     int pthread_barrier_wait(pthread_barrier_t*);
 820     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 821     int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
 822     int pthread_barrierattr_init(pthread_barrierattr_t*);
 823     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 824 }
 825 else version (OpenBSD)
 826 {
 827     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 828
 829     int pthread_barrier_destroy(pthread_barrier_t*);
 830     int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
 831     int pthread_barrier_wait(pthread_barrier_t*);
 832     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 833     int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
 834     int pthread_barrierattr_init(pthread_barrierattr_t*);
 835     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 836 }
 837 else version (Darwin)
 838 {
 839 }
 840 else version (Solaris)
 841 {
 842     enum PTHREAD_BARRIER_SERIAL_THREAD = -2;
 843
 844     int pthread_barrier_destroy(pthread_barrier_t*);
 845     int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
 846     int pthread_barrier_wait(pthread_barrier_t*);
 847     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 848     int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
 849     int pthread_barrierattr_init(pthread_barrierattr_t*);
 850     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 851 }
 852 else version (CRuntime_Bionic)
 853 {
 854 }
 855 else version (CRuntime_Musl)
 856 {
 857
 858 }
 859 else version (CRuntime_UClibc)
 860 {
 861     enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
 862
 863     int pthread_barrier_destroy(pthread_barrier_t*);
 864     int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
 865     int pthread_barrier_wait(pthread_barrier_t*);
 866     int pthread_barrierattr_destroy(pthread_barrierattr_t*);
 867     int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
 868     int pthread_barrierattr_init(pthread_barrierattr_t*);
 869     int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
 870 }
 871 else
 872 {
 873     static assert(false, "Unsupported platform");
 874 }
 875
 876 //
 877 // Clock (CS)
 878 //
 879 /*
 880 int pthread_condattr_getclock(in pthread_condattr_t*, clockid_t*);
 881 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
 882 */
 883
 884 //
 885 // Spinlock (SPI)
 886 //
 887 /*
 888 int pthread_spin_destroy(pthread_spinlock_t*);
 889 int pthread_spin_init(pthread_spinlock_t*, int);
 890 int pthread_spin_lock(pthread_spinlock_t*);
 891 int pthread_spin_trylock(pthread_spinlock_t*);
 892 int pthread_spin_unlock(pthread_spinlock_t*);
 893 */
 894
 895 version (CRuntime_Glibc)
 896 {
 897     int pthread_spin_destroy(pthread_spinlock_t*);
 898     int pthread_spin_init(pthread_spinlock_t*, int);
 899     int pthread_spin_lock(pthread_spinlock_t*);
 900     int pthread_spin_trylock(pthread_spinlock_t*);
 901     int pthread_spin_unlock(pthread_spinlock_t*);
 902 }
 903 else version (FreeBSD)
 904 {
 905     int pthread_spin_init(pthread_spinlock_t*, int);
 906     int pthread_spin_destroy(pthread_spinlock_t*);
 907     int pthread_spin_lock(pthread_spinlock_t*);
 908     int pthread_spin_trylock(pthread_spinlock_t*);
 909     int pthread_spin_unlock(pthread_spinlock_t*);
 910 }
 911 else version (DragonFlyBSD)
 912 {
 913     int pthread_spin_init(pthread_spinlock_t*, int);
 914     int pthread_spin_destroy(pthread_spinlock_t*);
 915     int pthread_spin_lock(pthread_spinlock_t*);
 916     int pthread_spin_trylock(pthread_spinlock_t*);
 917     int pthread_spin_unlock(pthread_spinlock_t*);
 918 }
 919 else version (NetBSD)
 920 {
 921     int pthread_spin_init(pthread_spinlock_t*, int);
 922     int pthread_spin_destroy(pthread_spinlock_t*);
 923     int pthread_spin_lock(pthread_spinlock_t*);
 924     int pthread_spin_trylock(pthread_spinlock_t*);
 925     int pthread_spin_unlock(pthread_spinlock_t*);
 926 }
 927 else version (OpenBSD)
 928 {
 929     int pthread_spin_init(pthread_spinlock_t*, int);
 930     int pthread_spin_destroy(pthread_spinlock_t*);
 931     int pthread_spin_lock(pthread_spinlock_t*);
 932     int pthread_spin_trylock(pthread_spinlock_t*);
 933     int pthread_spin_unlock(pthread_spinlock_t*);
 934 }
 935 else version (Darwin)
 936 {
 937 }
 938 else version (Solaris)
 939 {
 940     int pthread_spin_init(pthread_spinlock_t*, int);
 941     int pthread_spin_destroy(pthread_spinlock_t*);
 942     int pthread_spin_lock(pthread_spinlock_t*);
 943     int pthread_spin_trylock(pthread_spinlock_t*);
 944     int pthread_spin_unlock(pthread_spinlock_t*);
 945 }
 946 else version (CRuntime_Bionic)
 947 {
 948 }
 949 else version (CRuntime_Musl)
 950 {
 951
 952 }
 953 else version (CRuntime_UClibc)
 954 {
 955     int pthread_spin_destroy(pthread_spinlock_t*);
 956     int pthread_spin_init(pthread_spinlock_t*, int);
 957     int pthread_spin_lock(pthread_spinlock_t*);
 958     int pthread_spin_trylock(pthread_spinlock_t*);
 959     int pthread_spin_unlock(pthread_spinlock_t*);
 960 }
 961 else
 962 {
 963     static assert(false, "Unsupported platform");
 964 }
 965
 966 //
 967 // XOpen (XSI)
 968 //
 969 /*
 970 PTHREAD_MUTEX_DEFAULT
 971 PTHREAD_MUTEX_ERRORCHECK
 972 PTHREAD_MUTEX_NORMAL
 973 PTHREAD_MUTEX_RECURSIVE
 974
 975 int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
 976 int pthread_attr_setguardsize(pthread_attr_t*, size_t);
 977 int pthread_getconcurrency();
 978 int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
 979 int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
 980 int pthread_setconcurrency(int);
 981 */
 982
 983 version (CRuntime_Glibc)
 984 {
 985     enum PTHREAD_MUTEX_NORMAL       = 0;
 986     enum PTHREAD_MUTEX_RECURSIVE    = 1;
 987     enum PTHREAD_MUTEX_ERRORCHECK   = 2;
 988     enum PTHREAD_MUTEX_DEFAULT      = PTHREAD_MUTEX_NORMAL;
 989
 990     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
 991     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
 992     int pthread_getconcurrency();
 993     int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
 994     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
 995     int pthread_setconcurrency(int);
 996 }
 997 else version (Darwin)
 998 {
 999     enum PTHREAD_MUTEX_NORMAL       = 0;
1000     enum PTHREAD_MUTEX_ERRORCHECK   = 1;
1001     enum PTHREAD_MUTEX_RECURSIVE    = 2;
1002     enum PTHREAD_MUTEX_DEFAULT      = PTHREAD_MUTEX_NORMAL;
1003
1004     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
1005     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1006     int pthread_getconcurrency();
1007     int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
1008     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1009     int pthread_setconcurrency(int);
1010 }
1011 else version (FreeBSD)
1012 {
1013     enum
1014     {
1015         PTHREAD_MUTEX_ERRORCHECK    = 1,
1016         PTHREAD_MUTEX_RECURSIVE     = 2,
1017         PTHREAD_MUTEX_NORMAL        = 3,
1018         PTHREAD_MUTEX_ADAPTIVE_NP   = 4,
1019         PTHREAD_MUTEX_TYPE_MAX
1020     }
1021     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
1022
1023     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
1024     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1025     int pthread_getconcurrency();
1026     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1027     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1028     int pthread_setconcurrency(int);
1029 }
1030 else version (NetBSD)
1031 {
1032     enum
1033     {
1034         PTHREAD_MUTEX_NORMAL        = 0,
1035         PTHREAD_MUTEX_ERRORCHECK    = 1,
1036         PTHREAD_MUTEX_RECURSIVE     = 2,
1037         PTHREAD_MUTEX_TYPE_MAX
1038     }
1039     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
1040
1041     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
1042     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1043     int pthread_getconcurrency();
1044     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1045     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1046     int pthread_setconcurrency(int);
1047 }
1048 else version (OpenBSD)
1049 {
1050     enum
1051     {
1052         PTHREAD_MUTEX_ERRORCHECK    = 1,
1053         PTHREAD_MUTEX_RECURSIVE     = 2,
1054         PTHREAD_MUTEX_NORMAL        = 3,
1055         PTHREAD_MUTEX_ADAPTIVE_NP   = 4,
1056         PTHREAD_MUTEX_TYPE_MAX
1057     }
1058     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
1059
1060     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
1061     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1062     int pthread_getconcurrency();
1063     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1064     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1065     int pthread_setconcurrency(int);
1066 }
1067 else version (DragonFlyBSD)
1068 {
1069     enum
1070     {
1071         PTHREAD_MUTEX_ERRORCHECK    = 1,
1072         PTHREAD_MUTEX_RECURSIVE     = 2,
1073         PTHREAD_MUTEX_NORMAL        = 3,
1074         PTHREAD_MUTEX_TYPE_MAX
1075     }
1076     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
1077
1078     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
1079     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1080     int pthread_getconcurrency();
1081     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1082     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1083     int pthread_setconcurrency(int);
1084 }
1085 else version (Solaris)
1086 {
1087     enum
1088     {
1089         PTHREAD_MUTEX_ERRORCHECK    = 2,
1090         PTHREAD_MUTEX_RECURSIVE     = 4,
1091         PTHREAD_MUTEX_NORMAL        = 0,
1092     }
1093
1094     enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL;
1095
1096     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
1097     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1098     int pthread_getconcurrency();
1099     int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
1100     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1101     int pthread_setconcurrency(int);
1102 }
1103 else version (CRuntime_Bionic)
1104 {
1105     enum PTHREAD_MUTEX_NORMAL     = 0;
1106     enum PTHREAD_MUTEX_RECURSIVE  = 1;
1107     enum PTHREAD_MUTEX_ERRORCHECK = 2;
1108     enum PTHREAD_MUTEX_DEFAULT    = PTHREAD_MUTEX_NORMAL;
1109
1110     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
1111     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1112     int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
1113     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1114 }
1115 else version (CRuntime_Musl)
1116 {
1117     enum {
1118         PTHREAD_MUTEX_NORMAL      = 0,
1119         PTHREAD_MUTEX_RECURSIVE   = 1,
1120         PTHREAD_MUTEX_ERRORCHECK  = 2,
1121         PTHREAD_MUTEX_DEFAULT     = PTHREAD_MUTEX_NORMAL,
1122     }
1123     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1124 }
1125 else version (CRuntime_UClibc)
1126 {
1127     enum
1128     {
1129       PTHREAD_MUTEX_TIMED_NP,
1130       PTHREAD_MUTEX_RECURSIVE_NP,
1131       PTHREAD_MUTEX_ERRORCHECK_NP,
1132       PTHREAD_MUTEX_ADAPTIVE_NP,
1133       PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
1134       PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
1135       PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
1136       PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL,
1137       PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
1138     }
1139
1140     int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
1141     int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1142     int pthread_getconcurrency();
1143     int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
1144     int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted;
1145     int pthread_setconcurrency(int);
1146 }
1147 else
1148 {
1149     static assert(false, "Unsupported platform");
1150 }
1151
1152 //
1153 // CPU Time (TCT)
1154 //
1155 /*
1156 int pthread_getcpuclockid(pthread_t, clockid_t*);
1157 */
1158
1159 version (CRuntime_Glibc)
1160 {
1161     int pthread_getcpuclockid(pthread_t, clockid_t*);
1162 }
1163 else version (FreeBSD)
1164 {
1165     int pthread_getcpuclockid(pthread_t, clockid_t*);
1166 }
1167 else version (DragonFlyBSD)
1168 {
1169     int pthread_getcpuclockid(pthread_t, clockid_t*);
1170 }
1171 else version (NetBSD)
1172 {
1173 }
1174 else version (OpenBSD)
1175 {
1176     int pthread_getcpuclockid(pthread_t, clockid_t*);
1177 }
1178 else version (Darwin)
1179 {
1180 }
1181 else version (Solaris)
1182 {
1183 }
1184 else version (CRuntime_Bionic)
1185 {
1186     int pthread_getcpuclockid(pthread_t, clockid_t*);
1187 }
1188 else version (CRuntime_Musl)
1189 {
1190
1191 }
1192 else version (CRuntime_UClibc)
1193 {
1194     int pthread_getcpuclockid(pthread_t, clockid_t*);
1195 }
1196 else
1197 {
1198     static assert(false, "Unsupported platform");
1199 }
1200
1201 //
1202 // Timeouts (TMO)
1203 //
1204 /*
1205 int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1206 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1207 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1208 */
1209
1210 version (CRuntime_Glibc)
1211 {
1212     int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1213     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1214     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1215 }
1216 else version (Darwin)
1217 {
1218     int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1219     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1220     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1221 }
1222 else version (FreeBSD)
1223 {
1224     int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1225     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1226     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1227 }
1228 else version (NetBSD)
1229 {
1230     int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1231     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1232     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1233 }
1234 else version (OpenBSD)
1235 {
1236     int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1237     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1238     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1239 }
1240 else version (DragonFlyBSD)
1241 {
1242     int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1243     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1244     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1245 }
1246 else version (Solaris)
1247 {
1248     int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1249     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1250     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1251 }
1252 else version (CRuntime_Bionic)
1253 {
1254     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1255     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1256 }
1257 else version (CRuntime_Musl)
1258 {
1259
1260 }
1261 else version (CRuntime_UClibc)
1262 {
1263     int pthread_mutex_timedlock(pthread_mutex_t*, in timespec*);
1264     int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
1265     int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
1266 }
1267 else
1268 {
1269     static assert(false, "Unsupported platform");
1270 }
1271
1272 //
1273 // Priority (TPI|TPP)
1274 //
1275 /*
1276 PTHREAD_PRIO_INHERIT (TPI)
1277 PTHREAD_PRIO_NONE (TPP|TPI)
1278 PTHREAD_PRIO_PROTECT (TPI)
1279
1280 int pthread_mutex_getprioceiling(in pthread_mutex_t*, int*); (TPP)
1281 int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); (TPP)
1282 int pthread_mutexattr_getprioceiling(pthread_mutexattr_t*, int*); (TPP)
1283 int pthread_mutexattr_getprotocol(in pthread_mutexattr_t*, int*); (TPI|TPP)
1284 int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); (TPP)
1285 int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); (TPI|TPP)
1286 */
1287 version (Darwin)
1288 {
1289     enum
1290     {
1291         PTHREAD_PRIO_NONE,
1292         PTHREAD_PRIO_INHERIT,
1293         PTHREAD_PRIO_PROTECT
1294     }
1295
1296     int pthread_mutex_getprioceiling(in pthread_mutex_t*, int*);
1297     int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*);
1298     int pthread_mutexattr_getprioceiling(in pthread_mutexattr_t*, int*);
1299     int pthread_mutexattr_getprotocol(in pthread_mutexattr_t*, int*);
1300     int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int);
1301     int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int);
1302 }
1303 else version (Solaris)
1304 {
1305     enum
1306     {
1307         PTHREAD_PRIO_NONE    = 0x00,
1308         PTHREAD_PRIO_INHERIT = 0x10,
1309         PTHREAD_PRIO_PROTECT = 0x20,
1310     }
1311
1312     int pthread_mutex_getprioceiling(in pthread_mutex_t*, int*);
1313     int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*);
1314     int pthread_mutexattr_getprioceiling(in pthread_mutexattr_t*, int*);
1315     int pthread_mutexattr_getprotocol(in pthread_mutexattr_t*, int*);
1316     int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int);
1317     int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int);
1318 }
1319
1320 //
1321 // Scheduling (TPS)
1322 //
1323 /*
1324 PTHREAD_SCOPE_PROCESS
1325 PTHREAD_SCOPE_SYSTEM
1326
1327 int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1328 int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1329 int pthread_attr_getscope(in pthread_attr_t*, int*);
1330 int pthread_attr_setinheritsched(pthread_attr_t*, int);
1331 int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1332 int pthread_attr_setscope(pthread_attr_t*, int);
1333 int pthread_getschedparam(pthread_t, int*, sched_param*);
1334 int pthread_setschedparam(pthread_t, int, in sched_param*);
1335 int pthread_setschedprio(pthread_t, int);
1336 */
1337
1338 version (CRuntime_Glibc)
1339 {
1340     enum
1341     {
1342         PTHREAD_SCOPE_SYSTEM,
1343         PTHREAD_SCOPE_PROCESS
1344     }
1345
1346     int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1347     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1348     int pthread_attr_getscope(in pthread_attr_t*, int*);
1349     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1350     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1351     int pthread_attr_setscope(pthread_attr_t*, int);
1352     int pthread_getschedparam(pthread_t, int*, sched_param*);
1353     int pthread_setschedparam(pthread_t, int, in sched_param*);
1354     int pthread_setschedprio(pthread_t, int);
1355 }
1356 else version (Darwin)
1357 {
1358     enum
1359     {
1360         PTHREAD_SCOPE_SYSTEM    = 1,
1361         PTHREAD_SCOPE_PROCESS   = 2
1362     }
1363
1364     int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1365     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1366     int pthread_attr_getscope(in pthread_attr_t*, int*);
1367     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1368     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1369     int pthread_attr_setscope(pthread_attr_t*, int);
1370     int pthread_getschedparam(pthread_t, int*, sched_param*);
1371     int pthread_setschedparam(pthread_t, int, in sched_param*);
1372     // int pthread_setschedprio(pthread_t, int); // not implemented
1373 }
1374 else version (FreeBSD)
1375 {
1376     enum
1377     {
1378         PTHREAD_SCOPE_PROCESS   = 0,
1379         PTHREAD_SCOPE_SYSTEM    = 0x2
1380     }
1381
1382     int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1383     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1384     int pthread_attr_getscope(in pthread_attr_t*, int*);
1385     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1386     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1387     int pthread_attr_setscope(in pthread_attr_t*, int);
1388     int pthread_getschedparam(pthread_t, int*, sched_param*);
1389     int pthread_setschedparam(pthread_t, int, sched_param*);
1390     // int pthread_setschedprio(pthread_t, int); // not implemented
1391 }
1392 else version (NetBSD)
1393 {
1394     enum
1395     {
1396         PTHREAD_SCOPE_PROCESS   = 0,
1397         PTHREAD_SCOPE_SYSTEM    = 0x1
1398     }
1399
1400     int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1401     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1402     int pthread_attr_getscope(in pthread_attr_t*, int*);
1403     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1404     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1405     int pthread_attr_setscope(in pthread_attr_t*, int);
1406     int pthread_getschedparam(pthread_t, int*, sched_param*);
1407     int pthread_setschedparam(pthread_t, int, sched_param*);
1408     //int pthread_setschedprio(pthread_t, int);
1409 }
1410 else version (OpenBSD)
1411 {
1412     enum
1413     {
1414         PTHREAD_SCOPE_PROCESS   = 0,
1415         PTHREAD_SCOPE_SYSTEM    = 0x2
1416     }
1417
1418     int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1419     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1420     int pthread_attr_getscope(in pthread_attr_t*, int*);
1421     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1422     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1423     int pthread_attr_setscope(in pthread_attr_t*, int);
1424     int pthread_getschedparam(pthread_t, int*, sched_param*);
1425     int pthread_setschedparam(pthread_t, int, sched_param*);
1426     // int pthread_setschedprio(pthread_t, int); // not implemented
1427 }
1428 else version (DragonFlyBSD)
1429 {
1430     enum
1431     {
1432         PTHREAD_SCOPE_PROCESS   = 0,
1433         PTHREAD_SCOPE_SYSTEM    = 0x2
1434     }
1435
1436     int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1437     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1438     int pthread_attr_getscope(in pthread_attr_t*, int*);
1439     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1440     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1441     int pthread_attr_setscope(in pthread_attr_t*, int);
1442     int pthread_getschedparam(pthread_t, int*, sched_param*);
1443     int pthread_setschedparam(pthread_t, int, sched_param*);
1444 }
1445 else version (Solaris)
1446 {
1447     enum
1448     {
1449         PTHREAD_SCOPE_PROCESS = 0,
1450         PTHREAD_SCOPE_SYSTEM = 1,
1451     }
1452
1453     int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1454     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1455     int pthread_attr_getscope(in pthread_attr_t*, int*);
1456     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1457     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1458     int pthread_attr_setscope(in pthread_attr_t*, int);
1459     int pthread_getschedparam(pthread_t, int*, sched_param*);
1460     int pthread_setschedparam(pthread_t, int, sched_param*);
1461     int pthread_setschedprio(pthread_t, int);
1462 }
1463 else version (CRuntime_Bionic)
1464 {
1465     enum
1466     {
1467         PTHREAD_SCOPE_SYSTEM,
1468         PTHREAD_SCOPE_PROCESS
1469     }
1470
1471     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1472     int pthread_attr_getscope(in pthread_attr_t*);
1473     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1474     int pthread_attr_setscope(pthread_attr_t*, int);
1475     int pthread_getschedparam(pthread_t, int*, sched_param*);
1476     int pthread_setschedparam(pthread_t, int, in sched_param*);
1477 }
1478 else version (CRuntime_Musl)
1479 {
1480     enum
1481     {
1482         PTHREAD_SCOPE_SYSTEM,
1483         PTHREAD_SCOPE_PROCESS
1484     }
1485
1486     int pthread_getschedparam(pthread_t, int*, sched_param*);
1487     int pthread_setschedparam(pthread_t, int, in sched_param*);
1488     int pthread_setschedprio(pthread_t, int);
1489 }
1490 else version (CRuntime_UClibc)
1491 {
1492     enum
1493     {
1494         PTHREAD_SCOPE_SYSTEM,
1495         PTHREAD_SCOPE_PROCESS
1496     }
1497
1498     int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
1499     int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
1500     int pthread_attr_getscope(in pthread_attr_t*, int*);
1501     int pthread_attr_setinheritsched(pthread_attr_t*, int);
1502     int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1503     int pthread_attr_setscope(pthread_attr_t*, int);
1504     int pthread_getschedparam(pthread_t, int*, sched_param*);
1505     int pthread_setschedparam(pthread_t, int, in sched_param*);
1506     int pthread_setschedprio(pthread_t, int);
1507 }
1508 else
1509 {
1510     static assert(false, "Unsupported platform");
1511 }
1512
1513 //
1514 // Stack (TSA|TSS)
1515 //
1516 /*
1517 int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*); (TSA|TSS)
1518 int pthread_attr_getstackaddr(in pthread_attr_t*, void**); (TSA)
1519 int pthread_attr_getstacksize(in pthread_attr_t*, size_t*); (TSS)
1520 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); (TSA|TSS)
1521 int pthread_attr_setstackaddr(pthread_attr_t*, void*); (TSA)
1522 int pthread_attr_setstacksize(pthread_attr_t*, size_t); (TSS)
1523 */
1524
1525 version (CRuntime_Glibc)
1526 {
1527     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1528     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1529     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1530     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1531     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1532     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1533 }
1534 else version (Darwin)
1535 {
1536     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1537     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1538     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1539     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1540     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1541     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1542 }
1543 else version (FreeBSD)
1544 {
1545     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1546     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1547     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1548     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1549     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1550     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1551 }
1552 else version (NetBSD)
1553 {
1554     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1555     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1556     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1557     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1558     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1559     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1560 }
1561 else version (OpenBSD)
1562 {
1563     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1564     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1565     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1566     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1567     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1568     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1569 }
1570 else version (DragonFlyBSD)
1571 {
1572     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1573     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1574     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1575     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1576     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1577     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1578 }
1579 else version (Solaris)
1580 {
1581     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1582     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1583     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1584     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1585     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1586     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1587 }
1588 else version (CRuntime_Bionic)
1589 {
1590     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1591     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1592     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1593     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1594     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1595     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1596 }
1597 else version (CRuntime_Musl)
1598 {
1599     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1600     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1601 }
1602 else version (CRuntime_UClibc)
1603 {
1604     int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
1605     int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
1606     int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
1607     int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
1608     int pthread_attr_setstackaddr(pthread_attr_t*, void*);
1609     int pthread_attr_setstacksize(pthread_attr_t*, size_t);
1610 }
1611 else
1612 {
1613     static assert(false, "Unsupported platform");
1614 }
1615
1616 //
1617 // Shared Synchronization (TSH)
1618 //
1619 /*
1620 int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
1621 int pthread_condattr_setpshared(pthread_condattr_t*, int);
1622 int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
1623 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1624 int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
1625 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1626 */
1627
1628 version (CRuntime_Glibc)
1629 {
1630     int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
1631     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1632     int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
1633     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1634     int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
1635     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1636 }
1637 else version (FreeBSD)
1638 {
1639     int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
1640     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1641     int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
1642     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1643     int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
1644     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1645 }
1646 else version (NetBSD)
1647 {
1648     int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
1649     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1650     int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
1651     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1652     int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
1653     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1654 }
1655 else version (OpenBSD)
1656 {
1657 }
1658 else version (DragonFlyBSD)
1659 {
1660     int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
1661     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1662     int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
1663     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1664     int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
1665     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1666 }
1667 else version (Darwin)
1668 {
1669     int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
1670     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1671     int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
1672     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1673     int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
1674     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1675 }
1676 else version (Solaris)
1677 {
1678     int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
1679     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1680     int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
1681     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1682     int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
1683     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1684 }
1685 else version (CRuntime_Bionic)
1686 {
1687     int pthread_condattr_getpshared(pthread_condattr_t*, int*);
1688     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1689     int pthread_mutexattr_getpshared(pthread_mutexattr_t*, int*);
1690     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1691     int pthread_rwlockattr_getpshared(pthread_rwlockattr_t*, int*);
1692     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1693 }
1694 else version (CRuntime_Musl)
1695 {
1696
1697 }
1698 else version (CRuntime_UClibc)
1699 {
1700     int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
1701     int pthread_condattr_setpshared(pthread_condattr_t*, int);
1702     int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
1703     int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1704     int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
1705     int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1706 }
1707 else
1708 {
1709     static assert(false, "Unsupported platform");
1710 }