Index: libcfa/src/Makefile.am =================================================================== --- libcfa/src/Makefile.am (revision a7d696f24154f74fedcb586aaa645387836cdff2) +++ libcfa/src/Makefile.am (revision 20be7824be588cb516b811f2b84e12e776350a51) @@ -124,5 +124,5 @@ concurrency/monitor.hfa \ concurrency/mutex.hfa \ - concurrency/thread.hfa + concurrency/thread.hfa thread_libsrc = ${inst_thread_headers_src} ${inst_thread_headers_src:.hfa=.cfa} \ Index: libcfa/src/bits/defs.hfa =================================================================== --- libcfa/src/bits/defs.hfa (revision a7d696f24154f74fedcb586aaa645387836cdff2) +++ libcfa/src/bits/defs.hfa (revision 20be7824be588cb516b811f2b84e12e776350a51) @@ -21,5 +21,5 @@ #include #include -#include + #define likely(x) __builtin_expect(!!(x), 1) @@ -44,24 +44,15 @@ void abort( bool signalAbort, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )); extern "C" { -#endif -void __cabi_abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )); -int real_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); -int real_pthread_join(pthread_t _thread, void **retval); -pthread_t real_pthread_self(void); -int real_pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t *attr); -int real_pthread_mutex_destroy(pthread_mutex_t *_mutex); -int real_pthread_mutex_lock(pthread_mutex_t *_mutex); -int real_pthread_mutex_unlock(pthread_mutex_t *_mutex); -int real_pthread_mutex_trylock(pthread_mutex_t *_mutex); -int real_pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); -int real_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *_mutex); -int real_pthread_cond_signal(pthread_cond_t *cond); -int real_pthread_cond_broadcast(pthread_cond_t *cond); -int real_pthread_cond_destroy(pthread_cond_t *cond); -int real_pthread_attr_init(pthread_attr_t *attr); -int real_pthread_attr_destroy(pthread_attr_t *attr); -int real_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ); -int real_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ); -#ifdef __cforall + #include + void __cabi_abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )); + int real_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); + int real_pthread_join(pthread_t _thread, void **retval); + pthread_t real_pthread_self(void); + int real_pthread_attr_init(pthread_attr_t *attr); + int real_pthread_attr_destroy(pthread_attr_t *attr); + int real_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ); + int real_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ); + //int real_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value); + //int real_pthread_sigmask( int /* how */, const sigset_t * /* set */, sigset_t * /* oset */ ); } #endif Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision a7d696f24154f74fedcb586aaa645387836cdff2) +++ libcfa/src/concurrency/kernel/startup.cfa (revision 20be7824be588cb516b811f2b84e12e776350a51) @@ -279,6 +279,15 @@ } +extern "C"{ + void pthread_delete_kernel_threads_(); +} + + static void __kernel_shutdown(void) { if(!cfa_main_returned) return; + + //delete kernel threads for pthread_concurrency + pthread_delete_kernel_threads_(); + /* paranoid */ verify( __preemption_enabled() ); disable_interrupts(); Index: libcfa/src/concurrency/pthread.cfa =================================================================== --- libcfa/src/concurrency/pthread.cfa (revision a7d696f24154f74fedcb586aaa645387836cdff2) +++ libcfa/src/concurrency/pthread.cfa (revision 20be7824be588cb516b811f2b84e12e776350a51) @@ -1,24 +1,32 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// pthread.cfa -- +// +// Author : Zhenyan Zhu +// Created On : Sat Aug 6 16:29:18 2022 +// Last Modified By : +// Last Modified On : +// Update Count : +// #define __cforall_thread__ #define _GNU_SOURCE +#include +#include #include "locks.hfa" -#include -#include -#include -#include -#include - -#ifdef PNOOUTPUT - #define PRINT( stmt ) -#else - #define PRINT( stmt ) stmt -#endif // NOOUTPUT +#include "bits/stack.hfa" + #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wnonnull-compare" -/* pthread key, pthread once*/ +/* pthread key, pthread once inner routine mutual exclusion */ static simple_owner_lock once_lock,key_lock,magic_mutex_check, concurrency_lock; + //######################### Local Storage Helpers ######################### @@ -32,8 +40,8 @@ -Pthread_values *& Back( Pthread_values * n ) { +static Pthread_values *& Back( Pthread_values * n ) { return (Pthread_values *)Back( (Seqable *)n ); } -Pthread_values *& Next( Pthread_values * n ) { +static Pthread_values *& Next( Pthread_values * n ) { return (Pthread_values *)Next( (Colable *)n ); } @@ -54,5 +62,5 @@ static Pthread_keys cfa_pthread_keys_storage[PTHREAD_KEYS_MAX] __attribute__((aligned (16))); -void init_pthread_storage(){ +static void init_pthread_storage(){ for (int i = 0; i < PTHREAD_KEYS_MAX; i++){ cfa_pthread_keys_storage[i]{}; @@ -89,4 +97,5 @@ /* condvar helper routines */ static void init(pthread_cond_t* pcond){ + static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)"); cfa2pthr_cond_var_t* _cond = (cfa2pthr_cond_var_t*)pcond; ?{}(*_cond); @@ -94,8 +103,10 @@ static cfa2pthr_cond_var_t* get(pthread_cond_t* pcond){ + static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)"); return (cfa2pthr_cond_var_t*)pcond; } static void destroy(pthread_cond_t* cond){ + static_assert(sizeof(pthread_cond_t) >= sizeof(cfa2pthr_cond_var_t),"sizeof(pthread_t) < sizeof(cfa2pthr_cond_var_t)"); ^?{}(*get(cond)); } @@ -110,6 +121,5 @@ // SKULLDUGGERY: not a portable way to access the kind field, /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h int _lock_val = ((pthread_mutex_t *)mutex_)->__data.__lock; - //sout | _lock_val ; - // kind is a small pthread enumerated type. If it greater than 32, it is a value in an uOwnerlock field. + // if pthread_mutex_t is initialized by PTHREAD_MUTEX_INITIALIZER, _lock_val should be 0 if ( _lock_val == 0 ) { // static initialized ? lock(magic_mutex_check); // race @@ -124,4 +134,5 @@ static void init(pthread_mutex_t* plock){ + static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)"); simple_owner_lock* _lock = (simple_owner_lock*)plock; ?{}(*_lock); @@ -129,8 +140,10 @@ static simple_owner_lock* get(pthread_mutex_t* plock){ + static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)"); return (simple_owner_lock*)plock; } static void destroy(pthread_mutex_t* plock){ + static_assert(sizeof(pthread_mutex_t) >= sizeof(simple_owner_lock),"sizeof(pthread_mutex_t) < sizeof(simple_owner_lock)"); ^?{}(*get(plock)); } @@ -159,5 +172,5 @@ /* -cfaPthread_attr_t default_attrs = { +static const cfaPthread_attr_t default_attrs = { PTHREAD_SCOPE_SYSTEM, PTHREAD_CREATE_JOINABLE, @@ -171,5 +184,7 @@ + static cfaPthread_attr_t* get(const pthread_attr_t* attr){ + static_assert(sizeof(pthread_attr_t) >= sizeof(cfaPthread_attr_t),"sizeof(pthread_attr_t) < sizeof(cfaPthread_attr_t)"); return (cfaPthread_attr_t*)attr; } @@ -178,4 +193,5 @@ //######################### Threads Helper ######################### +// exception for cancel_stack in pthread_exit exception pthread_exit_exp {}; static vtable(pthread_exit_exp) exp; @@ -201,12 +217,14 @@ // generate pthread_t by cfaPthread ptr static pthread_t create( cfaPthread *p ) { - return (pthread_t)p; + static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*),"sizeof(pthread_t) < sizeof(cfaPthread*)"); + return (pthread_t)p; } static cfaPthread *lookup( pthread_t p ){ + static_assert(sizeof(pthread_t) >= sizeof(cfaPthread*),"sizeof(pthread_t) < sizeof(cfaPthread*)"); return (cfaPthread*)p; } -void pthread_deletespecific_( Pthread_values* values ) { // see uMachContext::invokeTask +static void pthread_deletespecific_( Pthread_values* values ) { // see uMachContext::invokeTask Pthread_values* value; Pthread_keys* key; @@ -240,9 +258,8 @@ } -void ^?{}(cfaPthread & mutex t){ - //^?{}((thread$&)t); +static void ^?{}(cfaPthread & mutex t){ + // delete pthread local storage Pthread_values* values = t.pthreadData; pthread_deletespecific_(values); - PRINT(sout | "thread exited" | t.pthreadId;) } @@ -270,5 +287,5 @@ //######################### Pthread Attrs ######################### - int pthread_attr_init(pthread_attr_t *attr){ + int pthread_attr_init(pthread_attr_t *attr) libcfa_public __THROW { cfaPthread_attr_t* _attr = get(attr); ?{}(*_attr); @@ -276,58 +293,58 @@ return 0; } - int pthread_attr_destroy(pthread_attr_t *attr){ + int pthread_attr_destroy(pthread_attr_t *attr) libcfa_public __THROW { ^?{}(*get(attr)); return 0; } - int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) { + int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) libcfa_public __THROW { get( attr )->contentionscope = contentionscope; return 0; } // pthread_attr_setscope - int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) { + int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) libcfa_public __THROW { *contentionscope = get( attr )->contentionscope; return 0; } // pthread_attr_getscope - int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) { + int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) libcfa_public __THROW { get( attr )->detachstate = detachstate; return 0; } // pthread_attr_setdetachstate - int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) { + int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) libcfa_public __THROW { *detachstate = get( attr )->detachstate; return 0; } // pthread_attr_getdetachstate - int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) { + int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) libcfa_public __THROW { get( attr )->stacksize = stacksize; return 0; } // pthread_attr_setstacksize - int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) { + int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) libcfa_public __THROW { *stacksize = get( attr )->stacksize; return 0; } // pthread_attr_getstacksize - int pthread_attr_getguardsize( const pthread_attr_t * /* attr */, size_t * /* guardsize */ ) { + int pthread_attr_getguardsize( const pthread_attr_t * /* attr */, size_t * /* guardsize */ ) libcfa_public __THROW { return 0; } // pthread_attr_getguardsize - int pthread_attr_setguardsize( pthread_attr_t * /* attr */, size_t /* guardsize */ ) { + int pthread_attr_setguardsize( pthread_attr_t * /* attr */, size_t /* guardsize */ ) libcfa_public __THROW { return 0; } // pthread_attr_setguardsize - int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) { + int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) libcfa_public __THROW { get( attr )->stackaddr = stackaddr; return 0; } // pthread_attr_setstackaddr - int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) { + int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) libcfa_public __THROW { *stackaddr = get( attr )->stackaddr; return 0; } // pthread_attr_getstackaddr - int pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ) { + int pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ) libcfa_public __THROW { get( attr )->stackaddr = stackaddr; get( attr )->stacksize = stacksize; @@ -335,5 +352,5 @@ } // pthread_attr_setstack - int pthread_attr_getstack( const pthread_attr_t *attr, void **stackaddr, size_t *stacksize ) { + int pthread_attr_getstack( const pthread_attr_t *attr, void **stackaddr, size_t *stacksize ) libcfa_public __THROW { *stackaddr = get( attr )->stackaddr; *stacksize = get( attr )->stacksize; @@ -344,5 +361,5 @@ // already running thread threadID. It shall be called on unitialized attr // and destroyed with pthread_attr_destroy when no longer needed. - int pthread_getattr_np( pthread_t threadID, pthread_attr_t *attr ) __THROW { // GNU extension + int pthread_getattr_np( pthread_t threadID, pthread_attr_t *attr ) libcfa_public __THROW { // GNU extension // race condition during copy cfaPthread_attr_t* _attr = get(attr); @@ -358,5 +375,5 @@ //######################### Threads ######################### - int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(*start_routine)(void *), void * arg){ + int pthread_create(pthread_t * _thread, const pthread_attr_t * attr, void *(*start_routine)(void *), void * arg) libcfa_public __THROW { cfaPthread *t = alloc(); (*t){_thread, attr, start_routine, arg}; @@ -367,5 +384,5 @@ - int pthread_join(pthread_t _thread, void **value_ptr){ + int pthread_join(pthread_t _thread, void **value_ptr) libcfa_public __THROW { if (_thread == NULL) return EINVAL; // if thread is invalid if (_thread == pthread_self()) return EDEADLK; @@ -379,5 +396,5 @@ } //pthread_join_ - int pthread_tryjoin_np(pthread_t _thread, void **value_ptr){ + int pthread_tryjoin_np(pthread_t _thread, void **value_ptr) libcfa_public __THROW { if (_thread == NULL) return EINVAL; // if thread is invalid if (_thread == pthread_self()) return EDEADLK; @@ -390,9 +407,9 @@ } //pthread_join_ - pthread_t pthread_self(void){ + pthread_t pthread_self(void) libcfa_public __THROW { return (pthread_t)((char*)active_thread()-(sizeof(cfaPthread)-sizeof(thread$))); } //pthread_self_ - void pthread_exit(void * status){ + void pthread_exit(void * status) libcfa_public __THROW { pthread_t pid = pthread_self(); cfaPthread* _thread = (cfaPthread*)pid; @@ -402,9 +419,13 @@ } //pthread_exit_ + int pthread_yield( void ) __THROW { // GNU extension + yield(); + return 0; + } //######################### Mutex ######################### - int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t *attr){ + int pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t *attr) libcfa_public __THROW { if (_mutex == NULL) return EINVAL; @@ -414,5 +435,5 @@ - int pthread_mutex_destroy(pthread_mutex_t *_mutex){ + int pthread_mutex_destroy(pthread_mutex_t *_mutex) libcfa_public __THROW{ if (_mutex == NULL){ return EINVAL; @@ -426,5 +447,5 @@ } //pthread_mutex_destroy_ - int pthread_mutex_lock(pthread_mutex_t *_mutex){ + int pthread_mutex_lock(pthread_mutex_t *_mutex) libcfa_public __THROW{ if (_mutex == NULL) { return EINVAL; @@ -436,5 +457,5 @@ } //pthread_mutex_lock_ - int pthread_mutex_unlock(pthread_mutex_t *_mutex){ + int pthread_mutex_unlock(pthread_mutex_t *_mutex) libcfa_public __THROW{ if (_mutex == NULL) { return EINVAL; @@ -448,5 +469,5 @@ } //pthread_mutex_unlock_ - int pthread_mutex_trylock(pthread_mutex_t *_mutex){ + int pthread_mutex_trylock(pthread_mutex_t *_mutex) libcfa_public __THROW{ if (_mutex == NULL) { return EINVAL; @@ -463,10 +484,11 @@ /* conditional variable routines */ - int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr){ + int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) libcfa_public __THROW { if (cond == NULL) return EINVAL; init(cond); return 0; - } - int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *_mutex){ + } //pthread_cond_init + + int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *_mutex) libcfa_public __THROW { if (cond == NULL || _mutex == NULL){ return EINVAL; @@ -474,7 +496,7 @@ wait(*get(cond), *get(_mutex)); return 0; - } - - int pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * _mutex, const struct timespec * abstime){ + } // pthread_cond_wait + + int pthread_cond_timedwait(pthread_cond_t * cond, pthread_mutex_t * _mutex, const struct timespec * abstime) libcfa_public __THROW { if (cond == NULL || _mutex == NULL){ return EINVAL; @@ -482,20 +504,21 @@ wait(*get(cond), *get(_mutex), *abstime); return 0; - } - - - int pthread_cond_signal(pthread_cond_t *cond){ + } // pthread_cond_timedwait + + int pthread_cond_signal(pthread_cond_t *cond) libcfa_public __THROW { if (cond == NULL){ return EINVAL; } // invalid cond return notify_one(*get(cond)); - } - int pthread_cond_broadcast(pthread_cond_t *cond){ + } // pthread_cond_signal + + int pthread_cond_broadcast(pthread_cond_t *cond) libcfa_public __THROW { if (cond == NULL){ return EINVAL; } // invalid cond return notify_all(*get(cond)); - } - int pthread_cond_destroy(pthread_cond_t *cond){ + } // pthread_cond_broadcast + + int pthread_cond_destroy(pthread_cond_t *cond) libcfa_public __THROW { if (cond == NULL){ return EINVAL; @@ -503,5 +526,5 @@ destroy(cond); return 0; - } + } // pthread_cond_destroy @@ -509,5 +532,12 @@ //######################### Local storage ######################### - int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)){ + int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) libcfa_public __THROW { + static_assert(sizeof(pthread_once_t) >= sizeof(int),"sizeof(pthread_once_t) < sizeof(int)"); + if (once_control == NULL){ + return EINVAL; + } + if (init_routine == NULL){ + return EINVAL; + } lock(once_lock); if ( *((int *)once_control) == 0 ) { @@ -517,7 +547,7 @@ unlock(once_lock); return 0; - } - - int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ){ + } // pthread_once + + int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) libcfa_public __THROW { lock(key_lock); for ( int i = 0; i < PTHREAD_KEYS_MAX; i += 1 ) { @@ -534,5 +564,5 @@ } // pthread_key_create - int pthread_key_delete( pthread_key_t key ){ + int pthread_key_delete( pthread_key_t key ) libcfa_public __THROW { lock(key_lock); if ( key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use ) { @@ -554,5 +584,5 @@ } // pthread_key_delete - int pthread_setspecific( pthread_key_t key, const void *value ){ + int pthread_setspecific( pthread_key_t key, const void *value ) libcfa_public __THROW { // get current thread cfaPthread* t = lookup(pthread_self()); @@ -585,5 +615,5 @@ } //pthread_setspecific - void* pthread_getspecific(pthread_key_t key){ + void* pthread_getspecific(pthread_key_t key) libcfa_public __THROW { if (key >= PTHREAD_KEYS_MAX || ! cfa_pthread_keys[key].in_use) return NULL; @@ -604,5 +634,5 @@ //######################### Parallelism ######################### - void pthread_delete_kernel_threads_() { // see uMain::~uMain + void pthread_delete_kernel_threads_() libcfa_public __THROW { // see uMain::~uMain Pthread_kernel_threads& p; for ( StackIter(Pthread_kernel_threads) iter = {cfa_pthreads_kernel_threads}; iter | p; ) { @@ -611,9 +641,9 @@ } // pthread_delete_kernel_threads_ - int pthread_getconcurrency( void ) { // XOPEN extension + int pthread_getconcurrency( void ) libcfa_public __THROW { // XOPEN extension return cfa_pthreads_kernel_threads_zero ? 0 : cfa_pthreads_no_kernel_threads; } // pthread_getconcurrency - int pthread_setconcurrency( int new_level ) { // XOPEN extension + int pthread_setconcurrency( int new_level ) libcfa_public __THROW { // XOPEN extension if ( new_level < 0 ) return EINVAL; if ( new_level == 0 ) { @@ -633,64 +663,87 @@ } // pthread_setconcurrency + //######################### Signal ######################### + + + // int pthread_sigmask( int /* how */, const sigset_t * /* set */, sigset_t * /* oset */ ) libcfa_public __THROW { + // return 0; + // } // pthread_sigmask + + int pthread_kill( pthread_t _thread __attribute__(( unused )), int sig ) libcfa_public __THROW { + if ( sig == 0 ) { + return 0; + } else { + abort( "pthread_kill : not implemented" ); + } // if + return 0; + } // pthread_kill + + // int pthread_sigqueue(pthread_t , int sig, const union sigval) libcfa_public __THROW { + // return 0; + // } // pthread_sigqueue + //######################### Scheduling ######################### - - - int pthread_setschedparam( pthread_t /* thread */, int /* policy */, const struct sched_param * /* param */ ) __THROW { - abort( "pthread_setschedparam : not implemented" ); - return 0; + int pthread_detach( pthread_t threadID ) __THROW { + abort( "pthread_detach" ); + return 0; + } // pthread_detach + + int pthread_setschedparam( pthread_t /* thread */, int /* policy */, const struct sched_param * /* param */ ) libcfa_public __THROW { + abort( "pthread_setschedparam : not implemented" ); + return 0; } // pthread_setschedparam - int pthread_getschedparam( pthread_t /* thread */, int */* policy */, struct sched_param * /* param */ ) __THROW { - abort( "pthread_getschedparam : not implemented" ); - return 0; + int pthread_getschedparam( pthread_t /* thread */, int */* policy */, struct sched_param * /* param */ ) libcfa_public __THROW { + abort( "pthread_getschedparam : not implemented" ); + return 0; } // pthread_getschedparam //######################### Mutex Attr ######################### - int pthread_mutexattr_init( pthread_mutexattr_t * /* attr */ ) __THROW { - return 0; + int pthread_mutexattr_init( pthread_mutexattr_t * /* attr */ ) libcfa_public __THROW { + return 0; } // pthread_mutexattr_init - int pthread_mutexattr_destroy( pthread_mutexattr_t * /* attr */ ) __THROW { + int pthread_mutexattr_destroy( pthread_mutexattr_t * /* attr */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_destroy - int pthread_mutexattr_setpshared( pthread_mutexattr_t * /* attr */, int /* pshared */ ) __THROW { + int pthread_mutexattr_setpshared( pthread_mutexattr_t * /* attr */, int /* pshared */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_setpshared - int pthread_mutexattr_getpshared( const pthread_mutexattr_t * /* attr */, int * /* pshared */ ) __THROW { + int pthread_mutexattr_getpshared( const pthread_mutexattr_t * /* attr */, int * /* pshared */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_getpshared - int pthread_mutexattr_setprotocol( pthread_mutexattr_t * /* attr */, int /* protocol */ ) __THROW { + int pthread_mutexattr_setprotocol( pthread_mutexattr_t * /* attr */, int /* protocol */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_setprotocol - int pthread_mutexattr_getprotocol( const pthread_mutexattr_t * /* attr */, int * /* protocol */ ) __THROW { + int pthread_mutexattr_getprotocol( const pthread_mutexattr_t * /* attr */, int * /* protocol */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_getprotocol - int pthread_mutexattr_setprioceiling( pthread_mutexattr_t * /* attr */, int /* prioceiling */ ) __THROW { + int pthread_mutexattr_setprioceiling( pthread_mutexattr_t * /* attr */, int /* prioceiling */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_setprioceiling - int pthread_mutexattr_getprioceiling( const pthread_mutexattr_t * /* attr */, int * /* ceiling */ ) __THROW { + int pthread_mutexattr_getprioceiling( const pthread_mutexattr_t * /* attr */, int * /* ceiling */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_getprioceiling - int pthread_mutex_setprioceiling( pthread_mutex_t * /* mutex */, int /* prioceiling */, int * /* old_ceiling */ ) __THROW { + int pthread_mutex_setprioceiling( pthread_mutex_t * /* mutex */, int /* prioceiling */, int * /* old_ceiling */ ) libcfa_public __THROW { return 0; } // pthread_mutex_setprioceiling - int pthread_mutex_getprioceiling( const pthread_mutex_t * /* mutex */, int * /* ceiling */ ) __THROW { + int pthread_mutex_getprioceiling( const pthread_mutex_t * /* mutex */, int * /* ceiling */ ) libcfa_public __THROW { return 0; } // pthread_mutex_getprioceiling - int pthread_mutexattr_gettype( __const pthread_mutexattr_t * __restrict /* __attr */, int * __restrict /* __kind */ ) __THROW { + int pthread_mutexattr_gettype( __const pthread_mutexattr_t * __restrict /* __attr */, int * __restrict /* __kind */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_gettype - int pthread_mutexattr_settype( pthread_mutexattr_t * /* __attr */, int /* __kind */ ) __THROW { + int pthread_mutexattr_settype( pthread_mutexattr_t * /* __attr */, int /* __kind */ ) libcfa_public __THROW { return 0; } // pthread_mutexattr_settype @@ -698,5 +751,5 @@ //######################### Mutex ######################### - int pthread_mutex_timedlock( pthread_mutex_t *__restrict /* __mutex */, __const struct timespec *__restrict /* __abstime */ ) __THROW { + int pthread_mutex_timedlock( pthread_mutex_t *__restrict /* __mutex */, __const struct timespec *__restrict /* __abstime */ ) libcfa_public __THROW { abort( "pthread_mutex_timedlock" ); } // pthread_mutex_timedlock @@ -704,9 +757,9 @@ //######################### Condition ######################### - int pthread_condattr_getclock( __const pthread_condattr_t * __restrict /* __attr */, __clockid_t *__restrict /* __clock_id */ ) __THROW { + int pthread_condattr_getclock( __const pthread_condattr_t * __restrict /* __attr */, __clockid_t *__restrict /* __clock_id */ ) libcfa_public __THROW { abort( "pthread_condattr_getclock" ); } // pthread_condattr_getclock - int pthread_condattr_setclock( pthread_condattr_t * /* __attr */, __clockid_t /* __clock_id */ ) __THROW { + int pthread_condattr_setclock( pthread_condattr_t * /* __attr */, __clockid_t /* __clock_id */ ) libcfa_public __THROW { abort( "pthread_condattr_setclock" ); } // pthread_condattr_setclock @@ -714,21 +767,21 @@ //######################### Spinlock ######################### - int pthread_spin_init( pthread_spinlock_t * /* __lock */, int /*__pshared */ ) __THROW { + int pthread_spin_init( pthread_spinlock_t * /* __lock */, int /*__pshared */ ) libcfa_public __THROW { abort( "pthread_spin_init" ); } // pthread_spin_init - int pthread_spin_destroy( pthread_spinlock_t * /* __lock */ ) __THROW { + int pthread_spin_destroy( pthread_spinlock_t * /* __lock */ ) libcfa_public __THROW { abort( "pthread_spin_destroy" ); } // pthread_spin_destroy - int pthread_spin_lock( pthread_spinlock_t * /* __lock */ ) __THROW { + int pthread_spin_lock( pthread_spinlock_t * /* __lock */ ) libcfa_public __THROW { abort( "pthread_spin_lock" ); } // pthread_spin_lock - int pthread_spin_trylock( pthread_spinlock_t * /* __lock */ ) __THROW { + int pthread_spin_trylock( pthread_spinlock_t * /* __lock */ ) libcfa_public __THROW { abort( "pthread_spin_trylock" ); } // pthread_spin_trylock - int pthread_spin_unlock( pthread_spinlock_t * /* __lock */ ) __THROW { + int pthread_spin_unlock( pthread_spinlock_t * /* __lock */ ) libcfa_public __THROW { abort( "pthread_spin_unlock" ); } // pthread_spin_unlock @@ -736,29 +789,29 @@ //######################### Barrier ######################### - int pthread_barrier_init( pthread_barrier_t *__restrict /* __barrier */, __const pthread_barrierattr_t *__restrict /* __attr */, unsigned int /* __count */ ) __THROW { + int pthread_barrier_init( pthread_barrier_t *__restrict /* __barrier */, __const pthread_barrierattr_t *__restrict /* __attr */, unsigned int /* __count */ ) libcfa_public __THROW { abort( "pthread_barrier_init" ); } // pthread_barrier_init - int pthread_barrier_destroy( pthread_barrier_t * /* __barrier */ ) __THROW { + int pthread_barrier_destroy( pthread_barrier_t * /* __barrier */ ) libcfa_public __THROW { abort( "pthread_barrier_destroy" ); } // pthread_barrier_destroy - int pthread_barrier_wait( pthread_barrier_t * /* __barrier */ ) __THROW { + int pthread_barrier_wait( pthread_barrier_t * /* __barrier */ ) libcfa_public __THROW { abort( "pthread_barrier_wait" ); } // pthread_barrier_wait - int pthread_barrierattr_init( pthread_barrierattr_t * /* __attr */ ) __THROW { + int pthread_barrierattr_init( pthread_barrierattr_t * /* __attr */ ) libcfa_public __THROW { abort( "pthread_barrierattr_init" ); } // pthread_barrierattr_init - int pthread_barrierattr_destroy( pthread_barrierattr_t * /* __attr */ ) __THROW { + int pthread_barrierattr_destroy( pthread_barrierattr_t * /* __attr */ ) libcfa_public __THROW { abort( "pthread_barrierattr_destroy" ); } // pthread_barrierattr_destroy - int pthread_barrierattr_getpshared( __const pthread_barrierattr_t * __restrict /* __attr */, int *__restrict /* __pshared */ ) __THROW { + int pthread_barrierattr_getpshared( __const pthread_barrierattr_t * __restrict /* __attr */, int *__restrict /* __pshared */ ) libcfa_public __THROW { abort( "pthread_barrierattr_getpshared" ); } // pthread_barrierattr_getpshared - int pthread_barrierattr_setpshared( pthread_barrierattr_t * /* __attr */, int /* __pshared */ ) __THROW { + int pthread_barrierattr_setpshared( pthread_barrierattr_t * /* __attr */, int /* __pshared */ ) libcfa_public __THROW { abort( "pthread_barrierattr_setpshared" ); } // pthread_barrierattr_setpshared @@ -766,5 +819,5 @@ //######################### Clock ######################### - int pthread_getcpuclockid( pthread_t /* __thread_id */, __clockid_t * /* __clock_id */ ) __THROW { + int pthread_getcpuclockid( pthread_t /* __thread_id */, __clockid_t * /* __clock_id */ ) libcfa_public __THROW { abort( "pthread_getcpuclockid" ); } // pthread_getcpuclockid @@ -776,53 +829,53 @@ //######################### Read/Write ######################### - int pthread_rwlock_init( pthread_rwlock_t *__restrict /* __rwlock */, __const pthread_rwlockattr_t *__restrict /* __attr */ ) __THROW { + int pthread_rwlock_init( pthread_rwlock_t *__restrict /* __rwlock */, __const pthread_rwlockattr_t *__restrict /* __attr */ ) libcfa_public __THROW { abort( "pthread_rwlock_init" ); } // pthread_rwlock_init - int pthread_rwlock_destroy( pthread_rwlock_t * /* __rwlock */ ) __THROW { + int pthread_rwlock_destroy( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW { abort( "pthread_rwlock_destroy" ); } // pthread_rwlock_destroy - int pthread_rwlock_rdlock( pthread_rwlock_t * /* __rwlock */ ) __THROW { + int pthread_rwlock_rdlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW { abort( "pthread_rwlock_rdlock" ); } // pthread_rwlock_rdlock - int pthread_rwlock_tryrdlock( pthread_rwlock_t * /* __rwlock */ ) __THROW { + int pthread_rwlock_tryrdlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW { abort( "pthread_rwlock_tryrdlock" ); } // pthread_rwlock_tryrdlock - int pthread_rwlock_wrlock( pthread_rwlock_t * /* __rwlock */ ) __THROW { + int pthread_rwlock_wrlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW { abort( "pthread_rwlock_wrlock" ); } // pthread_rwlock_wrlock - int pthread_rwlock_trywrlock( pthread_rwlock_t * /* __rwlock */ ) __THROW { + int pthread_rwlock_trywrlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW { abort( "pthread_rwlock_trywrlock" ); } // pthread_rwlock_trywrlock - int pthread_rwlock_unlock( pthread_rwlock_t * /* __rwlock */ ) __THROW { + int pthread_rwlock_unlock( pthread_rwlock_t * /* __rwlock */ ) libcfa_public __THROW { abort( "pthread_rwlock_unlock" ); } // pthread_rwlock_unlock - int pthread_rwlockattr_init( pthread_rwlockattr_t * /* __attr */ ) __THROW { + int pthread_rwlockattr_init( pthread_rwlockattr_t * /* __attr */ ) libcfa_public __THROW { abort( "pthread_rwlockattr_init" ); } // pthread_rwlockattr_init - int pthread_rwlockattr_destroy( pthread_rwlockattr_t * /*__attr */ ) __THROW { + int pthread_rwlockattr_destroy( pthread_rwlockattr_t * /*__attr */ ) libcfa_public __THROW { abort( "pthread_rwlockattr_destroy" ); } // pthread_rwlockattr_destroy - int pthread_rwlockattr_getpshared( __const pthread_rwlockattr_t * __restrict /* __attr */, int *__restrict /* __pshared */ ) __THROW { + int pthread_rwlockattr_getpshared( __const pthread_rwlockattr_t * __restrict /* __attr */, int *__restrict /* __pshared */ ) libcfa_public __THROW { abort( "pthread_rwlockattr_getpshared" ); } // pthread_rwlockattr_getpshared - int pthread_rwlockattr_setpshared( pthread_rwlockattr_t * /* __attr */, int /* __pshared */ ) __THROW { + int pthread_rwlockattr_setpshared( pthread_rwlockattr_t * /* __attr */, int /* __pshared */ ) libcfa_public __THROW { abort( "pthread_rwlockattr_setpshared" ); } // pthread_rwlockattr_setpshared - int pthread_rwlockattr_getkind_np( __const pthread_rwlockattr_t * /* __attr */, int * /* __pref */ ) __THROW { + int pthread_rwlockattr_getkind_np( __const pthread_rwlockattr_t * /* __attr */, int * /* __pref */ ) libcfa_public __THROW { abort( "pthread_rwlockattr_getkind_np" ); } // pthread_rwlockattr_getkind_np - int pthread_rwlockattr_setkind_np( pthread_rwlockattr_t * /* __attr */, int /* __pref */ ) __THROW { + int pthread_rwlockattr_setkind_np( pthread_rwlockattr_t * /* __attr */, int /* __pref */ ) libcfa_public __THROW { abort( "pthread_rwlockattr_setkind_np" ); } // pthread_rwlockattr_setkind_np @@ -830,9 +883,9 @@ // UNIX98 + XOPEN - int pthread_rwlock_timedrdlock( pthread_rwlock_t *__restrict /* __rwlock */, __const struct timespec *__restrict /* __abstime */ ) __THROW { + int pthread_rwlock_timedrdlock( pthread_rwlock_t *__restrict /* __rwlock */, __const struct timespec *__restrict /* __abstime */ ) libcfa_public __THROW { abort( "pthread_rwlock_timedrdlock" ); } // pthread_rwlock_timedrdlock - int pthread_rwlock_timedwrlock( pthread_rwlock_t *__restrict /* __rwlock */, __const struct timespec *__restrict /* __abstime */ ) __THROW { + int pthread_rwlock_timedwrlock( pthread_rwlock_t *__restrict /* __rwlock */, __const struct timespec *__restrict /* __abstime */ ) libcfa_public __THROW { abort( "pthread_rwlock_timedwrlock" ); } // pthread_rwlock_timedwrlock @@ -842,17 +895,17 @@ //######################### Parallelism ######################### - int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) __THROW { + int pthread_setaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { abort( "pthread_setaffinity_np" ); } // pthread_setaffinity_np - int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) __THROW { + int pthread_getaffinity_np( pthread_t /* __th */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { abort( "pthread_getaffinity_np" ); } // pthread_getaffinity_np - int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) __THROW { + int pthread_attr_setaffinity_np( pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, __const cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { abort( "pthread_attr_setaffinity_np" ); } // pthread_attr_setaffinity_np - int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) __THROW { + int pthread_attr_getaffinity_np( __const pthread_attr_t * /* __attr */, size_t /* __cpusetsize */, cpu_set_t * /* __cpuset */ ) libcfa_public __THROW { abort( "pthread_attr_getaffinity_np" ); } // pthread_attr_getaffinity_np @@ -860,27 +913,28 @@ //######################### Cancellation ######################### - void _pthread_cleanup_push_defer( struct _pthread_cleanup_buffer * /* __buffer */, void( * /* __routine */ )( void * ), void * /* __arg */ ) __THROW { + void _pthread_cleanup_push_defer( struct _pthread_cleanup_buffer * /* __buffer */, void( * /* __routine */ )( void * ), void * /* __arg */ ) libcfa_public __THROW { abort( "_pthread_cleanup_push_defer" ); } // _pthread_cleanup_push_defer - void _pthread_cleanup_pop_restore( struct _pthread_cleanup_buffer * /* __buffer */, int /* __execute */ ) __THROW { + void _pthread_cleanup_pop_restore( struct _pthread_cleanup_buffer * /* __buffer */, int /* __execute */ ) libcfa_public __THROW { abort( "_pthread_cleanup_pop_restore" ); } // _pthread_cleanup_pop_res - int pthread_cancel( pthread_t threadID ) __THROW { + int pthread_cancel( pthread_t threadID ) libcfa_public __THROW { abort("pthread cancel not implemented"); return 0; } // pthread_cancel - int pthread_setcancelstate( int state, int *oldstate ) __THROW { + int pthread_setcancelstate( int state, int *oldstate ) libcfa_public __THROW { abort("pthread_setcancelstate not implemented"); return 0; } // pthread_setcancelstate - int pthread_setcanceltype( int type, int *oldtype ) __THROW { + int pthread_setcanceltype( int type, int *oldtype ) libcfa_public __THROW { abort("pthread_setcanceltype not implemented"); return 0; } // pthread_setcanceltype -} +} // extern "C" + #pragma GCC diagnostic pop Index: libcfa/src/interpose.cfa =================================================================== --- libcfa/src/interpose.cfa (revision a7d696f24154f74fedcb586aaa645387836cdff2) +++ libcfa/src/interpose.cfa (revision 20be7824be588cb516b811f2b84e12e776350a51) @@ -114,18 +114,10 @@ typeof(pthread_join) pthread_join; typeof(pthread_self) pthread_self; - typeof(pthread_cond_init) pthread_cond_init; - typeof(pthread_cond_destroy) pthread_cond_destroy; - typeof(pthread_cond_signal) pthread_cond_signal; - typeof(pthread_cond_broadcast) pthread_cond_broadcast; - typeof(pthread_cond_wait) pthread_cond_wait; - typeof(pthread_mutex_init) pthread_mutex_init; - typeof(pthread_mutex_lock) pthread_mutex_lock; - typeof(pthread_mutex_trylock) pthread_mutex_trylock; - typeof(pthread_mutex_unlock) pthread_mutex_unlock; - typeof(pthread_mutex_destroy) pthread_mutex_destroy; - typeof(pthread_attr_init ) pthread_attr_init; + typeof(pthread_attr_init) pthread_attr_init; typeof(pthread_attr_setstack ) pthread_attr_setstack; typeof(pthread_attr_destroy) pthread_attr_destroy; typeof(pthread_attr_getstacksize) pthread_attr_getstacksize; + //typeof(pthread_sigmask) pthread_sigmask; + //typeof(pthread_sigqueue) pthread_sigqueue; } __cabi_libc; @@ -146,17 +138,10 @@ INTERPOSE_LIBC( pthread_join , version ); INTERPOSE_LIBC( pthread_self , version ); - INTERPOSE_LIBC( pthread_mutex_init , version ); - INTERPOSE_LIBC( pthread_mutex_lock , version ); - INTERPOSE_LIBC( pthread_mutex_unlock , version ); - INTERPOSE_LIBC( pthread_mutex_destroy , version ); - INTERPOSE_LIBC( pthread_cond_init , version ); - INTERPOSE_LIBC( pthread_cond_destroy , version ); - INTERPOSE_LIBC( pthread_cond_signal , version ); - INTERPOSE_LIBC( pthread_cond_broadcast , version ); - INTERPOSE_LIBC( pthread_cond_wait , version ); INTERPOSE_LIBC( pthread_attr_init , version ); INTERPOSE_LIBC( pthread_attr_destroy , version ); INTERPOSE_LIBC( pthread_attr_setstack , version ); INTERPOSE_LIBC( pthread_attr_getstacksize , version ); + //INTERPOSE_LIBC( pthread_sigmask , version ); + //INTERPOSE_LIBC( pthread_sigqueue , version ); #pragma GCC diagnostic pop @@ -232,35 +217,4 @@ return __cabi_libc.pthread_self(); } - /* mutex Default attr is PTHREAD_MUTEX_RECURSIVE*/ - libcfa_public int real_pthread_mutex_init(pthread_mutex_t *_mutex, const pthread_mutexattr_t *attr){ - return __cabi_libc.pthread_mutex_init(_mutex, attr); - } - libcfa_public int real_pthread_mutex_destroy(pthread_mutex_t *_mutex){ - return __cabi_libc.pthread_mutex_destroy(_mutex); - } - libcfa_public int real_pthread_mutex_lock(pthread_mutex_t *_mutex){ - return __cabi_libc.pthread_mutex_lock(_mutex); - } - libcfa_public int real_pthread_mutex_unlock(pthread_mutex_t *_mutex){ - return __cabi_libc.pthread_mutex_unlock(_mutex); - } - libcfa_public int real_pthread_mutex_trylock(pthread_mutex_t *_mutex){ - return __cabi_libc.pthread_mutex_trylock(_mutex); - } - libcfa_public int real_pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr){ - return __cabi_libc.pthread_cond_init(cond, attr); - } - libcfa_public int real_pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *_mutex){ - return __cabi_libc.pthread_cond_wait(cond, _mutex); - } - libcfa_public int real_pthread_cond_signal(pthread_cond_t *cond){ - return __cabi_libc.pthread_cond_signal(cond); - } - libcfa_public int real_pthread_cond_broadcast(pthread_cond_t *cond){ - return __cabi_libc.pthread_cond_broadcast(cond); - } - libcfa_public int real_pthread_cond_destroy(pthread_cond_t *cond){ - return __cabi_libc.pthread_cond_destroy(cond); - } libcfa_public int real_pthread_attr_init(pthread_attr_t *attr){ return __cabi_libc.pthread_attr_init(attr); @@ -272,8 +226,13 @@ return __cabi_libc.pthread_attr_setstack(attr, stackaddr, stacksize); } - libcfa_public int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ){ + libcfa_public int read_pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ){ return __cabi_libc.pthread_attr_getstacksize(attr, stacksize); } - + // libcfa_public int real_pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset){ + // return __cabi_libc.pthread_sigmask(how, set, oldset); + // } + // libcfa_public int real_pthread_sigqueue(pthread_t _thread, int sig, const union sigval value){ + // return __cabi_libc.real_pthread_sigqueue(_thread, sig, value); + // } }