Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
+++ src/libcfa/concurrency/invoke.h	(revision 8fc45b762b4e8374629230668423504c051c14e7)
@@ -50,13 +50,13 @@
       extern "Cforall" {
             void ?{}( struct __thread_queue_t & );
-            void append( struct __thread_queue_t *, struct thread_desc * );
-            struct thread_desc * pop_head( struct __thread_queue_t * );
-            struct thread_desc * remove( struct __thread_queue_t *, struct thread_desc ** );
+            void append( struct __thread_queue_t &, struct thread_desc * );
+            struct thread_desc * pop_head( struct __thread_queue_t & );
+            struct thread_desc * remove( struct __thread_queue_t &, struct thread_desc ** );
 
             void ?{}( struct __condition_stack_t & );
-            void push( struct __condition_stack_t *, struct __condition_criterion_t * );
-            struct __condition_criterion_t * pop( struct __condition_stack_t * );
+            void push( struct __condition_stack_t &, struct __condition_criterion_t * );
+            struct __condition_criterion_t * pop( struct __condition_stack_t & );
 
-            void ?{}(spinlock & this);
+            void  ?{}(spinlock & this);
             void ^?{}(spinlock & this);
       }
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
+++ src/libcfa/concurrency/kernel	(revision 8fc45b762b4e8374629230668423504c051c14e7)
@@ -99,6 +99,6 @@
 };
 
-void ?{}(processor & this);
-void ?{}(processor & this, cluster * cltr);
+void  ?{}(processor & this);
+void  ?{}(processor & this, cluster * cltr);
 void ^?{}(processor & this);
 
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
+++ src/libcfa/concurrency/kernel.c	(revision 8fc45b762b4e8374629230668423504c051c14e7)
@@ -335,5 +335,5 @@
 
 	lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
-	append( &this_processor->cltr->ready_queue, thrd );
+	append( this_processor->cltr->ready_queue, thrd );
 	unlock( &this_processor->cltr->ready_queue_lock );
 
@@ -344,5 +344,5 @@
 	verify( disable_preempt_count > 0 );
 	lock( &this->ready_queue_lock DEBUG_CTX2 );
-	thread_desc * head = pop_head( &this->ready_queue );
+	thread_desc * head = pop_head( this->ready_queue );
 	unlock( &this->ready_queue_lock );
 	verify( disable_preempt_count > 0 );
@@ -398,5 +398,5 @@
 }
 
