Changes in / [0bd46fd:7f6a7c9]

Files:

• libcfa/src/Makefile.am (modified) (2 diffs)
• libcfa/src/bits/defs.hfa (modified) (2 diffs)
• libcfa/src/concurrency/clib/cfathread.cfa (modified) (1 diff)
• libcfa/src/concurrency/io.cfa (modified) (1 diff)
• libcfa/src/concurrency/io/setup.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (5 diffs)
• libcfa/src/concurrency/preemption.cfa (modified) (9 diffs)
• libcfa/src/concurrency/pthread.cfa (added)
• libcfa/src/interpose.cfa (modified) (6 diffs)
• tests/concurrent/pthread/.expect/bounded_buffer.txt (added)
• tests/concurrent/pthread/.expect/pthread_attr_test.txt (added)
• tests/concurrent/pthread/.expect/pthread_cond_test.txt (added)
• tests/concurrent/pthread/.expect/pthread_demo_create_join.txt (added)
• tests/concurrent/pthread/.expect/pthread_demo_lock.txt (added)
• tests/concurrent/pthread/.expect/pthread_key_test.txt (added)
• tests/concurrent/pthread/.expect/pthread_once_test.txt (added)
• tests/concurrent/pthread/bounded_buffer.cfa (added)
• tests/concurrent/pthread/pthread_attr_test.cfa (added)
• tests/concurrent/pthread/pthread_cond_test.cfa (added)
• tests/concurrent/pthread/pthread_demo_create_join.cfa (added)
• tests/concurrent/pthread/pthread_demo_lock.cfa (added)
• tests/concurrent/pthread/pthread_key_test.cfa (added)
• tests/concurrent/pthread/pthread_once_test.cfa (added)

libcfa/src/Makefile.am

@@ -124 +124 @@
         concurrency/monitor.hfa \
         concurrency/mutex.hfa \
-        concurrency/thread.hfa
+        concurrency/thread.hfa 
 
 thread_libsrc = ${inst_thread_headers_src} ${inst_thread_headers_src:.hfa=.cfa} \
@@ -145 +145 @@
         concurrency/stats.cfa \
         concurrency/stats.hfa \
-        concurrency/stats.hfa
+        concurrency/stats.hfa \
+        concurrency/pthread.cfa
 
 else

libcfa/src/bits/defs.hfa

@@ -21 +21 @@
 #include <stdint.h>
 #include <assert.h>
+#include <signal.h>
 
 #define likely(x)   __builtin_expect(!!(x), 1)
@@ -58 +59 @@
 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__ ));
-#ifdef __cforall
+        #include <pthread.h>
+        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

libcfa/src/concurrency/clib/cfathread.cfa

@@ -172 +172 @@
 
                 pthread_attr_t attr;
