Index: src/benchmark/Makefile.am
===================================================================
--- src/benchmark/Makefile.am	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/benchmark/Makefile.am	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -27,4 +27,6 @@
 
 noinst_PROGRAMS =
+
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 
 bench$(EXEEXT) :
@@ -63,27 +65,4 @@
 ctxswitch-pthread$(EXEEXT):
 	@BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-## =========================================================================================================
-creation$(EXEEXT) :\
-	creation-pthread.run		\
-	creation-cfa_coroutine.run	\
-	creation-cfa_thread.run		\
-	creation-upp_coroutine.run	\
-	creation-upp_thread.run
-
-creation-cfa_coroutine$(EXEEXT):
-	${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-creation-cfa_thread$(EXEEXT):
-	${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-creation-upp_coroutine$(EXEEXT):
-	u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-creation-upp_thread$(EXEEXT):
-	u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-creation-pthread$(EXEEXT):
-	@BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 ## =========================================================================================================
@@ -153,4 +132,27 @@
 
 ## =========================================================================================================
+creation$(EXEEXT) :\
+	creation-pthread.run		\
+	creation-cfa_coroutine.run	\
+	creation-cfa_thread.run		\
+	creation-upp_coroutine.run	\
+	creation-upp_thread.run
+
+creation-cfa_coroutine$(EXEEXT):
+	${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-cfa_thread$(EXEEXT):
+	${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-upp_coroutine$(EXEEXT):
+	u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-upp_thread$(EXEEXT):
+	u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-pthread$(EXEEXT):
+	@BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+## =========================================================================================================
 
 %.run : %$(EXEEXT) ${REPEAT}
Index: src/benchmark/Makefile.in
===================================================================
--- src/benchmark/Makefile.in	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/benchmark/Makefile.in	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -444,4 +444,6 @@
 .NOTPARALLEL:
 
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
+
 bench$(EXEEXT) :
 	@for ccflags in "-debug" "-nodebug"; do \
@@ -479,26 +481,4 @@
 	@BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
-creation$(EXEEXT) :\
-	creation-pthread.run		\
-	creation-cfa_coroutine.run	\
-	creation-cfa_thread.run		\
-	creation-upp_coroutine.run	\
-	creation-upp_thread.run
-
-creation-cfa_coroutine$(EXEEXT):
-	${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-creation-cfa_thread$(EXEEXT):
-	${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-creation-upp_coroutine$(EXEEXT):
-	u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-creation-upp_thread$(EXEEXT):
-	u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
-creation-pthread$(EXEEXT):
-	@BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
 mutex$(EXEEXT) :\
 	mutex-function.run	\
@@ -562,4 +542,26 @@
 waitfor-cfa4$(EXEEXT):
 	${CC}        schedext/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation$(EXEEXT) :\
+	creation-pthread.run		\
+	creation-cfa_coroutine.run	\
+	creation-cfa_thread.run		\
+	creation-upp_coroutine.run	\
+	creation-upp_thread.run
+
+creation-cfa_coroutine$(EXEEXT):
+	${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-cfa_thread$(EXEEXT):
+	${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-upp_coroutine$(EXEEXT):
+	u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-upp_thread$(EXEEXT):
+	u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+
+creation-pthread$(EXEEXT):
+	@BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 
 %.run : %$(EXEEXT) ${REPEAT}
Index: src/benchmark/SchedInt.c
===================================================================
--- src/benchmark/SchedInt.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ 	(revision )
@@ -1,83 +1,0 @@
-#include <fstream>
-#include <stdlib>
-#include <thread>
-
-#include "bench.h"
-
-condition condA; 
-condition condB;
-condition condC;
-condition condD;
-
-monitor mon_t {};
-
-mon_t mon1, mon2;
-
-thread thrdA {};
-thread thrdB {};
-thread thrdC {};
-thread thrdD {};
-
-//-------------------------------------------------------------------
-// 1 monitor signal cycle
-void sideA( mon_t * mutex a ) {
-	long long int StartTime, EndTime;
-
-	StartTime = Time();
-	for( int i = 0;; i++ ) {
-		signal(&condA);
-		if( i > N ) break;
-		wait(&condB);
-	}
-	EndTime = Time();
-
-	sout | ( EndTime - StartTime ) / N;
-}
-
-void sideB( mon_t * mutex a ) {
-	for( int i = 0;; i++ ) {
-		signal(&condB);
-		if( i > N ) break;
-		wait(&condA);
-	}
-}
-
-//-------------------------------------------------------------------
-// 2 monitor signal cycle
-void sideC( mon_t * mutex a, mon_t * mutex b ) {
-	long long int StartTime, EndTime;
-
-	StartTime = Time();
-	for( int i = 0;; i++ ) {
-		signal(&condC);
-		if( i > N ) break;
-		wait(&condD);
-	}
-	EndTime = Time();
-
-	sout | ( EndTime - StartTime ) / N | endl;
-}
-
-void sideD( mon_t * mutex a, mon_t * mutex b ) {
-	for( int i = 0;; i++ ) {
-		signal(&condD);
-		if( i > N ) break;
-		wait(&condC);
-	}
-}
-
-void main( thrdA * this ) { sideA( &mon1 ); }
-void main( thrdB * this ) { sideB( &mon1 ); }
-void main( thrdC * this ) { sideC( &mon1, &mon2 ); }
-void main( thrdD * this ) { sideD( &mon1, &mon2 ); }
-
-int main() {
-	{
-		thrdA a;
-		thrdB b;
-	}
-	{
-		thrdC c;
-		thrdD d;
-	}
-}
Index: src/benchmark/csv-data.c
===================================================================
--- src/benchmark/csv-data.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/benchmark/csv-data.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -111,7 +111,7 @@
 	StartTime = Time();
 	for( int i = 0;; i++ ) {
-		signal(&cond1a);
-		if( i > N ) break;
-		wait(&cond1b);
+		signal(cond1a);
+		if( i > N ) break;
+		wait(cond1b);
 	}
 	EndTime = Time();
@@ -122,7 +122,7 @@
 void side1B( mon_t & mutex a ) {
 	for( int i = 0;; i++ ) {
-		signal(&cond1b);
-		if( i > N ) break;
-		wait(&cond1a);
+		signal(cond1b);
+		if( i > N ) break;
+		wait(cond1a);
 	}
 }
@@ -159,7 +159,7 @@
 	StartTime = Time();
 	for( int i = 0;; i++ ) {
-		signal(&cond2a);
-		if( i > N ) break;
-		wait(&cond2b);
+		signal(cond2a);
+		if( i > N ) break;
+		wait(cond2b);
 	}
 	EndTime = Time();
@@ -170,7 +170,7 @@
 void side2B( mon_t & mutex a, mon_t & mutex b ) {
 	for( int i = 0;; i++ ) {
-		signal(&cond2b);
-		if( i > N ) break;
-		wait(&cond2a);
+		signal(cond2b);
+		if( i > N ) break;
+		wait(cond2a);
 	}
 }
Index: src/benchmark/schedint/cfa1.c
===================================================================
--- src/benchmark/schedint/cfa1.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/benchmark/schedint/cfa1.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -15,5 +15,5 @@
 
 void __attribute__((noinline)) call( M & mutex a1 ) {
-	signal(&c);
+	signal(c);
 }
 
@@ -22,5 +22,5 @@
 	BENCH(
 		for (size_t i = 0; i < n; i++) {
-			wait(&c);
+			wait(c);
 		},
 		result
Index: src/benchmark/schedint/cfa2.c
===================================================================
--- src/benchmark/schedint/cfa2.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/benchmark/schedint/cfa2.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -15,5 +15,5 @@
 
 void __attribute__((noinline)) call( M & mutex a1, M & mutex a2 ) {
-	signal(&c);
+	signal(c);
 }
 
@@ -22,5 +22,5 @@
 	BENCH(
 		for (size_t i = 0; i < n; i++) {
-			wait(&c);
+			wait(c);
 		},
 		result
Index: src/benchmark/schedint/cfa4.c
===================================================================
--- src/benchmark/schedint/cfa4.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/benchmark/schedint/cfa4.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -15,5 +15,5 @@
 
 void __attribute__((noinline)) call( M & mutex a1, M & mutex a2, M & mutex a3, M & mutex a4 ) {
-	signal(&c);
+	signal(c);
 }
 
@@ -22,5 +22,5 @@
 	BENCH(
 		for (size_t i = 0; i < n; i++) {
-			wait(&c);
+			wait(c);
 		},
 		result
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/libcfa/concurrency/kernel	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -39,6 +39,6 @@
 void  ?{}(semaphore & this, int count = 1);
 void ^?{}(semaphore & this);
-void P(semaphore * this);
-void V(semaphore * this);
+void   P (semaphore & this);
+void   V (semaphore & this);
 
 
@@ -51,5 +51,5 @@
 };
 
-void ?{}(cluster & this);
+void ?{} (cluster & this);
 void ^?{}(cluster & this);
 
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/libcfa/concurrency/kernel.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -158,5 +158,5 @@
 		LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
 		this.do_terminate = true;
-		P( &this.terminated );
+		P( this.terminated );
 		pthread_join( this.kernel_thread, NULL );
 	}
@@ -216,5 +216,5 @@
 	}
 
-	V( &this->terminated );
+	V( this->terminated );
 
 	LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
@@ -618,29 +618,29 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore * this) {
-	lock( &this->lock DEBUG_CTX2 );
-	this->count -= 1;
-	if ( this->count < 0 ) {
+void P(semaphore & this) {
+	lock( &this.lock DEBUG_CTX2 );
+	this.count -= 1;
+	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
-		BlockInternal( &this->lock );
+		BlockInternal( &this.lock );
 	}
 	else {
-	    unlock( &this->lock );
-	}
-}
-
-void V(semaphore * this) {
+	    unlock( &this.lock );
+	}
+}
+
+void V(semaphore & this) {
 	thread_desc * thrd = NULL;
-	lock( &this->lock DEBUG_CTX2 );
-	this->count += 1;
-	if ( this->count <= 0 ) {
+	lock( &this.lock DEBUG_CTX2 );
+	this.count += 1;
+	if ( this.count <= 0 ) {
 		// remove task at head of waiting list
-		thrd = pop_head( &this->waiting );
-	}
-
-	unlock( &this->lock );
+		thrd = pop_head( &this.waiting );
+	}
+
+	unlock( &this.lock );
 
 	// make new owner
Index: src/libcfa/concurrency/monitor
===================================================================
--- src/libcfa/concurrency/monitor	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/libcfa/concurrency/monitor	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -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 e1e8408b22136702256cde37d937165f85a711fb)
+++ src/libcfa/concurrency/monitor.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -45,5 +45,5 @@
 
 static inline thread_desc *        check_condition   ( __condition_criterion_t * );
-static inline void                 brand_condition   ( condition * );
+static inline void                 brand_condition   ( condition & );
 static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc ** monitors, int count );
 
@@ -69,5 +69,5 @@
 	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                               */ \
 
@@ -387,14 +387,14 @@
 //-----------------------------------------------------------------------------
 // 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 (%i)", this->monitor_count );
-	verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", 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
@@ -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)
@@ -429,32 +429,32 @@
 }
 
-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] );
 			}
 		}
 	);
 
