source: libcfa/src/concurrency/pthread.cfa@ 2b12d6e

Last change on this file since 2b12d6e was 9d47c1f, checked in by caparsons <caparson@…>, 2 years ago

changes over all usages of uC++ collections to use dlist instead
  • Property mode set to 100644
File size: 30.7 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// pthread.cfa --
8//
9// Author : Zhenyan Zhu
10// Created On : Sat Aug 6 16:29:18 2022
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Mon Sep 4 15:37:51 2023
13// Update Count : 1
14//
15
16#define __cforall_thread__
17
18#include <signal.h>
19#include <pthread.h>
20#include <errno.h>
21#include "locks.hfa"
22
23#define check_nonnull(x) asm("": "+rm"(x)); if( x == 0p ) return EINVAL;
24
25/* pthread key, pthread once inner routine mutual exclusion */
26static simple_owner_lock once_lock,key_lock,magic_mutex_check, concurrency_lock;
27
28//######################### Local Storage Helpers #########################
29
30enum { PTHREAD_KEYS_MAX = 1024 };
31
32struct pthread_values{
33 inline dlink(pthread_values);
34 void * value;
35 bool in_use;
36};
37P9_EMBEDDED( pthread_values, dlink(pthread_values) )
38
39struct pthread_keys {
40 bool in_use;
41 void (* destructor)( void * );
42 dlist( pthread_values ) threads;
43};
44
45static void ?{}(pthread_keys& k) {
46 k.threads{};
47}
48
49// Create storage separately to ensure no constructors are called.
50static pthread_keys cfa_pthread_keys_storage[PTHREAD_KEYS_MAX] __attribute__((aligned (16)));
51
52static void init_pthread_storage() {
53 for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) {
54 cfa_pthread_keys_storage[i]{};
55 }
56}
57
58#define cfa_pthread_keys ((pthread_keys *)cfa_pthread_keys_storage)
59
60/* Controlling the iterations of destructors for thread-specific data. */
61#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
62/* Number of iterations this implementation does. */
63#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
64
65//######################### Parallelism Helpers #########################
66
67struct Pthread_kernel_threads{
68 inline dlink(Pthread_kernel_threads);
69 processor p;
70};
71P9_EMBEDDED( Pthread_kernel_threads, dlink(Pthread_kernel_threads) )
72
73static dlist(Pthread_kernel_threads) cfa_pthreads_kernel_threads;
74static bool cfa_pthreads_kernel_threads_zero = false; // set to zero ?
75static int cfa_pthreads_no_kernel_threads = 1; // number of kernel threads
76
77
78//######################### Cond Helpers #########################
79
80typedef pthread_cond_var(simple_owner_lock) cfa2pthr_cond_var_t;
81
82/* condvar helper routines */
83static void init(pthread_cond_t * pcond) {
84 static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
85 cfa2pthr_cond_var_t * _cond = (cfa2pthr_cond_var_t *)pcond;
86 ?{}(*_cond);
87}
88
89static cfa2pthr_cond_var_t * get(pthread_cond_t * pcond) {
90 static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
91 return (cfa2pthr_cond_var_t *)pcond;
92}
93
94static void destroy(pthread_cond_t * cond) {
95 static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)");
96 ^?{}(*get(cond));
97}
98
99
100//######################### Mutex Helper #########################
101
102/* mutex helper routines */
103static void mutex_check(pthread_mutex_t * t) {
104 // Use double check to improve performance.
105 // Check is safe on x86; volatile prevents compiler reordering
106 volatile pthread_mutex_t * const mutex_ = t;
107
108 // SKULLDUGGERY: not a portable way to access the kind field, /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h
109 int _lock_val = ((pthread_mutex_t *)mutex_)->__data.__lock;
110
111 // if pthread_mutex_t is initialized by PTHREAD_MUTEX_INITIALIZER, _lock_val should be 0
112 if ( _lock_val == 0 ) {
113 lock(magic_mutex_check);
114 _lock_val = ((pthread_mutex_t *)mutex_)->__data.__lock;
115 if ( _lock_val == 0 ) {
116 pthread_mutex_init( t, NULL );
117 }
118 unlock(magic_mutex_check);
119 }
120} // mutex_check
121
122
123static void init(pthread_mutex_t * plock) {
124 static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
125 simple_owner_lock * _lock = (simple_owner_lock *)plock;
126 ?{}(*_lock);
127}
128
129static simple_owner_lock * get(pthread_mutex_t * plock) {
130 static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
131 return (simple_owner_lock *)plock;
132}
133
134static void destroy(pthread_mutex_t * plock) {
135 static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)");
136 ^?{}(*get(plock));
137}
138
139//######################### Attr helpers #########################
140typedef struct cfaPthread_attr_t { // thread attributes
141 int contentionscope;
142 int detachstate;
143 size_t stacksize;
144 void * stackaddr;
145 int policy;
146 int inheritsched;
147 struct sched_param param;
148} cfaPthread_attr_t;
149
150static const cfaPthread_attr_t default_attrs {
151 0,
152 0,
153 65_000,
154 NULL,
155 0,
156 0,
157 {0}
158};
159
160static cfaPthread_attr_t * get(const pthread_attr_t * attr) {
161 static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t), "sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)");
162 return (cfaPthread_attr_t *)attr;
163}
164
165
166//######################### Threads Helper #########################
167
168// exception for cancel_stack in pthread_exit
169exception pthread_exit_exp {};
170static vtable(pthread_exit_exp) exp_vt;
171
172thread cfaPthread{
173 cfaPthread_attr_t attr;
174 pthread_t pthreadId;
175
176 // pthreads return value
177 void * joinval;
178
179 // pthread attributes
180 pthread_attr_t pthread_attr;
181
182 void *(* start_routine)(void *);
183 void * start_arg;
184
185 // thread local data
186 pthread_values * pthreadData;
187
188 // flag used for tryjoin
189 bool isTerminated;
190};
191
192/* thread part routines */
193// cfaPthread entry point
194void main(cfaPthread & _thread) with(_thread) {
195 joinval = start_routine(start_arg);
196 isTerminated = true;
197}
198
199static cfaPthread * lookup( pthread_t p ) {
200 static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *),"sizeof(pthread_t) < sizeof(cfaPthread *)");
201 return (cfaPthread *)p;
202}
203
204static void pthread_deletespecific_( pthread_values * values ) { // see uMachContext::invokeTask
205 pthread_values * value;
206 pthread_keys * key;
207 bool destcalled = true;
208 if (values != NULL) {
209 for ( int attempts = 0; attempts < PTHREAD_DESTRUCTOR_ITERATIONS && destcalled ; attempts += 1 ) {
210 destcalled = false;
211 lock(key_lock);
212 for ( int i = 0; i < PTHREAD_KEYS_MAX; i++ ) {
213 // for each valid key
214 if ( values[i].in_use) {
215 value = &values[i];
216 key = &cfa_pthread_keys[i];
217 value->in_use = false;
218 remove(*value);
219
220 // if a key value has a non-NULL destructor pointer, and the thread has a non-NULL value associated with that key,
221 // the value of the key is set to NULL, and then the function pointed to is called with the previously associated value as its sole argument.
222 if (value->value != NULL && key->destructor != NULL) {
223 unlock(key_lock);
224 key->destructor(value->value); // run destructor
225 lock(key_lock);
226 destcalled = true;
227 } // if
228 value->value = NULL;
229 } // if
230 } // for
231 unlock(key_lock);
232 } // for
233 free(values);
234 } // if
235}
236
237static void ^?{}(cfaPthread & mutex t) {
238 // delete pthread local storage
239 pthread_values * values = t.pthreadData;
240 pthread_deletespecific_(values);
241}
242
243static void ?{}(cfaPthread & t, pthread_t * _thread, const pthread_attr_t * _attr,void *(* start_routine)(void *), void * arg) {
244 static_assert(sizeof(pthread_t) >= sizeof(cfaPthread *), "pthread_t too small to hold a pointer: sizeof(pthread_t) < sizeof(cfaPthread *)");
245
246 // set up user thread stackSize
247 cfaPthread_attr_t * attr = get(_attr);
248 ((thread&)t){ attr ? attr->stacksize: DEFAULT_STACK_SIZE };
249
250 // initialize _thread & cfaPthread id
251 *_thread = t.pthreadId = (pthread_t)(&t);
252
253 // if attr null, self attr will be set as default_attrs; else set to attr
254 t.attr = (attr != NULL ? *attr : default_attrs);
255
256 // init start routine and arguments
257 t.start_routine = start_routine;
258 t.start_arg = arg;
259 t.pthreadData = NULL;
260}
261
262
263extern "C"{
264 //######################### Pthread Attrs #########################
265
266 int pthread_attr_init(pthread_attr_t * attr) libcfa_public __THROW {
267 cfaPthread_attr_t * _attr = get(attr);
268 ?{}(*_attr, default_attrs);
269 return 0;
270 }
271 int pthread_attr_destroy(pthread_attr_t * attr) libcfa_public __THROW {
272 ^?{}(*get(attr));
273 return 0;
274 }
275
276 int pthread_attr_setscope( pthread_attr_t * attr, int contentionscope ) libcfa_public __THROW {
277 get( attr )->contentionscope = contentionscope;
278 return 0;
279 } // pthread_attr_setscope
280
281 int pthread_attr_getscope( const pthread_attr_t * attr, int * contentionscope ) libcfa_public __THROW {
282 *contentionscope = get( attr )->contentionscope;
283 return 0;
284 } // pthread_attr_getscope
285
286 int pthread_attr_setdetachstate( pthread_attr_t * attr, int detachstate ) libcfa_public __THROW {
287 get( attr )->detachstate = detachstate;
288 return 0;
289 } // pthread_attr_setdetachstate
290
291 int pthread_attr_getdetachstate( const pthread_attr_t * attr, int * detachstate ) libcfa_public __THROW {
292 *detachstate = get( attr )->detachstate;
293 return 0;
294 } // pthread_attr_getdetachstate
295
296 int pthread_attr_setstacksize( pthread_attr_t * attr, size_t stacksize ) libcfa_public __THROW {
297 get( attr )->stacksize = stacksize;
298 return 0;
299 } // pthread_attr_setstacksize
300
301 int pthread_attr_getstacksize( const pthread_attr_t * attr, size_t * stacksize ) libcfa_public __THROW {
302 *stacksize = get( attr )->stacksize;
303 return 0;
304 } // pthread_attr_getstacksize
305
306 int pthread_attr_getguardsize( const pthread_attr_t * /* attr */, size_t * /* guardsize */ ) libcfa_public __THROW {
307 return 0;
308 } // pthread_attr_getguardsize
309
310 int pthread_attr_setguardsize( pthread_attr_t * /* attr */, size_t /* guardsize */ ) libcfa_public __THROW {
311 return 0;
312 } // pthread_attr_setguardsize
313
314 int pthread_attr_setstackaddr( pthread_attr_t * attr, void * stackaddr ) libcfa_public __THROW {
315 get( attr )->stackaddr = stackaddr;
316 return 0;
317 } // pthread_attr_setstackaddr
318
319 int pthread_attr_getstackaddr( const pthread_attr_t * attr, void ** stackaddr ) libcfa_public __THROW {
320 *stackaddr = get( attr )->stackaddr;
321 return 0;
322 } // pthread_attr_getstackaddr
323
324 int pthread_attr_setstack( pthread_attr_t * attr, void * stackaddr, size_t stacksize ) libcfa_public __THROW {
325 get( attr )->stackaddr = stackaddr;
326 get( attr )->stacksize = stacksize;
327 return 0;
328 } // pthread_attr_setstack
329
330 int pthread_attr_getstack( const pthread_attr_t * attr, void ** stackaddr, size_t * stacksize ) libcfa_public __THROW {
331 *stackaddr = get( attr )->stackaddr;
332 *stacksize = get( attr )->stacksize;
333 return 0;
334 } // pthread_attr_getstack
335
336 // Initialize thread attribute *attr with attributes corresponding to the
337 // already running thread threadID. It shall be called on unitialized attr
338 // and destroyed with pthread_attr_destroy when no longer needed.
339 int pthread_getattr_np( pthread_t threadID, pthread_attr_t * attr ) libcfa_public __THROW { // GNU extension
340 check_nonnull(attr);
341
342 // copy all fields
343 *get(attr) = lookup( threadID )->attr;
344
345 return 0;
346 } // pthread_getattr_np
347
348
349 //######################### Threads #########################
350
351 int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(* start_routine)(void *), void * arg) libcfa_public __THROW {
352 cfaPthread * t = alloc();
353 (*t){_thread, attr, start_routine, arg};
354 return 0;
355 }
356
357 int pthread_join(pthread_t _thread, void ** value_ptr) libcfa_public __THROW {
358 // if thread is invalid
359 if (_thread == NULL) return EINVAL;
360 if (_thread == pthread_self()) return EDEADLK;
361
362 // get user thr pointer
363 cfaPthread * p = lookup(_thread);
364 try {
365 join(*p);
366 }
367 // if thread called pthread_exit
368 catchResume (ThreadCancelled(cfaPthread) * cancel) {}
369
370 // fetch result
371 if (value_ptr != NULL ) *value_ptr = p->joinval;
372 delete(p);
373 return 0;
374 }
375
376 int pthread_tryjoin_np(pthread_t _thread, void ** value_ptr) libcfa_public __THROW {
377 // if thread is invalid
378 if (_thread == NULL) return EINVAL;
379 if (_thread == pthread_self()) return EDEADLK;
380
381 cfaPthread * p = lookup(_thread);
382
383 // thread not finished ?
384 if (!p->isTerminated) return EBUSY;
385
386 join( *p );
387
388 if (value_ptr != NULL ) *value_ptr = p->joinval;
389 delete(p);
390 return 0;
391 }
392
393 pthread_t pthread_self(void) libcfa_public __THROW {
394 return (pthread_t)((uintptr_t)active_thread() - (sizeof(cfaPthread) - sizeof(thread$)));
395 }
396
397 void pthread_exit(void * status) libcfa_public __THROW {
398 pthread_t pid = pthread_self();
399 cfaPthread * _thread = (cfaPthread *)pid;
400 _thread->joinval = status; // set return value
401 _thread->isTerminated = 1; // set terminated flag
402 cancel_stack((pthread_exit_exp){&exp_vt});
403 } //pthread_exit_
404
405 int pthread_yield( void ) __THROW { // GNU extension
406 yield();
407 return 0;
408 }
409
410
411 //######################### Mutex #########################
412
413 int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t * attr) libcfa_public __THROW {
414 check_nonnull(_mutex);
415 init(_mutex);
416 return 0;
417 } //pthread_mutex_init_
418
419
420 int pthread_mutex_destroy(pthread_mutex_t *_mutex) libcfa_public __THROW {
421 check_nonnull(_mutex);
422 simple_owner_lock * _lock = get(_mutex);
423 if (_lock->owner != NULL) {
424 return EBUSY;
425 }
426 destroy(_mutex);
427 return 0;
428 } //pthread_mutex_destroy_
429
430 int pthread_mutex_lock(pthread_mutex_t *_mutex) libcfa_public __THROW {
431 check_nonnull(_mutex);
432 mutex_check(_mutex);
433 simple_owner_lock * _lock = get(_mutex);
434 lock(*_lock);
435 return 0;
436 } //pthread_mutex_lock_
437
438 int pthread_mutex_unlock(pthread_mutex_t *_mutex) libcfa_public __THROW {
439 check_nonnull(_mutex);
440 simple_owner_lock * _lock = get(_mutex);
441 if (_lock->owner != active_thread()) {
442 return EPERM;
443 } // current thread does not hold the mutex
444 unlock(*_lock);
445 return 0;
446 } //pthread_mutex_unlock_
447
448 int pthread_mutex_trylock(pthread_mutex_t *_mutex) libcfa_public __THROW {
449 check_nonnull(_mutex);
450 simple_owner_lock * _lock = get(_mutex);
451 if (_lock->owner != active_thread() && _lock->owner != NULL) {
452 return EBUSY;
453 } // if mutex is owned
454 lock(*_lock);
455 return 0;
456 } //pthread_mutex_trylock_
457
458 //######################### Conditional Variable #########################
459
460 /* conditional variable routines */
461 int pthread_cond_init(pthread_cond_t * cond, const pthread_condattr_t * attr) libcfa_public __THROW {
462 check_nonnull(cond);
463 init(cond);
464 return 0;
465 } //pthread_cond_init
466
467 int pthread_cond_wait(pthread_cond_t * cond, pthread_mutex_t *_mutex) libcfa_public __THROW {
468 check_nonnull(_mutex);
469 check_nonnull(cond);
470 wait(*get(cond), *get(_mutex));
471 return 0;
472 } // pthread_cond_wait
473
474 int pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * _mutex, const struct timespec * abstime) libcfa_public __THROW {
475 check_nonnull(_mutex);
476 check_nonnull(cond);
477 wait(*get(cond), *get(_mutex), *abstime);
478 return 0;
479 } // pthread_cond_timedwait
480
481 int pthread_cond_signal(pthread_cond_t * cond) libcfa_public __THROW {
482 check_nonnull(cond);
483 return notify_one(*get(cond));
484 } // pthread_cond_signal
485
486 int pthread_cond_broadcast(pthread_cond_t * cond) libcfa_public __THROW {
487 check_nonnull(cond);
488 return notify_all(*get(cond));
489 } // pthread_cond_broadcast
490
491 int pthread_cond_destroy(pthread_cond_t * cond) libcfa_public __THROW {
492 check_nonnull(cond);
493 destroy(cond);
494 return 0;
495 } // pthread_cond_destroy
496
497
498
499 //######################### Local storage #########################
500
501 int pthread_once(pthread_once_t * once_control, void (* init_routine)(void)) libcfa_public __THROW {
502 static_assert(sizeof(pthread_once_t) >= sizeof(int),"sizeof(pthread_once_t) < sizeof(int)");
503 check_nonnull(once_control);
504 check_nonnull(init_routine);
505 lock(once_lock);
506 if ( *((int *)once_control) == 0 ) {
507 init_routine();
508 *((int *)once_control) = 1;
509 } // if
510 unlock(once_lock);
511 return 0;
512 } // pthread_once
513
514 int pthread_key_create( pthread_key_t * key, void (* destructor)( void * ) ) libcfa_public __THROW {
515 lock(key_lock);
516 for ( int i = 0; i < PTHREAD_KEYS_MAX; i += 1 ) {
517 if ( ! cfa_pthread_keys[i].in_use ) {
518 cfa_pthread_keys[i].in_use = true;
519 cfa_pthread_keys[i].destructor = destructor;
520 unlock( key_lock );
521 *key = i;
522 return 0;
523 } // if
524 } // for
525 unlock(key_lock);
526 return EAGAIN;
527 } // pthread_key_create
528
529 int pthread_key_delete( pthread_key_t key ) libcfa_public __THROW {
530 lock(key_lock);
531 if ( key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use ) {
532 unlock( key_lock );
533 return EINVAL;
534 } // if
535 cfa_pthread_keys[key].in_use = false;
536 cfa_pthread_keys[key].destructor = NULL;
537
538 // Remove key from all threads with a value.
539
540 // Sequence(pthread_values)& head = cfa_pthread_keys[key].threads;
541 // for ( SeqIter(pthread_values) iter = { head }; iter | p; ) {
542 // remove(head, p);
543 // p.in_use = false;
544 // }
545 pthread_values * p = &try_pop_front( cfa_pthread_keys[key].threads );
546 for ( ; p; ) {
547 p->in_use = false;
548 p = &try_pop_front( cfa_pthread_keys[key].threads );
549 }
550 unlock(key_lock);
551 return 0;
552 } // pthread_key_delete
553
554 int pthread_setspecific( pthread_key_t key, const void * value ) libcfa_public __THROW {
555 // get current thread
556 cfaPthread * t = lookup(pthread_self());
557 // if current thread's pthreadData is NULL; initialize it
558 pthread_values * values;
559 if (t->pthreadData == NULL) {
560 values = anew( PTHREAD_KEYS_MAX);
561 t->pthreadData = values;
562 for ( int i = 0;i < PTHREAD_KEYS_MAX; i++ ) {
563 t->pthreadData[i].in_use = false;
564 } // for
565 } else {
566 values = t->pthreadData;
567 } // if
568 // find corresponding key and set value
569 lock(key_lock);
570 // if invalid key
571 if ( key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use ) {
572 unlock( key_lock );
573 return EINVAL;
574 } // if
575 pthread_values &entry = values[key];
576 if ( ! entry.in_use ) {
577 entry.in_use = true;
578 insert_last(cfa_pthread_keys[key].threads, entry);
579 } // if
580 entry.value = (void *)value;
581 unlock(key_lock);
582 return 0;
583 } //pthread_setspecific
584
585 void * pthread_getspecific(pthread_key_t key) libcfa_public __THROW {
586 if (key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use) return NULL;
587
588 // get current thread
589 cfaPthread * t = lookup(pthread_self());
590 if (t->pthreadData == NULL) return NULL;
591 lock(key_lock);
592 pthread_values & entry = ((pthread_values *)t->pthreadData)[key];
593 if ( ! entry.in_use ) {
594 unlock( key_lock );
595 return NULL;
596 } // if
597 void * value = entry.value;
598 unlock(key_lock);
599
600 return value;
601 } //pthread_get_specific
602
603 //######################### Parallelism #########################
604 void pthread_delete_kernel_threads_() __THROW { // see uMain::~uMain
605 Pthread_kernel_threads * p = &try_pop_front(cfa_pthreads_kernel_threads);
606 for ( ; p; ) {
607 delete(p);
608 p = &try_pop_front(cfa_pthreads_kernel_threads);
609 } // for
610 } // pthread_delete_kernel_threads_
611
612 int pthread_getconcurrency( void ) __THROW { // XOPEN extension
613 return cfa_pthreads_kernel_threads_zero ? 0 : cfa_pthreads_no_kernel_threads;
614 } // pthread_getconcurrency
615
616 int pthread_setconcurrency( int new_level ) libcfa_public __THROW { // XOPEN extension
617 if ( new_level < 0 ) return EINVAL;
618 if ( new_level == 0 ) {
619 cfa_pthreads_kernel_threads_zero = true; // remember set to zero, but ignore
620 return 0; // do not do kernel thread management
621 } // exit
622 cfa_pthreads_kernel_threads_zero = false;
623 lock( concurrency_lock );
624 for ( ; new_level > cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads += 1 ) { // add processors ?
625 insert_last(cfa_pthreads_kernel_threads, *new() );
626 } // for
627 for ( ; new_level < cfa_pthreads_no_kernel_threads; cfa_pthreads_no_kernel_threads -= 1 ) { // remove processors ?
628 delete(&try_pop_front(cfa_pthreads_kernel_threads));
629 } // for
630 unlock( concurrency_lock );
631 return 0;
632 } // pthread_setconcurrency
633
634 //######################### Signal #########################
635
636
637 int pthread_sigmask( int /* how */, const sigset_t * /* set */, sigset_t * /* oset */ ) libcfa_public __THROW {
638 abort( "pthread_sigmask : not implemented" );
639 return 0;
640 } // pthread_sigmask
641
642 int pthread_kill( pthread_t _thread __attribute__(( unused )), int sig ) libcfa_public __THROW {
643 if ( sig == 0 ) {
644 return 0;
645 } else {
646 abort( "pthread_kill : not implemented" );
647 } // if
648 return 0;
649 } // pthread_kill
650
651 int pthread_sigqueue(pthread_t , int sig, const union sigval) libcfa_public __THROW {
652 abort( "pthread_sigqueue : not implemented" );
653 return 0;
654 } // pthread_sigqueue
655
656 //######################### Scheduling #########################
657 int pthread_detach( pthread_t threadID ) __THROW {
658 abort( "pthread_detach : not implemented" );
659 return 0;
660 } // pthread_detach
661
662 int pthread_setschedparam( pthread_t /* thread */, int /* policy */, const struct sched_param * /* param */ ) libcfa_public __THROW {
663 abort( "pthread_setschedparam : not implemented" );
664 return 0;
665 } // pthread_setschedparam
666
667 int pthread_getschedparam( pthread_t /* thread */, int */* policy */, struct sched_param * /* param */ ) libcfa_public __THROW {
668 abort( "pthread_getschedparam : not implemented" );
669 return 0;
670 } // pthread_getschedparam
671
672 //######################### Mutex Attr #########################
673
674 int pthread_mutexattr_init( pthread_mutexattr_t * /* attr */ ) libcfa_public __THROW {
675 return 0;
676 } // pthread_mutexattr_init
677
678 int pthread_mutexattr_destroy( pthread_mutexattr_t * /* attr */ ) libcfa_public __THROW {
679 return 0;
680 } // pthread_mutexattr_destroy
681
682 int pthread_mutexattr_setpshared( pthread_mutexattr_t * /* attr */, int /* pshared */ ) libcfa_public __THROW {
683 return 0;
684 } // pthread_mutexattr_setpshared
685
686 int pthread_mutexattr_getpshared( const pthread_mutexattr_t * /* attr */, int * /* pshared */ ) libcfa_public __THROW {
687 return 0;
688 } // pthread_mutexattr_getpshared
689
690 int pthread_mutexattr_setprotocol( pthread_mutexattr_t * /* attr */, int /* protocol */ ) libcfa_public __THROW {
691 return 0;
692 } // pthread_mutexattr_setprotocol
693
694 int pthread_mutexattr_getprotocol( const pthread_mutexattr_t * /* attr */, int * /* protocol */ ) libcfa_public __THROW {
695 return 0;
696 } // pthread_mutexattr_getprotocol
697
698 int pthread_mutexattr_setprioceiling( pthread_mutexattr_t * /* attr */, int /* prioceiling */ ) libcfa_public __THROW {
699 return 0;
700 } // pthread_mutexattr_setprioceiling
701
702 int pthread_mutexattr_getprioceiling( const pthread_mutexattr_t * /* attr */, int * /* ceiling */ ) libcfa_public __THROW {
703 return 0;
704 } // pthread_mutexattr_getprioceiling
705
706 int pthread_mutex_setprioceiling( pthread_mutex_t * /* mutex */, int /* prioceiling */, int * /* old_ceiling */ ) libcfa_public __THROW {
707 return 0;
708 } // pthread_mutex_setprioceiling
709
710 int pthread_mutex_getprioceiling( const pthread_mutex_t * /* mutex */, int * /* ceiling */ ) libcfa_public __THROW {
711 return 0;
712 } // pthread_mutex_getprioceiling
713
714 int pthread_mutexattr_gettype( __const pthread_mutexattr_t * __restrict /* __attr */, int * __restrict /* __kind */ ) libcfa_public __THROW {
715 return 0;
716 } // pthread_mutexattr_gettype
717
718 int pthread_mutexattr_settype( pthread_mutexattr_t * /* __attr */, int /* __kind */ ) libcfa_public __THROW {
719 return 0;
720 } // pthread_mutexattr_settype
721
722 //######################### Mutex #########################
723
724 int pthread_mutex_timedlock( pthread_mutex_t *__restrict /* __mutex */, __const struct timespec *__restrict /* __abstime */ ) libcfa_public __THROW {
725 abort( "pthread_mutex_timedlock" );
726 } // pthread_mutex_timedlock
727
728 //######################### Condition #########################
729
730 int pthread_condattr_getclock( __const pthread_condattr_t * __restrict /* __attr */, __clockid_t *__restrict /* __clock_id */ ) libcfa_public __THROW {
731 abort( "pthread_condattr_getclock" );
732 } // pthread_condattr_getclock
733
734 int pthread_condattr_setclock( pthread_condattr_t * /* __attr */, __clockid_t /* __clock_id */ ) libcfa_public __THROW {
735 abort( "pthread_condattr_setclock" );
736 } // pthread_condattr_setclock
737
738 //######################### Spinlock #########################
739
740 int pthread_spin_init( pthread_spinlock_t * /* __lock */, int /*__pshared */ ) libcfa_public __THROW {
741 abort( "pthread_spin_init" );
742 } // pthread_spin_init
743
744 int pthread_spin_destroy( pthread_spinlock_t * /* __lock */ ) libcfa_public __THROW {
745 abort( "pthread_spin_destroy" );
746 } // pthread_spin_destroy
747
748 int pthread_spin_lock( pthread_spinlock_t * /* __lock */ ) libcfa_public __THROW {
749 abort( "pthread_spin_lock" );
750 } // pthread_spin_lock
751
752 int pthread_spin_trylock( pthread_spinlock_t * /* __lock */ ) libcfa_public __THROW {
753 abort( "pthread_spin_trylock" );
754 } // pthread_spin_trylock
755
756 int pthread_spin_unlock( pthread_spinlock_t * /* __lock */ ) libcfa_public __THROW {
757 abort( "pthread_spin_unlock" );
758 } // pthread_spin_unlock
759
760 //######################### Barrier #########################
761
762 int pthread_barrier_init( pthread_barrier_t *__restrict /* __barrier */, __const pthread_barrierattr_t *__restrict /* __attr */, unsigned int /* __count */ ) libcfa_public __THROW {
763 abort( "pthread_barrier_init" );
764 } // pthread_barrier_init
765
766 int pthread_barrier_destroy( pthread_barrier_t * /* __barrier */ ) libcfa_public __THROW {
767 abort( "pthread_barrier_destroy" );
768 } // pthread_barrier_destroy
769
770 int pthread_barrier_wait( pthread_barrier_t * /* __barrier */ ) libcfa_public __THROW {
771 abort( "pthread_barrier_wait" );
772 } // pthread_barrier_wait
773
774 int pthread_barrierattr_init( pthread_barrierattr_t * /* __attr */ ) libcfa_public __THROW {
775 abort( "pthread_barrierattr_init" );
776 } // pthread_barrierattr_init
777
778 int pthread_barrierattr_destroy( pthread_barrierattr_t * /* __attr */ ) libcfa_public __THROW {
779 abort( "pthread_barrierattr_destroy" );
780 } // pthread_barrierattr_destroy
781
782 int pthread_barrierattr_getpshared( __const pthread_barrierattr_t * __restrict /* __attr */, int *__restrict /* __pshared */ ) libcfa_public __THROW {
783 abort( "pthread_barrierattr_getpshared" );
784 } // pthread_barrierattr_getpshared
785
786 int pthread_barrierattr_setpshared( pthread_barrierattr_t * /* __attr */, int /* __pshared */ ) libcfa_public __THROW {
787 abort( "pthread_barrierattr_setpshared" );
788 } // pthread_barrierattr_setpshared
789
790 //######################### Clock #########################
791
792 int pthread_getcpuclockid( pthread_t /* __thread_id */, __clockid_t * /* __clock_id */ ) libcfa_public __THROW {
793 abort( "pthread_getcpuclockid" );
794 } // pthread_getcpuclockid
795
796 // pthread_atfork()
797
798// UNIX98
799
800 //######################### Read/Write #########################
801
802 int pthread_rwlock_init( pthread_rwlock_t *__restrict /* __rwlock */, __const pthread_rwlockattr_t *__restrict /* __attr */ ) libcfa_public __THROW {
803 abort( "pthread_rwlock_init" );
804 } // pthread_rwlock_init
805
806 int pthread_rwlock_destroy( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW {
807 abort( "pthread_rwlock_destroy" );
808 } // pthread_rwlock_destroy
809
810 int pthread_rwlock_rdlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW {
811 abort( "pthread_rwlock_rdlock" );
812 } // pthread_rwlock_rdlock
813
814 int pthread_rwlock_tryrdlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW {
815 abort( "pthread_rwlock_tryrdlock" );
816 } // pthread_rwlock_tryrdlock
817
818 int pthread_rwlock_wrlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW {
819 abort( "pthread_rwlock_wrlock" );
820 } // pthread_rwlock_wrlock
821
822 int pthread_rwlock_trywrlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW {
823 abort( "pthread_rwlock_trywrlock" );
824 } // pthread_rwlock_trywrlock
825
826 int pthread_rwlock_unlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW {
827 abort( "pthread_rwlock_unlock" );
828 } // pthread_rwlock_unlock
829
830 int pthread_rwlockattr_init( pthread_rwlockattr_t * /* __attr */ ) libcfa_public __THROW {
831 abort( "pthread_rwlockattr_init" );
832 } // pthread_rwlockattr_init
833
834 int pthread_rwlockattr_destroy( pthread_rwlockattr_t * /*__attr */ ) libcfa_public __THROW {
835 abort( "pthread_rwlockattr_destroy" );
836 } // pthread_rwlockattr_destroy
837
838 int pthread_rwlockattr_getpshared( __const pthread_rwlockattr_t * __restrict /* __attr */, int *__restrict /* __pshared */ ) libcfa_public __THROW {
839 abort( "pthread_rwlockattr_getpshared" );
840 } // pthread_rwlockattr_getpshared
841
842 int pthread_rwlockattr_setpshared( pthread_rwlockattr_t * /* __attr */, int /* __pshared */ ) libcfa_public __THROW {
843 abort( "pthread_rwlockattr_setpshared" );
844 } // pthread_rwlockattr_setpshared
845
846 int pthread_rwlockattr_getkind_np( __const pthread_rwlockattr_t * /* __attr */, int * /* __pref */ ) libcfa_public __THROW {
847 abort( "pthread_rwlockattr_getkind_np" );
848 } // pthread_rwlockattr_getkind_np
849
850 int pthread_rwlockattr_setkind_np( pthread_rwlockattr_t * /* __attr */, int /* __pref */ ) libcfa_public __THROW {
851 abort( "pthread_rwlockattr_setkind_np" );
852 } // pthread_rwlockattr_setkind_np
853
854// UNIX98 + XOPEN
855
856 int pthread_rwlock_timedrdlock( pthread_rwlock_t *__restrict /* __rwlock */, __const struct timespec *__restrict /* __abstime */ ) libcfa_public __THROW {
857 abort( "pthread_rwlock_timedrdlock" );
858 } // pthread_rwlock_timedrdlock
859
860 int pthread_rwlock_timedwrlock( pthread_rwlock_t *__restrict /* __rwlock */, __const struct timespec *__restrict /* __abstime */ ) libcfa_public __THROW {
861 abort( "pthread_rwlock_timedwrlock" );
862 } // pthread_rwlock_timedwrlock
863
864// GNU
865
866 //######################### Parallelism #########################
867
868 // int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
869 // abort( "pthread_setaffinity_np" );
870 // } // pthread_setaffinity_np
871
872 // int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
873 // abort( "pthread_getaffinity_np" );
874 // } // pthread_getaffinity_np
875
876 // int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
877 // abort( "pthread_attr_setaffinity_np" );
878 // } // pthread_attr_setaffinity_np
879
880 // int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW {
881 // abort( "pthread_attr_getaffinity_np" );
882 // } // pthread_attr_getaffinity_np
883
884 //######################### Cancellation #########################
885
886 void _pthread_cleanup_push_defer( struct _pthread_cleanup_buffer * /* __buffer */, void( * /* __routine */ )( void * ), void * /* __arg */ ) libcfa_public __THROW {
887 abort( "_pthread_cleanup_push_defer" );
888 } // _pthread_cleanup_push_defer
889
890 void _pthread_cleanup_pop_restore( struct _pthread_cleanup_buffer * /* __buffer */, int /* __execute */ ) libcfa_public __THROW {
891 abort( "_pthread_cleanup_pop_restore" );
892 } // _pthread_cleanup_pop_res
893
894 int pthread_cancel( pthread_t threadID ) libcfa_public __THROW {
895 abort("pthread cancel not implemented");
896 return 0;
897 } // pthread_cancel
898
899 int pthread_setcancelstate( int state, int * oldstate ) libcfa_public __THROW {
900 abort("pthread_setcancelstate not implemented");
901 return 0;
902 } // pthread_setcancelstate
903
904 int pthread_setcanceltype( int type, int * oldtype ) libcfa_public __THROW {
905 abort("pthread_setcanceltype not implemented");
906 return 0;
907 } // pthread_setcanceltype
908} // extern "C"
909
910#pragma GCC diagnostic pop
Note: See TracBrowser for help on using the repository browser.