Changes in libcfa/src/concurrency/monitor.cfa [2026bb6:ae66348]

File:

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

libcfa/src/concurrency/monitor.cfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// monitor_desc.c --
+// $monitor.c --
 //
 // Author           : Thierry Delisle
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 30 14:30:26 2018
-// Update Count     : 9
+// Last Modified On : Wed Dec  4 07:55:14 2019
+// Update Count     : 10
 //
 
@@ -27 +27 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-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 __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 lock_all  ( __spinlock_t * locks [], __lock_size_t count );
-static inline void lock_all  ( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
+static inline void lock_all  ( $monitor * 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_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 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                 brand_condition   ( condition & );
-static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
+static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * 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_desc * storage [], const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( $monitor * 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_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        $monitor ** 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
-
-
-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;
-                }
+// 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 );
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
-                // Release the lock and leave
+                /* 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 );
+
                 unlock( this->lock );
                 return;
         }
-
-        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 ** 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
+                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);
                 }
-                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 );
+                if( this->recursion != 1 ) {
+                        abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
                 }
-
-                __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 );
-
-                //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);
-                        }
-                )
-        }
-
+        )
+}
+
+extern "C" {
         // Leave the thread monitor
         // last routine called by a thread.
         // Should never return
-        void __leave_thread_monitor( thread_desc * thrd ) {
-                monitor_desc * this = &thrd->self_mon;
+        void __cfactx_thrd_leave() {
+                $thread * thrd = TL_GET( this_thread );
+                $monitor * this = &thrd->self_mon;
 
                 // Lock the monitor now
@@ -251 +275 @@
                 disable_interrupts();
 
-                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 );
+                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 );
 
                 // Leaving a recursion level, decrement the counter
@@ -263 +287 @@
 
                 // Fetch the next thread, can be null
-                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 );
+                $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();
 
                 // Control flow should never reach here!
@@ -278 +311 @@
 static inline void enter( __monitor_group_t monitors ) {
         for( __lock_size_t i = 0; i < monitors.size; i++) {
-                __enter_monitor_desc( monitors[i], monitors );
+                __enter( monitors[i], monitors );
         }
 }
@@ -284 +317 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave(monitor_desc * monitors [], __lock_size_t count) {
+static inline void leave($monitor * monitors [], __lock_size_t count) {
         for( __lock_size_t i = count - 1; i >= 0; i--) {
-                __leave_monitor_desc( monitors[i] );
+                __leave( monitors[i] );
         }
 }
@@ -292 +325 @@
 // Ctor for monitor guard
 // 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 );
+void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) {
+        $thread * thrd = TL_GET( this_thread );
 
         // Store current array
@@ -333 +366 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
+void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func ) {
         // optimization
-        thread_desc * thrd = TL_GET( this_thread );
+        $thread * thrd = TL_GET( this_thread );
 
         // Store current array
@@ -346 +379 @@
         (thrd->monitors){m, 1, func};
 
-        __enter_monitor_dtor( this.m, func );
+        __dtor_enter( this.m, func );
 }
 
@@ -352 +385 @@
 void ^?{}( monitor_dtor_guard_t & this ) {
         // Leave the monitors in order
-        __leave_dtor_monitor_desc( this.m );
+        __dtor_leave( this.m );
 
         // Restore thread context
@@ -360 +393 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
-        this.next = NULL;
+        this.next = 0p;
         this.user_info = user_info;
 }
@@ -369 +402 @@
 void ?{}(__condition_criterion_t & this ) with( this ) {
         ready  = false;
-        target = NULL;
-        owner  = NULL;
-        next   = NULL;
-}
-
-void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
+        target = 0p;
+        owner  = 0p;
+        next   = 0p;
+}
+
+void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
         this.owner  = &owner;
-        this.next   = NULL;
+        this.next   = 0p;
 }
 
@@ -387 +420 @@
 
         // Check that everything is as expected
-        assertf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        assertf( this.monitors != 0p, "Waiting with no monitors (%p)", this.monitors );
         verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
         verifyf( this.monitor_count < 32u, "Excessive monitor count (%"PRIiFAST16")", this.monitor_count );
@@ -399 +432 @@
         // 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)
@@ -406 +441 @@
         // Find the next thread(s) to run
         __lock_size_t thread_count = 0;
-        thread_desc * threads[ count ];
+        $thread * threads[ count ];
         __builtin_memset( threads, 0, sizeof( threads ) );
 
@@ -414 +449 @@
         // Remove any duplicate threads
         for( __lock_size_t i = 0; i < count; i++) {
-                thread_desc * new_owner = next_thread( monitors[i] );
+                $thread * 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
-        BlockInternal( locks, count, threads, thread_count );
+        park( __cfaabi_dbg_ctx );
 
         // We are back, restore the owners and recursions
@@ -434 +479 @@
         //Some more checking in debug
         __cfaabi_dbg_debug_do(
-                thread_desc * this_thrd = TL_GET( this_thread );
+                $thread * 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 );
@@ -449 +494 @@
 
         // Lock all monitors
-        lock_all( this.monitors, NULL, count );
+        lock_all( this.monitors, 0p, count );
 
         //Pop the head of the waiting queue
@@ -471 +516 @@
 
         //Check that everything is as expected
-        verifyf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitors != 0p, "Waiting with no monitors (%p)", this.monitors );
         verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
 
@@ -488 +533 @@
 
         //Find the thread to run
-        thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
-        set_owner( monitors, count, signallee );
+        $thread * 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
-        BlockInternal( locks, count, &signallee, 1 );
+        park( __cfaabi_dbg_ctx );
 
 
@@ -535 +586 @@
         // Create one!
         __lock_size_t max = count_max( mask );
-        monitor_desc * mon_storage[max];
+        $monitor * mon_storage[max];
         __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         __lock_size_t actual_count = aggregate( mon_storage, mask );
@@ -553 +604 @@
         {
                 // Check if the entry queue
-                thread_desc * next; int index;
+                $thread * next; int index;
                 [next, index] = search_entry_queue( mask, monitors, count );
 
@@ -563 +614 @@
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
-                                monitor_desc * mon2dtor = accepted[0];
+                                $monitor * mon2dtor = accepted[0];
                                 verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -589 +640 @@
 
                                 // 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 );
+                                __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 );
 
                                 // We are back, restore the owners and recursions
@@ -630 +687 @@
         }
 
+        // unlock all the monitors
+        unlock_all( locks, count );
+
         //Everything is ready to go to sleep
-        BlockInternal( locks, count );
+        park( __cfaabi_dbg_ctx );
 
 
@@ -648 +708 @@
 // Utilities
 
-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 );
+static inline void __set_owner( $monitor * this, $thread * owner ) {
+        /* paranoid */ verify( this->lock.lock );
 
         //Pass the monitor appropriately
@@ -658 +718 @@
 }
 
-static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
-        monitors[0]->owner     = owner;
-        monitors[0]->recursion = 1;
+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;
         for( __lock_size_t i = 1; i < count; i++ ) {
-                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 ) {
+                /* 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 ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 storage[i]->mask = mask;
@@ -673 +737 @@
 }
 
-static inline void reset_mask( monitor_desc * this ) {
-        this->mask.accepted = NULL;
-        this->mask.data = NULL;
+static inline void reset_mask( $monitor * this ) {
+        this->mask.accepted = 0p;
+        this->mask.data = 0p;
         this->mask.size = 0;
 }
 
-static inline thread_desc * next_thread( monitor_desc * this ) {
+static inline $thread * next_thread( $monitor * this ) {
         //Check the signaller stack
         __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
@@ -687 +751 @@
                 //regardless of if we are ready to baton pass,
                 //we need to set the monitor as in use
-                set_owner( this,  urgent->owner->waiting_thread );
+                /* 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 );
 
                 return check_condition( urgent );
@@ -694 +759 @@
         // No signaller thread
         // Get the next thread in the entry_queue
-        thread_desc * new_owner = pop_head( this->entry_queue );
-        set_owner( this, new_owner );
+        $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 );
 
         return new_owner;
 }
 
-static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
+static inline bool is_accepted( $monitor * this, const __monitor_group_t & group ) {
         __acceptable_t * it = this->mask.data; // Optim
         __lock_size_t count = this->mask.size;
@@ -722 +789 @@
 }
 
-static inline void init( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -730 +797 @@
 }
 
-static inline void init_push( __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 * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -746 +813 @@
 }
 
-static inline void lock_all( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
+static inline void lock_all( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
@@ -760 +827 @@
 }
 
-static inline void unlock_all( monitor_desc * locks [], __lock_size_t count ) {
+static inline void unlock_all( $monitor * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 unlock( locks[i]->lock );
@@ -767 +834 @@
 
 static inline void save(
-        monitor_desc * ctx [],
+        $monitor * ctx [],
         __lock_size_t count,
         __attribute((unused)) __spinlock_t * locks [],
@@ -780 +847 @@
 
 static inline void restore(
-        monitor_desc * ctx [],
+        $monitor * ctx [],
         __lock_size_t count,
         __spinlock_t * locks [],
@@ -798 +865 @@
 // 2 - Checks if all the monitors are ready to run
 //     if so return the thread to run
-static inline thread_desc * check_condition( __condition_criterion_t * target ) {
+static inline $thread * check_condition( __condition_criterion_t * target ) {
         __condition_node_t * node = target->owner;
         unsigned short count = node->count;
@@ -816 +883 @@
         }
 
-        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
-        return ready2run ? node->waiting_thread : NULL;
+        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : 0p );
+        return ready2run ? node->waiting_thread : 0p;
 }
 
 static inline void brand_condition( condition & this ) {
-        thread_desc * thrd = TL_GET( this_thread );
+        $thread * thrd = TL_GET( this_thread );
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );
-                assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
+                assertf( thrd->monitors.data != 0p, "No current monitor to brand condition %p", thrd->monitors.data );
                 this.monitor_count = thrd->monitors.size;
 
-                this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
+                this.monitors = ($monitor **)malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
                         this.monitors[i] = thrd->monitors[i];
@@ -834 +901 @@
 }
 
-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;
+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;
 
         // For each thread in the entry-queue
-        for(    thread_desc ** thrd_it = &entry_queue.head;
-                *thrd_it;
+        for(    $thread ** thrd_it = &entry_queue.head;
+                *thrd_it != 1p;
                 thrd_it = &(*thrd_it)->next
         ) {
@@ -883 +950 @@
 }
 
-static inline __lock_size_t aggregate( monitor_desc * storage [], const __waitfor_mask_t & mask ) {
+static inline __lock_size_t aggregate( $monitor * storage [], const __waitfor_mask_t & mask ) {
         __lock_size_t size = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {