Changeset 6840e7c for src/libcfa/concurrency/monitor.c

Timestamp:

Oct 19, 2017, 12:01:04 PM (8 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:

837ce06

Parents:

b96ec83 (diff), a15b72c (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:

• src/libcfa/concurrency/monitor.c (modified) (18 diffs)

src/libcfa/concurrency/monitor.c

@@ -23 +23 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void set_owner( monitor_desc * this, thread_desc * owner );
-static inline void set_owner( monitor_desc ** storage, short count, thread_desc * owner );
-static inline void set_mask ( monitor_desc ** storage, short count, const __waitfor_mask_t & mask );
+static inline void set_owner ( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc ** storage, short count, thread_desc * owner );
+static inline void set_mask  ( monitor_desc ** storage, short count, const __waitfor_mask_t & mask );
+static inline void reset_mask( monitor_desc * this );
 
 static inline thread_desc * next_thread( monitor_desc * this );
@@ -72 +73 @@
 #define monitor_restore restore( monitors, count, locks, recursions, masks )
 
-#define blockAndWake( thrd, cnt )                               /* Create the necessary information to use the signaller stack                         */ \
-        monitor_save;                                             /* Save monitor states                                                                 */ \
-        BlockInternal( locks, count, thrd, cnt );                 /* Everything is ready to go to sleep                                                  */ \
-        monitor_restore;                                          /* We are back, restore the owners and recursions                                      */ \
-
 
 //-----------------------------------------------------------------------------
@@ -98 +94 @@
                 }
                 else if( this->owner == thrd) {
-                        // We already have the monitor, just not how many times we took it
+                        // We already have the monitor, just note how many times we took it
                         verify( this->recursion > 0 );
                         this->recursion += 1;
@@ -108 +104 @@
                         set_owner( this, thrd );
 
+                        // Reset mask
+                        reset_mask( this );
+
                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
                 }
@@ -128 +127 @@
                 unlock( &this->lock );
                 return;
+        }
+
+        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
+                // Lock the monitor spinlock, lock_yield to reduce contention
+                lock_yield( &this->lock DEBUG_CTX2 );
+                thread_desc * thrd = this_thread;
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+
+
+                if( !this->owner ) {
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this);
+
+                        // No one has the monitor, just take it
+                        set_owner( this, thrd );
+
+                        unlock( &this->lock );
+                        return;
+                }
+                else if( this->owner == thrd) {
+                        // 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.");
+                }
+
+                int count = 1;
+                monitor_desc ** monitors = &this;
+                __monitor_group_t group = { &this, 1, func };
+                if( is_accepted( this, group) ) {
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts dtor, block and signal it \n");
+
+                        // Wake the thread that is waiting for this
+                        __condition_criterion_t * urgent = pop( &this->signal_stack );
+                        verify( urgent );
+
+                        // Reset mask
+                        reset_mask( this );
+
+                        // Create the node specific to this wait operation
+                        wait_ctx_primed( this_thread, 0 )
+
+                        // Some one else has the monitor, wait for him to finish and then run
+                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
+
+                        // Some one was waiting for us, enter
+                        set_owner( this, thrd );
+                }
+                else {
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
+
+                        wait_ctx( this_thread, 0 )
+                        this->dtor_node = &waiter;
+
+                        // Some one else has the monitor, wait in line for it
+                        append( &this->entry_queue, thrd );
+                        BlockInternal( &this->lock );
+
+                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        return;
+                }
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);
+
         }
 
@@ -159 +221 @@
         }
 
+        // Leave single monitor for the last time
+        void __leave_dtor_monitor_desc( monitor_desc * this ) {
+                LIB_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( this->recursion != 1 ) {
+                                abortf("Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                        }
+                )
+        }
+
         // Leave the thread monitor
         // last routine called by a thread.
@@ -211 +285 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() ) {
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, fptr_t func ) {
         // Store current array
         this.m = m;
@@ -229 +303 @@
         this_thread->monitors.func = func;
 
-        LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
 
         // Enter the monitors in order
@@ -235 +309 @@
         enter( group );
 
-        LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
 }
 
@@ -241 +315 @@
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
-        LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
 
         // Leave the monitors in order
         leave( this.m, this.count );
 
