Changeset a7d696f

Timestamp:

Aug 3, 2022, 6:32:06 PM (2 years ago)

Author:

z277zhu <z277zhu@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

20be782

Parents:

80d16f8

git-author:

z277zhu <z277zhu@…> (08/03/22 18:24:16)

git-committer:

z277zhu <z277zhu@…> (08/03/22 18:32:06)

Message:

added pthread symbol interpose

Signed-off-by: z277zhu <z277zhu@…>

Files:

• libcfa/src/Makefile.am (modified) (1 diff)
• libcfa/src/bits/defs.hfa (modified) (2 diffs)
• libcfa/src/concurrency/clib/cfathread.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (4 diffs)
• libcfa/src/concurrency/pthread.cfa (added)
• libcfa/src/interpose.cfa (modified) (6 diffs)
• tests/collections/stack.cfa (modified) (2 diffs)

libcfa/src/Makefile.am

@@ -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 <pthread.h>
 
 #define likely(x)   __builtin_expect(!!(x), 1)
@@ -45 +46 @@
 #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
 }

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/kernel/startup.cfa

@@ -218 +218 @@
                 ( this.runner ){};
                 init( this, "Main Processor", *mainCluster, 0p );
-                kernel_thread = pthread_self();
+                kernel_thread = real_pthread_self();
 
                 runner{ &this };
@@ -769 +769 @@
         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 );
@@ -796 +796 @@
         #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));
 
@@ -808 +808 @@
                 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/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_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_setstack ) pthread_attr_setstack;
+        typeof(pthread_attr_destroy) pthread_attr_destroy;
+        typeof(pthread_attr_getstacksize) pthread_attr_getstacksize;
 } __cabi_libc;
 
@@ -107 +143 @@
                 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_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 );
 #pragma GCC diagnostic pop
 
@@ -168 +220 @@
                 __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();
+        }
+        /* 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);
+        }
+        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 pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ){
+                return __cabi_libc.pthread_attr_getstacksize(attr, stacksize);
+        }
+
 }
 

tests/collections/stack.cfa

@@ -3 +3 @@
 #include <bits/stack.hfa>
 
+struct Fred {
+                inline Colable;                                                                 // Plan 9 inheritance
+                int i;
+};
+
+Stack(Fred) fred;
+
 int main() {
         // Fred test
 
-        struct Fred {
-                inline Colable;                                                                 // Plan 9 inheritance
-                int i;
-        };
+        
         void ?{}( Fred & fred ) { abort(); }
         void ?{}( Fred & fred, int p ) with( fred ) {
@@ -18 +22 @@
         }
 
-        Stack(Fred) fred;
+        
         StackIter(Fred) inter = { fred };
         Fred & f;