Changeset 3e3f236 for libcfa/src/concurrency

Timestamp:

Dec 10, 2020, 4:00:29 PM (5 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

97aca3df, b3a0df6

Parents:

6a45bd78 (diff), 297cf18 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

libcfa/src/concurrency

Files:

• coroutine.cfa (modified) (5 diffs)
• coroutine.hfa (modified) (1 diff)
• io/setup.cfa (modified) (1 diff)
• kernel/startup.cfa (modified) (5 diffs)
• kernel_private.hfa (modified) (1 diff)
• preemption.cfa (modified) (9 diffs)

libcfa/src/concurrency/coroutine.cfa

@@ -28 +28 @@
 #include "kernel_private.hfa"
 #include "exception.hfa"
+#include "math.hfa"
 
 #define __CFA_INVOKE_PRIVATE__
@@ -87 +88 @@
 
 void __stack_prepare( __stack_info_t * this, size_t create_size );
+void __stack_clean  ( __stack_info_t * this );
 
 //-----------------------------------------------------------------------------
@@ -107 +109 @@
         bool userStack = ((intptr_t)this.storage & 0x1) != 0;
         if ( ! userStack && this.storage ) {
-                __attribute__((may_alias)) intptr_t * istorage = (intptr_t *)&this.storage;
-                *istorage &= (intptr_t)-1;
-
-                void * storage = this.storage->limit;
-                __cfaabi_dbg_debug_do(
-                        storage = (char*)(storage) - __page_size;
-                        if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) {
-                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
-                        }
-                );
-                __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage);
-                free( storage );
+                __stack_clean( &this );
+                // __attribute__((may_alias)) intptr_t * istorage = (intptr_t *)&this.storage;
+                // *istorage &= (intptr_t)-1;
+
+                // void * storage = this.storage->limit;
+                // __cfaabi_dbg_debug_do(
+                //      storage = (char*)(storage) - __page_size;
+                //      if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) {
+                //              abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
+                //      }
+                // );
+                // __cfaabi_dbg_print_safe("Kernel : Deleting stack %p\n", storage);
+                // free( storage );
         }
 }
@@ -167 +170 @@
         assert(__page_size != 0l);
         size_t size = libCeiling( storageSize, 16 ) + stack_data_size;
+        size = ceiling(size, __page_size);
 
         // If we are running debug, we also need to allocate a guardpage to catch stack overflows.
         void * storage;
