Changes in src/libcfa/concurrency/monitor.c [2f6a7e93:de737c8]

File:

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

src/libcfa/concurrency/monitor.c

@@ -17 +17 @@
 
 #include <stdlib>
-#include <inttypes.h>
 
 #include "libhdr.h"
@@ -27 +26 @@
 // 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 set_owner ( monitor_desc ** storage, short count, thread_desc * owner );
+static inline void set_mask  ( monitor_desc ** storage, short count, const __waitfor_mask_t & mask );
 static inline void reset_mask( monitor_desc * this );
 
@@ -34 +33 @@
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 
-static inline void lock_all  ( spinlock * locks [], __lock_size_t count );
-static inline void lock_all  ( monitor_desc * source [], spinlock * /*out*/ locks [], __lock_size_t count );
-static inline void unlock_all( spinlock * 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 * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
-static inline void restore( monitor_desc * ctx [], __lock_size_t count, spinlock * 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 void lock_all( spinlock ** locks, unsigned short count );
+static inline void lock_all( monitor_desc ** source, spinlock ** /*out*/ locks, unsigned short count );
+static inline void unlock_all( spinlock ** locks, unsigned short count );
+static inline void unlock_all( monitor_desc ** locks, unsigned short count );
+
+static inline void save   ( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks );
+static inline void restore( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*in */ recursions, __waitfor_mask_t * /*in */ masks );
+
+static inline void init     ( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
+static inline void init_push( int 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_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
+static inline void                 brand_condition   ( condition * );
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc ** monitors, int 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 short insert_unique( T ** array, short & size, T * val );
+static inline short count_max    ( const __waitfor_mask_t & mask );
+static inline short aggregate    ( monitor_desc ** storage, const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
@@ -59 +58 @@
         __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
         __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
-        init( count, monitors, waiter, criteria );                /* Link everything together                                                            */ \
+        init( count, monitors, &waiter, criteria );               /* Link everything together                                                            */ \
 
 #define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack                         */ \
         __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
         __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
-        init_push( count, monitors, waiter, criteria );           /* Link everything together and push it to the AS-Stack                                */ \
+        init_push( count, monitors, &waiter, criteria );          /* Link everything together and push it to the AS-Stack                                */ \
 
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
         monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
-        __lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
+        unsigned short count = cnt;                               /* Save the count to a local variable                                                  */ \
         unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
-        __waitfor_mask_t masks [ count ];                         /* Save the current waitfor masks to restore them later                                */ \
+        __waitfor_mask_t masks[ count ];                          /* Save the current waitfor masks to restore them later                                */ \
         spinlock *   locks     [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
 
@@ -115 +114 @@
 
                         // Some one else has the monitor, wait in line for it
-                        append( this->entry_queue, thrd );
+                        append( &this->entry_queue, thrd );
                         BlockInternal( &this->lock );
 
@@ -154 +153 @@
                 }
 
-                __lock_size_t count = 1;
+                int count = 1;
                 monitor_desc ** monitors = &this;
                 __monitor_group_t group = { &this, 1, func };
@@ -161 +160 @@
 
                         // Wake the thread that is waiting for this
-                        __condition_criterion_t * urgent = pop( this->signal_stack );
+                        __condition_criterion_t * urgent = pop( &this->signal_stack );
                         verify( urgent );
 
@@ -183 +182 @@
 
                         // Some one else has the monitor, wait in line for it
-                        append( this->entry_queue, thrd );
+                        append( &this->entry_queue, thrd );
                         BlockInternal( &this->lock );
 
@@ -273 +272 @@
 // relies on the monitor array being sorted
 static inline void enter( __monitor_group_t monitors ) {
-        for( __lock_size_t i = 0; i < monitors.size; i++) {
+        for(int i = 0; i < monitors.size; i++) {
                 __enter_monitor_desc( monitors.list[i], monitors );
         }
@@ -280 +279 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave(monitor_desc * monitors [], __lock_size_t count) {
-        for( __lock_size_t i = count - 1; i >= 0; i--) {
+static inline void leave(monitor_desc ** monitors, int count) {
+        for(int i = count - 1; i >= 0; i--) {
                 __leave_monitor_desc( monitors[i] );
         }
@@ -288 +287 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, fptr_t func ) {
         // Store current array
         this.m = m;
@@ -297 +296 @@
 
         // Save previous thread context
-        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
+        this.prev_mntrs = this_thread->monitors.list;
+        this.prev_count = this_thread->monitors.size;
+        this.prev_func  = this_thread->monitors.func;
 
         // Update thread context (needed for conditions)
-        this_thread->monitors.[list, size, func] = [m, count, func];
+        this_thread->monitors.list = m;
+        this_thread->monitors.size = count;
+        this_thread->monitors.func = func;
 
         // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
@@ -322 +325 @@
 
         // Restore thread context
-        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
-}
+        this_thread->monitors.list = this.prev_mntrs;
+        this_thread->monitors.size = this.prev_count;
+        this_thread->monitors.func = this.prev_func;
+}
+
 
 // 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_desc ** m, fptr_t func ) {
         // Store current array
         this.m = *m;
 
         // Save previous thread context
-        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
+        this.prev_mntrs = this_thread->monitors.list;
+        this.prev_count = this_thread->monitors.size;
+        this.prev_func  = this_thread->monitors.func;
 
         // Update thread context (needed for conditions)
-        this_thread->monitors.[list, size, func] = [m, 1, func];
+        this_thread->monitors.list = m;
+        this_thread->monitors.size = 1;
+        this_thread->monitors.func = func;
 
         __enter_monitor_dtor( this.m, func );
 }
+
 
 // Dtor for monitor guard
@@ -346 +357 @@
 
         // Restore thread context
-        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+        this_thread->monitors.list = this.prev_mntrs;
+        this_thread->monitors.size = this.prev_count;
+        this_thread->monitors.func = this.prev_func;
 }
 
 //-----------------------------------------------------------------------------
 // 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_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
@@ -365 +378 @@
 }
 
-void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) {
         this.ready  = false;
         this.target = target;
-        this.owner  = &owner;
+        this.owner  = owner;
         this.next   = NULL;
 }
@@ -374 +387 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling
-void wait( condition & this, uintptr_t user_info = 0 ) {
+void wait( condition * this, uintptr_t user_info = 0 ) {
         brand_condition( this );
 
         // Check that everything is as expected
-        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 );
+        assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
+        verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+        verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
 
         // Create storage for monitor context
-        monitor_ctx( this.monitors, this.monitor_count );
+        monitor_ctx( this->monitors, this->monitor_count );
 
         // Create the node specific to this wait operation
@@ -390 +403 @@
         // 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
-        append( this.blocked, &waiter );
+        append( &this->blocked, &waiter );
 
         // Lock all monitors (aggregates the locks as well)
@@ -396 +409 @@
 
         // Find the next thread(s) to run
-        __lock_size_t thread_count = 0;
+        short thread_count = 0;
         thread_desc * threads[ count ];
         __builtin_memset( threads, 0, sizeof( threads ) );
@@ -404 +417 @@
 
         // Remove any duplicate threads
-        for( __lock_size_t i = 0; i < count; i++) {
+        for( int i = 0; i < count; i++) {
                 thread_desc * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
@@ -416 +429 @@
 }
 
-bool signal( condition & this ) {
+bool signal( condition * this ) {
         if( is_empty( this ) ) { return false; }
 
         //Check that everything is as expected
-        verify( this.monitors );
-        verify( this.monitor_count != 0 );
+        verify( this->monitors );
+        verify( this->monitor_count != 0 );
 
         //Some more checking in debug
         LIB_DEBUG_DO(
                 thread_desc * this_thrd = this_thread;
-                if ( this.monitor_count != this_thrd->monitors.size ) {
-                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", &this, this.monitor_count, this_thrd->monitors.size );
-                }
-
-                for(int i = 0; i < this.monitor_count; i++) {
-                        if ( this.monitors[i] != this_thrd->monitors.list[i] ) {
-                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors.list[i] );
+                if ( this->monitor_count != this_thrd->monitors.size ) {
+                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->monitors.size );
+                }
+
+                for(int i = 0; i < this->monitor_count; i++) {
+                        if ( this->monitors[i] != this_thrd->monitors.list[i] ) {
+                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->monitors.list[i] );
                         }
                 }
         );
 
-        __lock_size_t count = this.monitor_count;
+        unsigned short count = this->monitor_count;
 
         // Lock all monitors
-        lock_all( this.monitors, NULL, count );
+        lock_all( this->monitors, NULL, count );
 
         //Pop the head of the waiting queue
-        __condition_node_t * node = pop_head( this.blocked );
+        __condition_node_t * node = pop_head( &this->blocked );
 
         //Add the thread to the proper AS stack
@@ -449 +462 @@
                 __condition_criterion_t * crit = &node->criteria[i];
                 assert( !crit->ready );
-                push( crit->target->signal_stack, crit );
+                push( &crit->target->signal_stack, crit );
         }
 
         //Release
-        unlock_all( this.monitors, count );
+        unlock_all( this->monitors, count );
 
         return true;
 }
 
-bool signal_block( condition & this ) {
-        if( !this.blocked.head ) { return false; }
+bool signal_block( condition * this ) {
+        if( !this->blocked.head ) { return false; }
 
         //Check that everything is as expected
-        verifyf( 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->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
+        verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
 
         // Create storage for monitor context
-        monitor_ctx( this.monitors, this.monitor_count );
+        monitor_ctx( this->monitors, this->monitor_count );
 
         // Lock all monitors (aggregates the locks them as well)
@@ -478 +491 @@
 
         //Find the thread to run
-        thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
+        thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
         set_owner( monitors, count, signallee );
 
-        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", this, signallee );
 
         //Everything is ready to go to sleep
@@ -499 +512 @@
 
 // Access the user_info of the thread waiting at the front of the queue
-uintptr_t front( condition & this ) {
+uintptr_t front( condition * this ) {
         verifyf( !is_empty(this),
                 "Attempt to access user data on an empty condition.\n"
                 "Possible cause is not checking if the condition is empty before reading stored data."
         );
-        return this.blocked.head->user_info;
+        return this->blocked.head->user_info;
 }
 
@@ -524 +537 @@
         // This statment doesn't have a contiguous list of monitors...
         // Create one!
-        __lock_size_t max = count_max( mask );
+        short max = count_max( mask );
         monitor_desc * mon_storage[max];
         __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
-        __lock_size_t actual_count = aggregate( mon_storage, mask );
-
-        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
+        short actual_count = aggregate( mon_storage, mask );
+
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (short)max);
 
         if(actual_count == 0) return;
@@ -556 +569 @@
 
                                 __condition_criterion_t * dtor_crit = mon2dtor->dtor_node->criteria;
-                                push( mon2dtor->signal_stack, dtor_crit );
+                                push( &mon2dtor->signal_stack, dtor_crit );
 
                                 unlock_all( locks, count );
@@ -616 +629 @@
         set_mask( monitors, count, mask );
 
-        for( __lock_size_t i = 0; i < count; i++) {
+        for(int i = 0; i < count; i++) {
                 verify( monitors[i]->owner == this_thread );
         }
@@ -648 +661 @@
 }
 
-static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
+static inline void set_owner( monitor_desc ** monitors, short count, thread_desc * owner ) {
         monitors[0]->owner     = owner;
         monitors[0]->recursion = 1;
-        for( __lock_size_t i = 1; i < count; i++ ) {
+        for( int i = 1; i < count; i++ ) {
                 monitors[i]->owner     = owner;
                 monitors[i]->recursion = 0;
@@ -657 +670 @@
 }
 
-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++) {
+static inline void set_mask( monitor_desc ** storage, short count, const __waitfor_mask_t & mask ) {
+        for(int i = 0; i < count; i++) {
                 storage[i]->mask = mask;
         }
@@ -672 +685 @@
         //Check the signaller stack
         LIB_DEBUG_PRINT_SAFE("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
-        __condition_criterion_t * urgent = pop( this->signal_stack );
+        __condition_criterion_t * urgent = pop( &this->signal_stack );
         if( urgent ) {
                 //The signaller stack is not empty,
@@ -684 +697 @@
         // No signaller thread
         // Get the next thread in the entry_queue
-        thread_desc * new_owner = pop_head( this->entry_queue );
+        thread_desc * new_owner = pop_head( &this->entry_queue );
         set_owner( this, new_owner );
 
@@ -692 +705 @@
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
         __acceptable_t * it = this->mask.clauses; // Optim
-        __lock_size_t count = this->mask.size;
+        int count = this->mask.size;
 
         // Check if there are any acceptable functions
@@ -701 +714 @@
 
         // For all acceptable functions check if this is the current function.
-        for( __lock_size_t i = 0; i < count; i++, it++ ) {
+        for( short i = 0; i < count; i++, it++ ) {
                 if( *it == group ) {
                         *this->mask.accepted = i;
@@ -712 +725 @@
 }
 
-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++) {
+static inline void init( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
+        for(int i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
         }
 
-        waiter.criteria = 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++) {
+        waiter->criteria = criteria;
+}
+
+static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
+        for(int i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
                 LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
-                push( criteria[i].target->signal_stack, &criteria[i] );
-        }
-
-        waiter.criteria = criteria;
-}
-
-static inline void lock_all( spinlock * locks [], __lock_size_t count ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+                push( &criteria[i].target->signal_stack, &criteria[i] );
+        }
+
+        waiter->criteria = criteria;
+}
+
+static inline void lock_all( spinlock ** locks, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
                 lock_yield( locks[i] DEBUG_CTX2 );
         }
 }
 
-static inline void lock_all( monitor_desc * source [], spinlock * /*out*/ locks [], __lock_size_t count ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+static inline void lock_all( monitor_desc ** source, spinlock ** /*out*/ locks, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
                 spinlock * l = &source[i]->lock;
                 lock_yield( l DEBUG_CTX2 );
@@ -744 +757 @@
 }
 
-static inline void unlock_all( spinlock * locks [], __lock_size_t count ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+static inline void unlock_all( spinlock ** locks, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
                 unlock( locks[i] );
         }
 }
 
-static inline void unlock_all( monitor_desc * locks [], __lock_size_t count ) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+static inline void unlock_all( monitor_desc ** locks, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
                 unlock( &locks[i]->lock );
         }
 }
 
-static inline void save(
-        monitor_desc * ctx [],
-        __lock_size_t count,
-        __attribute((unused)) spinlock * locks [],
-        unsigned int /*out*/ recursions [],
-        __waitfor_mask_t /*out*/ masks []
-) {
-        for( __lock_size_t i = 0; i < count; i++ ) {
+static inline void save( monitor_desc ** ctx, short count, __attribute((unused)) spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
+        for( int i = 0; i < count; i++ ) {
                 recursions[i] = ctx[i]->recursion;
                 masks[i]      = ctx[i]->mask;
@@ -769 +776 @@
 }
 
-static inline void restore(
-        monitor_desc * ctx [],
-        __lock_size_t count,
-        spinlock * locks [],
-        unsigned int /*out*/ recursions [],
-        __waitfor_mask_t /*out*/ masks []
-) {
+static inline void restore( monitor_desc ** ctx, short count, spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
         lock_all( locks, count );
-        for( __lock_size_t i = 0; i < count; i++ ) {
+        for( int i = 0; i < count; i++ ) {
                 ctx[i]->recursion = recursions[i];
                 ctx[i]->mask      = masks[i];
@@ -810 +811 @@
 }
 
-static inline void brand_condition( condition & this ) {
+static inline void brand_condition( condition * this ) {
         thread_desc * thrd = this_thread;
-        if( !this.monitors ) {
+        if( !this->monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
                 assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
-                this.monitor_count = thrd->monitors.size;
-
-                this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
-                for( int i = 0; i < this.monitor_count; i++ ) {
-                        this.monitors[i] = thrd->monitors.list[i];
-                }
-        }
-}
-
-static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
-
-        __thread_queue_t & entry_queue = monitors[0]->entry_queue;
+                this->monitor_count = thrd->monitors.size;
+
+                this->monitors = malloc( this->monitor_count * sizeof( *this->monitors ) );
+                for( int i = 0; i < this->monitor_count; i++ ) {
+                        this->monitors[i] = thrd->monitors.list[i];
+                }
+        }
+}
+
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc ** monitors, int count ) {
+
+        __thread_queue_t * entry_queue = &monitors[0]->entry_queue;
 
         // For each thread in the entry-queue
-        for(    thread_desc ** thrd_it = &entry_queue.head;
+        for(    thread_desc ** thrd_it = &entry_queue->head;
                 *thrd_it;
                 thrd_it = &(*thrd_it)->next
@@ -851 +852 @@
 
 forall(dtype T | sized( T ))
-static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val ) {
+static inline short insert_unique( T ** array, short & size, T * val ) {
         if( !val ) return size;
 
-        for( __lock_size_t i = 0; i <= size; i++) {
+        for(int i = 0; i <= size; i++) {
                 if( array[i] == val ) return size;
         }
@@ -863 +864 @@
 }
 
-static inline __lock_size_t count_max( const __waitfor_mask_t & mask ) {
-        __lock_size_t max = 0;
-        for( __lock_size_t i = 0; i < mask.size; i++ ) {
+static inline short count_max( const __waitfor_mask_t & mask ) {
+        short max = 0;
+        for( int i = 0; i < mask.size; i++ ) {
                 max += mask.clauses[i].size;
         }
@@ -871 +872 @@
 }
 
-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++ ) {
+static inline short aggregate( monitor_desc ** storage, const __waitfor_mask_t & mask ) {
+        short size = 0;
+        for( int i = 0; i < mask.size; i++ ) {
                 __libcfa_small_sort( mask.clauses[i].list, mask.clauses[i].size );
-                for( __lock_size_t j = 0; j < mask.clauses[i].size; j++) {
+                for( int j = 0; j < mask.clauses[i].size; j++) {
                         insert_unique( storage, size, mask.clauses[i].list[j] );
                 }
@@ -889 +890 @@
 }
 
-void append( __condition_blocked_queue_t & this, __condition_node_t * c ) {
-        verify(this.tail != NULL);
-        *this.tail = c;
-        this.tail = &c->next;
-}
-
-__condition_node_t * pop_head( __condition_blocked_queue_t & this ) {
-        __condition_node_t * head = this.head;
+void append( __condition_blocked_queue_t * this, __condition_node_t * c ) {
+        verify(this->tail != NULL);
+        *this->tail = c;
+        this->tail = &c->next;
+}
+
+__condition_node_t * pop_head( __condition_blocked_queue_t * this ) {
+        __condition_node_t * head = this->head;
         if( head ) {
-                this.head = head->next;
+                this->head = head->next;
                 if( !head->next ) {
-                        this.tail = &this.head;
+                        this->tail = &this->head;
                 }
                 head->next = NULL;