Changeset c60e5094

Timestamp:

Nov 19, 2021, 11:59:55 AM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

813dfd86, cd4c605

Parents:

3e417bf (diff), a633f6f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

libcfa/src/concurrency

Files:

• kernel.cfa (modified) (5 diffs)
• kernel.hfa (modified) (1 diff)
• kernel/startup.cfa (modified) (1 diff)
• kernel_private.hfa (modified) (3 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -126 +126 @@
 static bool 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 * );
@@ -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__)
@@ -813 +809 @@
                 remove(proc);
                 insert_first(this.idles, proc);
+
+                __atomic_store_n(&this.fd, proc.idle, __ATOMIC_SEQ_CST);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -826 +824 @@
                 remove(proc);
                 insert_last(this.actives, proc);
+
+                {
+                        int fd = 0;
+                        if(!this.idles`isEmpty) fd = this.idles`first.idle;
+                        __atomic_store_n(&this.fd, fd, __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 +893 @@
                 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;

libcfa/src/concurrency/kernel.hfa

@@ -195 +195 @@
 struct __cluster_proc_list {
         // Spin lock protecting the queue
-        volatile uint64_t lock;
+        __spinlock_t lock;
+
+        // FD to use to wake a processor
+        volatile int fd;
 
         // Total number of processors

libcfa/src/concurrency/kernel/startup.cfa

@@ -584 +584 @@
 // Cluster
 static void ?{}(__cluster_proc_list & this) {
-        this.lock  = 0;
+        this.fd    = 0;
         this.idle  = 0;
         this.total = 0;

libcfa/src/concurrency/kernel_private.hfa

@@ -268 +268 @@
         ready_schedule_lock();
 
-        // Simple counting lock, acquired, acquired by incrementing the counter
-        // to an odd number
-        for() {
-                uint64_t l = this.lock;
-                if(
-                        (0 == (l % 2))
-                        && __atomic_compare_exchange_n(&this.lock, &l, l + 1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
-                ) return;
-                Pause();
-        }
+        lock( this.lock __cfaabi_dbg_ctx2 );
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -289 +280 @@
         ready_schedule_lock();
 
-        // Simple counting lock, acquired, acquired by incrementing the counter
-        // to an odd number
-        uint64_t l = this.lock;
-        if(
-                (0 == (l % 2))
-                && __atomic_compare_exchange_n(&this.lock, &l, l + 1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
-        ) {
+        if(try_lock( this.lock __cfaabi_dbg_ctx2 )) {
                 // success
                 /* paranoid */ verify( ! __preemption_enabled() );
@@ -311 +296 @@
         /* paranoid */ verify( ! __preemption_enabled() );
 
-        /* paranoid */ verify( 1 == (this.lock % 2) );
-        // Simple couting lock, release by incrementing to an even number
-        __atomic_fetch_add( &this.lock, 1, __ATOMIC_SEQ_CST );
+        unlock(this.lock);
 
         // Release the global lock, which we acquired when locking