Changeset 3b56166 for libcfa/src/concurrency/kernel.cfa

Timestamp:

Feb 10, 2020, 11:17:38 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

3966d9a, 41efd33

Parents:

807a632 (diff), d231700 (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

File:

• libcfa/src/concurrency/kernel.cfa (modified) (27 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 20 17:21:23 2019
-// Update Count     : 25
+// Last Modified On : Tue Feb  4 13:03:15 2020
+// Update Count     : 58
 //
 
@@ -26 +26 @@
 #include <signal.h>
 #include <unistd.h>
+#include <limits.h>                                                                             // PTHREAD_STACK_MIN
+#include <sys/mman.h>                                                                   // mprotect
 }
 
@@ -40 +42 @@
 //-----------------------------------------------------------------------------
 // Some assembly required
-#if   defined( __i386 )
+#if defined( __i386 )
         #define CtxGet( ctx )        \
                 __asm__ volatile (     \
@@ -123 +125 @@
 
 extern "C" {
-struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
+        struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
 }
 
@@ -131 +133 @@
 // Global state
 thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) = {
+        NULL,                                                                                           // cannot use 0p
         NULL,
-        NULL,
-        { 1, false, false }
+        { 1, false, false },
+        6u //this should be seeded better but due to a bug calling rdtsc doesn't work
 };
 
@@ -139 +142 @@
 // Struct to steal stack
 struct current_stack_info_t {
-        __stack_t * storage;            // pointer to stack object
-        void *base;                             // base of stack
-        void *limit;                    // stack grows towards stack limit
-        void *context;                  // address of cfa_context_t
+        __stack_t * storage;                                                            // pointer to stack object
+        void * base;                                                                            // base of stack
+        void * limit;                                                                           // stack grows towards stack limit
+        void * context;                                                                         // address of cfa_context_t
 };
 
@@ -171 +174 @@
         name = "Main Thread";
         state = Start;
-        starter = NULL;
-        last = NULL;
-        cancellation = NULL;
+        starter = 0p;
+        last = 0p;
+        cancellation = 0p;
 }
 
@@ -184 +187 @@
         self_mon.recursion = 1;
         self_mon_p = &self_mon;
-        next = NULL;
-
-        node.next = NULL;
-        node.prev = NULL;
+        next = 0p;
+
+        node.next = 0p;
+        node.prev = 0p;
         doregister(curr_cluster, this);
 
@@ -206 +209 @@
 
 static void start(processor * this);
-void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
+void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
         this.name = name;
         this.cltr = &cltr;
         terminated{ 0 };
         do_terminate = false;
-        preemption_alarm = NULL;
+        preemption_alarm = 0p;
         pending_preemption = false;
         runner.proc = &this;
@@ -231 +234 @@
         }
 
-        pthread_join( kernel_thread, NULL );
-}
-
-void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
+        pthread_join( kernel_thread, 0p );
+        free( this.stack );
+}
+
+void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
         this.name = name;
         this.preemption_rate = preemption_rate;
