Changeset 6a9b12b

Timestamp:

Apr 14, 2021, 4:28:55 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

fc59b580

Parents:

a7504db

Message:

Incremental change towards having the cluster keep a list of active processors.

Location:

libcfa/src/concurrency

Files:

• kernel.cfa (modified) (10 diffs)
• kernel.hfa (modified) (3 diffs)
• kernel/startup.cfa (modified) (3 diffs)
• kernel_private.hfa (modified) (2 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -113 +113 @@
 static void __wake_one(cluster * cltr);
 
-static void push  (__cluster_idles & idles, processor & proc);
-static void remove(__cluster_idles & idles, processor & proc);
-static [unsigned idle, unsigned total, * processor] query( & __cluster_idles idles );
+static void mark_idle (__cluster_proc_list & idles, processor & proc);
+static void mark_awake(__cluster_proc_list & idles, processor & proc);
+static [unsigned idle, unsigned total, * processor] query_idles( & __cluster_proc_list idles );
 
 extern void __cfa_io_start( processor * );
@@ -189 +189 @@
 
                                 // Push self to idle stack
-                                push(this->cltr->idles, * this);
+                                mark_idle(this->cltr->procs, * this);
 
                                 // Confirm the ready-queue is empty
@@ -195 +195 @@
                                 if( readyThread ) {
                                         // A thread was found, cancel the halt
-                                        remove(this->cltr->idles, * this);
+                                        mark_awake(this->cltr->procs, * this);
 
                                         #if !defined(__CFA_NO_STATISTICS__)
@@ -225 +225 @@
 
                                 // We were woken up, remove self from idle
-                                remove(this->cltr->idles, * this);
+                                mark_awake(this->cltr->procs, * this);
 
                                 // DON'T just proceed, start looking again
@@ -617 +617 @@
         unsigned idle;
         unsigned total;
-        [idle, total, p] = query(this->idles);
+        [idle, total, p] = query_idles(this->procs);
 
         // If no one is sleeping, we are done
@@ -654 +654 @@
 }
 
-static void push  (__cluster_idles & this, processor & proc) {
+static void mark_idle(__cluster_proc_list & this, processor & proc) {
         /* paranoid */ verify( ! __preemption_enabled() );
         lock( this );
@@ -660 +660 @@
                 /* paranoid */ verify( this.idle <= this.total );
 
-                insert_first(this.list, proc);
+                insert_first(this.idles, proc);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
 }
 
-static void remove(__cluster_idles & this, processor & proc) {
+static void mark_awake(__cluster_proc_list & this, processor & proc) {
         /* paranoid */ verify( ! __preemption_enabled() );
         lock( this );
@@ -676 +676 @@
 }
 
-static [unsigned idle, unsigned total, * processor] query( & __cluster_idles this ) {
+static [unsigned idle, unsigned total, * processor] query_idles( & __cluster_proc_list this ) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        /* paranoid */ verify( ready_schedule_islocked() );
+
         for() {
                 uint64_t l = __atomic_load_n(&this.lock, __ATOMIC_SEQ_CST);
@@ -682 +685 @@
                 unsigned idle    = this.idle;
                 unsigned total   = this.total;
-                processor * proc = &this.list`first;
+                processor * proc = &this.idles`first;
                 // Compiler fence is unnecessary, but gcc-8 and older incorrectly reorder code without it
                 asm volatile("": : :"memory");
@@ -688 +691 @@
                 return [idle, total, proc];
         }
+
+        /* paranoid */ verify( ready_schedule_islocked() );
+        /* paranoid */ verify( ! __preemption_enabled() );
 }
 

libcfa/src/concurrency/kernel.hfa

@@ -180 +180 @@
 
 // Idle Sleep
-struct __cluster_idles {
+struct __cluster_proc_list {
         // Spin lock protecting the queue
         volatile uint64_t lock;
@@ -191 +191 @@
 
         // List of idle processors
-        dlist(processor, processor) list;
+        dlist(processor, processor) idles;
 };
 
@@ -207 +207 @@
 
         // List of idle processors
-        __cluster_idles idles;
+        __cluster_proc_list procs;
 
         // List of threads

libcfa/src/concurrency/kernel/startup.cfa

@@ -491 +491 @@
         // Register and Lock the RWlock so no-one pushes/pops while we are changing the queue
         uint_fast32_t last_size = ready_mutate_register((__processor_id_t*)&this);
-                int target = this.cltr->idles.total += 1u;
+                int target = this.cltr->procs.total += 1u;
 
                 // Adjust the ready queue size
@@ -506 +506 @@
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
         uint_fast32_t last_size = ready_mutate_lock();
-                int target = this.cltr->idles.total -= 1u;
+                int target = this.cltr->procs.total -= 1u;
 
                 // Adjust the ready queue size
@@ -555 +555 @@
 //-----------------------------------------------------------------------------
 // Cluster
-static void ?{}(__cluster_idles & this) {
+static void ?{}(__cluster_proc_list & this) {
         this.lock  = 0;
         this.idle  = 0;
         this.total = 0;
-        (this.list){};
 }
 

libcfa/src/concurrency/kernel_private.hfa

@@ -247 +247 @@
 //-----------------------------------------------------------------------
 // Cluster idle lock/unlock
-static inline void lock(__cluster_idles & this) {
+static inline void lock(__cluster_proc_list & this) {
         /* paranoid */ verify( ! __preemption_enabled() );
 
@@ -268 +268 @@
 }
 
-static inline void unlock(__cluster_idles & this) {
+static inline void unlock(__cluster_proc_list & this) {
         /* paranoid */ verify( ! __preemption_enabled() );