Changes in libcfa/src/concurrency/kernel.cfa [5f5a729:34b8cb7]

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -124 +124 @@
 static void __wake_one(cluster * cltr);
 
-static bool mark_idle (__cluster_proc_list & idles, processor & proc);
+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 * );
@@ -213 +212 @@
 
                                 // Push self to idle stack
-                                if(!mark_idle(this->cltr->procs, * this)) continue MAIN_LOOP;
+                                mark_idle(this->cltr->procs, * this);
 
                                 // Confirm the ready-queue is empty
@@ -331 +330 @@
                                 // Push self to idle stack
                                 ready_schedule_unlock();
-                                if(!mark_idle(this->cltr->procs, * this)) goto SEARCH;
+                                mark_idle(this->cltr->procs, * this);
                                 ready_schedule_lock();
 
@@ -766 +765 @@
 
         // Check if there is a sleeping processor
-        processor * p;
-        unsigned idle;
-        unsigned total;
-        [idle, total, p] = query_idles(this->procs);
+        int fd = __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST);
 
         // If no one is sleeping, we are done
-        if( idle == 0 ) return;
+        if( fd == 0 ) return;
 
         // We found a processor, wake it up
         eventfd_t val;
         val = 1;
-        eventfd_write( p->idle, val );
+        eventfd_write( fd, val );
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -806 +802 @@
 }
 
-static bool mark_idle(__cluster_proc_list & this, processor & proc) {
-        /* paranoid */ verify( ! __preemption_enabled() );
-        if(!try_lock( this )) return false;
+static void mark_idle(__cluster_proc_list & this, processor & proc) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        lock( this );
                 this.idle++;
                 /* paranoid */ verify( this.idle <= this.total );
                 remove(proc);
                 insert_first(this.idles, proc);
+
+                __atomic_store_n(&this.fd, proc.idle, __ATOMIC_SEQ_CST);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
-
-        return true;
 }
 
@@ -826 +822 @@
                 remove(proc);
                 insert_last(this.actives, proc);
+
+                __atomic_store_n(&this.fd, this.idles`first.idle, __ATOMIC_SEQ_CST);
         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() );
-
-        for() {
-                uint64_t l = __atomic_load_n(&this.lock, __ATOMIC_SEQ_CST);
-                if( 1 == (l % 2) ) { Pause(); continue; }
-                unsigned idle    = this.idle;
-                unsigned total   = this.total;
-                processor * proc = &this.idles`first;
-                // Compiler fence is unnecessary, but gcc-8 and older incorrectly reorder code without it
-                asm volatile("": : :"memory");
-                if(l != __atomic_load_n(&this.lock, __ATOMIC_SEQ_CST)) { Pause(); continue; }
-                return [idle, total, proc];
-        }
-
-        /* paranoid */ verify( ready_schedule_islocked() );
         /* paranoid */ verify( ! __preemption_enabled() );
 }
@@ -908 +886 @@
                 if(head == tail) return false;
                 #if OLD_MAIN
-                ready_schedule_lock();
-                ret = __cfa_io_drain( proc );
-                ready_schedule_unlock();
+                        ready_schedule_lock();
+                        ret = __cfa_io_drain( proc );
+                        ready_schedule_unlock();
                 #else
                         ret = __cfa_io_drain( proc );
-        #endif
+                #endif
         #endif
         return ret;