@@ -260 +264 @@
 //Main of the processor contexts
 void main(processorCtx_t & runner) {
+        // Because of a bug, we couldn't initialized the seed on construction
+        // Do it here
+        kernelTLS.rand_seed ^= rdtscl();
+
         processor * this = runner.proc;
         verify(this);
@@ -273 +281 @@
                 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 
-                thread_desc * readyThread = NULL;
-                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ )
-                {
+                thread_desc * readyThread = 0p;
+                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
                         readyThread = nextThread( this->cltr );
 
-                        if(readyThread)
-                        {
+                        if(readyThread) {
                                 verify( ! kernelTLS.preemption_state.enabled );
 
@@ -290 +296 @@
 
                                 spin_count = 0;
-                        }
-                        else
-                        {
+                        } else {
                                 // spin(this, &spin_count);
                                 halt(this);
@@ -405 +409 @@
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
-        kernelTLS.this_thread    = NULL;
+        kernelTLS.this_thread    = 0p;
         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
         // SKULLDUGGERY: We want to create a context for the processor coroutine
@@ -418 +422 @@
 
         //Set global state
-        kernelTLS.this_thread    = NULL;
+        kernelTLS.this_thread = 0p;
 
         //We now have a proper context from which to schedule threads
@@ -434 +438 @@
         __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner);
 
-        return NULL;
+        return 0p;
+}
+
+static void Abort( int ret, const char func[] ) {
+        if ( ret ) {                                                                            // pthread routines return errno values
+                abort( "%s : internal error, error(%d) %s.", func, ret, strerror( ret ) );
+        } // if
+} // Abort
+
+void * create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
+        pthread_attr_t attr;
+
+        Abort( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
+
+        size_t stacksize;
+        // default stack size, normally defined by shell limit
+        Abort( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
+        assert( stacksize >= PTHREAD_STACK_MIN );
+
+        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 );
+        );
+
+        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
+
+        Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
+        return stack;
 }
 
@@ -440 +478 @@
         __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
 
-        pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
+        this->stack = create_pthread( &this->kernel_thread, CtxInvokeProcessor, (void *)this );
 
         __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
@@ -452 +490 @@
         verify( ! kernelTLS.preemption_state.enabled );
 
+        kernelTLS.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
-        CtxStart(&this->runner, CtxInvokeCoroutine);
+        CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -468 +507 @@
         // when CtxSwitch returns we are back in the src coroutine
 
+        mainThread->curr_cor = &mainThread->self_cor;
+
         // set state of new coroutine to active
         src->state = Active;
@@ -497 +538 @@
         verify( ! kernelTLS.preemption_state.enabled );
 
-        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
+        verifyf( thrd->next == 0p, "Expected null got %p", thrd->next );
 
         with( *thrd->curr_cluster ) {
@@ -676 +717 @@
         void ?{}(processorCtx_t & this, processor * proc) {
                 (this.__cor){ "Processor" };
-                this.__cor.starter = NULL;
+                this.__cor.starter = 0p;
                 this.proc = proc;
         }
@@ -685 +726 @@
                 terminated{ 0 };
                 do_terminate = false;
-                preemption_alarm = NULL;
+                preemption_alarm = 0p;
                 pending_preemption = false;
                 kernel_thread = pthread_self();
@@ -803 +844 @@
                 sigemptyset( &mask );
                 sigaddset( &mask, SIGALRM );            // block SIGALRM signals
-                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
-                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
+                sigaddset( &mask, SIGUSR1 );            // block SIGALRM signals
+                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
         }
         else {
@@ -819 +861 @@
         if(thrd) {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
-                __cfaabi_dbg_bits_write( abort_text, len );
+                __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
 
                 if ( &thrd->self_cor != thrd->curr_cor ) {
                         len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", thrd->curr_cor->name, thrd->curr_cor );
-                        __cfaabi_dbg_bits_write( abort_text, len );
+                        __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
                 }
                 else {
-                        __cfaabi_dbg_bits_write( ".\n", 2 );
+                        __cfaabi_bits_write( STDERR_FILENO, ".\n", 2 );
                 }
         }
         else {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
-                __cfaabi_dbg_bits_write( abort_text, len );
+                __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
         }
 }
@@ -842 +884 @@
 
 extern "C" {
-        void __cfaabi_dbg_bits_acquire() {
+        void __cfaabi_bits_acquire() {
                 lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
         }
 
-        void __cfaabi_dbg_bits_release() {
+        void __cfaabi_bits_release() {
                 unlock( kernel_debug_lock );
         }
@@ -879 +921 @@
 
 void V(semaphore & this) with( this ) {
-        thread_desc * thrd = NULL;
+        thread_desc * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;
@@ -939 +981 @@
 __cfaabi_dbg_debug_do(
         extern "C" {
-                void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
+                void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]) {
                         this.prev_name = prev_name;
                         this.prev_thrd = kernelTLS.this_thread;