Changes in libcfa/src/concurrency/kernel.cfa [431cd4f:ec43cf9]

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -113 +113 @@
 static void __wake_one(cluster * cltr);
 
-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 );
+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 );
 
 extern void __cfa_io_start( processor * );
@@ -189 +189 @@
 
                                 // Push self to idle stack
-                                mark_idle(this->cltr->procs, * this);
+                                push(this->cltr->idles, * this);
 
                                 // Confirm the ready-queue is empty
@@ -195 +195 @@
                                 if( readyThread ) {
                                         // A thread was found, cancel the halt
-                                        mark_awake(this->cltr->procs, * this);
+                                        remove(this->cltr->idles, * this);
 
                                         #if !defined(__CFA_NO_STATISTICS__)
@@ -225 +225 @@
 
                                 // We were woken up, remove self from idle
-                                mark_awake(this->cltr->procs, * this);
+                                remove(this->cltr->idles, * this);
 
                                 // DON'T just proceed, start looking again
@@ -359 +359 @@
                                 #if !defined(__CFA_NO_STATISTICS__)
                                         __tls_stats()->ready.threads.threads++;
-                                        __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", this );
                                 #endif
                                 // This is case 2, the racy case, someone tried to run this thread before it finished blocking
@@ -377 +376 @@
         #if !defined(__CFA_NO_STATISTICS__)
                 __tls_stats()->ready.threads.threads--;
-                __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", this );
         #endif
 
@@ -457 +455 @@
                 if( kernelTLS().this_stats ) {
                         __tls_stats()->ready.threads.threads++;
-                        __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", kernelTLS().this_processor );
                 }
                 else {
                         __atomic_fetch_add(&cl->stats->ready.threads.threads, 1, __ATOMIC_RELAXED);
-                        __push_stat( cl->stats, cl->stats->ready.threads.threads, true, "Cluster", cl );
                 }
         #endif
@@ -474 +470 @@
 
         ready_schedule_lock();
-                $thread * thrd = pop_fast( this );
+                $thread * thrd = pop( this );
         ready_schedule_unlock();
 
@@ -617 +613 @@
         unsigned idle;
         unsigned total;
-        [idle, total, p] = query_idles(this->procs);
+        [idle, total, p] = query(this->idles);
 
         // If no one is sleeping, we are done
@@ -654 +650 @@
 }
 
-static void mark_idle(__cluster_proc_list & this, processor & proc) {
+static void push  (__cluster_idles & this, processor & proc) {
         /* paranoid */ verify( ! __preemption_enabled() );
         lock( this );
                 this.idle++;
                 /* paranoid */ verify( this.idle <= this.total );
-                remove(proc);
-                insert_first(this.idles, proc);
+
+                insert_first(this.list, proc);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
 }
 
-static void mark_awake(__cluster_proc_list & this, processor & proc) {
+static void remove(__cluster_idles & this, processor & proc) {
         /* paranoid */ verify( ! __preemption_enabled() );
         lock( this );
                 this.idle--;
                 /* paranoid */ verify( this.idle >= 0 );
+
                 remove(proc);
-                insert_last(this.actives, proc);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
 }
 
-static [unsigned idle, unsigned total, * processor] query_idles( & __cluster_proc_list this ) {
-        /* paranoid */ verify( ! __preemption_enabled() );
-        /* paranoid */ verify( ready_schedule_islocked() );
-
+static [unsigned idle, unsigned total, * processor] query( & __cluster_idles this ) {
         for() {
                 uint64_t l = __atomic_load_n(&this.lock, __ATOMIC_SEQ_CST);
@@ -685 +678 @@
                 unsigned idle    = this.idle;
                 unsigned total   = this.total;
-                processor * proc = &this.idles`first;
+                processor * proc = &this.list`first;
                 // Compiler fence is unnecessary, but gcc-8 and older incorrectly reorder code without it
                 asm volatile("": : :"memory");
@@ -691 +684 @@
                 return [idle, total, proc];
         }
-
-        /* paranoid */ verify( ready_schedule_islocked() );
-        /* paranoid */ verify( ! __preemption_enabled() );
 }