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 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
version(Posix)33 version (Posix):
34 extern (C)
35 nothrow:
36 @system:
37
38 //
39 // Required
40 //
41 /*
42 PTHREAD_CANCEL_ASYNCHRONOUS
43 PTHREAD_CANCEL_ENABLE
44 PTHREAD_CANCEL_DEFERRED
45 PTHREAD_CANCEL_DISABLE
46 PTHREAD_CANCELED
47 PTHREAD_COND_INITIALIZER
48 PTHREAD_CREATE_DETACHED
49 PTHREAD_CREATE_JOINABLE
50 PTHREAD_EXPLICIT_SCHED
51 PTHREAD_INHERIT_SCHED
52 PTHREAD_MUTEX_INITIALIZER
53 PTHREAD_ONCE_INIT
54 PTHREAD_PROCESS_SHARED
55 PTHREAD_PROCESS_PRIVATE
56
57 int pthread_atfork(void function(), void function(), void function());
58 int pthread_attr_destroy(pthread_attr_t*);
59 int pthread_attr_getdetachstate(const scope pthread_attr_t*, int*);
60 int pthread_attr_getschedparam(const scope pthread_attr_t*, sched_param*);
61 int pthread_attr_init(pthread_attr_t*);
62 int pthread_attr_setdetachstate(pthread_attr_t*, int);
63 int pthread_attr_setschedparam(const scope pthread_attr_t*, sched_param*);
64 int pthread_cancel(pthread_t);
65 void pthread_cleanup_push(void function(void*), void*);
66 void pthread_cleanup_pop(int);
67 int pthread_cond_broadcast(pthread_cond_t*);
68 int pthread_cond_destroy(pthread_cond_t*);
69 int pthread_cond_init(const scope pthread_cond_t*, pthread_condattr_t*);
70 int pthread_cond_signal(pthread_cond_t*);
71 int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, const scope timespec*);
72 int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
73 int pthread_condattr_destroy(pthread_condattr_t*);
74 int pthread_condattr_init(pthread_condattr_t*);
75 int pthread_create(pthread_t*, const scope pthread_attr_t*, void* function(void*), void*);
76 int pthread_detach(pthread_t);
77 int pthread_equal(pthread_t, pthread_t);
78 void pthread_exit(void*);
79 void* pthread_getspecific(pthread_key_t);
80 int pthread_join(pthread_t, void**);
81 int pthread_key_create(pthread_key_t*, void function(void*));
82 int pthread_key_delete(pthread_key_t);
83 int pthread_mutex_destroy(pthread_mutex_t*);
84 int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*);
85 int pthread_mutex_lock(pthread_mutex_t*);
86 int pthread_mutex_trylock(pthread_mutex_t*);
87 int pthread_mutex_unlock(pthread_mutex_t*);
88 int pthread_mutexattr_destroy(pthread_mutexattr_t*);
89 int pthread_mutexattr_init(pthread_mutexattr_t*);
90 int pthread_once(pthread_once_t*, void function());
91 int pthread_rwlock_destroy(pthread_rwlock_t*);
92 int pthread_rwlock_init(pthread_rwlock_t*, const scope pthread_rwlockattr_t*);
93 int pthread_rwlock_rdlock(pthread_rwlock_t*);
94 int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
95 int pthread_rwlock_trywrlock(pthread_rwlock_t*);
96 int pthread_rwlock_unlock(pthread_rwlock_t*);
97 int pthread_rwlock_wrlock(pthread_rwlock_t*);
98 int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
99 int pthread_rwlockattr_init(pthread_rwlockattr_t*);
100 pthread_t pthread_self();
101 int pthread_setcancelstate(int, int*);
102 int pthread_setcanceltype(int, int*);
103 int pthread_setspecific(pthread_key_t, const scope void*);
104 void pthread_testcancel();
105 */
106 version (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 }
145 else 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 }
184 else 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 }
222 else 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 }
258 else 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 }
298 else 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 }
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(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
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(const scope 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*, const scope 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*, const scope 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*, const scope 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, const scope 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*, const scope 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(const scope 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*, 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 }
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*, 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 }
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*, 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 }
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*, 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 }
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*, 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 }
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*, 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 }
852 else version (CRuntime_Bionic)
853 {
854 }
855 else 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 }
867 else 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 }
879 else
880 {
881 static assert(false, "Unsupported platform");
882 }
883
884 //
885 // Clock (CS)
886 //
887 /*
888 int pthread_condattr_getclock(const scope pthread_condattr_t*, clockid_t*);
889 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
890 */
891 version (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 }
896 else 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 }
901 else 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 }
906 else version (NetBSD)
907 {
908 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
909 }
910 else 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 }
915 else version (Darwin)
916 {
917 }
918 else 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 }
923 else version (CRuntime_Bionic)
924 {
925 }
926 else 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 }
931 else 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 }
936 else
937 {
938 static assert(false, "Unsupported platform");
939 }
940
941 //
942 // Spinlock (SPI)
943 //
944 /*
945 int pthread_spin_destroy(pthread_spinlock_t*);
946 int pthread_spin_init(pthread_spinlock_t*, int);
947 int pthread_spin_lock(pthread_spinlock_t*);
948 int pthread_spin_trylock(pthread_spinlock_t*);
949 int pthread_spin_unlock(pthread_spinlock_t*);
950 */
951
952 version (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 }
960 else 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 }
968 else 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 }
976 else 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 }
984 else 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 }
992 else version (Darwin)
993 {
994 }
995 else 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 }
1003 else version (CRuntime_Bionic)
1004 {
1005 }
1006 else 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 }
1014 else 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 }
1022 else
1023 {
1024 static assert(false, "Unsupported platform");
1025 }
1026
1027 //
1028 // XOpen (XSI)
1029 //
1030 /*
1031 PTHREAD_MUTEX_DEFAULT
1032 PTHREAD_MUTEX_ERRORCHECK
1033 PTHREAD_MUTEX_NORMAL
1034 PTHREAD_MUTEX_RECURSIVE
1035
1036 int pthread_attr_getguardsize(const scope pthread_attr_t*, size_t*);
1037 int pthread_attr_setguardsize(pthread_attr_t*, size_t);
1038 int pthread_getconcurrency();
1039 int pthread_mutexattr_gettype(const scope pthread_mutexattr_t*, int*);
1040 int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
1041 int pthread_setconcurrency(int);
1042 */
1043
1044 version (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 }
1058 else 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 }
1072 else 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 }
1091 else 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 }
1109 else 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 }
1128 else 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 }
1146 else 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 }
1164 else 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 }
1176 else 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 }
1186 else 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 }
1208 else
1209 {
1210 static assert(false, "Unsupported platform");
1211 }
1212
1213 //
1214 // CPU Time (TCT)
1215 //
1216 /*
1217 int pthread_getcpuclockid(pthread_t, clockid_t*);
1218 */
1219
1220 version (CRuntime_Glibc)
1221 {
1222 int pthread_getcpuclockid(pthread_t, clockid_t*);
1223 }
1224 else version (FreeBSD)
1225 {
1226 int pthread_getcpuclockid(pthread_t, clockid_t*);
1227 }
1228 else version (DragonFlyBSD)
1229 {
1230 int pthread_getcpuclockid(pthread_t, clockid_t*);
1231 }
1232 else version (NetBSD)
1233 {
1234 }
1235 else version (OpenBSD)
1236 {
1237 int pthread_getcpuclockid(pthread_t, clockid_t*);
1238 }
1239 else version (Darwin)
1240 {
1241 }
1242 else version (Solaris)
1243 {
1244 }
1245 else version (CRuntime_Bionic)
1246 {
1247 int pthread_getcpuclockid(pthread_t, clockid_t*);
1248 }
1249 else version (CRuntime_Musl)
1250 {
1251 int pthread_getcpuclockid(pthread_t, clockid_t*);
1252 }
1253 else version (CRuntime_UClibc)
1254 {
1255 int pthread_getcpuclockid(pthread_t, clockid_t*);
1256 }
1257 else
1258 {
1259 static assert(false, "Unsupported platform");
1260 }
1261
1262 //
1263 // Timeouts (TMO)
1264 //
1265 /*
1266 int pthread_mutex_timedlock(pthread_mutex_t*, const scope timespec*);
1267 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, const scope timespec*);
1268 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, const scope timespec*);
1269 */
1270
1271 version (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 }
1277 else 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 }
1283 else 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 }
1289 else 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 }
1295 else 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 }
1301 else 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 }
1307 else 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 }
1313 else 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 }
1318 else 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 }
1324 else 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 }
1330 else
1331 {
1332 static assert(false, "Unsupported platform");
1333 }
1334
1335 //
1336 // Priority (TPI|TPP)
1337 //
1338 /*
1339 PTHREAD_PRIO_INHERIT (TPI)
1340 PTHREAD_PRIO_NONE (TPP|TPI)
1341 PTHREAD_PRIO_PROTECT (TPI)
1342
1343 int pthread_mutex_getprioceiling(const scope pthread_mutex_t*, int*); (TPP)
1344 int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); (TPP)
1345 int pthread_mutexattr_getprioceiling(pthread_mutexattr_t*, int*); (TPP)
1346 int pthread_mutexattr_getprotocol(const scope pthread_mutexattr_t*, int*); (TPI|TPP)
1347 int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); (TPP)
1348 int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); (TPI|TPP)
1349 */
1350 version (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 }
1366 else 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 /*
1387 PTHREAD_SCOPE_PROCESS
1388 PTHREAD_SCOPE_SYSTEM
1389
1390 int pthread_attr_getinheritsched(const scope pthread_attr_t*, int*);
1391 int pthread_attr_getschedpolicy(const scope pthread_attr_t*, int*);
1392 int pthread_attr_getscope(const scope pthread_attr_t*, int*);
1393 int pthread_attr_setinheritsched(pthread_attr_t*, int);
1394 int pthread_attr_setschedpolicy(pthread_attr_t*, int);
1395 int pthread_attr_setscope(pthread_attr_t*, int);
1396 int pthread_getschedparam(pthread_t, int*, sched_param*);
1397 int pthread_setschedparam(pthread_t, int, const scope sched_param*);
1398 int pthread_setschedprio(pthread_t, int);
1399 */
1400
1401 version (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 }
1419 else 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 }
1437 else 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 }
1455 else 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 }
1473 else 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 }
1491 else 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 }
1508 else 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 }
1526 else 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 }
1541 else 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 }
1553 else 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 }
1571 else
1572 {
1573 static assert(false, "Unsupported platform");
1574 }
1575
1576 //
1577 // Stack (TSA|TSS)
1578 //
1579 /*
1580 int pthread_attr_getstack(const scope pthread_attr_t*, void**, size_t*); (TSA|TSS)
1581 int pthread_attr_getstackaddr(const scope pthread_attr_t*, void**); (TSA)
1582 int pthread_attr_getstacksize(const scope pthread_attr_t*, size_t*); (TSS)
1583 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); (TSA|TSS)
1584 int pthread_attr_setstackaddr(pthread_attr_t*, void*); (TSA)
1585 int pthread_attr_setstacksize(pthread_attr_t*, size_t); (TSS)
1586 */
1587
1588 version (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 }
1597 else 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 }
1606 else 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 }
1615 else 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 }
1624 else 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 }
1633 else 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 }
1642 else 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 }
1651 else 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 }
1660 else 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 }
1665 else 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 }
1674 else
1675 {
1676 static assert(false, "Unsupported platform");
1677 }
1678
1679 //
1680 // Shared Synchronization (TSH)
1681 //
1682 /*
1683 int pthread_condattr_getpshared(const scope pthread_condattr_t*, int*);
1684 int pthread_condattr_setpshared(pthread_condattr_t*, int);
1685 int pthread_mutexattr_getpshared(const scope pthread_mutexattr_t*, int*);
1686 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
1687 int pthread_rwlockattr_getpshared(const scope pthread_rwlockattr_t*, int*);
1688 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
1689 */
1690
1691 version (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 }
1700 else 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 }
1709 else 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 }
1718 else version (OpenBSD)
1719 {
1720 }
1721 else 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 }
1730 else 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 }
1739 else 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 }
1748 else 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 }
1757 else 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 }
1766 else 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 }
1775 else
1776 {
1777 static assert(false, "Unsupported platform");
1778 }
1779