Changes in libcfa/src/concurrency/kernel.cfa [1805b1b:27f5f71]

File:

• libcfa/src/concurrency/kernel.cfa (modified) (18 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 : Sun Dec  1 17:52:57 2019
-// Update Count     : 45
+// Last Modified On : Fri Nov 29 17:59:16 2019
+// Update Count     : 35
 //
 
@@ -41 +41 @@
 //-----------------------------------------------------------------------------
 // Some assembly required
-#if defined( __i386 )
+#if   defined( __i386 )
         #define CtxGet( ctx )        \
                 __asm__ volatile (     \
@@ -124 +124 @@
 
 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;
 }
 
@@ -132 +132 @@
 // Global state
 thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) = {
-        NULL,                                                                                           // cannot use 0p
+        NULL,
         NULL,
         { NULL, 1, false, false },
@@ -141 +141 @@
 // 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
 };
 
@@ -173 +173 @@
         name = "Main Thread";
         state = Start;
-        starter = 0p;
-        last = 0p;
-        cancellation = 0p;
+        starter = NULL;
+        last = NULL;
+        cancellation = NULL;
 }
 
@@ -186 +186 @@
         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);
 
@@ -213 +213 @@
         terminated{ 0 };
         do_terminate = false;
-        preemption_alarm = 0p;
+        preemption_alarm = NULL;
         pending_preemption = false;
         runner.proc = &this;
@@ -233 +233 @@
         }
 
-        pthread_join( kernel_thread, 0p );
+        pthread_join( kernel_thread, NULL );
         free( this.stack );
 }
@@ -280 +280 @@
                 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 
-                thread_desc * readyThread = 0p;
+                thread_desc * readyThread = NULL;
                 for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ )
                 {
@@ -412 +412 @@
         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
@@ -425 +425 @@
 
         //Set global state
-        kernelTLS.this_thread = 0p;
+        kernelTLS.this_thread    = NULL;
 
         //We now have a proper context from which to schedule threads
@@ -441 +441 @@
         __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 ) {
-                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
-
-#ifdef __CFA_DEBUG__
-        size_t guardsize;
-        Abort( pthread_attr_getguardsize( &attr, &guardsize ), "pthread_attr_getguardsize" );
-        Abort( pthread_attr_setguardsize( &attr, guardsize ), "pthread_attr_setguardsize" );
-#endif
-
-        size_t stacksize;
-        Abort( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" ); // default stack size, normally defined by shell limit
-        assert( stacksize >= PTHREAD_STACK_MIN );
-        void * 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;
 }
 
@@ -474 +447 @@
         __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
 
-        this->stack = create_pthread( &this->kernel_thread, CtxInvokeProcessor, (void *)this );
+        pthread_attr_t attr;
+        int ret;
+        ret = pthread_attr_init( &attr );                                       // initialize attribute
+        if ( ret ) {
+                abort( "%s : internal error, pthread_attr_init failed, error(%d) %s.", __PRETTY_FUNCTION__, ret, strerror( ret ) );
+        } // if
+
+        size_t stacksize;
+        ret = pthread_attr_getstacksize( &attr, &stacksize ); // default stack size, normally defined by shell limit
+        if ( ret ) {
+                abort( "%s : internal error, pthread_attr_getstacksize failed, error(%d) %s.", __PRETTY_FUNCTION__, ret, strerror( ret ) );
+        } // if
+        assert( stacksize >= PTHREAD_STACK_MIN );
+
+        this->stack = malloc( stacksize );
+        ret = pthread_attr_setstack( &attr, this->stack, stacksize ); 
+        if ( ret ) {
+                abort( "%s : internal error, pthread_attr_setstack failed, error(%d) %s.", __PRETTY_FUNCTION__, ret, strerror( ret ) );
+        } // if
+
+        ret = pthread_create( &this->kernel_thread, &attr, CtxInvokeProcessor, (void *)this );
+        if ( ret ) {
+                abort( "%s : internal error, pthread_create failed, error(%d) %s.", __PRETTY_FUNCTION__, ret, strerror( ret ) );
+        } // if
+//      pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
 
         __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
@@ -531 +528 @@
         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 ) {
@@ -710 +707 @@
         void ?{}(processorCtx_t & this, processor * proc) {
                 (this.__cor){ "Processor" };
-                this.__cor.starter = 0p;
+                this.__cor.starter = NULL;
                 this.proc = proc;
         }
@@ -719 +716 @@
                 terminated{ 0 };
                 do_terminate = false;
-                preemption_alarm = 0p;
+                preemption_alarm = NULL;
                 pending_preemption = false;
                 kernel_thread = pthread_self();
@@ -913 +910 @@
 
 void V(semaphore & this) with( this ) {
-        thread_desc * thrd = 0p;
+        thread_desc * thrd = NULL;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;