Changeset 5a40e4e for libcfa

Timestamp:

Sep 9, 2021, 3:56:32 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

d0b9247

Parents:

dd1cc02 (diff), d8d512e (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

Files:

• prelude/builtins.c (modified) (2 diffs)
• src/Makefile.am (modified) (5 diffs)
• src/concurrency/kernel/startup.cfa (modified) (2 diffs)
• src/concurrency/locks.hfa (modified) (2 diffs)
• src/concurrency/monitor.cfa (modified) (2 diffs)
• src/concurrency/monitor.hfa (modified) (2 diffs)
• src/concurrency/mutex_stmt.hfa (added)
• src/concurrency/thread.cfa (modified) (1 diff)
• src/containers/string.cfa (added)
• src/containers/string.hfa (added)
• src/containers/string_res.cfa (added)
• src/containers/string_res.hfa (added)
• src/fstream.cfa (modified) (2 diffs)
• src/heap.cfa (modified) (3 diffs)
• src/memory.cfa (modified) (1 diff)
• src/memory.hfa (modified) (1 diff)
• src/parseconfig.cfa (added)
• src/parseconfig.hfa (added)

libcfa/prelude/builtins.c

@@ -10 +10 @@
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jul 21 13:31:34 2021
-// Update Count     : 129
+// Last Modified On : Sat Aug 14 08:45:54 2021
+// Update Count     : 133
 //
 
@@ -107 +107 @@
 #endif // __SIZEOF_INT128__
 
+// for-control index constraints
+// forall( T | { void ?{}( T &, zero_t ); void ?{}( T &, one_t ); T ?+=?( T &, T ); T ?-=?( T &, T ); int ?<?( T, T ); } )
+// static inline T __for_control_index_constraints__( T t ) { return t; }
+
 // exponentiation operator implementation
 

libcfa/src/Makefile.am

@@ -48 +48 @@
         math.hfa \
         time_t.hfa \
+        bits/algorithm.hfa \
         bits/align.hfa \
         bits/containers.hfa \
@@ -77 +78 @@
         memory.hfa \
         parseargs.hfa \
+        parseconfig.hfa \
         rational.hfa \
         stdlib.hfa \
@@ -85 +87 @@
         containers/pair.hfa \
         containers/result.hfa \
+        containers/string.hfa \
+        containers/string_res.hfa \
         containers/vector.hfa \
         device/cpu.hfa
@@ -90 +94 @@
 libsrc = ${inst_headers_src} ${inst_headers_src:.hfa=.cfa} \
         assert.cfa \
-        bits/algorithm.hfa \
         bits/debug.cfa \
         exception.c \
@@ -106 +109 @@
         concurrency/invoke.h \
         concurrency/future.hfa \
-        concurrency/kernel/fwd.hfa
+        concurrency/kernel/fwd.hfa \
+        concurrency/mutex_stmt.hfa
 
 inst_thread_headers_src = \

libcfa/src/concurrency/kernel/startup.cfa

@@ -235 +235 @@
 
         register_tls( mainProcessor );
+        mainThread->last_cpu = __kernel_getcpu();
 
         //initialize the global state variables
@@ -478 +479 @@
         state = Start;
         self_cor{ info };
-        last_cpu = __kernel_getcpu();
         curr_cor = &self_cor;
         curr_cluster = mainCluster;

libcfa/src/concurrency/locks.hfa

@@ -324 +324 @@
         }
 
-        // linear backoff bounded by spin_count
-        spin = spin_start;
-        int spin_counter = 0;
-        int yield_counter = 0;
-        for ( ;; ) {
-                if(try_lock_contention(this)) return true;
-                if(spin_counter < spin_count) {
-                        for (int i = 0; i < spin; i++) Pause();
-                        if (spin < spin_end) spin += spin;
-                        else spin_counter++;
-                } else if (yield_counter < yield_count) {
-                        // after linear backoff yield yield_count times
-                        yield_counter++;
-                        yield();
-                } else { break; }
-        }
-
-        // block until signalled
-        while (block(this)) if(try_lock_contention(this)) return true;
-
-        // this should never be reached as block(this) always returns true
-        return false;
-}
-
-static inline bool lock_improved(linear_backoff_then_block_lock & this) with(this) {
-        // if owner just return
-        if (active_thread() == owner) return true;
-        size_t compare_val = 0;
-        int spin = spin_start;
-        // linear backoff
-        for( ;; ) {
-                compare_val = 0;
-                if (internal_try_lock(this, compare_val)) return true;
-                if (2 == compare_val) break;
-                for (int i = 0; i < spin; i++) Pause();
-                if (spin >= spin_end) break;
-                spin += spin;
-        }
-
-        // linear backoff bounded by spin_count
-        spin = spin_start;
-        int spin_counter = 0;
-        int yield_counter = 0;
-        for ( ;; ) {
-                compare_val = 0;
-                if(internal_try_lock(this, compare_val)) return true;
-                if (2 == compare_val) break;
-                if(spin_counter < spin_count) {
-                        for (int i = 0; i < spin; i++) Pause();
-                        if (spin < spin_end) spin += spin;
-                        else spin_counter++;
-                } else if (yield_counter < yield_count) {
-                        // after linear backoff yield yield_count times
-                        yield_counter++;
-                        yield();
-                } else { break; }
-        }
-
         if(2 != compare_val && try_lock_contention(this)) return true;
         // block until signalled
@@ -402 +344 @@
 static inline void on_notify(linear_backoff_then_block_lock & this, struct thread$ * t ) { unpark(t); }
 static inline size_t on_wait(linear_backoff_then_block_lock & this) { unlock(this); return 0; }
-static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock_improved(this); }
+static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock(this); }
 
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/monitor.cfa

