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

File:

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

libcfa/src/concurrency/monitor.cfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// $monitor.c --
+// monitor_desc.c --
 //
 // Author           : Thierry Delisle
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec  4 07:55:14 2019
-// Update Count     : 10
+// Last Modified On : Fri Mar 30 14:30:26 2018
+// Update Count     : 9
 //
 
@@ -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 ) {
+                monitor_desc * this = &thrd->self_mon;
 
                 // Lock the monitor now
@@ -275 +251 @@
                 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 +263 @@
 
                 // 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 +278 @@
 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 +284 @@
 // 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 +292 @@
 // 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 +333 @@
 // 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 +346 @@
         (thrd->monitors){m, 1, func};
 
-        __dtor_enter( this.m, func );
+        __enter_monitor_dtor( this.m, func );
 }
 
@@ -385 +352 @@
 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 +360 @@
 //-----------------------------------------------------------------------------
 // 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;
-        this.next = 0p;
+        this.next = NULL;
         this.user_info = user_info;
 }
@@ -402 +369 @@
 void ?{}(__condition_criterion_t & this ) with( this ) {
         ready  = false;
-        target = 0p;
-        owner  = 0p;
-        next   = 0p;
-}
-
-void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
+        target = NULL;
+        owner  = NULL;
+        next   = NULL;
+}
+
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
         this.owner  = &owner;
-        this.next   = 0p;
+        this.next   = NULL;
 }
 
@@ -420 +387 @@
 
         // Check that everything is as expected
-        assertf( this.monitors != 0p, "Waiting with no monitors (%p)", this.monitors );
+        assertf( this.monitors != NULL, "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 );
@@ -432 +399 @@
         // 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 +406 @@
         // 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 +414 @@
         // 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 +434 @@
         //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 );
@@ -494 +449 @@
 
         // Lock all monitors
-        lock_all( this.monitors, 0p, count );
+        lock_all( this.monitors, NULL, count );
 
         //Pop the head of the waiting queue
@@ -516 +471 @@
 
         //Check that everything is as expected
-        verifyf( this.monitors != 0p, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
         verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
 
@@ -533 +488 @@
 
         //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 +535 @@
         // 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 +553 @@
         {
                 // Check if the entry queue
-                $thread * next; int index;
+                thread_desc * next; int index;
                 [next, index] = search_entry_queue( mask, monitors, count );
 
@@ -614 +563 @@
                                 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 +589 @@
 
                                 // 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 +630 @@
         }
 
-        // unlock all the monitors
-        unlock_all( locks, count );
-
         //Everything is ready to go to sleep
-        park( __cfaabi_dbg_ctx );
+        BlockInternal( locks, count );
 
 
@@ -708 +648 @@
 // 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 +658 @@
 }
 
-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 +673 @@
 }
 
-static inline void reset_mask( $monitor * this ) {
-        this->mask.accepted = 0p;
-        this->mask.data = 0p;
+static inline void reset_mask( monitor_desc * this ) {
+        this->mask.accepted = NULL;
+        this->mask.data = NULL;
         this->mask.size = 0;
 }
 
-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 +687 @@
                 //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 +694 @@
         // 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 +722 @@
 }
 
-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 +730 @@
 }
 
-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 +746 @@
 }
 
-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 +760 @@
 }
 
-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 +767 @@
 
 static inline void save(
-        $monitor * ctx [],
+        monitor_desc * ctx [],
         __lock_size_t count,
         __attribute((unused)) __spinlock_t * locks [],
@@ -847 +780 @@
 
 static inline void restore(
-        $monitor * ctx [],
+        monitor_desc * ctx [],
         __lock_size_t count,
         __spinlock_t * locks [],
@@ -865 +798 @@
 // 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;
@@ -883 +816 @@
         }
 
-        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : 0p );
-        return ready2run ? node->waiting_thread : 0p;
+        __cfaabi_dbg_print_safe( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
+        return ready2run ? node->waiting_thread : NULL;
 }
 
 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" );
-                assertf( thrd->monitors.data != 0p, "No current monitor to brand condition %p", thrd->monitors.data );
+                assertf( thrd->monitors.data != NULL, "No current monitor to brand condition %p", thrd->monitors.data );
                 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 +834 @@
 }
 
-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 +883 @@
 }
 
-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++ ) {