-	unsigned short 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
@@ -466,18 +466,18 @@
 
 	//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 (%i)", 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)
@@ -491,8 +491,8 @@
 
 	//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
@@ -512,10 +512,10 @@
 
 // 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;
 }
 
@@ -811,14 +811,14 @@
 }
 
-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];
+		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];
 		}
 	}
Index: src/tests/boundedBuffer.c
===================================================================
--- src/tests/boundedBuffer.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/tests/boundedBuffer.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -1,8 +1,8 @@
-// 
+//
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// boundedBuffer.c -- 
-// 
+//
+// boundedBuffer.c --
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Oct 30 12:45:13 2017
@@ -10,5 +10,5 @@
 // Last Modified On : Mon Oct 30 18:00:10 2017
 // Update Count     : 7
-// 
+//
 
 #include <stdlib>
@@ -31,16 +31,16 @@
 
 void insert( Buffer & mutex buffer, int elem ) {
-	if ( buffer.count == 20 ) wait( &buffer.empty );
+	if ( buffer.count == 20 ) wait( buffer.empty );
 	buffer.elements[buffer.back] = elem;
 	buffer.back = ( buffer.back + 1 ) % 20;
 	buffer.count += 1;
-	signal( &buffer.full );
+	signal( buffer.full );
 }
 int remove( Buffer & mutex buffer ) {
-	if ( buffer.count == 0 ) wait( &buffer.full );
+	if ( buffer.count == 0 ) wait( buffer.full );
 	int elem = buffer.elements[buffer.front];
 	buffer.front = ( buffer.front + 1 ) % 20;
 	buffer.count -= 1;
-	signal( &buffer.empty );
+	signal( buffer.empty );
 	return elem;
 }