-        __cfaabi_dbg_debug_do(
-                storage = memalign( __page_size, size + __page_size );
-        );
-        __cfaabi_dbg_no_debug_do(
-                storage = (void*)malloc(size);
-        );
-
-        __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size);
-        __cfaabi_dbg_debug_do(
-                if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
-                        abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
-                }
-                storage = (void *)(((intptr_t)storage) + __page_size);
-        );
+        // __cfaabi_dbg_debug_do(
+        //      storage = memalign( __page_size, size + __page_size );
+        // );
+        // __cfaabi_dbg_no_debug_do(
+        //      storage = (void*)malloc(size);
+        // );
+
+        // __cfaabi_dbg_print_safe("Kernel : Created stack %p of size %zu\n", storage, size);
+        // __cfaabi_dbg_debug_do(
+        //      if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+        //              abort( "__stack_alloc : internal error, mprotect failure, error(%d) %s.", (int)errno, strerror( (int)errno ) );
+        //      }
+        //      storage = (void *)(((intptr_t)storage) + __page_size);
+        // );
+        storage = mmap(0p, size + __page_size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+        if(storage == ((void*)-1)) {
+                abort( "coroutine stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
+        }
+        if ( mprotect( storage, __page_size, PROT_NONE ) == -1 ) {
+                abort( "coroutine stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
+        } // if
+        storage = (void *)(((intptr_t)storage) + __page_size);
 
         verify( ((intptr_t)storage & (libAlign() - 1)) == 0ul );
         return [storage, size];
+}
+
+void __stack_clean  ( __stack_info_t * this ) {
+        size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
+        void * storage = this->storage->limit;
+
+        storage = (void *)(((intptr_t)storage) - __page_size);
+        if(munmap(storage, size + __page_size) == -1) {
+                abort( "coroutine stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
+        }
 }
 
@@ -210 +232 @@
         assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %zd bytes for a stack.", size, MinStackSize );
 
-        this->storage = (__stack_t *)((intptr_t)storage + size);
+        this->storage = (__stack_t *)((intptr_t)storage + size - sizeof(__stack_t));
         this->storage->limit = storage;
-        this->storage->base  = (void*)((intptr_t)storage + size);
+        this->storage->base  = (void*)((intptr_t)storage + size - sizeof(__stack_t));
         this->storage->exception_context.top_resume = 0p;
         this->storage->exception_context.current_exception = 0p;

libcfa/src/concurrency/coroutine.hfa

@@ -102 +102 @@
 }
 
-extern void __stack_prepare   ( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
+extern void __stack_prepare( __stack_info_t * this, size_t size /* ignored if storage already allocated */);
+extern void __stack_clean  ( __stack_info_t * this );
+
 
 // Suspend implementation inlined for performance

libcfa/src/concurrency/io/setup.cfa

@@ -132 +132 @@
                 // Wait for the io poller thread to finish
 
-                pthread_join( iopoll.thrd, 0p );
-                free( iopoll.stack );
+                __destroy_pthread( iopoll.thrd, iopoll.stack, 0p );
 
                 int ret = close(iopoll.epollfd);

libcfa/src/concurrency/kernel/startup.cfa

@@ -29 +29 @@
 #include "kernel_private.hfa"
 #include "startup.hfa"          // STARTUP_PRIORITY_XXX
+#include "math.hfa"
 
 //-----------------------------------------------------------------------------
@@ -539 +540 @@
 }
 
+extern size_t __page_size;
 void ^?{}(processor & this) with( this ){
         if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
@@ -550 +552 @@
         }
 
-        int err = pthread_join( kernel_thread, 0p );
-        if( err != 0 ) abort("KERNEL ERROR: joining processor %p caused error %s\n", &this, strerror(err));
-
-        free( this.stack );
+        __destroy_pthread( kernel_thread, this.stack, 0p );
 
         disable_interrupts();
@@ -678 +677 @@
 
         void * stack;
-        __cfaabi_dbg_debug_do(
-                stack = memalign( __page_size, stacksize + __page_size );
-                // pthread has no mechanism to create the guard page in user supplied stack.
-                if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
-                        abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
-                } // if
-        );
-        __cfaabi_dbg_no_debug_do(
-                stack = malloc( stacksize );
-        );
+        #warning due to the thunk problem, stack creation uses mmap, revert to malloc once this goes away
+        // __cfaabi_dbg_debug_do(
+        //      stack = memalign( __page_size, stacksize + __page_size );
+        //      // pthread has no mechanism to create the guard page in user supplied stack.
+        //      if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+        //              abort( "mprotect : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
+        //      } // if
+        // );
+        // __cfaabi_dbg_no_debug_do(
+        //      stack = malloc( stacksize );
+        // );
+        stacksize = ceiling( stacksize, __page_size ) + __page_size;
+        stack = mmap(0p, stacksize, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+        if(stack == ((void*)-1)) {
+                abort( "pthread stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
+        }
+        if ( mprotect( stack, __page_size, PROT_NONE ) == -1 ) {
+                abort( "pthread stack creation : internal error, mprotect failure, error(%d) %s.", errno, strerror( errno ) );
+        } // if
 
         check( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
@@ -694 +702 @@
         return stack;
 }
+
+void __destroy_pthread( pthread_t pthread, void * stack, void ** retval ) {
+        int err = pthread_join( pthread, retval );
+        if( err != 0 ) abort("KERNEL ERROR: joining pthread %p caused error %s\n", (void*)pthread, strerror(err));
+
+        pthread_attr_t attr;
+
+        check( 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" );
+        assert( stacksize >= PTHREAD_STACK_MIN );
+        stacksize += __page_size;
+
+        if(munmap(stack, stacksize) == -1) {
+                abort( "pthread stack destruction : internal error, munmap failure, error(%d) %s.", errno, strerror( errno ) );
+        }
+}
+
 
 #if defined(__CFA_WITH_VERIFY__)

libcfa/src/concurrency/kernel_private.hfa

@@ -49 +49 @@
 
 void * __create_pthread( pthread_t *, void * (*)(void *), void * );
+void __destroy_pthread( pthread_t pthread, void * stack, void ** retval );
 
 

libcfa/src/concurrency/preemption.cfa

@@ -354 +354 @@
 }
 
+//-----------------------------------------------------------------------------
+// Kernel Signal Debug
+void __cfaabi_check_preemption() {
+        bool ready = __preemption_enabled();
+        if(!ready) { abort("Preemption should be ready"); }
+
+        __cfaasm_label(debug, before);
+
+                sigset_t oldset;
+                int ret;
+                ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
+                if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
+
+                ret = sigismember(&oldset, SIGUSR1);
+                if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+                if(ret == 1) { abort("ERROR SIGUSR1 is disabled"); }
+
+                ret = sigismember(&oldset, SIGALRM);
+                if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+                if(ret == 0) { abort("ERROR SIGALRM is enabled"); }
+
+                ret = sigismember(&oldset, SIGTERM);
+                if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+                if(ret == 1) { abort("ERROR SIGTERM is disabled"); }
+
+        __cfaasm_label(debug, after);
+}
+
+#ifdef __CFA_WITH_VERIFY__
+bool __cfaabi_dbg_in_kernel() {
+        return !__preemption_enabled();
+}
+#endif
+
 #undef __cfaasm_label
+
+//-----------------------------------------------------------------------------
+// Signal handling
 
 // sigprocmask wrapper : unblock a single signal
@@ -405 +442 @@
                 #define RELOC_SUFFIX ""
         #endif
-        #define __cfaasm_label( label ) static struct asm_region label = \
+        #define __cfaasm_label( label ) struct asm_region label = \
                 ({ \
                         struct asm_region region; \
@@ -424 +461 @@
                 #define RELOC_SUFFIX ""
         #endif
-        #define __cfaasm_label( label ) static struct asm_region label = \
+        #define __cfaasm_label( label ) struct asm_region label = \
                 ({ \
                         struct asm_region region; \
@@ -437 +474 @@
         #ifdef __PIC__
                 // Note that this works only for gcc
-                #define __cfaasm_label( label ) static struct asm_region label = \
+                #define __cfaasm_label( label ) struct asm_region label = \
                 ({ \
                         struct asm_region region; \
@@ -452 +489 @@
                 #error this is not the right thing to do
                 /*
-                #define __cfaasm_label( label ) static struct asm_region label = \
+                #define __cfaasm_label( label ) struct asm_region label = \
                 ({ \
                         struct asm_region region; \
@@ -479 +516 @@
         __cfaasm_label( check  );
         __cfaasm_label( dsable );
+        __cfaasm_label( debug  );
 
         // Check if preemption is safe
@@ -485 +523 @@
         if( __cfaasm_in( ip, check  ) ) { ready = false; goto EXIT; };
         if( __cfaasm_in( ip, dsable ) ) { ready = false; goto EXIT; };
+        if( __cfaasm_in( ip, debug  ) ) { ready = false; goto EXIT; };
         if( !__cfaabi_tls.preemption_state.enabled) { ready = false; goto EXIT; };
         if( __cfaabi_tls.preemption_state.in_progress ) { ready = false; goto EXIT; };
@@ -536 +575 @@
         // Wait for the preemption thread to finish
 
-        pthread_join( alarm_thread, 0p );
-        free( alarm_stack );
+        __destroy_pthread( alarm_thread, alarm_stack, 0p );
 
         // Preemption is now fully stopped
@@ -697 +735 @@
 }
 
-//=============================================================================================
-// Kernel Signal Debug
-//=============================================================================================
-
-void __cfaabi_check_preemption() {
-        bool ready = __preemption_enabled();
-        if(!ready) { abort("Preemption should be ready"); }
-
-        sigset_t oldset;
-        int ret;
-        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
-        if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
-
-        ret = sigismember(&oldset, SIGUSR1);
-        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
-        if(ret == 1) { abort("ERROR SIGUSR1 is disabled"); }
-
-        ret = sigismember(&oldset, SIGALRM);
-        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
-        if(ret == 0) { abort("ERROR SIGALRM is enabled"); }
-
-        ret = sigismember(&oldset, SIGTERM);
-        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
-        if(ret == 1) { abort("ERROR SIGTERM is disabled"); }
-}
-
-#ifdef __CFA_WITH_VERIFY__
-bool __cfaabi_dbg_in_kernel() {
-        return !__preemption_enabled();
-}
-#endif
-
 // Local Variables: //
 // mode: c //