Changeset 504a7dc for libcfa/src/concurrency/kernel.cfa

Timestamp:

May 12, 2020, 1:32:45 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

4fa44e7

Parents:

6a490b2

Message:

Some fixes after the merge, compiles but still has livelocks

File:

• libcfa/src/concurrency/kernel.cfa (modified) (12 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, bool was_empty);
+static bool __wake_one(cluster * cltr);
 static bool __wake_proc(processor *);
 
@@ -299 +299 @@
         // 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);
+                this->id = doregister2(this->cltr, this);
                 ready_queue_grow( this->cltr );
         }
 
+        doregister(this->cltr, this);
 
         {
@@ -325 +326 @@
                                 /* 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->next == 0p, "Expected null got %p", readyThread->next );
+                                /* paranoid */ verifyf( readyThread->link.next == 0p, "Expected null got %p", readyThread->link.next );
 
                                 // We found a thread run it
@@ -337 +338 @@
         }
 
+        unregister(this->cltr, this);
+
         V( this->terminated );
 
@@ -342 +345 @@
         if(this != mainProcessor) {
                 ready_queue_shrink( this->cltr );
-                unregister(this->cltr, this);
+                unregister2(this->cltr, this);
         }
         else {
@@ -610 +613 @@
         /* 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 );
@@ -620 +623 @@
 
         ready_schedule_lock(thrd->curr_cluster, kernelTLS.this_processor);
-                bool was_empty = push( thrd->curr_cluster, thrd );
+                push( thrd->curr_cluster, thrd );
+
+                __wake_one(thrd->curr_cluster);
         ready_schedule_unlock(thrd->curr_cluster, kernelTLS.this_processor);
-
-        __wake_one(thrd->curr_cluster, was_empty);
 
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -718 +721 @@
         // If that is the case, abandon the preemption.
         bool preempted = false;
-        if(thrd->next == 0p) {
+        if(thrd->link.next == 0p) {
                 preempted = true;
                 thrd->preempted = reason;
@@ -789 +792 @@
         (*mainProcessor){};
 
-        mainProcessor->id = doregister(mainCluster, mainProcessor);
+        mainProcessor->id = doregister2(mainCluster, mainProcessor);
 
         //initialize the global state variables
@@ -844 +847 @@
         kernel_stop_preemption();
 
-        unregister(mainCluster, mainProcessor);
+        unregister2(mainCluster, mainProcessor);
 
         // Destroy the main processor and its context in reverse order of construction
@@ -909 +912 @@
 
 // Wake a thread from the front if there are any
-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;
-
+static bool __wake_one(cluster * this) {
         // First, lock the cluster idle
         lock( this->idle_lock __cfaabi_dbg_ctx2 );
@@ -1099 +1099 @@
         cltr->nthreads -= 1;
         unlock(cltr->thread_list_lock);
+}
+
+void doregister( cluster * cltr, processor * proc ) {
+        lock      (cltr->idle_lock __cfaabi_dbg_ctx2);
+        cltr->nprocessors += 1;
+        push_front(cltr->procs, *proc);
+        unlock    (cltr->idle_lock);
+}
+
+void unregister( cluster * cltr, processor * proc ) {
+        lock  (cltr->idle_lock __cfaabi_dbg_ctx2);
+        remove(cltr->procs, *proc );
+        cltr->nprocessors -= 1;
+        unlock(cltr->idle_lock);
 }