-void BlockInternal(spinlock ** locks, unsigned short count) {
+void BlockInternal(spinlock * locks [], unsigned short count) {
 	disable_interrupts();
 	this_processor->finish.action_code = Release_Multi;
@@ -411,5 +411,5 @@
 }
 
-void BlockInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) {
+void BlockInternal(spinlock * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
 	disable_interrupts();
 	this_processor->finish.action_code = Release_Multi_Schedule;
@@ -623,5 +623,5 @@
 	if ( this.count < 0 ) {
 		// queue current task
-		append( &this.waiting, (thread_desc *)this_thread );
+		append( this.waiting, (thread_desc *)this_thread );
 
 		// atomically release spin lock and block
@@ -639,5 +639,5 @@
 	if ( this.count <= 0 ) {
 		// remove task at head of waiting list
-		thrd = pop_head( &this.waiting );
+		thrd = pop_head( this.waiting );
 	}
 
@@ -655,16 +655,16 @@
 }
 
-void append( __thread_queue_t * this, thread_desc * t ) {
-	verify(this->tail != NULL);
-	*this->tail = t;
-	this->tail = &t->next;
-}
-
-thread_desc * pop_head( __thread_queue_t * this ) {
-	thread_desc * head = this->head;
+void append( __thread_queue_t & this, thread_desc * t ) {
+	verify(this.tail != NULL);
+	*this.tail = t;
+	this.tail = &t->next;
+}
+
+thread_desc * pop_head( __thread_queue_t & this ) {
+	thread_desc * 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;
@@ -673,5 +673,5 @@
 }
 
-thread_desc * remove( __thread_queue_t * this, thread_desc ** it ) {
+thread_desc * remove( __thread_queue_t & this, thread_desc ** it ) {
 	thread_desc * thrd = *it;
 	verify( thrd );
@@ -679,12 +679,12 @@
 	(*it) = thrd->next;
 
-	if( this->tail == &thrd->next ) {
-		this->tail = it;
+	if( this.tail == &thrd->next ) {
+		this.tail = it;
 	}
 
 	thrd->next = NULL;
 
-	verify( (this->head == NULL) == (&this->head == this->tail) );
-	verify( *this->tail == NULL );
+	verify( (this.head == NULL) == (&this.head == this.tail) );
+	verify( *this.tail == NULL );
 	return thrd;
 }
@@ -694,14 +694,14 @@
 }
 
-void push( __condition_stack_t * this, __condition_criterion_t * t ) {
+void push( __condition_stack_t & this, __condition_criterion_t * t ) {
 	verify( !t->next );
-	t->next = this->top;
-	this->top = t;
-}
-
-__condition_criterion_t * pop( __condition_stack_t * this ) {
-	__condition_criterion_t * top = this->top;
+	t->next = this.top;
+	this.top = t;
+}
+
+__condition_criterion_t * pop( __condition_stack_t & this ) {
+	__condition_criterion_t * top = this.top;
 	if( top ) {
-		this->top = top->next;
+		this.top = top->next;
 		top->next = NULL;
 	}
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
+++ src/libcfa/concurrency/kernel_private.h	(revision 8fc45b762b4e8374629230668423504c051c14e7)
@@ -48,6 +48,6 @@
 void BlockInternal(thread_desc * thrd);
 void BlockInternal(spinlock * lock, thread_desc * thrd);
-void BlockInternal(spinlock ** locks, unsigned short count);
-void BlockInternal(spinlock ** locks, unsigned short count, thread_desc ** thrds, unsigned short thrd_count);
+void BlockInternal(spinlock * locks [], unsigned short count);
+void BlockInternal(spinlock * locks [], unsigned short count, thread_desc * thrds [], unsigned short thrd_count);
 void LeaveThread(spinlock * lock, thread_desc * thrd);
 
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
+++ src/libcfa/concurrency/monitor	(revision 8fc45b762b4e8374629230668423504c051c14e7)
@@ -98,6 +98,6 @@
 
 void ?{}( __condition_blocked_queue_t & );
-void append( __condition_blocked_queue_t *, __condition_node_t * );
-__condition_node_t * pop_head( __condition_blocked_queue_t * );
+void append( __condition_blocked_queue_t &, __condition_node_t * );
+__condition_node_t * pop_head( __condition_blocked_queue_t & );
 
 struct condition {
@@ -116,9 +116,9 @@
 }
 
-void wait( condition & this, uintptr_t user_info = 0 );
-bool signal( condition & this );
-bool signal_block( condition & this );
-static inline bool is_empty( condition & this ) { return !this.blocked.head; }
-uintptr_t front( condition & this );
+              void wait        ( condition & this, uintptr_t user_info = 0 );
+              bool signal      ( condition & this );
+              bool signal_block( condition & this );
+static inline bool is_empty    ( condition & this ) { return !this.blocked.head; }
+         uintptr_t front       ( condition & this );
 
 //-----------------------------------------------------------------------------
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
+++ src/libcfa/concurrency/monitor.c	(revision 8fc45b762b4e8374629230668423504c051c14e7)
@@ -26,6 +26,6 @@
 // Forward declarations
 static inline void set_owner ( monitor_desc * this, thread_desc * owner );
-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 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 );
 
@@ -33,23 +33,23 @@
 static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
 
-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 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, int count );
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], int count );
 
 forall(dtype T | sized( T ))
-static inline short insert_unique( T ** array, short & size, T * val );
+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 );
+static inline short aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
@@ -58,10 +58,10 @@
 	__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 */ \
@@ -114,5 +114,5 @@
 
 			// Some one else has the monitor, wait in line for it
-			append( &this->entry_queue, thrd );
+			append( this->entry_queue, thrd );
 			BlockInternal( &this->lock );
 
@@ -160,5 +160,5 @@
 
 			// 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 );
 
@@ -182,5 +182,5 @@
 
 			// Some one else has the monitor, wait in line for it
-			append( &this->entry_queue, thrd );
+			append( this->entry_queue, thrd );
 			BlockInternal( &this->lock );
 
@@ -279,5 +279,5 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave(monitor_desc ** monitors, int count) {
+static inline void leave(monitor_desc * monitors [], int count) {
 	for(int i = count - 1; i >= 0; i--) {
 		__leave_monitor_desc( monitors[i] );
@@ -287,5 +287,5 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, fptr_t func ) {
+void ?{}( monitor_guard_t & this, monitor_desc * m [], int count, fptr_t func ) {
 	// Store current array
 	this.m = m;
@@ -333,5 +333,5 @@
 // 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;
@@ -378,8 +378,8 @@
 }
 
-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;
 }
@@ -403,5 +403,5 @@
 	// 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)
@@ -456,5 +456,5 @@
 
 	//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
@@ -462,5 +462,5 @@
 		__condition_criterion_t * crit = &node->criteria[i];
 		assert( !crit->ready );
-		push( &crit->target->signal_stack, crit );
+		push( crit->target->signal_stack, crit );
 	}
 
@@ -491,5 +491,5 @@
 
 	//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 );
 
@@ -569,5 +569,5 @@
 
 				__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 );
@@ -661,5 +661,5 @@
 }
 
