Changeset f681823

Timestamp:

Jan 26, 2022, 12:14:23 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

376c632a

Parents:

c26b98c4 (diff), 97fed44 (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

Files:

• libcfa/src/concurrency/kernel.cfa (modified) (7 diffs)
• libcfa/src/concurrency/kernel.hfa (modified) (3 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (2 diffs)
• libcfa/src/concurrency/mutex_stmt.hfa (modified) (1 diff)
• libcfa/src/concurrency/stats.cfa (modified) (3 diffs)
• libcfa/src/concurrency/stats.hfa (modified) (1 diff)
• tests/concurrent/mutexstmt/.expect/locks.txt (modified) (1 diff)
• tests/concurrent/mutexstmt/locks.cfa (modified) (3 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -205 +205 @@
                                 // Don't block if we are done
                                 if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
-
-                                #if !defined(__CFA_NO_STATISTICS__)
-                                        __tls_stats()->ready.sleep.halts++;
-                                #endif
 
                                 // Push self to idle stack
@@ -732 +728 @@
 // Wake a thread from the front if there are any
 static void __wake_one(cluster * this) {
+        eventfd_t val;
+
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verify( ready_schedule_islocked() );
 
         // Check if there is a sleeping processor
-        // int fd = __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST);
-        int fd = 0;
-        if( __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST) != 0 ) {
-                fd = __atomic_exchange_n(&this->procs.fd, 0, __ATOMIC_RELAXED);
-        }
-
-        // If no one is sleeping, we are done
-        if( fd == 0 ) return;
-
-        // We found a processor, wake it up
-        eventfd_t val;
-        val = 1;
-        eventfd_write( fd, val );
-
-        #if !defined(__CFA_NO_STATISTICS__)
-                if( kernelTLS().this_stats ) {
-                        __tls_stats()->ready.sleep.wakes++;
-                }
-                else {
-                        __atomic_fetch_add(&this->stats->ready.sleep.wakes, 1, __ATOMIC_RELAXED);
-                }
-        #endif
+        struct __fd_waitctx * fdp = __atomic_load_n(&this->procs.fdw, __ATOMIC_SEQ_CST);
+
+        // If no one is sleeping: we are done
+        if( fdp == 0p ) return;
+
+        int fd = 1;
+        if( __atomic_load_n(&fdp->fd, __ATOMIC_SEQ_CST) != 1 ) {
+                fd = __atomic_exchange_n(&fdp->fd, 1, __ATOMIC_RELAXED);
+        }
+
+        switch(fd) {
+        case 0:
+                // If the processor isn't ready to sleep then the exchange will already wake it up
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if( kernelTLS().this_stats ) { __tls_stats()->ready.sleep.early++;
+                        } else { __atomic_fetch_add(&this->stats->ready.sleep.early, 1, __ATOMIC_RELAXED); }
+                #endif
+                break;
+        case 1:
+                // If someone else already said they will wake them: we are done
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if( kernelTLS().this_stats ) { __tls_stats()->ready.sleep.seen++;
+                        } else { __atomic_fetch_add(&this->stats->ready.sleep.seen, 1, __ATOMIC_RELAXED); }
+                #endif
+                break;
+        default:
+                // If the processor was ready to sleep, we need to wake it up with an actual write
+                val = 1;
+                eventfd_write( fd, val );
+
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if( kernelTLS().this_stats ) { __tls_stats()->ready.sleep.wakes++;
+                        } else { __atomic_fetch_add(&this->stats->ready.sleep.wakes, 1, __ATOMIC_RELAXED); }
+                #endif
+                break;
+        }
 
         /* paranoid */ verify( ready_schedule_islocked() );
@@ -770 +782 @@
 
         __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
+
+        this->idle_wctx.fd = 1;
 
         eventfd_t val;
@@ -779 +793 @@
 
 static void idle_sleep(processor * this, io_future_t & future, iovec & iov) {
+        // Tell everyone we are ready to go do sleep
+        for() {
+                int expected = this->idle_wctx.fd;
+
+                // Someone already told us to wake-up! No time for a nap.
+                if(expected == 1) { return; }
+
+                // Try to mark that we are going to sleep
+                if(__atomic_compare_exchange_n(&this->idle_wctx.fd, &expected, this->idle_fd, false,  __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ) {
+                        // Every one agreed, taking a nap
+                        break;
+                }
+        }
+
+
         #if !defined(CFA_WITH_IO_URING_IDLE)
                 #if !defined(__CFA_NO_STATISTICS__)
@@ -825 +854 @@
 
 static bool mark_idle(__cluster_proc_list & this, processor & proc) {
+        #if !defined(__CFA_NO_STATISTICS__)
+                __tls_stats()->ready.sleep.halts++;
+        #endif
+
+        proc.idle_wctx.fd = 0;
+
         /* paranoid */ verify( ! __preemption_enabled() );
         if(!try_lock( this )) return false;
@@ -832 +867 @@
                 insert_first(this.idles, proc);
 
-                __atomic_store_n(&this.fd, proc.idle_fd, __ATOMIC_SEQ_CST);
+                __atomic_store_n(&this.fdw, &proc.idle_wctx, __ATOMIC_SEQ_CST);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -848 +883 @@
 
                 {
-                        int fd = 0;
-                        if(!this.idles`isEmpty) fd = this.idles`first.idle_fd;
-                        __atomic_store_n(&this.fd, fd, __ATOMIC_SEQ_CST);
+                        struct __fd_waitctx * wctx = 0;
+                        if(!this.idles`isEmpty) wctx = &this.idles`first.idle_wctx;
+                        __atomic_store_n(&this.fdw, wctx, __ATOMIC_SEQ_CST);
                 }
 

libcfa/src/concurrency/kernel.hfa

@@ -53 +53 @@
 coroutine processorCtx_t {
         struct processor * proc;
+};
+
+
+struct __fd_waitctx {
+        volatile int fd;
 };
 
@@ -101 +106 @@
         int idle_fd;
 
+        // Idle waitctx
+        struct __fd_waitctx idle_wctx;
+
         // Termination synchronisation (user semaphore)
         oneshot terminated;
@@ -207 +215 @@
 
         // FD to use to wake a processor
-        volatile int fd;
+        struct __fd_waitctx * volatile fdw;
 
         // Total number of processors

libcfa/src/concurrency/kernel/startup.cfa

@@ -537 +537 @@
         }
 
+        this.idle_wctx.fd = 0;
+
+        // I'm assuming these two are reserved for standard input and output
+        // so I'm using them as sentinels with idle_wctx.
+        /* paranoid */ verify( this.idle_fd != 0 );
+        /* paranoid */ verify( this.idle_fd != 1 );
+
         #if !defined(__CFA_NO_STATISTICS__)
                 print_stats = 0;
@@ -590 +597 @@
 // Cluster
 static void ?{}(__cluster_proc_list & this) {
-        this.fd    = 0;
+        this.fdw   = 0p;
         this.idle  = 0;
         this.total = 0;

libcfa/src/concurrency/mutex_stmt.hfa

@@ -38 +38 @@
     }
 
+    struct scoped_lock {
+        L * internal_lock;
+    };
+
+    static inline void ?{}( scoped_lock(L) & this, L & internal_lock ) {
+        this.internal_lock = &internal_lock;
+        lock(internal_lock);
+    }
+    
+    static inline void ^?{}( scoped_lock(L) & this ) with(this) {
+        unlock(*internal_lock);
+    }
+
     static inline L * __get_ptr( L & this ) {
         return &this;

libcfa/src/concurrency/stats.cfa

@@ -31 +31 @@
                 stats->ready.sleep.halts   = 0;
                 stats->ready.sleep.cancels = 0;
+                stats->ready.sleep.early   = 0;
                 stats->ready.sleep.wakes   = 0;
+                stats->ready.sleep.seen    = 0;
                 stats->ready.sleep.exits   = 0;
 
@@ -91 +93 @@
                 tally_one( &cltr->ready.sleep.halts       , &proc->ready.sleep.halts        );
                 tally_one( &cltr->ready.sleep.cancels     , &proc->ready.sleep.cancels      );
+                tally_one( &cltr->ready.sleep.early       , &proc->ready.sleep.early        );
                 tally_one( &cltr->ready.sleep.wakes       , &proc->ready.sleep.wakes        );
+                tally_one( &cltr->ready.sleep.seen        , &proc->ready.sleep.wakes        );
                 tally_one( &cltr->ready.sleep.exits       , &proc->ready.sleep.exits        );
 
@@ -153 +157 @@
                              | " (" | eng3(ready.pop.search.attempt) | " try)";
 
-                        sstr | "- Idle Slp : " | eng3(ready.sleep.halts) | "halt," | eng3(ready.sleep.cancels) | "cancel," | eng3(ready.sleep.wakes) | "wake," | eng3(ready.sleep.exits) | "exit";
+                        sstr | "- Idle Slp : " | eng3(ready.sleep.halts) | "halt," | eng3(ready.sleep.cancels) | "cancel,"
+                             | eng3(ready.sleep.wakes + ready.sleep.early) | '(' | eng3(ready.sleep.early) | ',' | eng3(ready.sleep.seen) | ')' | " wake(early, seen),"
+                             | eng3(ready.sleep.exits) | "exit";
                         sstr | nl;
                 }

libcfa/src/concurrency/stats.hfa

@@ -69 +69 @@
                         volatile uint64_t halts;
                         volatile uint64_t cancels;
+                        volatile uint64_t early;
                         volatile uint64_t wakes;
+                        volatile uint64_t seen;
                         volatile uint64_t exits;
                 } sleep;

tests/concurrent/mutexstmt/.expect/locks.txt

@@ -3 +3 @@
 Start Test: multi lock deadlock/mutual exclusion
 End Test: multi lock deadlock/mutual exclusion
+Start Test: single scoped lock mutual exclusion
+End Test: single scoped lock mutual exclusion
+Start Test: multi scoped lock deadlock/mutual exclusion
+End Test: multi scoped lock deadlock/mutual exclusion

tests/concurrent/mutexstmt/locks.cfa

@@ -59 +59 @@
 }
 
+thread T_Mutex_Scoped {};
 
+void main( T_Mutex_Scoped & this ) {
+        for (unsigned int i = 0; i < num_times; i++) {
+                {
+                        scoped_lock(single_acquisition_lock) s{m1};
+                        count++;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s{m1};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+        }
+}
+
+thread T_Multi_Scoped {};
+
+void main( T_Multi_Scoped & this ) {
+        for (unsigned int i = 0; i < num_times; i++) {
+                {
+                        scoped_lock(single_acquisition_lock) s{m1};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s1{m1};
+                        scoped_lock(single_acquisition_lock) s2{m2};
+                        scoped_lock(single_acquisition_lock) s3{m3};
+                        scoped_lock(single_acquisition_lock) s4{m4};
+                        scoped_lock(single_acquisition_lock) s5{m5};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s1{m1};
+                        scoped_lock(single_acquisition_lock) s3{m3};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s1{m1};
+                        scoped_lock(single_acquisition_lock) s2{m2};
+                        scoped_lock(single_acquisition_lock) s4{m4};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s1{m1};
+                        scoped_lock(single_acquisition_lock) s3{m3};
+                        scoped_lock(single_acquisition_lock) s4{m4};
+                        scoped_lock(single_acquisition_lock) s5{m5};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+        }
+}
+
+int num_tasks = 10;
 int main() {
         processor p[10];
@@ -67 +137 @@
                 T_Mutex t[10];
         }
+        assert(count == num_tasks * num_times);
         printf("End Test: single lock mutual exclusion\n");
         printf("Start Test: multi lock deadlock/mutual exclusion\n");
@@ -73 +144 @@
         }
         printf("End Test: multi lock deadlock/mutual exclusion\n");
+        
+        count = 0;
+        printf("Start Test: single scoped lock mutual exclusion\n");
+        {
+                T_Mutex_Scoped t[10];
+        }
+        assert(count == num_tasks * num_times);
+        printf("End Test: single scoped lock mutual exclusion\n");
+        printf("Start Test: multi scoped lock deadlock/mutual exclusion\n");
+        {
+                T_Multi_Scoped t[10];
+        }
+        printf("End Test: multi scoped lock deadlock/mutual exclusion\n");      
 }