Changes in src/libcfa/concurrency/monitor.c [0cf5b79:36982fc]

File:

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

src/libcfa/concurrency/monitor.c

@@ -91 +91 @@
         static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock DEBUG_CTX2 );
+                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
                 thread_desc * thrd = this_thread;
 
-                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+                __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
 
                 if( !this->owner ) {
@@ -100 +100 @@
                         set_owner( this, thrd );
 
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon is free \n");
+                        __cfaabi_dbg_print_safe("Kernel :  mon is free \n");
                 }
                 else if( this->owner == thrd) {
@@ -106 +106 @@
                         this->recursion += 1;
 
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
+                        __cfaabi_dbg_print_safe("Kernel :  mon already owned \n");
                 }
                 else if( is_accepted( this, group) ) {
@@ -115 +115 @@
                         reset_mask( this );
 
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
+                        __cfaabi_dbg_print_safe("Kernel :  mon accepts \n");
                 }
                 else {
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
+                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
 
                         // Some one else has the monitor, wait in line for it
@@ -124 +124 @@
                         BlockInternal( &this->lock );
 
-                        LIB_DEBUG_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
@@ -130 +130 @@
                 }
 
-                LIB_DEBUG_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
@@ -139 +139 @@
         static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
                 // Lock the monitor spinlock
-                DO_LOCK( this->lock DEBUG_CTX2 );
+                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
                 thread_desc * thrd = this_thread;
 
-                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+                __cfaabi_dbg_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);
+                        __cfaabi_dbg_print_safe("Kernel : Destroying free mon %p\n", this);
 
                         // No one has the monitor, just take it
@@ -164 +164 @@
                 __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");
+                        __cfaabi_dbg_print_safe("Kernel :  mon accepts dtor, block and signal it \n");
 
                         // Wake the thread that is waiting for this
@@ -183 +183 @@
                 }
                 else {
-                        LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
+                        __cfaabi_dbg_print_safe("Kernel :  blocking \n");
 
                         wait_ctx( this_thread, 0 )
@@ -196 +196 @@
                 }
 
-                LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);
+                __cfaabi_dbg_print_safe("Kernel : Destroying %p\n", this);
 
         }
