Changeset 90152a4 for libcfa/src/concurrency/monitor.cfa

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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' into cleanup-dtors

File:

• libcfa/src/concurrency/monitor.cfa (moved) (moved from src/libcfa/concurrency/monitor.c ) (41 diffs)

libcfa/src/concurrency/monitor.cfa

@@ -10 +10 @@
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul 31 14:59:05 2017
-// Update Count     : 3
+// Last Modified On : Fri Mar 30 14:30:26 2018
+// Update Count     : 9
 //
 
-#include "monitor"
-
-#include <stdlib>
+#include "monitor.hfa"
+
+#include <stdlib.hfa>
 #include <inttypes.h>
 
-#include "kernel_private.h"
-
-#include "bits/algorithms.h"
+#include "kernel_private.hfa"
+
+#include "bits/algorithm.hfa"
 
 //-----------------------------------------------------------------------------
@@ -53 +53 @@
 static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
 
-#ifndef __CFA_LOCK_NO_YIELD
-#define DO_LOCK lock_yield
-#else
-#define DO_LOCK lock
-#endif
-
 //-----------------------------------------------------------------------------
 // Useful defines
@@ -90 +84 @@
         static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
-                thread_desc * thrd = this_thread;
-
-                __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+                lock( this->lock __cfaabi_dbg_ctx2 );
+                // Interrupts disable inside critical section
+                thread_desc * thrd = kernelTLS.this_thread;
+
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
 
                 if( !this->owner ) {
@@ -99 +94 @@
                         set_owner( this, thrd );
 
-                        __cfaabi_dbg_print_safe("Kernel :  mon is free \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
                 }
                 else if( this->owner == thrd) {
@@ -105 +100 @@
                         this->recursion += 1;
 
-                        __cfaabi_dbg_print_safe("Kernel :  mon already owned \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
                 }
                 else if( is_accepted( this, group) ) {
@@ -114 +109 @@
                         reset_mask( this );
 
-                        __cfaabi_dbg_print_safe("Kernel :  mon accepts \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
                 }
                 else {
-                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
 
                         // Some one else has the monitor, wait in line for it
                         append( this->entry_queue, thrd );
+
                         BlockInternal( &this->lock );
 
-                        __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
+                        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
                         // BlockInternal will unlock spinlock, no need to unlock ourselves
@@ -129 +125 @@
                 }
 
-                __cfaabi_dbg_print_safe("Kernel : %10p Entered  mon %p\n", thrd, this);
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
                 // Release the lock and leave
@@ -138 +134 @@
         static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
-                thread_desc * thrd = this_thread;
-
-                __cfaabi_dbg_print_safe("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+                lock( this->lock __cfaabi_dbg_ctx2 );
+                // Interrupts disable inside critical section
+                thread_desc * thrd = kernelTLS.this_thread;
+
+                __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
 
 
                 if( !this->owner ) {
-                        __cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this);
+                        __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
 
                         // No one has the monitor, just take it
@@ -156 +153 @@
                         // We already have the monitor... but where about to destroy it so the nesting will fail
                         // Abort!
-                        abortf("Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.");
+                        abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
                 }
 
@@ -163 +160 @@
                 __monitor_group_t group = { &this, 1, func };
                 if( is_accepted( this, group) ) {
-                        __cfaabi_dbg_print_safe("Kernel :  mon accepts dtor, block and signal it \n");
+                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
 
                         // Wake the thread that is waiting for this
@@ -173 +170 @@
 
                         // Create the node specific to this wait operation
-                        wait_ctx_primed( this_thread, 0 )
+                        wait_ctx_primed( thrd, 0 )
 
                         // Some one else has the monitor, wait for him to finish and then run
@@ -182 +179 @@
                 }
                 else {
-                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
-
-                        wait_ctx( this_thread, 0 )
+                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+
+                        wait_ctx( thrd, 0 )
                         this->dtor_node = &waiter;
 
@@ -195 +192 @@
                 }
 
-                __cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this);
+                __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
 
         }
@@ -201 +198 @@
         // Leave single monitor
         void __leave_monitor_desc( monitor_desc * this ) {
-                // Lock the monitor spinlock, DO_LOCK to reduce contention
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
-
-                __cfaabi_dbg_print_safe("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
-
-                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
+                // Lock the monitor spinlock
+                lock( this->lock __cfaabi_dbg_ctx2 );
+
+                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
+
+                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -214 +211 @@
                 // it means we don't need to do anything
                 if( this->recursion != 0) {
-                        __cfaabi_dbg_print_safe("Kernel :  recursion still %d\n", this->recursion);
+                        __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
                         unlock( this->lock );
                         return;
@@ -232 +229 @@
         void __leave_dtor_monitor_desc( monitor_desc * this ) {
                 __cfaabi_dbg_debug_do(
-                        if( this_thread != this->owner ) {
-                                abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
+                        if( TL_GET( this_thread ) != this->owner ) {
+                                abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, TL_GET( this_thread ), this->owner);
                         }
                         if( this->recursion != 1 ) {
-                                abortf("Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                                abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
                         }
                 )
@@ -248 +245 @@
 
                 // Lock the monitor now
-                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
+                lock( this->lock __cfaabi_dbg_ctx2 );
 
                 disable_interrupts();
@@ -261 +258 @@
                 // If we haven't left the last level of recursion
                 // it must mean there is an error
-                if( this->recursion != 0) { abortf("Thread internal monitor has unbalanced recursion"); }
+                if( this->recursion != 0) { abort( "Thread internal monitor has unbalanced recursion" ); }
 
                 // Fetch the next thread, can be null
@@ -294 +291 @@
 // Sorts monitors before entering
 void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
+        thread_desc * thrd = TL_GET( this_thread );
+
         // Store current array
         this.m = m;
         this.count = count;
 
-        // Sort monitors based on address -> TODO use a sort specialized for small numbers
+        // Sort monitors based on address
         __libcfa_small_sort(this.m, count);
 
         // Save previous thread context
-        this.prev = this_thread->monitors;
+        this.prev = thrd->monitors;
 
         // Update thread context (needed for conditions)
-        (this_thread->monitors){m, count, func};
-
-        // __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count);
+        (thrd->monitors){m, count, func};
+
+        // __cfaabi_dbg_print_safe( "MGUARD : enter %d\n", count);
 
         // Enter the monitors in order
@@ -313 +312 @@
         enter( group );
 
-        // __cfaabi_dbg_print_safe("MGUARD : entered\n");
+        // __cfaabi_dbg_print_safe( "MGUARD : entered\n" );
 }
 
@@ -319 +318 @@
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
-        // __cfaabi_dbg_print_safe("MGUARD : leaving %d\n", this.count);
+        // __cfaabi_dbg_print_safe( "MGUARD : leaving %d\n", this.count);
 
         // Leave the monitors in order
         leave( this.m, this.count );
 
-        // __cfaabi_dbg_print_safe("MGUARD : left\n");
+        // __cfaabi_dbg_print_safe( "MGUARD : left\n" );
 
         // Restore thread context
-        this_thread->monitors = this.prev;
+        TL_GET( this_thread )->monitors = this.prev;
 }
 
@@ -333 +332 @@
 // Sorts monitors before entering
 void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
+        // optimization
+        thread_desc * thrd = TL_GET( this_thread );
+
         // Store current array
         this.m = *m;
 
         // Save previous thread context
-        this.prev = this_thread->monitors;
+        this.prev = thrd->monitors;
 
         // Update thread context (needed for conditions)
-        (this_thread->monitors){m, 1, func};
+        (thrd->monitors){m, 1, func};
 
         __enter_monitor_dtor( this.m, func );
@@ -351 +353 @@
 
         // Restore thread context
-        this_thread->monitors = this.prev;
+        TL_GET( this_thread )->monitors = this.prev;
 }
 
@@ -363 +365 @@
 }
 
-void ?{}(__condition_criterion_t & this ) {
-        this.ready  = false;
-        this.target = NULL;
-        this.owner  = NULL;
-        this.next   = NULL;
+void ?{}(__condition_criterion_t & this ) with( this ) {
+        ready  = false;
+        target = NULL;
+        owner  = NULL;
+        next   = NULL;
 }
 
@@ -391 +393 @@
 
         // Create the node specific to this wait operation
-        wait_ctx( this_thread, user_info );
+        wait_ctx( TL_GET( this_thread ), user_info );
 
         // Append the current wait operation to the ones already queued on the condition
@@ -430 +432 @@
         //Some more checking in debug
         __cfaabi_dbg_debug_do(
-                thread_desc * this_thrd = this_thread;
+                thread_desc * this_thrd = TL_GET( this_thread );
                 if ( this.monitor_count != this_thrd->monitors.size ) {
-                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", &this, this.monitor_count, this_thrd->monitors.size );
+                        abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size );
                 }
 
                 for(int i = 0; i < this.monitor_count; i++) {
                         if ( this.monitors[i] != this_thrd->monitors[i] ) {
-                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors[i] );
+                                abort( "Signal on condition %p made with different monitor, expected %p got %p", &this, this.monitors[i], this_thrd->monitors[i] );
                         }
                 }
@@ -476 +478 @@
         lock_all( monitors, locks, count );
 
+
         // Create the node specific to this wait operation
-        wait_ctx_primed( this_thread, 0 )
+        wait_ctx_primed( kernelTLS.this_thread, 0 )
 
         //save contexts
@@ -534 +537 @@
         __lock_size_t actual_count = aggregate( mon_storage, mask );
 
-        __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
+        __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %"PRIdFAST16" (s: %"PRIdFAST16", m: %"PRIdFAST16")\n", actual_count, mask.size, (__lock_size_t)max);
 
         if(actual_count == 0) return;
 
-        __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n");
+        __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n" );
 
         // Create storage for monitor context
@@ -555 +558 @@
                         __acceptable_t& accepted = mask[index];
                         if( accepted.is_dtor ) {
-                                __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n");
+                                __cfaabi_dbg_print_buffer_local( "Kernel : dtor already there\n" );
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
@@ -567 +570 @@
                         }
                         else {
-                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n");
+                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, baton-passing\n" );
 
                                 // Create the node specific to this wait operation
-                                wait_ctx_primed( this_thread, 0 );
+                                wait_ctx_primed( kernelTLS.this_thread, 0 );
 
                                 // Save monitor states
                                 monitor_save;
 
-                                __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %d monitors : ", count );
+                                __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %"PRIdFAST16" monitors : ", count );
                                 #ifdef __CFA_DEBUG_PRINT__
                                         for( int i = 0; i < count; i++) {
@@ -581 +584 @@
                                         }
                                 #endif
-                                __cfaabi_dbg_print_buffer_local( "\n");
+                                __cfaabi_dbg_print_buffer_local( "\n" );
 
                                 // Set the owners to be the next thread
@@ -592 +595 @@
                                 monitor_restore;
 
-                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n");
+                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n" );
                         }
 
@@ -602 +605 @@
 
         if( duration == 0 ) {
-                __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n");
+                __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n" );
 
                 unlock_all( locks, count );
@@ -611 +614 @@
 
 
-        verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
-
-        __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n");
+        verifyf( duration < 0, "Timeout on waitfor statments not supported yet." );
+
+        __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n" );
 
         // Create the node specific to this wait operation
-        wait_ctx_primed( this_thread, 0 );
+        wait_ctx_primed( kernelTLS.this_thread, 0 );
 
         monitor_save;
@@ -622 +625 @@
 
         for( __lock_size_t i = 0; i < count; i++) {
-                verify( monitors[i]->owner == this_thread );
+                verify( monitors[i]->owner == kernelTLS.this_thread );
         }
 
@@ -635 +638 @@
         monitor_restore;
 
-        __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n");
+        __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n" );
 
         __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
@@ -644 +647 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-        // __cfaabi_dbg_print_safe("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+        // __cfaabi_dbg_print_safe( "Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
 
         //Pass the monitor appropriately
@@ -676 +679 @@
 static inline thread_desc * next_thread( monitor_desc * this ) {
         //Check the signaller stack
-        __cfaabi_dbg_print_safe("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
+        __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
         __condition_criterion_t * urgent = pop( this->signal_stack );
         if( urgent ) {
@@ -737 +740 @@
 static inline void lock_all( __spinlock_t * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
-                DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );
+                lock( *locks[i] __cfaabi_dbg_ctx2 );
         }
 }
@@ -744 +747 @@
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
-                DO_LOCK( *l __cfaabi_dbg_ctx2 );
+                lock( *l __cfaabi_dbg_ctx2 );
                 if(locks) locks[i] = l;
         }
@@ -816 +819 @@
 
 static inline void brand_condition( condition & this ) {
-        thread_desc * thrd = this_thread;
+        thread_desc * thrd = TL_GET( this_thread );
         if( !this.monitors ) {
-                // __cfaabi_dbg_print_safe("Branding\n");
+                // __cfaabi_dbg_print_safe( "Branding\n" );
                 assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
                 this.monitor_count = thrd->monitors.size;