-static inline void set_owner( monitor_desc ** monitors, short 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;
@@ -670,5 +670,5 @@
 }
 
-static inline void set_mask( monitor_desc ** storage, short count, const __waitfor_mask_t & mask ) {
+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;
@@ -685,5 +685,5 @@
 	//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,
@@ -697,5 +697,5 @@
 	// 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 );
 
@@ -725,23 +725,23 @@
 }
 
-static inline void init( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
+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( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
+	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, unsigned short count ) {
+		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 );
@@ -749,5 +749,5 @@
 }
 
-static inline void lock_all( monitor_desc ** source, spinlock ** /*out*/ locks, unsigned short count ) {
+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;
@@ -757,5 +757,5 @@
 }
 
-static inline void unlock_all( spinlock ** locks, unsigned short count ) {
+static inline void unlock_all( spinlock * locks [], unsigned short count ) {
 	for( int i = 0; i < count; i++ ) {
 		unlock( locks[i] );
@@ -763,5 +763,5 @@
 }
 
-static inline void unlock_all( monitor_desc ** locks, unsigned short count ) {
+static inline void unlock_all( monitor_desc * locks [], unsigned short count ) {
 	for( int i = 0; i < count; i++ ) {
 		unlock( &locks[i]->lock );
@@ -769,5 +769,11 @@
 }
 
-static inline void save( monitor_desc ** ctx, short count, __attribute((unused)) spinlock ** locks, unsigned int * /*out*/ recursions, __waitfor_mask_t * /*out*/ masks ) {
+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;
@@ -776,5 +782,11 @@
 }
 
-static inline void restore( 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 /*out*/ recursions [],
+	__waitfor_mask_t /*out*/ masks []
+) {
 	lock_all( locks, count );
 	for( int i = 0; i < count; i++ ) {
@@ -825,10 +837,10 @@
 }
 
-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;
+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
@@ -852,5 +864,5 @@
 
 forall(dtype T | sized( T ))
-static inline short insert_unique( T ** array, short & size, T * val ) {
+static inline short insert_unique( T * array [], short & size, T * val ) {
 	if( !val ) return size;
 
@@ -872,5 +884,5 @@
 }
 
-static inline short aggregate( monitor_desc ** storage, const __waitfor_mask_t & mask ) {
+static inline short aggregate( monitor_desc * storage [], const __waitfor_mask_t & mask ) {
 	short size = 0;
 	for( int i = 0; i < mask.size; i++ ) {
@@ -890,16 +902,16 @@
 }
 
-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;