Changes in libcfa/src/concurrency/monitor.cfa [ae66348:09f357ec]

File:

• libcfa/src/concurrency/monitor.cfa (modified) (41 diffs)

libcfa/src/concurrency/monitor.cfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// $monitor.c --
+// monitor_desc.c --
 //
 // Author           : Thierry Delisle
@@ -27 +27 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void __set_owner ( $monitor * this, $thread * owner );
-static inline void __set_owner ( $monitor * storage [], __lock_size_t count, $thread * owner );
-static inline void set_mask  ( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
-static inline void reset_mask( $monitor * this );
-
-static inline $thread * next_thread( $monitor * this );
-static inline bool is_accepted( $monitor * this, const __monitor_group_t & monitors );
+static inline void set_owner ( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
+static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
+static inline void reset_mask( monitor_desc * this );
+
+static inline thread_desc * next_thread( monitor_desc * this );
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 
 static inline void lock_all  ( __spinlock_t * locks [], __lock_size_t count );
-static inline void lock_all  ( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
+static inline void lock_all  ( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
 static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count );
-static inline void unlock_all( $monitor * locks [], __lock_size_t count );
-
-static inline void save   ( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
-static inline void restore( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
-
-static inline void init     ( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-
-static inline $thread *        check_condition   ( __condition_criterion_t * );
+static inline void unlock_all( monitor_desc * locks [], __lock_size_t count );
+
+static inline void save   ( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
+static inline void restore( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
+
+static inline void init     ( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+
+static inline thread_desc *        check_condition   ( __condition_criterion_t * );
 static inline void                 brand_condition   ( condition & );
-static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count );
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
 
 forall(dtype T | sized( T ))
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
 static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
-static inline __lock_size_t aggregate    ( $monitor * storage [], const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
@@ -68 +68 @@
 
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
-        $monitor ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
         __lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
         unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
@@ -80 +80 @@
 //-----------------------------------------------------------------------------
 // Enter/Leave routines
-// Enter single monitor
-static void __enter( $monitor * this, const __monitor_group_t & group ) {
-        // Lock the monitor spinlock
-        lock( this->lock __cfaabi_dbg_ctx2 );
-        // Interrupts disable inside critical section
-        $thread * thrd = kernelTLS.this_thread;
-
-        __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
-
-        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 if( is_accepted( this, group) ) {
-                // Some one was waiting for us, enter
-                __set_owner( this, thrd );
-
-                // Reset mask
-                reset_mask( this );
-
-                __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
-        }
-        else {
-                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
-
-                // Some one else has the monitor, wait in line for it
-                /* paranoid */ verify( thrd->next == 0p );
-                append( this->entry_queue, thrd );
-                /* paranoid */ verify( thrd->next == 1p );
-
-                unlock( this->lock );
-                park( __cfaabi_dbg_ctx );
+
+
+extern "C" {
+        // Enter single monitor
+        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
+                // Lock the monitor spinlock
+                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 ) {
+                        // 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 if( is_accepted( this, group) ) {
+                        // Some one was waiting for us, enter
+                        set_owner( this, thrd );
+
+                        // Reset mask
+                        reset_mask( this );
+
+                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
+                }
+                else {
+                        __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);
+
+                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        return;
+                }
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
-                /* paranoid */ 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 );
-                return;
-        }
-
-        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
-
-        /* paranoid */ 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 );
-        /* paranoid */ verify( this->lock.lock );
-
-        // Release the lock and leave
-        unlock( this->lock );
-        return;
-}
-
-static void __dtor_enter( $monitor * this, fptr_t func ) {
-        // Lock the monitor spinlock
-        lock( this->lock __cfaabi_dbg_ctx2 );
-        // Interrupts disable inside critical section
-        $thread * 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);
-
-                // No one has the monitor, just take it
-                __set_owner( this, thrd );
-
-                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 );
-
+                // Release the lock and leave
                 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!
-                abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
-        }
-
-        __lock_size_t count = 1;
-        $monitor ** monitors = &this;
-        __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" );
-
-                // Wake the thread that is waiting for this
-                __condition_criterion_t * urgent = pop( this->signal_stack );
-                /* paranoid */ verify( urgent );
-
-                // Reset mask
-                reset_mask( this );
-
-                // Create the node specific to this wait operation
-                wait_ctx_primed( thrd, 0 )
-
-                // Some one else has the monitor, wait for him to finish and then run
+
+        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
+                // Lock the monitor spinlock
+                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);
+
+                        // 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!
+                        abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
+                }
+
+                __lock_size_t count = 1;
+                monitor_desc ** monitors = &this;
+                __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" );
+
+                        // 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( thrd, 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 {
+                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+
+                        wait_ctx( thrd, 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;
+                }
+
+                __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
+
+        }
+
+        // Leave single monitor
+        void __leave_monitor_desc( monitor_desc * 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
+                this->recursion -= 1;
+
+                // If we haven't left the last level of recursion
+                // it means we don't need to do anything
+                if( this->recursion != 0) {
+                        __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
+                        unlock( this->lock );
+                        return;
+                }
+
+                // Get the next thread, will be null on low contention monitor
+                thread_desc * new_owner = next_thread( this );
+
+                // We can now let other threads in safely
                 unlock( this->lock );
 
-                // Release the next thread
-                /* paranoid */ verifyf( urgent->owner->waiting_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-                unpark( urgent->owner->waiting_thread __cfaabi_dbg_ctx2 );
-
-                // Park current thread waiting
-                park( __cfaabi_dbg_ctx );
-
-                // Some one was waiting for us, enter
-                /* paranoid */ 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 );
-        }
-        else {
-                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
-
-                wait_ctx( thrd, 0 )
-                this->dtor_node = &waiter;
-
-                // Some one else has the monitor, wait in line for it
-                /* paranoid */ verify( thrd->next == 0p );
-                append( this->entry_queue, thrd );
-                /* paranoid */ verify( thrd->next == 1p );
-                unlock( this->lock );
-
-                // Park current thread waiting
-                park( __cfaabi_dbg_ctx );
-
-                /* paranoid */ 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 );
-                return;
-        }
-
-        __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
-
-}
-
-// Leave single monitor
-void __leave( $monitor * 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);
-
-        /* paranoid */ 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
-        this->recursion -= 1;
-
-        // If we haven't left the last level of recursion
-        // it means we don't need to do anything
-        if( this->recursion != 0) {
-                __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
-                unlock( this->lock );
-                return;
-        }
-
-        // Get the next thread, will be null on low contention monitor
-        $thread * new_owner = next_thread( this );
-
-        // Check the new owner is consistent with who we wake-up
-        // new_owner might be null even if someone owns the monitor when the owner is still waiting for another monitor
-        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
-
-        // We can now let other threads in safely
-        unlock( this->lock );
-
-        //We need to wake-up the thread
-        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
-        unpark( new_owner __cfaabi_dbg_ctx2 );
-}
-
-// Leave single monitor for the last time
-void __dtor_leave( $monitor * this ) {
-        __cfaabi_dbg_debug_do(
-                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 ) {
-                        abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
-                }
-        )
-}
-
-extern "C" {
+                //We need to wake-up the thread
+                WakeThread( new_owner );
+        }
+
+        // Leave single monitor for the last time
+        void __leave_dtor_monitor_desc( monitor_desc * this ) {
+                __cfaabi_dbg_debug_do(
+                        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 ) {
+                                abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                        }
+                )
+        }
+
         // Leave the thread monitor
         // last routine called by a thread.
         // Should never return