-                if (int ret = pthread_attr_init(&attr); 0 != ret) {
+                if (int ret = real_pthread_attr_init(&attr); 0 != ret) {
                         abort | "failed to create master epoll thread attr: " | ret | strerror(ret);
                 }
 
-                if (int ret = pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
+                if (int ret = real_pthread_create(&master_poller, &attr, master_epoll, 0p); 0 != ret) {
                         abort | "failed to create master epoll thread: " | ret | strerror(ret);
                 }

libcfa/src/concurrency/io.cfa

@@ -610 +610 @@
                 if( we ) {
                         sigval_t value = { PREEMPT_IO };
-                        pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
+                        real_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
                 }
 

libcfa/src/concurrency/io/setup.cfa

@@ -344 +344 @@
         //      iopoll.run = false;
         //      sigval val = { 1 };
-        //      pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
+        //      real_pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
 
         //      // Make sure all this is done

libcfa/src/concurrency/kernel/startup.cfa

@@ -219 +219 @@
                 ( this.runner ){};
                 init( this, "Main Processor", *mainCluster, 0p );
-                kernel_thread = pthread_self();
+                kernel_thread = real_pthread_self();
 
                 runner{ &this };
@@ -280 +280 @@
 }
 
+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();
@@ -770 +779 @@
         pthread_attr_t attr;
 
-        check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+        check( real_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
         size_t stacksize = max( PTHREAD_STACK_MIN, DEFAULT_STACK_SIZE );
@@ -797 +806 @@
         #endif
 
-        check( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
-        check( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
+        check( real_pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
+        check( real_pthread_create( pthread, &attr, start, arg ), "pthread_create" );
         return stack;
 }
 
 void __destroy_pthread( pthread_t pthread, void * stack, void ** retval ) {
-        int err = pthread_join( pthread, retval );
+        int err = real_pthread_join( pthread, retval );
         if( err != 0 ) abort("KERNEL ERROR: joining pthread %p caused error %s\n", (void*)pthread, strerror(err));
 
@@ -809 +818 @@
                 pthread_attr_t attr;
 
-                check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+                check( real_pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
                 size_t stacksize;
                 // default stack size, normally defined by shell limit
-                check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
+                check( real_pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
                 assert( stacksize >= PTHREAD_STACK_MIN );
                 stacksize += __page_size;

libcfa/src/concurrency/preemption.cfa

@@ -406 +406 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -439 +439 @@
         sigaddset( &mask, sig );
 
-        if ( pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
+        if ( real_pthread_sigmask( SIG_UNBLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
         }
@@ -450 +450 @@
         sigaddset( &mask, sig );
 
-        if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+        if ( real_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
                 abort( "internal error, pthread_sigmask" );
         }
@@ -458 +458 @@
 static void preempt( processor * this ) {
         sigval_t value = { PREEMPT_NORMAL };
-        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+        real_pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
 }
 
@@ -469 +469 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -488 +488 @@
         sigset_t oldset;
         int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+        ret = real_pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
 
@@ -559 +559 @@
         sigval val;
         val.sival_int = 0;
-        pthread_sigqueue( alarm_thread, SIGALRM, val );
+        real_pthread_sigqueue( alarm_thread, SIGALRM, val );
 
         // Wait for the preemption thread to finish
@@ -633 +633 @@
         static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
         #endif
-        if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
+        if ( real_pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), 0p ) == -1 ) {
                 abort( "internal error, sigprocmask" );
         }
@@ -661 +661 @@
         sigset_t mask;
         sigfillset(&mask);
-        if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
+        if ( real_pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
             abort( "internal error, pthread_sigmask" );
         }

libcfa/src/interpose.cfa

@@ -46 +46 @@
 
         static void * library;
+        static void * pthread_library;
         if ( ! library ) {
                 #if defined( RTLD_NEXT )
@@ -58 +59 @@
                 #endif
         } // if
+        if ( ! pthread_library ) {
+                #if defined( RTLD_NEXT )
+                        pthread_library = RTLD_NEXT;
+                #else
+                        // missing RTLD_NEXT => must hard-code library name, assuming libstdc++
+                        pthread_library = dlopen( "libpthread.so", RTLD_LAZY );
+                        error = dlerror();
+                        if ( error ) {
+                                abort( "interpose_symbol : failed to open libpthread, %s\n", error );
+                        }
+                #endif
+        } // if
 
         union { generic_fptr_t fptr; void * ptr; } originalFunc;
@@ -72 +85 @@
 
         error = dlerror();
-        if ( error ) abort( "interpose_symbol : internal error, %s\n", error );
+        if ( error ) {
+                originalFunc.ptr = dlsym( pthread_library, symbol );
+                error = dlerror();
+                if (error){
+                        abort( "interpose_symbol : internal error, %s\n", error );
+                }       // if
+        }       // if
 
         return originalFunc.fptr;
@@ -92 +111 @@
         void (* exit)( int ) __attribute__(( __noreturn__ ));
         void (* abort)( void ) __attribute__(( __noreturn__ ));
+        typeof(pthread_create) pthread_create;
+        typeof(pthread_join) pthread_join;
+        typeof(pthread_self) pthread_self;
+        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;
 
@@ -107 +135 @@
                 INTERPOSE_LIBC( abort, version );
                 INTERPOSE_LIBC( exit , version );
+                INTERPOSE_LIBC( pthread_create , version );
+                INTERPOSE_LIBC( pthread_join , version );
+                INTERPOSE_LIBC( pthread_self , 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
 
@@ -167 +204 @@
         libcfa_public void exit( int status ) __attribute__(( __nothrow__, __leaf__, __noreturn__ )) {
                 __cabi_libc.exit( status );
+        }
+
+        libcfa_public int real_pthread_create(pthread_t *_thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg){
+                return __cabi_libc.pthread_create(_thread, attr, start_routine, arg);
+        }
+
+        libcfa_public int real_pthread_join(pthread_t _thread, void **retval){
+                return __cabi_libc.pthread_join(_thread, retval);
+        }
+
+        libcfa_public pthread_t real_pthread_self(void){
+                return __cabi_libc.pthread_self();
+        }
+        libcfa_public int real_pthread_attr_init(pthread_attr_t *attr){
+                return __cabi_libc.pthread_attr_init(attr);
+        }
+        libcfa_public int real_pthread_attr_destroy(pthread_attr_t *attr){
+                return __cabi_libc.pthread_attr_destroy(attr);
+        }
+        libcfa_public int real_pthread_attr_setstack( pthread_attr_t *attr, void *stackaddr, size_t stacksize ){
+                return __cabi_libc.pthread_attr_setstack(attr, stackaddr, 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.pthread_sigqueue(_thread, sig, value);
         }
 }