Changeset 19c43b7 for src/libcfa

Timestamp:

Sep 26, 2017, 2:30:51 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

daacf82

Parents:

a2d4d1c

Message:

Added test to check correct statment is executed after waitfor

File:

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

src/libcfa/concurrency/monitor.c

@@ -72 +72 @@
 #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                                      */ \
-
 
 //-----------------------------------------------------------------------------
@@ -229 +224 @@
         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 +230 @@
         enter( group );
 
-        LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
 }
 
@@ -241 +236 @@
 // 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
@@ -425 +420 @@
 //              block
 void __waitfor_internal( const __waitfor_mask_t & mask, int duration ) {
+        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor internal \n");
+
         // This statment doesn't have a contiguous list of monitors...
         // Create one!
@@ -431 +428 @@
         short actual_count = aggregate( mon_storage, mask );
 
-        if(actual_count == 0) return;
+        if(actual_count == 0) {
+                LIB_DEBUG_PRINT_SAFE("Kernel :  nothing to wait for \n");
+                return;
+        }
+
+        LIB_DEBUG_PRINT_SAFE("Kernel : waitfor internal proceeding\n");
 
         // Create storage for monitor context
@@ -445 +447 @@
 
                 if( next ) {
+                        *mask.accepted = index;
                         if( mask.clauses[index].is_dtor ) {
                                 #warning case not implemented
                         }
                         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 +480 @@
 
         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 +491 @@
         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
+        //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 +518 @@
 
 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
@@ -559 +599 @@
 
 static inline void lock_all( spinlock ** locks, unsigned short count ) {
+        LIB_DEBUG_ACQUIRE();
+        LIB_DEBUG_PRINT_NOLOCK("Kernel :   Locking");
         for( int i = 0; i < count; i++ ) {
+                LIB_DEBUG_PRINT_NOLOCK(" %p", locks[i]);
                 lock_yield( locks[i] DEBUG_CTX2 );
         }
+        LIB_DEBUG_PRINT_NOLOCK("\n");
+        LIB_DEBUG_RELEASE();
 }
 
 static inline void lock_all( monitor_desc ** source, spinlock ** /*out*/ locks, unsigned short count ) {
+        LIB_DEBUG_ACQUIRE();
+        LIB_DEBUG_PRINT_NOLOCK("Kernel :   Locking");
         for( int i = 0; i < count; i++ ) {
                 spinlock * l = &source[i]->lock;
+                LIB_DEBUG_PRINT_NOLOCK(" %p", l);
                 lock_yield( l DEBUG_CTX2 );
                 if(locks) locks[i] = l;
         }
+        LIB_DEBUG_PRINT_NOLOCK("\n");
+        LIB_DEBUG_RELEASE();
 }