Changes in libcfa/src/concurrency/kernel.cfa [c84b4be:e3fea42]

File:

• libcfa/src/concurrency/kernel.cfa (modified) (16 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 : Tue Feb  4 13:03:15 2020
+// Update Count     : 58
 //
 
@@ -187 +187 @@
         self_mon.recursion = 1;
         self_mon_p = &self_mon;
-        link.next = 0p;
-        link.prev = 0p;
+        next = 0p;
 
         node.next = 0p;
@@ -210 +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;
-        id = -1u;
         terminated{ 0 };
         do_terminate = false;
@@ -240 +238 @@
 }
 
-void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
+void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
         this.name = name;
         this.preemption_rate = preemption_rate;
         ready_queue{};
-        ready_lock{};
-
+        ready_queue_lock{};
+
+        procs{ __get };
         idles{ __get };
         threads{ __get };
@@ -274 +273 @@
         __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
 
-        // register the processor unless it's the main thread which is handled in the boot sequence
-        if(this != mainProcessor) {
-                this->id = doregister(this->cltr, this);
-                ready_queue_grow( this->cltr );
-        }
-
+        doregister(this->cltr, this);
 
         {
@@ -311 +305 @@
         }
 
+        unregister(this->cltr, this);
+
         V( this->terminated );
 
-
-        // unregister the processor unless it's the main thread which is handled in the boot sequence
-        if(this != mainProcessor) {
-                ready_queue_shrink( this->cltr );
-                unregister(this->cltr, this);
-        }
-
         __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
-
-        stats_tls_tally(this->cltr);
 }
 
@@ -454 +441 @@
 }
 
-static void Abort( int ret, const char * func ) {
+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 ) );
@@ -482 +469 @@
         );
 
-        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
+        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" ); 
 
         Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
@@ -548 +535 @@
         verify( ! kernelTLS.preemption_state.enabled );
 
-        verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
-
-
-        ready_schedule_lock(thrd->curr_cluster, kernelTLS.this_processor);
-                bool was_empty = push( thrd->curr_cluster, thrd );
-        ready_schedule_unlock(thrd->curr_cluster, kernelTLS.this_processor);
+        verifyf( thrd->next == 0p, "Expected null got %p", thrd->next );
 
         with( *thrd->curr_cluster ) {
-                // if(was_empty) {
-                //      lock      (proc_list_lock __cfaabi_dbg_ctx2);
-                //      if(idles) {
-                //              wake_fast(idles.head);
-                //      }
-                //      unlock    (proc_list_lock);
-                // }
-                // else if( struct processor * idle = idles.head ) {
-                //      wake_fast(idle);
-                // }
+                lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+                bool was_empty = !(ready_queue != 0);
+                append( ready_queue, thrd );
+                unlock( ready_queue_lock );
+
+                if(was_empty) {
+                        lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                        if(idles) {
+                                wake_fast(idles.head);
+                        }
+                        unlock    (proc_list_lock);
+                }
+                else if( struct processor * idle = idles.head ) {
+                        wake_fast(idle);
+                }
+
         }
 
@@ -574 +562 @@
 thread_desc * nextThread(cluster * this) with( *this ) {
         verify( ! kernelTLS.preemption_state.enabled );
-
-        ready_schedule_lock(this, kernelTLS.this_processor);
-                thread_desc * head = pop( this );
-        ready_schedule_unlock(this, kernelTLS.this_processor);
-
+        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+        thread_desc * head = pop_head( ready_queue );
+        unlock( ready_queue_lock );
         verify( ! kernelTLS.preemption_state.enabled );
         return head;
@@ -740 +726 @@
                 pending_preemption = false;
                 kernel_thread = pthread_self();
-                id = -1u;
 
                 runner{ &this };
@@ -750 +735 @@
         mainProcessor = (processor *)&storage_mainProcessor;
         (*mainProcessor){};
-
-        mainProcessor->id = doregister(mainCluster, mainProcessor);
 
         //initialize the global state variables
@@ -798 +781 @@
         kernel_stop_preemption();
 
-        unregister(mainCluster, mainProcessor);
-
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        void ^?{}(processor & this) with( this ) {
-                //don't join the main thread here, that wouldn't make any sense
-                __cfaabi_dbg_print_safe("Kernel : destroyed main processor context %p\n", &runner);
-        }
-
-        ^(*mainProcessor){};
+        ^(mainProcessor->runner){};
+        ^(mainProcessor){};
 
         // Final step, destroy the main thread since it is no longer needed
-        // Since we provided a stack to this task it will not destroy anything
-        ^(*mainThread){};
-
-        ^(*mainCluster){};
+        // Since we provided a stack to this taxk it will not destroy anything
+        ^(mainThread){};
 
         ^(__cfa_dbg_global_clusters.list){};
@@ -825 +800 @@
 //=============================================================================================
 static void halt(processor * this) with( *this ) {
-        // // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
-
-        // with( *cltr ) {
-        //      lock      (proc_list_lock __cfaabi_dbg_ctx2);
-        //      push_front(idles, *this);
-        //      unlock    (proc_list_lock);
-        // }
-
-        // __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
-
-        // wait( idleLock );
-
-        // __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
-
-        // with( *cltr ) {
-        //      lock      (proc_list_lock __cfaabi_dbg_ctx2);
-        //      remove    (idles, *this);
-        //      unlock    (proc_list_lock);
-        // }
+        // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+
+        with( *cltr ) {
+                lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                remove    (procs, *this);
+                push_front(idles, *this);
+                unlock    (proc_list_lock);
+        }
+
+        __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
+
+        wait( idleLock );
+
+        __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
+
+        with( *cltr ) {
+                lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                remove    (idles, *this);
+                push_front(procs, *this);
+                unlock    (proc_list_lock);
+        }
 }
 
@@ -864 +841 @@
                 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 {
@@ -982 +960 @@
 }
 
+void doregister( cluster * cltr, processor * proc ) {
+        lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        cltr->nprocessors += 1;
+        push_front(cltr->procs, *proc);
+        unlock    (cltr->proc_list_lock);
+}
+
+void unregister( cluster * cltr, processor * proc ) {
+        lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        remove(cltr->procs, *proc );
+        cltr->nprocessors -= 1;
+        unlock(cltr->proc_list_lock);
+}
+
 //-----------------------------------------------------------------------------
 // Debug
 __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;