Changeset cc287800 for libcfa/src/concurrency

Timestamp:

Nov 8, 2021, 5:28:21 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

36a05d7

Parents:

949339b (diff), 5ee153d (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:

• io.cfa (modified) (2 diffs)
• io/types.hfa (modified) (1 diff)
• kernel.cfa (modified) (6 diffs)
• kernel/startup.cfa (modified) (2 diffs)
• monitor.hfa (modified) (1 diff)
• mutex_stmt.hfa (modified) (1 diff)

libcfa/src/concurrency/io.cfa

@@ -183 +183 @@
                 ctx.proc->io.pending = false;
 
-                ready_schedule_lock();
                 __cfa_io_drain( proc );
-                ready_schedule_unlock();
                 // for(i; 2) {
                 //      unsigned idx = proc->rdq.id + i;
@@ -311 +309 @@
                 // Make the sqes visible to the submitter
                 __atomic_store_n(sq.kring.tail, tail + have, __ATOMIC_RELEASE);
-                sq.to_submit++;
+                sq.to_submit += have;
 
                 ctx->proc->io.pending = true;
                 ctx->proc->io.dirty   = true;
                 if(sq.to_submit > 30 || !lazy) {
+                        ready_schedule_lock();
                         __cfa_io_flush( ctx->proc );
+                        ready_schedule_unlock();
                 }
         }

libcfa/src/concurrency/io/types.hfa

@@ -188 +188 @@
                 return wait(this.self);
         }
+
+        void reset( io_future_t & this ) {
+                return reset(this.self);
+        }
 }

libcfa/src/concurrency/kernel.cfa

@@ -196 +196 @@
 
                         if( !readyThread ) {
+                                ready_schedule_lock();
                                 __cfa_io_flush( this );
+                                ready_schedule_unlock();
+
                                 readyThread = __next_thread_slow( this->cltr );
                         }
@@ -277 +280 @@
 
                         if(this->io.pending && !this->io.dirty) {
+                                ready_schedule_lock();
                                 __cfa_io_flush( this );
+                                ready_schedule_unlock();
                         }
 
@@ -317 +322 @@
 
                                 // Don't block if we are done
-                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
+                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
+                                        ready_schedule_unlock();
+                                        break MAIN_LOOP;
+                                }
 
                                 __STATS( __tls_stats()->ready.sleep.halts++; )
@@ -939 +947 @@
                         /* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
                         /* paranoid */ verify( it->local_data->this_stats );
+                        // __print_stats( it->local_data->this_stats, cltr->print_stats, "Processor", it->name, (void*)it );
                         __tally_stats( cltr->stats, it->local_data->this_stats );
                         it = &(*it)`next;
@@ -948 +957 @@
                 // this doesn't solve all problems but does solve many
                 // so it's probably good enough
+                disable_interrupts();
                 uint_fast32_t last_size = ready_mutate_lock();
 
@@ -955 +965 @@
                 // Unlock the RWlock
                 ready_mutate_unlock( last_size );
+                enable_interrupts();
         }
 

libcfa/src/concurrency/kernel/startup.cfa

@@ -100 +100 @@
 // Other Forward Declarations
 extern void __wake_proc(processor *);
+extern int cfa_main_returned;                                                   // from interpose.cfa
 
 //-----------------------------------------------------------------------------
@@ -268 +269 @@
 
 static void __kernel_shutdown(void) {
+        if(!cfa_main_returned) return;
         /* paranoid */ verify( __preemption_enabled() );
         disable_interrupts();

libcfa/src/concurrency/monitor.hfa

@@ -65 +65 @@
         free( th );
 }
+
+static inline forall( T & | sized(T) | { void ^?{}( T & mutex ); } )
+void adelete( T arr[] ) {
+        if ( arr ) {                                                                            // ignore null
+                size_t dim = malloc_size( arr ) / sizeof( T );
+                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
+                        ^(arr[i]){};                                                            // run destructor
+                } // for
+                free( arr );
+        } // if
+} // adelete
 
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/mutex_stmt.hfa

@@ -1 +1 @@
 #include "bits/algorithm.hfa"
-#include <assert.h>
-#include "invoke.h"
-#include "stdlib.hfa"
-#include <stdio.h>
+#include "bits/defs.hfa"
 
 //-----------------------------------------------------------------------------