-        void __cfactx_thrd_leave() {
-                $thread * thrd = TL_GET( this_thread );
-                $monitor * this = &thrd->self_mon;
+        void __leave_thread_monitor() {
+                thread_desc * thrd = TL_GET( this_thread );
+                monitor_desc * this = &thrd->self_mon;
 
                 // Lock the monitor now
@@ -275 +252 @@
                 disable_interrupts();
 
-                thrd->state = Halted;
-
-                /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
+                thrd->self_cor.state = Halted;
+
+                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -287 +264 @@
 
                 // Fetch the next thread, can be null
-                $thread * new_owner = next_thread( this );
-
-                // Release the monitor lock
-                unlock( this->lock );
-
-                // Unpark the next owner if needed
-                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
-                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-                /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
-                /* paranoid */ verify( thrd->state == Halted );
-
-                kernelTLS.this_processor->destroyer = new_owner;
-
-                // Leave the thread
-                __leave_thread();
+                thread_desc * new_owner = next_thread( this );
+
+                // Leave the thread, this will unlock the spinlock
+                // Use leave thread instead of BlockInternal which is
+                // specialized for this case and supports null new_owner
+                LeaveThread( &this->lock, new_owner );
 
                 // Control flow should never reach here!
@@ -311 +279 @@
 static inline void enter( __monitor_group_t monitors ) {
         for( __lock_size_t i = 0; i < monitors.size; i++) {
-                __enter( monitors[i], monitors );
+                __enter_monitor_desc( monitors[i], monitors );
         }
 }
@@ -317 +285 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave($monitor * monitors [], __lock_size_t count) {
+static inline void leave(monitor_desc * monitors [], __lock_size_t count) {
         for( __lock_size_t i = count - 1; i >= 0; i--) {
-                __leave( monitors[i] );
+                __leave_monitor_desc( monitors[i] );
         }
 }
@@ -325 +293 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) {
-        $thread * thrd = TL_GET( this_thread );
+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
@@ -366 +334 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func ) {
+void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
         // optimization
-        $thread * thrd = TL_GET( this_thread );
+        thread_desc * thrd = TL_GET( this_thread );
 
         // Store current array
@@ -379 +347 @@
         (thrd->monitors){m, 1, func};
 
-        __dtor_enter( this.m, func );
+        __enter_monitor_dtor( this.m, func );
 }
 
@@ -385 +353 @@
 void ^?{}( monitor_dtor_guard_t & this ) {
         // Leave the monitors in order
-        __dtor_leave( this.m );
+        __leave_dtor_monitor_desc( this.m );
 
         // Restore thread context
@@ -393 +361 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
@@ -407 +375 @@
 }
 
-void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
@@ -432 +400 @@
         // Append the current wait operation to the ones already queued on the condition
         // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
-        /* paranoid */ verify( waiter.next == 0p );
         append( this.blocked, &waiter );
-        /* paranoid */ verify( waiter.next == 1p );
 
         // Lock all monitors (aggregates the locks as well)
@@ -441 +407 @@
         // Find the next thread(s) to run
         __lock_size_t thread_count = 0;
-        $thread * threads[ count ];
+        thread_desc * threads[ count ];
         __builtin_memset( threads, 0, sizeof( threads ) );
 
@@ -449 +415 @@
         // Remove any duplicate threads
         for( __lock_size_t i = 0; i < count; i++) {
-                $thread * new_owner = next_thread( monitors[i] );
+                thread_desc * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
         }
 
-        // Unlock the locks, we don't need them anymore
-        for(int i = 0; i < count; i++) {
-                unlock( *locks[i] );
-        }
-
-        // Wake the threads
-        for(int i = 0; i < thread_count; i++) {
-                unpark( threads[i] __cfaabi_dbg_ctx2 );
-        }
-
         // Everything is ready to go to sleep
-        park( __cfaabi_dbg_ctx );
+        BlockInternal( locks, count, threads, thread_count );
 
         // We are back, restore the owners and recursions
@@ -479 +435 @@
         //Some more checking in debug
         __cfaabi_dbg_debug_do(
-                $thread * this_thrd = TL_GET( this_thread );
+                thread_desc * this_thrd = TL_GET( this_thread );
                 if ( 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 );
@@ -533 +489 @@
 
         //Find the thread to run
-        $thread * signallee = pop_head( this.blocked )->waiting_thread;
-        __set_owner( monitors, count, signallee );
+        thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
+        set_owner( monitors, count, signallee );
 
         __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
-        // unlock all the monitors
-        unlock_all( locks, count );
-
-        // unpark the thread we signalled
-        unpark( signallee __cfaabi_dbg_ctx2 );
-
         //Everything is ready to go to sleep
-        park( __cfaabi_dbg_ctx );
+        BlockInternal( locks, count, &signallee, 1 );
 
 
@@ -586 +536 @@
         // Create one!
         __lock_size_t max = count_max( mask );
-        $monitor * mon_storage[max];
+        monitor_desc * mon_storage[max];
         __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         __lock_size_t actual_count = aggregate( mon_storage, mask );
@@ -604 +554 @@
         {
                 // Check if the entry queue
-                $thread * next; int index;
+                thread_desc * next; int index;
                 [next, index] = search_entry_queue( mask, monitors, count );
 
@@ -614 +564 @@
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
-                                $monitor * mon2dtor = accepted[0];
+                                monitor_desc * mon2dtor = accepted[0];
                                 verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -640 +590 @@
 
                                 // Set the owners to be the next thread
-                                __set_owner( monitors, count, next );
-
-                                // unlock all the monitors
-                                unlock_all( locks, count );
-
-                                // unpark the thread we signalled
-                                unpark( next __cfaabi_dbg_ctx2 );
-
-                                //Everything is ready to go to sleep
-                                park( __cfaabi_dbg_ctx );
+                                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
@@ -687 +631 @@
         }
 
-        // unlock all the monitors
-        unlock_all( locks, count );
-
         //Everything is ready to go to sleep
-        park( __cfaabi_dbg_ctx );
+        BlockInternal( locks, count );
 
 
@@ -708 +649 @@
 // Utilities
 
-static inline void __set_owner( $monitor * this, $thread * owner ) {
-        /* paranoid */ verify( this->lock.lock );
+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 );
 
         //Pass the monitor appropriately
@@ -718 +659 @@
 }
 
-static inline void __set_owner( $monitor * monitors [], __lock_size_t count, $thread * owner ) {
-        /* paranoid */ verify ( monitors[0]->lock.lock );
-        /* paranoid */ verifyf( monitors[0]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[0]->owner, monitors[0]->recursion, monitors[0] );
-        monitors[0]->owner        = owner;
-        monitors[0]->recursion    = 1;
+static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
+        monitors[0]->owner     = owner;
+        monitors[0]->recursion = 1;
         for( __lock_size_t i = 1; i < count; i++ ) {
-                /* paranoid */ verify ( monitors[i]->lock.lock );
-                /* paranoid */ verifyf( monitors[i]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[i]->owner, monitors[i]->recursion, monitors[i] );
-                monitors[i]->owner        = owner;
-                monitors[i]->recursion    = 0;
-        }
-}
-
-static inline void set_mask( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
+                monitors[i]->owner     = owner;
+                monitors[i]->recursion = 0;
+        }
+}
+
+static inline void set_mask( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 storage[i]->mask = mask;
@@ -737 +674 @@
 }
 
-static inline void reset_mask( $monitor * this ) {
+static inline void reset_mask( monitor_desc * this ) {
         this->mask.accepted = 0p;
         this->mask.data = 0p;
@@ -743 +680 @@
 }
 
-static inline $thread * next_thread( $monitor * this ) {
+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);
@@ -751 +688 @@
                 //regardless of if we are ready to baton pass,
                 //we need to set the monitor as in use
-                /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-                __set_owner( this,  urgent->owner->waiting_thread );
+                set_owner( this,  urgent->owner->waiting_thread );
 
                 return check_condition( urgent );
@@ -759 +695 @@
         // No signaller thread
         // Get the next thread in the entry_queue
-        $thread * new_owner = pop_head( this->entry_queue );
-        /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-        /* paranoid */ verify( !new_owner || new_owner->next == 0p );
-        __set_owner( this, new_owner );
+        thread_desc * new_owner = pop_head( this->entry_queue );
+        set_owner( this, new_owner );
 
         return new_owner;
 }
 
-static inline bool is_accepted( $monitor * this, const __monitor_group_t & group ) {
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
         __acceptable_t * it = this->mask.data; // Optim
         __lock_size_t count = this->mask.size;
@@ -789 +723 @@
 }
 
-static inline void init( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -797 +731 @@
 }
 
-static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -813 +747 @@
 }
 