Index: src/tests/datingService.c
===================================================================
--- src/tests/datingService.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/tests/datingService.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -1,9 +1,9 @@
-//                               -*- Mode: C -*- 
-// 
+//                               -*- Mode: C -*-
+//
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// datingService.c -- 
-// 
+//
+// datingService.c --
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Oct 30 12:56:20 2017
@@ -11,5 +11,5 @@
 // Last Modified On : Mon Oct 30 17:58:41 2017
 // Update Count     : 14
-// 
+//
 
 #include <stdlib>										// rand48
@@ -18,8 +18,4 @@
 #include <thread>
 #include <unistd.h>										// getpid
-
-bool empty( condition & c ) {
-	return c.blocked.head == NULL;
-}
 
 enum { NoOfPairs = 20 };
@@ -31,10 +27,10 @@
 
 unsigned int girl( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) {
-	if ( empty( ds.Boys[ccode] ) ) {
-		wait( &ds.Girls[ccode] );
+	if ( is_empty( ds.Boys[ccode] ) ) {
+		wait( ds.Girls[ccode] );
 		ds.GirlPhoneNo = PhoneNo;
 	} else {
 		ds.GirlPhoneNo = PhoneNo;
-		signal_block( &ds.Boys[ccode] );
+		signal_block( ds.Boys[ccode] );
 	} // if
 	return ds.BoyPhoneNo;
@@ -42,10 +38,10 @@
 
 unsigned int boy( DatingService & mutex ds, unsigned int PhoneNo, unsigned int ccode ) {
-	if ( empty( ds.Girls[ccode] ) ) {
-		wait( &ds.Boys[ccode] );
+	if ( is_empty( ds.Girls[ccode] ) ) {
+		wait( ds.Boys[ccode] );
 		ds.BoyPhoneNo = PhoneNo;
 	} else {
 		ds.BoyPhoneNo = PhoneNo;
-		signal_block( &ds.Girls[ccode] );
+		signal_block( ds.Girls[ccode] );
 	} // if
 	return ds.GirlPhoneNo;
Index: src/tests/sched-int-barge.c
===================================================================
--- src/tests/sched-int-barge.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/tests/sched-int-barge.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -73,5 +73,5 @@
 	if( action == c.do_wait1 || action == c.do_wait2 ) {
 		c.state = WAIT;
-		wait( &cond );
+		wait( cond );
 
 		if(c.state != SIGNAL) {
@@ -83,6 +83,6 @@
 		c.state = SIGNAL;
 
-		signal( &cond );
-		signal( &cond );
+		signal( cond );
+		signal( cond );
 	}
 	else {
Index: src/tests/sched-int-block.c
===================================================================
--- src/tests/sched-int-block.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/tests/sched-int-block.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -47,5 +47,5 @@
 //------------------------------------------------------------------------------
 void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) {
-	wait( &cond, (uintptr_t)this_thread );
+	wait( cond, (uintptr_t)this_thread );
 
 	yield( rand48(10) );
@@ -74,9 +74,9 @@
 	[a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread;
 
-	if( !is_empty( &cond ) ) {
+	if( !is_empty( cond ) ) {
 
-		thread_desc * next = front( &cond );
+		thread_desc * next = front( cond );
 
-		if( ! signal_block( &cond ) ) {
+		if( ! signal_block( cond ) ) {
 			sout | "ERROR expected to be able to signal" | endl;
 			abort();
Index: src/tests/sched-int-disjoint.c
===================================================================
--- src/tests/sched-int-disjoint.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/tests/sched-int-disjoint.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -59,5 +59,5 @@
 // Waiting logic
 bool wait( global_t & mutex m, global_data_t & mutex d ) {
-	wait( &cond );
+	wait( cond );
 	if( d.state != SIGNAL ) {
 		sout | "ERROR barging!" | endl;
@@ -80,5 +80,5 @@
 //------------------------------------------------------------------------------
 // Signalling logic
-void signal( condition * cond, global_t & mutex a, global_data_t & mutex b ) {
+void signal( condition & cond, global_t & mutex a, global_data_t & mutex b ) {
 	b.state = SIGNAL;
 	signal( cond );
@@ -86,5 +86,5 @@
 
 void logic( global_t & mutex a ) {
-	signal( &cond, a, data );
+	signal( cond, a, data );
 
 	yield( rand48(10) );
Index: src/tests/sched-int-wait.c
===================================================================
--- src/tests/sched-int-wait.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/tests/sched-int-wait.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -41,17 +41,17 @@
 //----------------------------------------------------------------------------------------------------
 // Tools
-void signal( condition * cond, global_t & mutex a, global_t & mutex b ) {
+void signal( condition & cond, global_t & mutex a, global_t & mutex b ) {
 	signal( cond );
 }
 
-void signal( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
+void signal( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
 	signal( cond );
 }
 
-void wait( condition * cond, global_t & mutex a, global_t & mutex b ) {
+void wait( condition & cond, global_t & mutex a, global_t & mutex b ) {
 	wait( cond );
 }
 
-void wait( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
+void wait( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
 	wait( cond );
 }
@@ -65,14 +65,14 @@
 		switch( action ) {
 			case 0:
-				signal( &condABC, globalA, globalB, globalC );
+				signal( condABC, globalA, globalB, globalC );
 				break;
 			case 1:
-				signal( &condAB , globalA, globalB );
+				signal( condAB , globalA, globalB );
 				break;
 			case 2:
-				signal( &condBC , globalB, globalC );
+				signal( condBC , globalB, globalC );
 				break;
 			case 3:
-				signal( &condAC , globalA, globalC );
+				signal( condAC , globalA, globalC );
 				break;
 			default:
@@ -88,5 +88,5 @@
 void main( WaiterABC & this ) {
 	for( int i = 0; i < N; i++ ) {
-		wait( &condABC, globalA, globalB, globalC );
+		wait( condABC, globalA, globalB, globalC );
 	}
 
@@ -98,5 +98,5 @@
 void main( WaiterAB & this ) {
 	for( int i = 0; i < N; i++ ) {
-		wait( &condAB , globalA, globalB );
+		wait( condAB , globalA, globalB );
 	}
 
@@ -108,5 +108,5 @@
 void main( WaiterAC & this ) {
 	for( int i = 0; i < N; i++ ) {
-		wait( &condAC , globalA, globalC );
+		wait( condAC , globalA, globalC );
 	}
 
@@ -118,5 +118,5 @@
 void main( WaiterBC & this ) {
 	for( int i = 0; i < N; i++ ) {
-		wait( &condBC , globalB, globalC );
+		wait( condBC , globalB, globalC );
 	}
 
Index: src/tests/thread.c
===================================================================
--- src/tests/thread.c	(revision e1e8408b22136702256cde37d937165f85a711fb)
+++ src/tests/thread.c	(revision 4cedd9fd7388881d56f46c8b5b5520dee1f9e9b2)
@@ -15,9 +15,9 @@
 		yield();
 	}
-	V(this.lock);
+	V(*this.lock);
 }
 
 void main(Second& this) {
-	P(this.lock);
+	P(*this.lock);
 	for(int i = 0; i < 10; i++) {
 		sout | "Second : Suspend No." | i + 1 | endl;