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

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 Dec  5 16:25:52 2019
-// Update Count     : 52
+// Last Modified On : Thu Jun 20 17:21:23 2019
+// Update Count     : 25
 //
 
@@ -26 +26 @@
 #include <signal.h>
 #include <unistd.h>
-#include <limits.h>                                                                             // PTHREAD_STACK_MIN
-#include <sys/mman.h>                                                                   // mprotect
 }
 
@@ -42 +40 @@
 //-----------------------------------------------------------------------------
 // Some assembly required
-#if defined( __i386 )
+#if   defined( __i386 )
         #define CtxGet( ctx )        \
                 __asm__ volatile (     \
@@ -125 +123 @@
 
 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;
 }
 
@@ -133 +131 @@
 // Global state
 thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) = {
-        NULL,                                                                                           // cannot use 0p
         NULL,
-        { 1, false, false },
-        6u //this should be seeded better but due to a bug calling rdtsc doesn't work
+        NULL,
+        { 1, false, false }
 };
 
@@ -142 +139 @@
 // 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
 };
 
@@ -174 +171 @@
         name = "Main Thread";
         state = Start;
-        starter = 0p;
-        last = 0p;
-        cancellation = 0p;
+        starter = NULL;
+        last = NULL;
+        cancellation = NULL;
 }
 
@@ -187 +184 @@
         self_mon.recursion = 1;
         self_mon_p = &self_mon;
-        next = 0p;
-
-        node.next = 0p;
-        node.prev = 0p;
+        next = NULL;
+
+        node.next = NULL;
+        node.prev = NULL;
         doregister(curr_cluster, this);
 
@@ -214 +211 @@
         terminated{ 0 };
         do_terminate = false;
-        preemption_alarm = 0p;
+        preemption_alarm = NULL;
         pending_preemption = false;
         runner.proc = &this;
@@ -234 +231 @@
         }
 
-        pthread_join( kernel_thread, 0p );
-        free( this.stack );
+        pthread_join( kernel_thread, NULL );
 }
 
@@ -264 +260 @@
 //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);
@@ -281 +273 @@
                 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 
-                thread_desc * readyThread = 0p;
-                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
+                thread_desc * readyThread = NULL;
+                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 );
 
@@ -296 +290 @@
 
                                 spin_count = 0;
-                        } else {
+                        }
+                        else
+                        {
                                 // spin(this, &spin_count);
                                 halt(this);
@@ -409 +405 @@
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
-        kernelTLS.this_thread    = 0p;
+        kernelTLS.this_thread    = NULL;
         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
         // SKULLDUGGERY: We want to create a context for the processor coroutine
@@ -422 +418 @@
 
         //Set global state
-        kernelTLS.this_thread = 0p;
+        kernelTLS.this_thread    = NULL;
 
         //We now have a proper context from which to schedule threads
@@ -438 +434 @@
         __cfaabi_dbg_print_safe("Kernel : core %p main ended (%p)\n", proc, &proc->runner);
 
-        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;
+        return NULL;
 }
 
@@ -478 +440 @@
         __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
 
-        this->stack = create_pthread( &this->kernel_thread, CtxInvokeProcessor, (void *)this );
+        pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
 
         __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
@@ -535 +497 @@
         verify( ! kernelTLS.preemption_state.enabled );
 
-        verifyf( thrd->next == 0p, "Expected null got %p", thrd->next );
+        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
         with( *thrd->curr_cluster ) {
@@ -714 +676 @@
         void ?{}(processorCtx_t & this, processor * proc) {
                 (this.__cor){ "Processor" };
-                this.__cor.starter = 0p;
+                this.__cor.starter = NULL;
                 this.proc = proc;
         }
@@ -723 +685 @@
                 terminated{ 0 };
                 do_terminate = false;
-                preemption_alarm = 0p;
+                preemption_alarm = NULL;
                 pending_preemption = false;
                 kernel_thread = pthread_self();
@@ -857 +819 @@
         if(thrd) {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
-                __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+                __cfaabi_dbg_bits_write( 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_bits_write( STDERR_FILENO, abort_text, len );
+                        __cfaabi_dbg_bits_write( abort_text, len );
                 }
                 else {
-                        __cfaabi_bits_write( STDERR_FILENO, ".\n", 2 );
+                        __cfaabi_dbg_bits_write( ".\n", 2 );
                 }
         }
         else {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
-                __cfaabi_bits_write( STDERR_FILENO, abort_text, len );
+                __cfaabi_dbg_bits_write( abort_text, len );
         }
 }
@@ -880 +842 @@
 
 extern "C" {
-        void __cfaabi_bits_acquire() {
+        void __cfaabi_dbg_bits_acquire() {
                 lock( kernel_debug_lock __cfaabi_dbg_ctx2 );
         }
 
-        void __cfaabi_bits_release() {
+        void __cfaabi_dbg_bits_release() {
                 unlock( kernel_debug_lock );
         }
@@ -917 +879 @@
 
 void V(semaphore & this) with( this ) {
-        thread_desc * thrd = 0p;
+        thread_desc * thrd = NULL;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;