Mercurial > projects > ldc

comparison druntime/import/core/sys/posix/pthread.d @ 1458:e0b2d67cfe7c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added druntime (this should be removed once it works).
author Robert Clipsham <robert@octarineparrot.com>
date Tue, 02 Jun 2009 17:43:06 +0100
parents
children
comparison
equal deleted inserted replaced
1456:7b218ec1044f 1458:e0b2d67cfe7c
1 /**
2 * D header file for POSIX.
3 *
4 * Copyright: Copyright Sean Kelly 2005 - 2009.
5 * License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
6 * Authors: Sean Kelly
7 * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
8 *
9 * Copyright Sean Kelly 2005 - 2009.
10 * Distributed under the Boost Software License, Version 1.0.
11 * (See accompanying file LICENSE_1_0.txt or copy at
12 * http://www.boost.org/LICENSE_1_0.txt)
13 */
14 module core.sys.posix.pthread;
15
16 private import core.sys.posix.config;
17 public import core.sys.posix.sys.types;
18 public import core.sys.posix.sched;
19 public import core.sys.posix.time;
20
21 extern (C):
22
23 //
24 // Required
25 //
26 /*
27 PTHREAD_CANCEL_ASYNCHRONOUS
28 PTHREAD_CANCEL_ENABLE
29 PTHREAD_CANCEL_DEFERRED
30 PTHREAD_CANCEL_DISABLE
31 PTHREAD_CANCELED
32 PTHREAD_COND_INITIALIZER
33 PTHREAD_CREATE_DETACHED
34 PTHREAD_CREATE_JOINABLE
35 PTHREAD_EXPLICIT_SCHED
36 PTHREAD_INHERIT_SCHED
37 PTHREAD_MUTEX_INITIALIZER
38 PTHREAD_ONCE_INIT
39 PTHREAD_PROCESS_SHARED
40 PTHREAD_PROCESS_PRIVATE
41
42 int pthread_atfork(void function(), void function(), void function());
43 int pthread_attr_destroy(pthread_attr_t*);
44 int pthread_attr_getdetachstate(in pthread_attr_t*, int*);
45 int pthread_attr_getschedparam(in pthread_attr_t*, sched_param*);
46 int pthread_attr_init(pthread_attr_t*);
47 int pthread_attr_setdetachstate(pthread_attr_t*, int);
48 int pthread_attr_setschedparam(in pthread_attr_t*, sched_param*);
49 int pthread_cancel(pthread_t);
50 void pthread_cleanup_push(void function(void*), void*);
51 void pthread_cleanup_pop(int);
52 int pthread_cond_broadcast(pthread_cond_t*);
53 int pthread_cond_destroy(pthread_cond_t*);
54 int pthread_cond_init(in pthread_cond_t*, pthread_condattr_t*);
55 int pthread_cond_signal(pthread_cond_t*);
56 int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, in timespec*);
57 int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
58 int pthread_condattr_destroy(pthread_condattr_t*);
59 int pthread_condattr_init(pthread_condattr_t*);
60 int pthread_create(pthread_t*, in pthread_attr_t*, void* function(void*), void*);
61 int pthread_detach(pthread_t);
62 int pthread_equal(pthread_t, pthread_t);
63 void pthread_exit(void*);
64 void* pthread_getspecific(pthread_key_t);
65 int pthread_join(pthread_t, void**);
66 int pthread_key_create(pthread_key_t*, void function(void*));
67 int pthread_key_delete(pthread_key_t);
68 int pthread_mutex_destroy(pthread_mutex_t*);
69 int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*);
70 int pthread_mutex_lock(pthread_mutex_t*);
71 int pthread_mutex_trylock(pthread_mutex_t*);
72 int pthread_mutex_unlock(pthread_mutex_t*);
73 int pthread_mutexattr_destroy(pthread_mutexattr_t*);
74 int pthread_mutexattr_init(pthread_mutexattr_t*);
75 int pthread_once(pthread_once_t*, void function());
76 int pthread_rwlock_destroy(pthread_rwlock_t*);
77 int pthread_rwlock_init(in pthread_rwlock_t*, pthread_rwlockattr_t*);
78 int pthread_rwlock_rdlock(pthread_rwlock_t*);
79 int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
80 int pthread_rwlock_trywrlock(pthread_rwlock_t*);
81 int pthread_rwlock_unlock(pthread_rwlock_t*);
82 int pthread_rwlock_wrlock(pthread_rwlock_t*);
83 int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
84 int pthread_rwlockattr_init(pthread_rwlockattr_t*);
85 pthread_t pthread_self();
86 int pthread_setcancelstate(int, int*);
87 int pthread_setcanceltype(int, int*);
88 int pthread_setspecific(pthread_key_t, in void*);
89 void pthread_testcancel();
90 */
91 version( linux )
92 {
93 enum
94 {
95 PTHREAD_CANCEL_ENABLE,
96 PTHREAD_CANCEL_DISABLE
97 }
98
99 enum
100 {
101 PTHREAD_CANCEL_DEFERRED,
102 PTHREAD_CANCEL_ASYNCHRONOUS
103 }
104
105 enum PTHREAD_CANCELED = cast(void*) -1;
106
107 //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 };
108
109 enum
110 {
111 PTHREAD_CREATE_JOINABLE,
112 PTHREAD_CREATE_DETACHED
113 }
114
115 enum
116 {
117 PTHREAD_INHERIT_SCHED,
118 PTHREAD_EXPLICIT_SCHED
119 }
120
121 //enum pthread_mutex_t PTHREAD_MUTEX_INITIALIZER = { 0, 0, null, PTHREAD_MUTEX_NORMAL, { 0, 0 } };
122
123 enum PTHREAD_ONCE_INIT = 0;
124
125 enum
126 {
127 PTHREAD_PROCESS_PRIVATE,
128 PTHREAD_PROCESS_SHARED
129 }
130 }
131 else version( OSX )
132 {
133 enum
134 {
135 PTHREAD_CANCEL_ENABLE = 1,
136 PTHREAD_CANCEL_DISABLE = 0
137 }
138
139 enum
140 {
141 PTHREAD_CANCEL_DEFERRED = 2,
142 PTHREAD_CANCEL_ASYNCHRONOUS = 0
143 }
144
145 enum PTHREAD_CANCELED = cast(void*) -1;
146
147 //enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 };
148
149 enum
150 {
151 PTHREAD_CREATE_JOINABLE = 1,
152 PTHREAD_CREATE_DETACHED = 2
153 }
154
155 enum
156 {
157 PTHREAD_INHERIT_SCHED = 1,
158 PTHREAD_EXPLICIT_SCHED = 2
159 }
160
161 //enum pthread_mutex_t PTHREAD_MUTEX_INITIALIZER = { 0, 0, null, PTHREAD_MUTEX_NORMAL, { 0, 0 } };
162
163 enum PTHREAD_ONCE_INIT = 0;
164
165 enum
166 {
167 PTHREAD_PROCESS_PRIVATE = 2,
168 PTHREAD_PROCESS_SHARED = 1
169 }
170 }
171
172 int pthread_atfork(void function(), void function(), void function());
173 int pthread_attr_destroy(pthread_attr_t*);
174 int pthread_attr_getdetachstate(in pthread_attr_t*, int*);
175 int pthread_attr_getschedparam(in pthread_attr_t*, sched_param*);
176 int pthread_attr_init(pthread_attr_t*);
177 int pthread_attr_setdetachstate(pthread_attr_t*, int);
178 int pthread_attr_setschedparam(in pthread_attr_t*, sched_param*);
179 int pthread_cancel(pthread_t);
180
181 version( linux )
182 {
183 alias void function(void*) _pthread_cleanup_routine;
184
185 struct _pthread_cleanup_buffer
186 {
187 _pthread_cleanup_routine __routine;
188 void* __arg;
189 int __canceltype;
190 _pthread_cleanup_buffer* __prev;
191 }
192
193 void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine, void*);
194 void _pthread_cleanup_pop(_pthread_cleanup_buffer*, int);
195
196 struct pthread_cleanup
197 {
198 _pthread_cleanup_buffer buffer = void;
199
200 void push()( _pthread_cleanup_routine routine, void* arg )
201 {
202 _pthread_cleanup_push( &buffer, routine, arg );
203 }
204
205 void pop()( int execute )
206 {
207 _pthread_cleanup_pop( &buffer, execute );
208 }
209 }
210 }
211 else version( OSX )
212 {
213 alias void function(void*) _pthread_cleanup_routine;
214
215 struct _pthread_cleanup_buffer
216 {
217 _pthread_cleanup_routine __routine;
218 void* __arg;
219 _pthread_cleanup_buffer* __next;
220 }
221
222 struct pthread_cleanup
223 {
224 _pthread_cleanup_buffer buffer = void;
225
226 void push()( _pthread_cleanup_routine routine, void* arg )
227 {
228 pthread_t self = pthread_self();
229 buffer.__routine = routine;
230 buffer.__arg = arg;
231 buffer.__next = cast(_pthread_cleanup_buffer*) self.__cleanup_stack;
232 self.__cleanup_stack = cast(pthread_handler_rec*) &buffer;
233 }
234
235 void pop()( int execute )
236 {
237 pthread_t self = pthread_self();
238 self.__cleanup_stack = cast(pthread_handler_rec*) buffer.__next;
239 if( execute )
240 {
241 buffer.__routine( buffer.__arg );
242 }
243 }
244 }
245 }
246 else
247 {
248 void pthread_cleanup_push(void function(void*), void*);
249 void pthread_cleanup_pop(int);
250 }
251
252 int pthread_cond_broadcast(pthread_cond_t*);
253 int pthread_cond_destroy(pthread_cond_t*);
254 int pthread_cond_init(in pthread_cond_t*, pthread_condattr_t*);
255 int pthread_cond_signal(pthread_cond_t*);
256 int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, in timespec*);
257 int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
258 int pthread_condattr_destroy(pthread_condattr_t*);
259 int pthread_condattr_init(pthread_condattr_t*);
260 int pthread_create(pthread_t*, in pthread_attr_t*, void* function(void*), void*);
261 int pthread_detach(pthread_t);
262 int pthread_equal(pthread_t, pthread_t);
263 void pthread_exit(void*);
264 void* pthread_getspecific(pthread_key_t);
265 int pthread_join(pthread_t, void**);
266 int pthread_key_create(pthread_key_t*, void function(void*));
267 int pthread_key_delete(pthread_key_t);
268 int pthread_mutex_destroy(pthread_mutex_t*);
269 int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*);
270 int pthread_mutex_lock(pthread_mutex_t*);
271 int pthread_mutex_trylock(pthread_mutex_t*);
272 int pthread_mutex_unlock(pthread_mutex_t*);
273 int pthread_mutexattr_destroy(pthread_mutexattr_t*);
274 int pthread_mutexattr_init(pthread_mutexattr_t*);
275 int pthread_once(pthread_once_t*, void function());
276 int pthread_rwlock_destroy(pthread_rwlock_t*);
277 int pthread_rwlock_init(in pthread_rwlock_t*, pthread_rwlockattr_t*);
278 int pthread_rwlock_rdlock(pthread_rwlock_t*);
279 int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
280 int pthread_rwlock_trywrlock(pthread_rwlock_t*);
281 int pthread_rwlock_unlock(pthread_rwlock_t*);
282 int pthread_rwlock_wrlock(pthread_rwlock_t*);
283 int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
284 int pthread_rwlockattr_init(pthread_rwlockattr_t*);
285 pthread_t pthread_self();
286 int pthread_setcancelstate(int, int*);
287 int pthread_setcanceltype(int, int*);
288 int pthread_setspecific(pthread_key_t, in void*);
289 void pthread_testcancel();
290
291 //
292 // Barrier (BAR)
293 //
294 /*
295 PTHREAD_BARRIER_SERIAL_THREAD
296
297 int pthread_barrier_destroy(pthread_barrier_t*);
298 int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
299 int pthread_barrier_wait(pthread_barrier_t*);
300 int pthread_barrierattr_destroy(pthread_barrierattr_t*);
301 int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*); (BAR|TSH)
302 int pthread_barrierattr_init(pthread_barrierattr_t*);
303 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); (BAR|TSH)
304 */
305
306 version( linux )
307 {
308 enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
309
310 int pthread_barrier_destroy(pthread_barrier_t*);
311 int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
312 int pthread_barrier_wait(pthread_barrier_t*);
313 int pthread_barrierattr_destroy(pthread_barrierattr_t*);
314 int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
315 int pthread_barrierattr_init(pthread_barrierattr_t*);
316 int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
317 }
318
319 //
320 // Clock (CS)
321 //
322 /*
323 int pthread_condattr_getclock(in pthread_condattr_t*, clockid_t*);
324 int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
325 */
326
327 //
328 // Spinlock (SPI)
329 //
330 /*
331 int pthread_spin_destroy(pthread_spinlock_t*);
332 int pthread_spin_init(pthread_spinlock_t*, int);
333 int pthread_spin_lock(pthread_spinlock_t*);
334 int pthread_spin_trylock(pthread_spinlock_t*);
335 int pthread_spin_unlock(pthread_spinlock_t*);
336 */
337
338 version( linux )
339 {
340 int pthread_spin_destroy(pthread_spinlock_t*);
341 int pthread_spin_init(pthread_spinlock_t*, int);
342 int pthread_spin_lock(pthread_spinlock_t*);
343 int pthread_spin_trylock(pthread_spinlock_t*);
344 int pthread_spin_unlock(pthread_spinlock_t*);
345 }
346
347 //
348 // XOpen (XSI)
349 //
350 /*
351 PTHREAD_MUTEX_DEFAULT
352 PTHREAD_MUTEX_ERRORCHECK
353 PTHREAD_MUTEX_NORMAL
354 PTHREAD_MUTEX_RECURSIVE
355
356 int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
357 int pthread_attr_setguardsize(pthread_attr_t*, size_t);
358 int pthread_getconcurrency();
359 int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
360 int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
361 int pthread_setconcurrency(int);
362 */
363
364 version( linux )
365 {
366 enum PTHREAD_MUTEX_NORMAL = 0;
367 enum PTHREAD_MUTEX_RECURSIVE = 1;
368 enum PTHREAD_MUTEX_ERRORCHECK = 2;
369 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL;
370
371 int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
372 int pthread_attr_setguardsize(pthread_attr_t*, size_t);
373 int pthread_getconcurrency();
374 int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
375 int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
376 int pthread_setconcurrency(int);
377 }
378 else version( OSX )
379 {
380 enum PTHREAD_MUTEX_NORMAL = 0;
381 enum PTHREAD_MUTEX_ERRORCHECK = 1;
382 enum PTHREAD_MUTEX_RECURSIVE = 2;
383 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL;
384
385 int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
386 int pthread_attr_setguardsize(pthread_attr_t*, size_t);
387 int pthread_getconcurrency();
388 int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
389 int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
390 int pthread_setconcurrency(int);
391 }
392 else version( freebsd )
393 {
394 enum
395 {
396 PTHREAD_MUTEX_ERRORCHECK = 1,
397 PTHREAD_MUTEX_RECURSIVE = 2,
398 PTHREAD_MUTEX_NORMAL = 3,
399 PTHREAD_MUTEX_ADAPTIVE_NP = 4,
400 PTHREAD_MUTEX_TYPE_MAX
401 }
402 enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
403
404 int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
405 int pthread_attr_setguardsize(pthread_attr_t*, size_t);
406 int pthread_getconcurrency();
407 int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
408 int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
409 int pthread_setconcurrency(int);
410 }
411
412 //
413 // CPU Time (TCT)
414 //
415 /*
416 int pthread_getcpuclockid(pthread_t, clockid_t*);
417 */
418
419 version( linux )
420 {
421 int pthread_getcpuclockid(pthread_t, clockid_t*);
422 }
423
424 //
425 // Timeouts (TMO)
426 //
427 /*
428 int pthread_mutex_timedlock(pthread_mutex_t*, timespec*);
429 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
430 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
431 */
432
433 version( linux )
434 {
435 int pthread_mutex_timedlock(pthread_mutex_t*, timespec*);
436 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
437 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
438 }
439 else version( OSX )
440 {
441 int pthread_mutex_timedlock(pthread_mutex_t*, timespec*);
442 int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
443 int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
444 }
445
446 //
447 // Priority (TPI|TPP)
448 //
449 /*
450 PTHREAD_PRIO_INHERIT (TPI)
451 PTHREAD_PRIO_NONE (TPP|TPI)
452 PTHREAD_PRIO_PROTECT (TPI)
453
454 int pthread_mutex_getprioceiling(in pthread_mutex_t*, int*); (TPP)
455 int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); (TPP)
456 int pthread_mutexattr_getprioceiling(pthread_mutexattr_t*, int*); (TPP)
457 int pthread_mutexattr_getprotocol(in pthread_mutexattr_t*, int*); (TPI|TPP)
458 int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); (TPP)
459 int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); (TPI|TPP)
460 */
461
462 //
463 // Scheduling (TPS)
464 //
465 /*
466 PTHREAD_SCOPE_PROCESS
467 PTHREAD_SCOPE_SYSTEM
468
469 int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
470 int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
471 int pthread_attr_getscope(in pthread_attr_t*, int*);
472 int pthread_attr_setinheritsched(pthread_attr_t*, int);
473 int pthread_attr_setschedpolicy(pthread_attr_t*, int);
474 int pthread_attr_setscope(pthread_attr_t*, int);
475 int pthread_getschedparam(pthread_t, int*, sched_param*);
476 int pthread_setschedparam(pthread_t, int, in sched_param*);
477 int pthread_setschedprio(pthread_t, int);
478 */
479
480 version( linux )
481 {
482 enum
483 {
484 PTHREAD_SCOPE_SYSTEM,
485 PTHREAD_SCOPE_PROCESS
486 }
487
488 int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
489 int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
490 int pthread_attr_getscope(in pthread_attr_t*, int*);
491 int pthread_attr_setinheritsched(pthread_attr_t*, int);
492 int pthread_attr_setschedpolicy(pthread_attr_t*, int);
493 int pthread_attr_setscope(pthread_attr_t*, int);
494 int pthread_getschedparam(pthread_t, int*, sched_param*);
495 int pthread_setschedparam(pthread_t, int, in sched_param*);
496 //int pthread_setschedprio(pthread_t, int);
497 }
498 else version( OSX )
499 {
500 enum
501 {
502 PTHREAD_SCOPE_SYSTEM = 1,
503 PTHREAD_SCOPE_PROCESS = 2
504 }
505
506 int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
507 int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
508 int pthread_attr_getscope(in pthread_attr_t*, int*);
509 int pthread_attr_setinheritsched(pthread_attr_t*, int);
510 int pthread_attr_setschedpolicy(pthread_attr_t*, int);
511 int pthread_attr_setscope(pthread_attr_t*, int);
512 int pthread_getschedparam(pthread_t, int*, sched_param*);
513 int pthread_setschedparam(pthread_t, int, in sched_param*);
514 //int pthread_setschedprio(pthread_t, int);
515 }
516 else version( freebsd )
517 {
518 enum
519 {
520 PTHREAD_SCOPE_PROCESS = 0,
521 PTHREAD_SCOPE_SYSTEM = 0x2
522 }
523
524 int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
525 int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
526 int pthread_attr_getscope(in pthread_attr_t*, int*);
527 int pthread_attr_setinheritsched(pthread_attr_t*, int);
528 int pthread_attr_setschedpolicy(pthread_attr_t*, int);
529 int pthread_attr_setscope(in pthread_attr_t*, int);
530 int pthread_getschedparam(pthread_t, int*, sched_param*);
531 int pthread_setschedparam(pthread_t, int, sched_param*);
532 //int pthread_setschedprio(pthread_t, int);
533 }
534
535 //
536 // Stack (TSA|TSS)
537 //
538 /*
539 int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*); (TSA|TSS)
540 int pthread_attr_getstackaddr(in pthread_attr_t*, void**); (TSA)
541 int pthread_attr_getstacksize(in pthread_attr_t*, size_t*); (TSS)
542 int pthread_attr_setstack(pthread_attr_t*, void*, size_t); (TSA|TSS)
543 int pthread_attr_setstackaddr(pthread_attr_t*, void*); (TSA)
544 int pthread_attr_setstacksize(pthread_attr_t*, size_t); (TSS)
545 */
546
547 version( linux )
548 {
549 int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
550 int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
551 int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
552 int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
553 int pthread_attr_setstackaddr(pthread_attr_t*, void*);
554 int pthread_attr_setstacksize(pthread_attr_t*, size_t);
555 }
556 else version( OSX )
557 {
558 int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
559 int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
560 int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
561 int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
562 int pthread_attr_setstackaddr(pthread_attr_t*, void*);
563 int pthread_attr_setstacksize(pthread_attr_t*, size_t);
564 }
565 else version( freebsd )
566 {
567 int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
568 int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
569 int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
570 int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
571 int pthread_attr_setstackaddr(pthread_attr_t*, void*);
572 int pthread_attr_setstacksize(pthread_attr_t*, size_t);
573 }
574
575 //
576 // Shared Synchronization (TSH)
577 //
578 /*
579 int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
580 int pthread_condattr_setpshared(pthread_condattr_t*, int);
581 int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
582 int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
583 int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
584 int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
585 */