@@ -367 +367 @@
 
         // __cfaabi_dbg_print_safe( "MGUARD : entered\n" );
+}
+
+void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count ) {
+        this{ m, count, 0p };
 }
 
@@ -986 +990 @@
 }
 
+//-----------------------------------------------------------------------------
+// Enter routine for mutex stmt
+// Can't be accepted since a mutex stmt is effectively an anonymous routine
+// Thus we do not need a monitor group
+void lock( monitor$ * this ) {
+        thread$ * thrd = active_thread();
+
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+
+        if( unlikely(0 != (0x1 & (uintptr_t)this->owner)) ) {
+                abort( "Attempt by thread \"%.256s\" (%p) to access joined monitor %p.", thrd->self_cor.name, thrd, this );
+        }
+        else if( !this->owner ) {
+                // No one has the monitor, just take it
+                __set_owner( this, thrd );
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
+        }
+        else if( this->owner == thrd) {
+                // We already have the monitor, just note how many times we took it
+                this->recursion += 1;
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
+        }
+        else {
+                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+
+                // Some one else has the monitor, wait in line for it
+                /* paranoid */ verify( thrd->link.next == 0p );
+                append( this->entry_queue, thrd );
+                /* paranoid */ verify( thrd->link.next == 1p );
+
+                unlock( this->lock );
+                park();
+
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+
+                /* paranoid */ verifyf( active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this );
+                return;
+        }
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
+
+        /* paranoid */ verifyf( active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this );
+        /* paranoid */ verify( this->lock.lock );
+
+        // Release the lock and leave
+        unlock( this->lock );
+        return;
+}
+
+// Leave routine for mutex stmt
+// Is just a wrapper around __leave for the is_lock trait to see
+void unlock( monitor$ * this ) { __leave( this ); }
+
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/monitor.hfa

@@ -48 +48 @@
 
 void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count );
 void ^?{}( monitor_guard_t & this );
 
@@ -148 +149 @@
 void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
 
+// lock and unlock routines for mutex statements to use
+void lock( monitor$ * this );
+void unlock( monitor$ * this );
+
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/thread.cfa

@@ -34 +34 @@
         preempted = __NO_PREEMPTION;
         corctx_flag = false;
+        disable_interrupts();
         last_cpu = __kernel_getcpu();
+        enable_interrupts();
         curr_cor = &self_cor;
         self_mon.owner = &this;

libcfa/src/fstream.cfa

@@ -124 +124 @@
 void open( ofstream & os, const char name[], const char mode[] ) {
         FILE * file = fopen( name, mode );
-        #ifdef __CFA_DEBUG__
+        // #ifdef __CFA_DEBUG__
         if ( file == 0p ) {
                 throw (Open_Failure){ os };
                 // abort | IO_MSG "open output file \"" | name | "\"" | nl | strerror( errno );
         } // if
-        #endif // __CFA_DEBUG__
+        // #endif // __CFA_DEBUG__
         (os){ file };
 } // open
@@ -262 +262 @@
 void open( ifstream & is, const char name[], const char mode[] ) {
         FILE * file = fopen( name, mode );
-        #ifdef __CFA_DEBUG__
+        // #ifdef __CFA_DEBUG__
         if ( file == 0p ) {
                 throw (Open_Failure){ is };
                 // abort | IO_MSG "open input file \"" | name | "\"" | nl | strerror( errno );
         } // if
-        #endif // __CFA_DEBUG__
+        // #endif // __CFA_DEBUG__
         is.file$ = file;
 } // open

libcfa/src/heap.cfa

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May 22 08:46:39 2021
-// Update Count     : 1036
+// Last Modified On : Mon Aug  9 19:03:02 2021
+// Update Count     : 1040
 //
 
@@ -102 +102 @@
 } // prtUnfreed
 
+extern int cfa_main_returned;                                                   // from bootloader.cf
 extern "C" {
         void heapAppStart() {                                                           // called by __cfaabi_appready_startup
@@ -109 +110 @@
         void heapAppStop() {                                                            // called by __cfaabi_appready_startdown
                 fclose( stdin ); fclose( stdout );
-                prtUnfreed();
+                if ( cfa_main_returned ) prtUnfreed();                  // do not check unfreed storage if exit called
         } // heapAppStop
 } // extern "C"

libcfa/src/memory.cfa

@@ -155 +155 @@
 
 forall(T &)
+T * release(unique_ptr(T) & this) {
+        T * data = this.data;
+        this.data = 0p;
+        return data;
+}
+
+forall(T &)
 int ?==?(unique_ptr(T) const & this, unique_ptr(T) const & that) {
         return this.data == that.data;

libcfa/src/memory.hfa

@@ -94 +94 @@
 
 forall(T &)
+T * release(unique_ptr(T) & this);
+
+forall(T &)
 int ?==?(unique_ptr(T) const & this, unique_ptr(T) const & that);
 forall(T &)