Mercurial > projects > ldc

comparison druntime/import/stdc/posix/pthread.d @ 760:6f33b427bfd1

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