-        LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
+
+        // Restore thread context
+        this_thread->monitors.list = this.prev_mntrs;
+        this_thread->monitors.size = this.prev_count;
+        this_thread->monitors.func = this.prev_func;
+}
+
+
+// Ctor for monitor guard
+// Sorts monitors before entering
+void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, fptr_t func ) {
+        // Store current array
+        this.m = *m;
+
+        // Save previous thread context
+        this.prev_mntrs = this_thread->monitors.list;
+        this.prev_count = this_thread->monitors.size;
+        this.prev_func  = this_thread->monitors.func;
+
+        // Update thread context (needed for conditions)
+        this_thread->monitors.list = m;
+        this_thread->monitors.size = 1;
+        this_thread->monitors.func = func;
+
+        __enter_monitor_dtor( this.m, func );
+}
+
+
+// Dtor for monitor guard
+void ^?{}( monitor_dtor_guard_t & this ) {
+        // Leave the monitors in order
+        __leave_dtor_monitor_desc( this.m );
 
         // Restore thread context
@@ -303 +409 @@
         short thread_count = 0;
         thread_desc * threads[ count ];
-        for(int i = 0; i < count; i++) {
-                threads[i] = 0;
-        }
+        __builtin_memset( threads, 0, sizeof( threads ) );
 
         // Save monitor states
@@ -429 +533 @@
         short max = count_max( mask );
         monitor_desc * mon_storage[max];
+        __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         short actual_count = aggregate( mon_storage, mask );
 
+        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (short)max);
+
         if(actual_count == 0) return;
+
+        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor internal proceeding\n");
 
         // Create storage for monitor context
@@ -445 +554 @@
 
                 if( next ) {
+                        *mask.accepted = index;
                         if( mask.clauses[index].is_dtor ) {
-                                #warning case not implemented
+                                LIB_DEBUG_PRINT_SAFE("Kernel : dtor already there\n");
+                                verifyf( mask.clauses[index].size == 1        , "ERROR: Accepted dtor has more than 1 mutex parameter." );
+
+                                monitor_desc * mon2dtor = mask.clauses[index].list[0];
+                                verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
+
+                                __condition_criterion_t * dtor_crit = mon2dtor->dtor_node->criteria;
+                                push( &mon2dtor->signal_stack, dtor_crit );
+
+                                unlock_all( locks, count );
                         }
                         else {
-                                blockAndWake( &next, 1 );
+                                LIB_DEBUG_PRINT_SAFE("Kernel : thread present, baton-passing\n");
+
+                                // Create the node specific to this wait operation
+                                wait_ctx_primed( this_thread, 0 );
+
+                                // Save monitor states
+                                monitor_save;
+
+                                // Set the owners to be the next thread
+                                set_owner( monitors, count, next );
+
+                                // Everything is ready to go to sleep
+                                BlockInternal( locks, count, &next, 1 );
+
+                                // We are back, restore the owners and recursions
+                                monitor_restore;
+
+                                LIB_DEBUG_PRINT_SAFE("Kernel : thread present, returned\n");
                         }
 
-                        return index;
+                        LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
+
+                        return;
                 }
         }
@@ -458 +596 @@
 
         if( duration == 0 ) {
+                LIB_DEBUG_PRINT_SAFE("Kernel : non-blocking, exiting\n");
+
                 unlock_all( locks, count );
+
+                LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
                 return;
         }
@@ -465 +607 @@
         verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
 
+        LIB_DEBUG_PRINT_SAFE("Kernel : blocking waitfor\n");
+
+        // Create the node specific to this wait operation
+        wait_ctx_primed( this_thread, 0 );
 
         monitor_save;
         set_mask( monitors, count, mask );
 
-        BlockInternal( locks, count );       // Everything is ready to go to sleep
-        //WE WOKE UP
-        monitor_restore;                     //We are back, restore the masks and recursions
+        for(int i = 0; i < count; i++) {
+                verify( monitors[i]->owner == this_thread );
+        }
+
+        //Everything is ready to go to sleep
+        BlockInternal( locks, count );
+
+
+        // WE WOKE UP
+
+
+        //We are back, restore the masks and recursions
+        monitor_restore;
+
+        LIB_DEBUG_PRINT_SAFE("Kernel : exiting\n");
+
+        LIB_DEBUG_PRINT_SAFE("Kernel : accepted %d\n", *mask.accepted);
 }
 
@@ -478 +638 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-        LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+        // LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
 
         //Pass the monitor appropriately
@@ -497 +657 @@
                 storage[i]->mask = mask;
         }
+}
+
+static inline void reset_mask( monitor_desc * this ) {
+        this->mask.accepted = NULL;
+        this->mask.clauses = NULL;
+        this->mask.size = 0;
 }
 
@@ -584 +750 @@
 }
 
-static inline void save   ( monitor_desc ** ctx, short count, __attribute((unused)) spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
+static inline void save( monitor_desc ** ctx, short count, __attribute((unused)) spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
         for( int i = 0; i < count; i++ ) {
                 recursions[i] = ctx[i]->recursion;