Changes in libcfa/src/concurrency/kernel.cfa [2026bb6:09d4b22]

File:

• libcfa/src/concurrency/kernel.cfa (modified) (23 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 : Thu Dec  5 16:25:52 2019
+// Update Count     : 52
 //
 
@@ -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);
 
@@ -211 +214 @@
         terminated{ 0 };
         do_terminate = false;
-        preemption_alarm = NULL;
+        preemption_alarm = 0p;
         pending_preemption = false;
         runner.proc = &this;
@@ -231 +234 @@
         }
 
-        pthread_join( kernel_thread, NULL );
+        pthread_join( kernel_thread, 0p );
+        free( this.stack );
 }
 
@@ -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);
@@ -497 +535 @@
         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 +714 @@
         void ?{}(processorCtx_t & this, processor * proc) {
                 (this.__cor){ "Processor" };
-                this.__cor.starter = NULL;
+                this.__cor.starter = 0p;
                 this.proc = proc;
         }
@@ -685 +723 @@
                 terminated{ 0 };
                 do_terminate = false;
-                preemption_alarm = NULL;
+                preemption_alarm = 0p;
                 pending_preemption = false;
                 kernel_thread = pthread_self();
@@ -819 +857 @@
         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 +880 @@
 
 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 +917 @@
 
 void V(semaphore & this) with( this ) {
-        thread_desc * thrd = NULL;
+        thread_desc * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;