-static inline void lock_all( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
+static inline void lock_all( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
@@ -827 +761 @@
 }
 
-static inline void unlock_all( $monitor * locks [], __lock_size_t count ) {
+static inline void unlock_all( monitor_desc * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 unlock( locks[i]->lock );
@@ -834 +768 @@
 
 static inline void save(
-        $monitor * ctx [],
+        monitor_desc * ctx [],
         __lock_size_t count,
         __attribute((unused)) __spinlock_t * locks [],
@@ -847 +781 @@
 
 static inline void restore(
-        $monitor * ctx [],
+        monitor_desc * ctx [],
         __lock_size_t count,
         __spinlock_t * locks [],
@@ -865 +799 @@
 // 2 - Checks if all the monitors are ready to run
 //     if so return the thread to run
-static inline $thread * check_condition( __condition_criterion_t * target ) {
+static inline thread_desc * check_condition( __condition_criterion_t * target ) {
         __condition_node_t * node = target->owner;
         unsigned short count = node->count;
@@ -888 +822 @@
 
 static inline void brand_condition( condition & this ) {
-        $thread * thrd = TL_GET( this_thread );
+        thread_desc * thrd = TL_GET( this_thread );
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );
@@ -894 +828 @@
                 this.monitor_count = thrd->monitors.size;
 
-                this.monitors = ($monitor **)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];
@@ -901 +835 @@
 }
 
-static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t & mask, $monitor * monitors [], __lock_size_t count ) {
-
-        __queue_t($thread) & entry_queue = monitors[0]->entry_queue;
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
+
+        __queue_t(thread_desc) & entry_queue = monitors[0]->entry_queue;
 
         // For each thread in the entry-queue
-        for(    $thread ** thrd_it = &entry_queue.head;
-                *thrd_it != 1p;
+        for(    thread_desc ** thrd_it = &entry_queue.head;
+                *thrd_it;
                 thrd_it = &(*thrd_it)->next
         ) {
@@ -950 +884 @@
 }
 
-static inline __lock_size_t aggregate( $monitor * storage [], const __waitfor_mask_t & mask ) {
+static inline __lock_size_t aggregate( monitor_desc * storage [], const __waitfor_mask_t & mask ) {
         __lock_size_t size = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {