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 */ 15module core.sys.posix.pthread; 16 17import core.sys.posix.config; 18public import core.sys.posix.sys.types; 19public import core.sys.posix.sched; 20public import core.sys.posix.time; 21 22import core.stdc.stdint; 23 24version (OSX) 25 version = Darwin; 26else version (iOS) 27 version = Darwin; 28else version (TVOS) 29 version = Darwin; 30else version (WatchOS) 31 version = Darwin; 32 33version (Posix): 34extern (C) 35nothrow: 36@system: 37 38// 39// Required 40// 41/* 42PTHREAD_CANCEL_ASYNCHRONOUS 43PTHREAD_CANCEL_ENABLE 44PTHREAD_CANCEL_DEFERRED 45PTHREAD_CANCEL_DISABLE 46PTHREAD_CANCELED 47PTHREAD_COND_INITIALIZER 48PTHREAD_CREATE_DETACHED 49PTHREAD_CREATE_JOINABLE 50PTHREAD_EXPLICIT_SCHED 51PTHREAD_INHERIT_SCHED 52PTHREAD_MUTEX_INITIALIZER 53PTHREAD_ONCE_INIT 54PTHREAD_PROCESS_SHARED 55PTHREAD_PROCESS_PRIVATE 56 57int pthread_atfork(void function(), void function(), void function()); 58int pthread_attr_destroy(pthread_attr_t*); 59int pthread_attr_getdetachstate(const scope pthread_attr_t*, int*); 60int pthread_attr_getschedparam(const scope pthread_attr_t*, sched_param*); 61int pthread_attr_init(pthread_attr_t*); 62int pthread_attr_setdetachstate(pthread_attr_t*, int); 63int pthread_attr_setschedparam(const scope pthread_attr_t*, sched_param*); 64int pthread_cancel(pthread_t); 65void pthread_cleanup_push(void function(void*), void*); 66void pthread_cleanup_pop(int); 67int pthread_cond_broadcast(pthread_cond_t*); 68int pthread_cond_destroy(pthread_cond_t*); 69int pthread_cond_init(const scope pthread_cond_t*, pthread_condattr_t*); 70int pthread_cond_signal(pthread_cond_t*); 71int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, const scope timespec*); 72int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*); 73int pthread_condattr_destroy(pthread_condattr_t*); 74int pthread_condattr_init(pthread_condattr_t*); 75int pthread_create(pthread_t*, const scope pthread_attr_t*, void* function(void*), void*); 76int pthread_detach(pthread_t); 77int pthread_equal(pthread_t, pthread_t); 78void pthread_exit(void*); 79void* pthread_getspecific(pthread_key_t); 80int pthread_join(pthread_t, void**); 81int pthread_key_create(pthread_key_t*, void function(void*)); 82int pthread_key_delete(pthread_key_t); 83int pthread_mutex_destroy(pthread_mutex_t*); 84int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*); 85int pthread_mutex_lock(pthread_mutex_t*); 86int pthread_mutex_trylock(pthread_mutex_t*); 87int pthread_mutex_unlock(pthread_mutex_t*); 88int pthread_mutexattr_destroy(pthread_mutexattr_t*); 89int pthread_mutexattr_init(pthread_mutexattr_t*); 90int pthread_once(pthread_once_t*, void function()); 91int pthread_rwlock_destroy(pthread_rwlock_t*); 92int pthread_rwlock_init(pthread_rwlock_t*, const scope pthread_rwlockattr_t*); 93int pthread_rwlock_rdlock(pthread_rwlock_t*); 94int pthread_rwlock_tryrdlock(pthread_rwlock_t*); 95int pthread_rwlock_trywrlock(pthread_rwlock_t*); 96int pthread_rwlock_unlock(pthread_rwlock_t*); 97int pthread_rwlock_wrlock(pthread_rwlock_t*); 98int pthread_rwlockattr_destroy(pthread_rwlockattr_t*); 99int pthread_rwlockattr_init(pthread_rwlockattr_t*); 100pthread_t pthread_self(); 101int pthread_setcancelstate(int, int*); 102int pthread_setcanceltype(int, int*); 103int pthread_setspecific(pthread_key_t, const scope void*); 104void pthread_testcancel(); 105*/ 106version (CRuntime_Glibc) 107{ 108 enum 109 { 110 PTHREAD_CANCEL_ENABLE, 111 PTHREAD_CANCEL_DISABLE 112 } 113 114 enum 115 { 116 PTHREAD_CANCEL_DEFERRED, 117 PTHREAD_CANCEL_ASYNCHRONOUS 118 } 119 120 enum PTHREAD_CANCELED = cast(void*) -1; 121 122 //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 }; 123 124 enum 125 { 126 PTHREAD_CREATE_JOINABLE, 127 PTHREAD_CREATE_DETACHED 128 } 129 130 enum 131 { 132 PTHREAD_INHERIT_SCHED, 133 PTHREAD_EXPLICIT_SCHED 134 } 135 136 enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t.init; 137 enum PTHREAD_ONCE_INIT = pthread_once_t.init; 138 139 enum 140 { 141 PTHREAD_PROCESS_PRIVATE, 142 PTHREAD_PROCESS_SHARED 143 } 144} 145else version (Darwin) 146{ 147 enum 148 { 149 PTHREAD_CANCEL_ENABLE = 1, 150 PTHREAD_CANCEL_DISABLE = 0 151 } 152 153 enum 154 { 155 PTHREAD_CANCEL_DEFERRED = 2, 156 PTHREAD_CANCEL_ASYNCHRONOUS = 0 157 } 158 159 enum PTHREAD_CANCELED = cast(void*) -1; 160 161 //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 }; 162 163 enum 164 { 165 PTHREAD_CREATE_JOINABLE = 1, 166 PTHREAD_CREATE_DETACHED = 2 167 } 168 169 enum 170 { 171 PTHREAD_INHERIT_SCHED = 1, 172 PTHREAD_EXPLICIT_SCHED = 2 173 } 174 175 enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0x32AAABA7); 176 enum PTHREAD_ONCE_INIT = pthread_once_t(0x30b1bcba); 177 178 enum 179 { 180 PTHREAD_PROCESS_PRIVATE = 2, 181 PTHREAD_PROCESS_SHARED = 1 182 } 183} 184else version (FreeBSD) 185{ 186 enum 187 { 188 PTHREAD_DETACHED = 0x1, 189 PTHREAD_INHERIT_SCHED = 0x4, 190 PTHREAD_NOFLOAT = 0x8, 191 192 PTHREAD_CREATE_DETACHED = PTHREAD_DETACHED, 193 PTHREAD_CREATE_JOINABLE = 0, 194 PTHREAD_EXPLICIT_SCHED = 0, 195 } 196 197 enum 198 { 199 PTHREAD_PROCESS_PRIVATE = 0, 200 PTHREAD_PROCESS_SHARED = 1, 201 } 202 203 enum 204 { 205 PTHREAD_CANCEL_ENABLE = 0, 206 PTHREAD_CANCEL_DISABLE = 1, 207 PTHREAD_CANCEL_DEFERRED = 0, 208 PTHREAD_CANCEL_ASYNCHRONOUS = 2, 209 } 210 211 enum PTHREAD_CANCELED = cast(void*) -1; 212 213 enum PTHREAD_NEEDS_INIT = 0; 214 enum PTHREAD_DONE_INIT = 1; 215 216 enum PTHREAD_MUTEX_INITIALIZER = null; 217 enum PTHREAD_ONCE_INIT = null; 218 enum PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP = null; 219 enum PTHREAD_COND_INITIALIZER = null; 220 enum PTHREAD_RWLOCK_INITIALIZER = null; 221} 222else version (NetBSD) 223{ 224 enum PRI_NONE = -1; 225 enum 226 { 227 PTHREAD_INHERIT_SCHED = 0x0, 228 229 PTHREAD_CREATE_DETACHED = 1, 230 PTHREAD_CREATE_JOINABLE = 0, 231 PTHREAD_EXPLICIT_SCHED = 1, 232 } 233 234 enum 235 { 236 PTHREAD_PROCESS_PRIVATE = 0, 237 PTHREAD_PROCESS_SHARED = 1, 238 } 239 240 enum 241 { 242 PTHREAD_CANCEL_ENABLE = 0, 243 PTHREAD_CANCEL_DISABLE = 1, 244 PTHREAD_CANCEL_DEFERRED = 0, 245 PTHREAD_CANCEL_ASYNCHRONOUS = 1, 246 } 247 248 enum PTHREAD_CANCELED = cast(void*) 1; 249 250 enum PTHREAD_DONE_INIT = 1; 251 252 enum PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0x33330003); 253 254 enum PTHREAD_ONCE_INIT = pthread_once_t(PTHREAD_MUTEX_INITIALIZER); 255 enum PTHREAD_COND_INITIALIZER = pthread_cond_t(0x55550005); 256 enum PTHREAD_RWLOCK_INITIALIZER = pthread_rwlock_t(0x99990009); 257} 258else version (OpenBSD) 259{ 260 enum 261 { 262 PTHREAD_DETACHED = 0x1, 263 PTHREAD_INHERIT_SCHED = 0x4, 264 PTHREAD_NOFLOAT = 0x8, 265 266 PTHREAD_CREATE_DETACHED = PTHREAD_DETACHED, 267 PTHREAD_CREATE_JOINABLE = 0, 268 PTHREAD_EXPLICIT_SCHED = 0, 269 } 270 271 enum 272 { 273 PTHREAD_PROCESS_PRIVATE = 0, 274 PTHREAD_PROCESS_SHARED = 1, 275 } 276 277 enum 278 { 279 PTHREAD_CANCEL_ENABLE = 0, 280 PTHREAD_CANCEL_DISABLE = 1, 281 PTHREAD_CANCEL_DEFERRED = 0, 282 PTHREAD_CANCEL_ASYNCHRONOUS = 2, 283 } 284 285 enum PTHREAD_CANCELED = cast(void*) 1; 286 287 enum 288 { 289 PTHREAD_NEEDS_INIT = 0, 290 PTHREAD_DONE_INIT = 1, 291 } 292 293 enum PTHREAD_MUTEX_INITIALIZER = null; 294 enum PTHREAD_ONCE_INIT = pthread_once_t.init; 295 enum PTHREAD_COND_INITIALIZER = null; 296 enum PTHREAD_RWLOCK_INITIALIZER = null; 297} 298else version (DragonFlyBSD) 299{ 300 enum 301 { 302 PTHREAD_DETACHED = 0x1, 303 //PTHREAD_SCOPE_SYSTEM = 0x2, // defined below 304 PTHREAD_INHERIT_SCHED = 0x4, 305 PTHREAD_NOFLOAT = 0x8, 306 307 PTHREAD_CREATE_DETACHED = PTHREAD_DETACHED, 308 PTHREAD_CREATE_JOINABLE = 0, 309 //PTHREAD_SCOPE_PROCESS = 0, // defined below 310 PTHREAD_EXPLICIT_SCHED = 0, 311 } 312 313 enum 314 { 315 PTHREAD_PROCESS_PRIVATE = 0, 316 PTHREAD_PROCESS_SHARED = 1, 317 } 318 319 enum 320 { 321 PTHREAD_CANCEL_ENABLE = 0, 322 PTHREAD_CANCEL_DISABLE = 1, 323 PTHREAD_CANCEL_DEFERRED = 0, 324 PTHREAD_CANCEL_ASYNCHRONOUS = 2, 325 } 326 327 enum PTHREAD_CANCELED = cast(void*) -1; 328 329 enum PTHREAD_NEEDS_INIT = 0; 330 enum PTHREAD_DONE_INIT = 1; 331 332 enum PTHREAD_MUTEX_INITIALIZER = null; 333 enum PTHREAD_ONCE_INIT = pthread_once_t.init; 334 enum PTHREAD_COND_INITIALIZER = null; 335 enum PTHREAD_RWLOCK_INITIALIZER = null; 336} 337else 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} 367else 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} 384else 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} 401else 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} 438else 439{ 440 static assert(false, "Unsupported platform"); 441} 442 443int 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(const scope pthread_attr_t*, int*); 448 int pthread_attr_getschedparam(const scope 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(const scope pthread_attr_t*, sched_param*); 452 int pthread_cancel(pthread_t); 453} 454 455alias void function(void*) _pthread_cleanup_routine; 456alias void function(void*) @nogc _pthread_cleanup_routine_nogc; 457version (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} 486else 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} 519else 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} 545else 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} 570else 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} 595else version (OpenBSD) 596{ 597 void pthread_cleanup_push(void function(void*), void*); 598 void pthread_cleanup_pop(int); 599} 600else 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} 628else 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} 656else 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} 681else 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} 710else 711{ 712 static assert(false, "Unsupported platform"); 713} 714 715@nogc: 716 717int pthread_cond_broadcast(pthread_cond_t*); 718int pthread_cond_destroy(pthread_cond_t*); 719int pthread_cond_init(const scope pthread_cond_t*, pthread_condattr_t*) @trusted; 720int pthread_cond_signal(pthread_cond_t*); 721int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, const scope timespec*); 722int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*); 723int pthread_condattr_destroy(pthread_condattr_t*); 724int pthread_condattr_init(pthread_condattr_t*); 725int pthread_create(pthread_t*, const scope pthread_attr_t*, void* function(void*), void*); 726int pthread_detach(pthread_t); 727int pthread_equal(pthread_t, pthread_t); 728void pthread_exit(void*); 729void* pthread_getspecific(pthread_key_t); 730int pthread_join(pthread_t, void**); 731int pthread_key_create(pthread_key_t*, void function(void*)); 732int pthread_key_delete(pthread_key_t); 733int pthread_mutex_destroy(pthread_mutex_t*); 734int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*) @trusted; 735int pthread_mutex_lock(pthread_mutex_t*); 736int pthread_mutex_lock(shared(pthread_mutex_t)*); 737int pthread_mutex_trylock(pthread_mutex_t*); 738int pthread_mutex_trylock(shared(pthread_mutex_t)*); 739int pthread_mutex_unlock(pthread_mutex_t*); 740int pthread_mutex_unlock(shared(pthread_mutex_t)*); 741int pthread_mutexattr_destroy(pthread_mutexattr_t*); 742int pthread_mutexattr_init(pthread_mutexattr_t*) @trusted; 743int pthread_once(pthread_once_t*, void function()); 744int pthread_rwlock_destroy(pthread_rwlock_t*); 745int pthread_rwlock_init(pthread_rwlock_t*, const scope pthread_rwlockattr_t*); 746int pthread_rwlock_rdlock(pthread_rwlock_t*); 747int pthread_rwlock_tryrdlock(pthread_rwlock_t*); 748int pthread_rwlock_trywrlock(pthread_rwlock_t*); 749int pthread_rwlock_unlock(pthread_rwlock_t*); 750int pthread_rwlock_wrlock(pthread_rwlock_t*); 751int pthread_rwlockattr_destroy(pthread_rwlockattr_t*); 752int pthread_rwlockattr_init(pthread_rwlockattr_t*); 753pthread_t pthread_self(); 754int pthread_setcancelstate(int, int*); 755int pthread_setcanceltype(int, int*); 756int pthread_setspecific(pthread_key_t, const scope void*); 757void pthread_testcancel(); 758 759// 760// Barrier (BAR) 761// 762/* 763PTHREAD_BARRIER_SERIAL_THREAD 764 765int pthread_barrier_destroy(pthread_barrier_t*); 766int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint); 767int pthread_barrier_wait(pthread_barrier_t*); 768int pthread_barrierattr_destroy(pthread_barrierattr_t*); 769int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*); (BAR|TSH) 770int pthread_barrierattr_init(pthread_barrierattr_t*); 771int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); (BAR|TSH) 772*/ 773 774version (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*, const scope 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(const scope pthread_barrierattr_t*, int*); 783 int pthread_barrierattr_init(pthread_barrierattr_t*); 784 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); 785} 786else 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*, const scope 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(const scope pthread_barrierattr_t*, int*); 795 int pthread_barrierattr_init(pthread_barrierattr_t*); 796 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); 797} 798else 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*, const scope 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(const scope pthread_barrierattr_t*, int*); 810 int pthread_barrierattr_init(pthread_barrierattr_t*); 811 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); 812} 813else 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*, const scope 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(const scope pthread_barrierattr_t*, int*); 822 int pthread_barrierattr_init(pthread_barrierattr_t*); 823 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); 824} 825else 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*, const scope 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(const scope pthread_barrierattr_t*, int*); 834 int pthread_barrierattr_init(pthread_barrierattr_t*); 835 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); 836} 837else version (Darwin) 838{ 839} 840else 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*, const scope 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(const scope pthread_barrierattr_t*, int*); 849 int pthread_barrierattr_init(pthread_barrierattr_t*); 850 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); 851} 852else version (CRuntime_Bionic) 853{ 854} 855else version (CRuntime_Musl) 856{ 857 enum PTHREAD_BARRIER_SERIAL_THREAD = -1; 858 859 int pthread_barrier_destroy(pthread_barrier_t*); 860 int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint); 861 int pthread_barrier_wait(pthread_barrier_t*); 862 int pthread_barrierattr_destroy(pthread_barrierattr_t*); 863 int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*); 864 int pthread_barrierattr_init(pthread_barrierattr_t*); 865 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); 866} 867else version (CRuntime_UClibc) 868{ 869 enum PTHREAD_BARRIER_SERIAL_THREAD = -1; 870 871 int pthread_barrier_destroy(pthread_barrier_t*); 872 int pthread_barrier_init(pthread_barrier_t*, const scope pthread_barrierattr_t*, uint); 873 int pthread_barrier_wait(pthread_barrier_t*); 874 int pthread_barrierattr_destroy(pthread_barrierattr_t*); 875 int pthread_barrierattr_getpshared(const scope pthread_barrierattr_t*, int*); 876 int pthread_barrierattr_init(pthread_barrierattr_t*); 877 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); 878} 879else 880{ 881 static assert(false, "Unsupported platform"); 882} 883 884// 885// Clock (CS) 886// 887/* 888int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*); 889int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 890*/ 891version (CRuntime_Glibc) 892{ 893 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*); 894 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 895} 896else version (FreeBSD) 897{ 898 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*); 899 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 900} 901else version (DragonFlyBSD) 902{ 903 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*); 904 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 905} 906else version (NetBSD) 907{ 908 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 909} 910else version (OpenBSD) 911{ 912 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*); 913 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 914} 915else version (Darwin) 916{ 917} 918else version (Solaris) 919{ 920 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*); 921 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 922} 923else version (CRuntime_Bionic) 924{ 925} 926else version (CRuntime_Musl) 927{ 928 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*); 929 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 930} 931else version (CRuntime_UClibc) 932{ 933 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*); 934 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t); 935} 936else 937{ 938 static assert(false, "Unsupported platform"); 939} 940 941// 942// Spinlock (SPI) 943// 944/* 945int pthread_spin_destroy(pthread_spinlock_t*); 946int pthread_spin_init(pthread_spinlock_t*, int); 947int pthread_spin_lock(pthread_spinlock_t*); 948int pthread_spin_trylock(pthread_spinlock_t*); 949int pthread_spin_unlock(pthread_spinlock_t*); 950*/ 951 952version (CRuntime_Glibc) 953{ 954 int pthread_spin_destroy(pthread_spinlock_t*); 955 int pthread_spin_init(pthread_spinlock_t*, int); 956 int pthread_spin_lock(pthread_spinlock_t*); 957 int pthread_spin_trylock(pthread_spinlock_t*); 958 int pthread_spin_unlock(pthread_spinlock_t*); 959} 960else version (FreeBSD) 961{ 962 int pthread_spin_init(pthread_spinlock_t*, int); 963 int pthread_spin_destroy(pthread_spinlock_t*); 964 int pthread_spin_lock(pthread_spinlock_t*); 965 int pthread_spin_trylock(pthread_spinlock_t*); 966 int pthread_spin_unlock(pthread_spinlock_t*); 967} 968else version (DragonFlyBSD) 969{ 970 int pthread_spin_init(pthread_spinlock_t*, int); 971 int pthread_spin_destroy(pthread_spinlock_t*); 972 int pthread_spin_lock(pthread_spinlock_t*); 973 int pthread_spin_trylock(pthread_spinlock_t*); 974 int pthread_spin_unlock(pthread_spinlock_t*); 975} 976else version (NetBSD) 977{ 978 int pthread_spin_init(pthread_spinlock_t*, int); 979 int pthread_spin_destroy(pthread_spinlock_t*); 980 int pthread_spin_lock(pthread_spinlock_t*); 981 int pthread_spin_trylock(pthread_spinlock_t*); 982 int pthread_spin_unlock(pthread_spinlock_t*); 983} 984else version (OpenBSD) 985{ 986 int pthread_spin_init(pthread_spinlock_t*, int); 987 int pthread_spin_destroy(pthread_spinlock_t*); 988 int pthread_spin_lock(pthread_spinlock_t*); 989 int pthread_spin_trylock(pthread_spinlock_t*); 990 int pthread_spin_unlock(pthread_spinlock_t*); 991} 992else version (Darwin) 993{ 994} 995else version (Solaris) 996{ 997 int pthread_spin_init(pthread_spinlock_t*, int); 998 int pthread_spin_destroy(pthread_spinlock_t*); 999 int pthread_spin_lock(pthread_spinlock_t*); 1000 int pthread_spin_trylock(pthread_spinlock_t*); 1001 int pthread_spin_unlock(pthread_spinlock_t*); 1002} 1003else version (CRuntime_Bionic) 1004{ 1005} 1006else version (CRuntime_Musl) 1007{ 1008 int pthread_spin_destroy(pthread_spinlock_t*); 1009 int pthread_spin_init(pthread_spinlock_t*, int); 1010 int pthread_spin_lock(pthread_spinlock_t*); 1011 int pthread_spin_trylock(pthread_spinlock_t*); 1012 int pthread_spin_unlock(pthread_spinlock_t*); 1013} 1014else version (CRuntime_UClibc) 1015{ 1016 int pthread_spin_destroy(pthread_spinlock_t*); 1017 int pthread_spin_init(pthread_spinlock_t*, int); 1018 int pthread_spin_lock(pthread_spinlock_t*); 1019 int pthread_spin_trylock(pthread_spinlock_t*); 1020 int pthread_spin_unlock(pthread_spinlock_t*); 1021} 1022else 1023{ 1024 static assert(false, "Unsupported platform"); 1025} 1026 1027// 1028// XOpen (XSI) 1029// 1030/* 1031PTHREAD_MUTEX_DEFAULT 1032PTHREAD_MUTEX_ERRORCHECK 1033PTHREAD_MUTEX_NORMAL 1034PTHREAD_MUTEX_RECURSIVE 1035 1036int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1037int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1038int pthread_getconcurrency(); 1039int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*); 1040int pthread_mutexattr_settype(pthread_mutexattr_t*, int); 1041int pthread_setconcurrency(int); 1042*/ 1043 1044version (CRuntime_Glibc) 1045{ 1046 enum PTHREAD_MUTEX_NORMAL = 0; 1047 enum PTHREAD_MUTEX_RECURSIVE = 1; 1048 enum PTHREAD_MUTEX_ERRORCHECK = 2; 1049 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL; 1050 1051 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1052 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1053 int pthread_getconcurrency(); 1054 int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*); 1055 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1056 int pthread_setconcurrency(int); 1057} 1058else version (Darwin) 1059{ 1060 enum PTHREAD_MUTEX_NORMAL = 0; 1061 enum PTHREAD_MUTEX_ERRORCHECK = 1; 1062 enum PTHREAD_MUTEX_RECURSIVE = 2; 1063 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL; 1064 1065 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1066 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1067 int pthread_getconcurrency(); 1068 int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*); 1069 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1070 int pthread_setconcurrency(int); 1071} 1072else version (FreeBSD) 1073{ 1074 enum 1075 { 1076 PTHREAD_MUTEX_ERRORCHECK = 1, 1077 PTHREAD_MUTEX_RECURSIVE = 2, 1078 PTHREAD_MUTEX_NORMAL = 3, 1079 PTHREAD_MUTEX_ADAPTIVE_NP = 4, 1080 PTHREAD_MUTEX_TYPE_MAX 1081 } 1082 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK; 1083 1084 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1085 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1086 int pthread_getconcurrency(); 1087 int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*); 1088 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1089 int pthread_setconcurrency(int); 1090} 1091else version (NetBSD) 1092{ 1093 enum 1094 { 1095 PTHREAD_MUTEX_NORMAL = 0, 1096 PTHREAD_MUTEX_ERRORCHECK = 1, 1097 PTHREAD_MUTEX_RECURSIVE = 2, 1098 PTHREAD_MUTEX_TYPE_MAX 1099 } 1100 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK; 1101 1102 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1103 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1104 int pthread_getconcurrency(); 1105 int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*); 1106 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1107 int pthread_setconcurrency(int); 1108} 1109else version (OpenBSD) 1110{ 1111 enum 1112 { 1113 PTHREAD_MUTEX_ERRORCHECK = 1, 1114 PTHREAD_MUTEX_RECURSIVE = 2, 1115 PTHREAD_MUTEX_NORMAL = 3, 1116 PTHREAD_MUTEX_ADAPTIVE_NP = 4, 1117 PTHREAD_MUTEX_TYPE_MAX 1118 } 1119 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK; 1120 1121 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1122 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1123 int pthread_getconcurrency(); 1124 int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*); 1125 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1126 int pthread_setconcurrency(int); 1127} 1128else version (DragonFlyBSD) 1129{ 1130 enum 1131 { 1132 PTHREAD_MUTEX_ERRORCHECK = 1, 1133 PTHREAD_MUTEX_RECURSIVE = 2, 1134 PTHREAD_MUTEX_NORMAL = 3, 1135 PTHREAD_MUTEX_TYPE_MAX 1136 } 1137 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK; 1138 1139 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1140 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1141 int pthread_getconcurrency(); 1142 int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*); 1143 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1144 int pthread_setconcurrency(int); 1145} 1146else version (Solaris) 1147{ 1148 enum 1149 { 1150 PTHREAD_MUTEX_ERRORCHECK = 2, 1151 PTHREAD_MUTEX_RECURSIVE = 4, 1152 PTHREAD_MUTEX_NORMAL = 0, 1153 } 1154 1155 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL; 1156 1157 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1158 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1159 int pthread_getconcurrency(); 1160 int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*); 1161 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1162 int pthread_setconcurrency(int); 1163} 1164else version (CRuntime_Bionic) 1165{ 1166 enum PTHREAD_MUTEX_NORMAL = 0; 1167 enum PTHREAD_MUTEX_RECURSIVE = 1; 1168 enum PTHREAD_MUTEX_ERRORCHECK = 2; 1169 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL; 1170 1171 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1172 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1173 int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*); 1174 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1175} 1176else version (CRuntime_Musl) 1177{ 1178 enum { 1179 PTHREAD_MUTEX_NORMAL = 0, 1180 PTHREAD_MUTEX_RECURSIVE = 1, 1181 PTHREAD_MUTEX_ERRORCHECK = 2, 1182 PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL, 1183 } 1184 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1185} 1186else version (CRuntime_UClibc) 1187{ 1188 enum 1189 { 1190 PTHREAD_MUTEX_TIMED_NP, 1191 PTHREAD_MUTEX_RECURSIVE_NP, 1192 PTHREAD_MUTEX_ERRORCHECK_NP, 1193 PTHREAD_MUTEX_ADAPTIVE_NP, 1194 PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, 1195 PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, 1196 PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, 1197 PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL, 1198 PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP 1199 } 1200 1201 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*); 1202 int pthread_attr_setguardsize(pthread_attr_t*, size_t); 1203 int pthread_getconcurrency(); 1204 int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*); 1205 int pthread_mutexattr_settype(pthread_mutexattr_t*, int) @trusted; 1206 int pthread_setconcurrency(int); 1207} 1208else 1209{ 1210 static assert(false, "Unsupported platform"); 1211} 1212 1213// 1214// CPU Time (TCT) 1215// 1216/* 1217int pthread_getcpuclockid(pthread_t, clockid_t*); 1218*/ 1219 1220version (CRuntime_Glibc) 1221{ 1222 int pthread_getcpuclockid(pthread_t, clockid_t*); 1223} 1224else version (FreeBSD) 1225{ 1226 int pthread_getcpuclockid(pthread_t, clockid_t*); 1227} 1228else version (DragonFlyBSD) 1229{ 1230 int pthread_getcpuclockid(pthread_t, clockid_t*); 1231} 1232else version (NetBSD) 1233{ 1234} 1235else version (OpenBSD) 1236{ 1237 int pthread_getcpuclockid(pthread_t, clockid_t*); 1238} 1239else version (Darwin) 1240{ 1241} 1242else version (Solaris) 1243{ 1244} 1245else version (CRuntime_Bionic) 1246{ 1247 int pthread_getcpuclockid(pthread_t, clockid_t*); 1248} 1249else version (CRuntime_Musl) 1250{ 1251 int pthread_getcpuclockid(pthread_t, clockid_t*); 1252} 1253else version (CRuntime_UClibc) 1254{ 1255 int pthread_getcpuclockid(pthread_t, clockid_t*); 1256} 1257else 1258{ 1259 static assert(false, "Unsupported platform"); 1260} 1261 1262// 1263// Timeouts (TMO) 1264// 1265/* 1266int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1267int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1268int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1269*/ 1270 1271version (CRuntime_Glibc) 1272{ 1273 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1274 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1275 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1276} 1277else version (Darwin) 1278{ 1279 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1280 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1281 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1282} 1283else version (FreeBSD) 1284{ 1285 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1286 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1287 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1288} 1289else version (NetBSD) 1290{ 1291 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1292 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1293 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1294} 1295else version (OpenBSD) 1296{ 1297 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1298 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1299 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1300} 1301else version (DragonFlyBSD) 1302{ 1303 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1304 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1305 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1306} 1307else version (Solaris) 1308{ 1309 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1310 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1311 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1312} 1313else version (CRuntime_Bionic) 1314{ 1315 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1316 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1317} 1318else version (CRuntime_Musl) 1319{ 1320 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1321 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1322 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1323} 1324else version (CRuntime_UClibc) 1325{ 1326 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*); 1327 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*); 1328 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*); 1329} 1330else 1331{ 1332 static assert(false, "Unsupported platform"); 1333} 1334 1335// 1336// Priority (TPI|TPP) 1337// 1338/* 1339PTHREAD_PRIO_INHERIT (TPI) 1340PTHREAD_PRIO_NONE (TPP|TPI) 1341PTHREAD_PRIO_PROTECT (TPI) 1342 1343int pthread_mutex_getprioceiling(const scope pthread_mutex_t*, int*); (TPP) 1344int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); (TPP) 1345int pthread_mutexattr_getprioceiling(pthread_mutexattr_t*, int*); (TPP) 1346int pthread_mutexattr_getprotocol(const scope pthread_mutexattr_t*, int*); (TPI|TPP) 1347int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); (TPP) 1348int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); (TPI|TPP) 1349*/ 1350version (Darwin) 1351{ 1352 enum 1353 { 1354 PTHREAD_PRIO_NONE, 1355 PTHREAD_PRIO_INHERIT, 1356 PTHREAD_PRIO_PROTECT 1357 } 1358 1359 int pthread_mutex_getprioceiling(const scope pthread_mutex_t*, int*); 1360 int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); 1361 int pthread_mutexattr_getprioceiling(const scope pthread_mutexattr_t*, int*); 1362 int pthread_mutexattr_getprotocol(const scope pthread_mutexattr_t*, int*); 1363 int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); 1364 int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); 1365} 1366else version (Solaris) 1367{ 1368 enum 1369 { 1370 PTHREAD_PRIO_NONE = 0x00, 1371 PTHREAD_PRIO_INHERIT = 0x10, 1372 PTHREAD_PRIO_PROTECT = 0x20, 1373 } 1374 1375 int pthread_mutex_getprioceiling(const scope pthread_mutex_t*, int*); 1376 int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); 1377 int pthread_mutexattr_getprioceiling(const scope pthread_mutexattr_t*, int*); 1378 int pthread_mutexattr_getprotocol(const scope pthread_mutexattr_t*, int*); 1379 int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); 1380 int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); 1381} 1382 1383// 1384// Scheduling (TPS) 1385// 1386/* 1387PTHREAD_SCOPE_PROCESS 1388PTHREAD_SCOPE_SYSTEM 1389 1390int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1391int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1392int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1393int pthread_attr_setinheritsched(pthread_attr_t*, int); 1394int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1395int pthread_attr_setscope(pthread_attr_t*, int); 1396int pthread_getschedparam(pthread_t, int*, sched_param*); 1397int pthread_setschedparam(pthread_t, int, const scope sched_param*); 1398int pthread_setschedprio(pthread_t, int); 1399*/ 1400 1401version (CRuntime_Glibc) 1402{ 1403 enum 1404 { 1405 PTHREAD_SCOPE_SYSTEM, 1406 PTHREAD_SCOPE_PROCESS 1407 } 1408 1409 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1410 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1411 int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1412 int pthread_attr_setinheritsched(pthread_attr_t*, int); 1413 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1414 int pthread_attr_setscope(pthread_attr_t*, int); 1415 int pthread_getschedparam(pthread_t, int*, sched_param*); 1416 int pthread_setschedparam(pthread_t, int, const scope sched_param*); 1417 int pthread_setschedprio(pthread_t, int); 1418} 1419else version (Darwin) 1420{ 1421 enum 1422 { 1423 PTHREAD_SCOPE_SYSTEM = 1, 1424 PTHREAD_SCOPE_PROCESS = 2 1425 } 1426 1427 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1428 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1429 int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1430 int pthread_attr_setinheritsched(pthread_attr_t*, int); 1431 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1432 int pthread_attr_setscope(pthread_attr_t*, int); 1433 int pthread_getschedparam(pthread_t, int*, sched_param*); 1434 int pthread_setschedparam(pthread_t, int, const scope sched_param*); 1435 // int pthread_setschedprio(pthread_t, int); // not implemented 1436} 1437else version (FreeBSD) 1438{ 1439 enum 1440 { 1441 PTHREAD_SCOPE_PROCESS = 0, 1442 PTHREAD_SCOPE_SYSTEM = 0x2 1443 } 1444 1445 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1446 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1447 int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1448 int pthread_attr_setinheritsched(pthread_attr_t*, int); 1449 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1450 int pthread_attr_setscope(const scope pthread_attr_t*, int); 1451 int pthread_getschedparam(pthread_t, int*, sched_param*); 1452 int pthread_setschedparam(pthread_t, int, sched_param*); 1453 // int pthread_setschedprio(pthread_t, int); // not implemented 1454} 1455else version (NetBSD) 1456{ 1457 enum 1458 { 1459 PTHREAD_SCOPE_PROCESS = 0, 1460 PTHREAD_SCOPE_SYSTEM = 0x1 1461 } 1462 1463 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1464 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1465 int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1466 int pthread_attr_setinheritsched(pthread_attr_t*, int); 1467 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1468 int pthread_attr_setscope(const scope pthread_attr_t*, int); 1469 int pthread_getschedparam(pthread_t, int*, sched_param*); 1470 int pthread_setschedparam(pthread_t, int, sched_param*); 1471 //int pthread_setschedprio(pthread_t, int); 1472} 1473else version (OpenBSD) 1474{ 1475 enum 1476 { 1477 PTHREAD_SCOPE_PROCESS = 0, 1478 PTHREAD_SCOPE_SYSTEM = 0x2 1479 } 1480 1481 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1482 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1483 int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1484 int pthread_attr_setinheritsched(pthread_attr_t*, int); 1485 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1486 int pthread_attr_setscope(const scope pthread_attr_t*, int); 1487 int pthread_getschedparam(pthread_t, int*, sched_param*); 1488 int pthread_setschedparam(pthread_t, int, sched_param*); 1489 // int pthread_setschedprio(pthread_t, int); // not implemented 1490} 1491else version (DragonFlyBSD) 1492{ 1493 enum 1494 { 1495 PTHREAD_SCOPE_PROCESS = 0, 1496 PTHREAD_SCOPE_SYSTEM = 0x2 1497 } 1498 1499 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1500 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1501 int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1502 int pthread_attr_setinheritsched(pthread_attr_t*, int); 1503 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1504 int pthread_attr_setscope(const scope pthread_attr_t*, int); 1505 int pthread_getschedparam(pthread_t, int*, sched_param*); 1506 int pthread_setschedparam(pthread_t, int, sched_param*); 1507} 1508else version (Solaris) 1509{ 1510 enum 1511 { 1512 PTHREAD_SCOPE_PROCESS = 0, 1513 PTHREAD_SCOPE_SYSTEM = 1, 1514 } 1515 1516 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1517 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1518 int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1519 int pthread_attr_setinheritsched(pthread_attr_t*, int); 1520 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1521 int pthread_attr_setscope(const scope pthread_attr_t*, int); 1522 int pthread_getschedparam(pthread_t, int*, sched_param*); 1523 int pthread_setschedparam(pthread_t, int, sched_param*); 1524 int pthread_setschedprio(pthread_t, int); 1525} 1526else version (CRuntime_Bionic) 1527{ 1528 enum 1529 { 1530 PTHREAD_SCOPE_SYSTEM, 1531 PTHREAD_SCOPE_PROCESS 1532 } 1533 1534 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1535 int pthread_attr_getscope(const scope pthread_attr_t*); 1536 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1537 int pthread_attr_setscope(pthread_attr_t*, int); 1538 int pthread_getschedparam(pthread_t, int*, sched_param*); 1539 int pthread_setschedparam(pthread_t, int, const scope sched_param*); 1540} 1541else version (CRuntime_Musl) 1542{ 1543 enum 1544 { 1545 PTHREAD_SCOPE_SYSTEM, 1546 PTHREAD_SCOPE_PROCESS 1547 } 1548 1549 int pthread_getschedparam(pthread_t, int*, sched_param*); 1550 int pthread_setschedparam(pthread_t, int, const scope sched_param*); 1551 int pthread_setschedprio(pthread_t, int); 1552} 1553else version (CRuntime_UClibc) 1554{ 1555 enum 1556 { 1557 PTHREAD_SCOPE_SYSTEM, 1558 PTHREAD_SCOPE_PROCESS 1559 } 1560 1561 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*); 1562 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*); 1563 int pthread_attr_getscope(const scope pthread_attr_t*, int*); 1564 int pthread_attr_setinheritsched(pthread_attr_t*, int); 1565 int pthread_attr_setschedpolicy(pthread_attr_t*, int); 1566 int pthread_attr_setscope(pthread_attr_t*, int); 1567 int pthread_getschedparam(pthread_t, int*, sched_param*); 1568 int pthread_setschedparam(pthread_t, int, const scope sched_param*); 1569 int pthread_setschedprio(pthread_t, int); 1570} 1571else 1572{ 1573 static assert(false, "Unsupported platform"); 1574} 1575 1576// 1577// Stack (TSA|TSS) 1578// 1579/* 1580int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); (TSA|TSS) 1581int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); (TSA) 1582int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); (TSS) 1583int pthread_attr_setstack(pthread_attr_t*, void*, size_t); (TSA|TSS) 1584int pthread_attr_setstackaddr(pthread_attr_t*, void*); (TSA) 1585int pthread_attr_setstacksize(pthread_attr_t*, size_t); (TSS) 1586*/ 1587 1588version (CRuntime_Glibc) 1589{ 1590 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1591 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1592 int pthread_attr_getstacksize(const scope 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} 1597else version (Darwin) 1598{ 1599 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1600 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1601 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); 1602 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); 1603 int pthread_attr_setstackaddr(pthread_attr_t*, void*); 1604 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1605} 1606else version (FreeBSD) 1607{ 1608 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1609 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1610 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); 1611 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); 1612 int pthread_attr_setstackaddr(pthread_attr_t*, void*); 1613 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1614} 1615else version (NetBSD) 1616{ 1617 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1618 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1619 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); 1620 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); 1621 int pthread_attr_setstackaddr(pthread_attr_t*, void*); 1622 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1623} 1624else version (OpenBSD) 1625{ 1626 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1627 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1628 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); 1629 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); 1630 int pthread_attr_setstackaddr(pthread_attr_t*, void*); 1631 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1632} 1633else version (DragonFlyBSD) 1634{ 1635 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1636 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1637 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); 1638 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); 1639 int pthread_attr_setstackaddr(pthread_attr_t*, void*); 1640 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1641} 1642else version (Solaris) 1643{ 1644 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1645 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1646 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); 1647 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); 1648 int pthread_attr_setstackaddr(pthread_attr_t*, void*); 1649 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1650} 1651else version (CRuntime_Bionic) 1652{ 1653 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1654 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1655 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); 1656 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); 1657 int pthread_attr_setstackaddr(pthread_attr_t*, void*); 1658 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1659} 1660else version (CRuntime_Musl) 1661{ 1662 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1663 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1664} 1665else version (CRuntime_UClibc) 1666{ 1667 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); 1668 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); 1669 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); 1670 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); 1671 int pthread_attr_setstackaddr(pthread_attr_t*, void*); 1672 int pthread_attr_setstacksize(pthread_attr_t*, size_t); 1673} 1674else 1675{ 1676 static assert(false, "Unsupported platform"); 1677} 1678 1679// 1680// Shared Synchronization (TSH) 1681// 1682/* 1683int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*); 1684int pthread_condattr_setpshared(pthread_condattr_t*, int); 1685int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*); 1686int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1687int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*); 1688int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1689*/ 1690 1691version (CRuntime_Glibc) 1692{ 1693 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*); 1694 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1695 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*); 1696 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1697 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*); 1698 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1699} 1700else version (FreeBSD) 1701{ 1702 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*); 1703 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1704 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*); 1705 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1706 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*); 1707 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1708} 1709else version (NetBSD) 1710{ 1711 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*); 1712 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1713 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*); 1714 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1715 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*); 1716 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1717} 1718else version (OpenBSD) 1719{ 1720} 1721else version (DragonFlyBSD) 1722{ 1723 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*); 1724 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1725 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*); 1726 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1727 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*); 1728 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1729} 1730else version (Darwin) 1731{ 1732 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*); 1733 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1734 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*); 1735 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1736 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*); 1737 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1738} 1739else version (Solaris) 1740{ 1741 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*); 1742 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1743 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*); 1744 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1745 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*); 1746 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1747} 1748else version (CRuntime_Bionic) 1749{ 1750 int pthread_condattr_getpshared(pthread_condattr_t*, int*); 1751 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1752 int pthread_mutexattr_getpshared(pthread_mutexattr_t*, int*); 1753 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1754 int pthread_rwlockattr_getpshared(pthread_rwlockattr_t*, int*); 1755 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1756} 1757else version (CRuntime_Musl) 1758{ 1759 int pthread_condattr_getpshared(pthread_condattr_t*, int*); 1760 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1761 int pthread_mutexattr_getpshared(pthread_mutexattr_t*, int*); 1762 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1763 int pthread_rwlockattr_getpshared(pthread_rwlockattr_t*, int*); 1764 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1765} 1766else version (CRuntime_UClibc) 1767{ 1768 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*); 1769 int pthread_condattr_setpshared(pthread_condattr_t*, int); 1770 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*); 1771 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int); 1772 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*); 1773 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int); 1774} 1775else 1776{ 1777 static assert(false, "Unsupported platform"); 1778} 1779