Changes in libcfa/src/concurrency/kernel.cfa [504a7dc:a7b486b]

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -120 +120 @@
 static void __run_thread(processor * this, $thread * dst);
 static $thread * __halt(processor * this);
-static bool __wake_one(cluster * cltr);
+static bool __wake_one(cluster * cltr, bool was_empty);
 static bool __wake_proc(processor *);
 
@@ -197 +197 @@
         self_mon.recursion = 1;
         self_mon_p = &self_mon;
-        link.next = 0p;
-        link.prev = 0p;
+        next = 0p;
 
         node.next = 0p;
@@ -224 +223 @@
         this.name = name;
         this.cltr = &cltr;
-        id = -1u;
         terminated{ 0 };
         destroyer = 0p;
@@ -262 +260 @@
         this.preemption_rate = preemption_rate;
         ready_queue{};
-        ready_lock{};
+        ready_queue_lock{};
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -297 +295 @@
         __cfadbg_print_safe(runtime_core, "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 = doregister2(this->cltr, this);
-                ready_queue_grow( this->cltr );
-        }
-
         doregister(this->cltr, this);
 
@@ -326 +318 @@
                                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
                                 /* paranoid */ verifyf( readyThread->state == Ready || readyThread->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", readyThread->state, readyThread->preempted);
-                                /* paranoid */ verifyf( readyThread->link.next == 0p, "Expected null got %p", readyThread->link.next );
+                                /* paranoid */ verifyf( readyThread->next == 0p, "Expected null got %p", readyThread->next );
 
                                 // We found a thread run it
@@ -342 +334 @@
         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 );
-                unregister2(this->cltr, this);
-        }
-        else {
-                // HACK : the coroutine context switch expects this_thread to be set
-                // and it make sense for it to be set in all other cases except here
-                // fake it
-                kernelTLS.this_thread = mainThread;
-        }
-
         __cfadbg_print_safe(runtime_core, "Kernel : core %p terminated\n", this);
 
-        stats_tls_tally(this->cltr);
+        // HACK : the coroutine context switch expects this_thread to be set
+        // and it make sense for it to be set in all other cases except here
+        // fake it
+        if( this == mainProcessor ) kernelTLS.this_thread = mainThread;
 }
 
@@ -608 +591 @@
 // Scheduler routines
 // KERNEL ONLY
-void __schedule_thread( $thread * thrd ) {
-        /* paranoid */ verify( thrd );
-        /* paranoid */ verify( thrd->state != Halted );
+void __schedule_thread( $thread * thrd ) with( *thrd->curr_cluster ) {
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
-        /* paranoid */  if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
-                                        "Error inactive thread marked as preempted, state %d, preemption %d\n", thrd->state, thrd->preempted );
-        /* paranoid */  if( thrd->preempted != __NO_PREEMPTION ) assertf(thrd->state == Active || thrd->state == Rerun,
-                                        "Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
+        /* paranoid */ if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
+                          "Error inactive thread marked as preempted, state %d, preemption %d\n", thrd->state, thrd->preempted );
+        /* paranoid */ if( thrd->preempted != __NO_PREEMPTION ) assertf(thrd->state == Active || thrd->state == Rerun,
+                          "Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
         /* paranoid */ #endif
-        /* paranoid */ verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
+        /* paranoid */ verifyf( thrd->next == 0p, "Expected null got %p", thrd->next );
 
         if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
 
-        ready_schedule_lock(thrd->curr_cluster, kernelTLS.this_processor);
-                push( thrd->curr_cluster, thrd );
-
-                __wake_one(thrd->curr_cluster);
-        ready_schedule_unlock(thrd->curr_cluster, kernelTLS.this_processor);
+        lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+        bool was_empty = !(ready_queue != 0);
+        append( ready_queue, thrd );
+        unlock( ready_queue_lock );
+
+        __wake_one(thrd->curr_cluster, was_empty);
 
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -635 +617 @@
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
-        ready_schedule_lock(this, kernelTLS.this_processor);
-                $thread * head = pop( this );
-        ready_schedule_unlock(this, kernelTLS.this_processor);
+        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
+        $thread * head = pop_head( ready_queue );
+        unlock( ready_queue_lock );
 
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -721 +703 @@
         // If that is the case, abandon the preemption.
         bool preempted = false;
-        if(thrd->link.next == 0p) {
+        if(thrd->next == 0p) {
                 preempted = true;
                 thrd->preempted = reason;
@@ -781 +763 @@
                 pending_preemption = false;
                 kernel_thread = pthread_self();
-                id = -1u;
 
                 runner{ &this };
@@ -791 +772 @@
         mainProcessor = (processor *)&storage_mainProcessor;
         (*mainProcessor){};
-
-        mainProcessor->id = doregister2(mainCluster, mainProcessor);
 
         //initialize the global state variables
@@ -847 +826 @@
         kernel_stop_preemption();
 
-        unregister2(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 ){
                 /* paranoid */ verify( this.do_terminate == true );
-                __cfaabi_dbg_print_safe("Kernel : destroyed main processor context %p\n", &runner);
         }
 
@@ -859 +835 @@
 
         // Final step, destroy the main thread since it is no longer needed
-
         // Since we provided a stack to this taxk it will not destroy anything
         /* paranoid */ verify(mainThread->self_cor.stack.storage == (__stack_t*)(((uintptr_t)&storage_mainThreadCtx)| 0x1));
@@ -912 +887 @@
 
 // Wake a thread from the front if there are any
-static bool __wake_one(cluster * this) {
+static bool __wake_one(cluster * this, __attribute__((unused)) bool force) {
+        // if we don't want to force check if we know it's false
+        // if( !this->idles.head && !force ) return false;
+
         // First, lock the cluster idle
         lock( this->idle_lock __cfaabi_dbg_ctx2 );