@@ -203 +203 @@
         void __leave_monitor_desc( monitor_desc * this ) {
                 // Lock the monitor spinlock, DO_LOCK to reduce contention
-                DO_LOCK( this->lock DEBUG_CTX2 );
-
-                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
+                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 );
@@ -215 +215 @@
                 // it means we don't need to do anything
                 if( this->recursion != 0) {
-                        LIB_DEBUG_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 +232 @@
         // Leave single monitor for the last time
         void __leave_dtor_monitor_desc( monitor_desc * this ) {
-                LIB_DEBUG_DO(
+                __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);
@@ -249 +249 @@
 
                 // Lock the monitor now
-                DO_LOCK( this->lock DEBUG_CTX2 );
+                DO_LOCK( this->lock __cfaabi_dbg_ctx2 );
 
                 disable_interrupts();
@@ -308 +308 @@
         (this_thread->monitors){m, count, func};
 
-        // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
+        // __cfaabi_dbg_print_safe("MGUARD : enter %d\n", count);
 
         // Enter the monitors in order
@@ -314 +314 @@
         enter( group );
 
-        // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
+        // __cfaabi_dbg_print_safe("MGUARD : entered\n");
 }
 
@@ -320 +320 @@
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
-        // LIB_DEBUG_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 );
 
-        // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
+        // __cfaabi_dbg_print_safe("MGUARD : left\n");
 
         // Restore thread context
@@ -430 +430 @@
 
         //Some more checking in debug
-        LIB_DEBUG_DO(
+        __cfaabi_dbg_debug_do(
                 thread_desc * this_thrd = this_thread;
                 if ( this.monitor_count != this_thrd->monitors.size ) {
@@ -487 +487 @@
         set_owner( monitors, count, signallee );
 
-        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
+        __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
         //Everything is ready to go to sleep
@@ -496 +496 @@
 
 
-        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :   signal_block returned\n" );
+        __cfaabi_dbg_print_buffer_local( "Kernel :   signal_block returned\n" );
 
         //We are back, restore the masks and recursions
@@ -535 +535 @@
         __lock_size_t actual_count = aggregate( mon_storage, mask );
 
-        LIB_DEBUG_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 %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
 
         if(actual_count == 0) return;
 
-        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");
+        __cfaabi_dbg_print_buffer_local( "Kernel : waitfor internal proceeding\n");
 
         // Create storage for monitor context
@@ -556 +556 @@
                         __acceptable_t& accepted = mask[index];
                         if( accepted.is_dtor ) {
-                                LIB_DEBUG_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." );
 
@@ -568 +568 @@
                         }
                         else {
-                                LIB_DEBUG_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
@@ -576 +576 @@
                                 monitor_save;
 
-                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :  baton of %d monitors : ", count );
+                                __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %d monitors : ", count );
                                 #ifdef __CFA_DEBUG_PRINT__
                                         for( int i = 0; i < count; i++) {
-                                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
+                                                __cfaabi_dbg_print_buffer_local( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
                                         }
                                 #endif
-                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");
+                                __cfaabi_dbg_print_buffer_local( "\n");
 
                                 // Set the owners to be the next thread
@@ -593 +593 @@
                                 monitor_restore;
 
-                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");
+                                __cfaabi_dbg_print_buffer_local( "Kernel : thread present, returned\n");
                         }
 
-                        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+                        __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
                         return;
                 }
@@ -603 +603 @@
 
         if( duration == 0 ) {
-                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");
+                __cfaabi_dbg_print_buffer_local( "Kernel : non-blocking, exiting\n");
 
                 unlock_all( locks, count );
 
-                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+                __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
                 return;
         }
@@ -614 +614 @@
         verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
 
-        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");
+        __cfaabi_dbg_print_buffer_local( "Kernel : blocking waitfor\n");
 
         // Create the node specific to this wait operation
@@ -636 +636 @@
         monitor_restore;
 
-        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");
-
-        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+        __cfaabi_dbg_print_buffer_local( "Kernel : exiting\n");
+
+        __cfaabi_dbg_print_buffer_local( "Kernel : accepted %d\n", *mask.accepted);
 }
 
@@ -645 +645 @@
 
 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 );
+        // __cfaabi_dbg_print_safe("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
 
         //Pass the monitor appropriately
@@ -677 +677 @@
 static inline thread_desc * next_thread( monitor_desc * this ) {
         //Check the signaller stack
-        LIB_DEBUG_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 ) {
@@ -729 +729 @@
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
-                LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
+                __cfaabi_dbg_print_safe( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
                 push( criteria[i].target->signal_stack, &criteria[i] );
         }
@@ -738 +738 @@
 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] DEBUG_CTX2 );
+                DO_LOCK( *locks[i] __cfaabi_dbg_ctx2 );
         }
 }
@@ -745 +745 @@
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
-                DO_LOCK( *l DEBUG_CTX2 );
+                DO_LOCK( *l __cfaabi_dbg_ctx2 );
                 if(locks) locks[i] = l;
         }
@@ -803 +803 @@
         for(    int i = 0; i < count; i++ ) {
 
-                // LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
+                // __cfaabi_dbg_print_safe( "Checking %p for %p\n", &criteria[i], target );
                 if( &criteria[i] == target ) {
                         criteria[i].ready = true;
-                        // LIB_DEBUG_PRINT_SAFE( "True\n" );
+                        // __cfaabi_dbg_print_safe( "True\n" );
                 }
 
@@ -812 +812 @@
         }
 
-        LIB_DEBUG_PRINT_SAFE( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
+        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
         return ready2run ? node->waiting_thread : NULL;
 }
@@ -819 +819 @@
         thread_desc * thrd = this_thread;
         if( !this.monitors ) {
-                // LIB_DEBUG_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;
 
-                this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
+                this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
                         this.monitors[i] = thrd->monitors[i];