Index: src/libcfa/concurrency/alarm.c
===================================================================
--- src/libcfa/concurrency/alarm.c	(revision 7bbba7649454f6cfd175bc2eca517e4d75022e10)
+++ src/libcfa/concurrency/alarm.c	(revision b227f6896f9a2f0cc65768eef401bb62ec7dc754)
@@ -38,10 +38,10 @@
 	clock_gettime( CLOCK_REALTIME, &curr );
 	__cfa_time_t curr_time = ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
-	LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : current time is %lu\n", curr_time );
+	// LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : current time is %lu\n", curr_time );
 	return curr_time;
 }
 
 void __kernel_set_timer( __cfa_time_t alarm ) {
-	LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : set timer to %lu\n", (__cfa_time_t)alarm );
+	// LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Kernel : set timer to %lu\n", (__cfa_time_t)alarm );
 	itimerval val;
 	val.it_value.tv_sec = alarm / TIMEGRAN;			// seconds
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 7bbba7649454f6cfd175bc2eca517e4d75022e10)
+++ src/libcfa/concurrency/invoke.h	(revision b227f6896f9a2f0cc65768eef401bb62ec7dc754)
@@ -32,5 +32,6 @@
             volatile int lock;
             #ifdef __CFA_DEBUG__
-                  const char * prev;
+                  const char * prev_name;
+                  void* prev_thrd;
             #endif
       };
@@ -101,5 +102,5 @@
 #ifndef _INVOKE_PRIVATE_H_
 #define _INVOKE_PRIVATE_H_
-      
+
       struct machine_context_t {
             void *SP;
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 7bbba7649454f6cfd175bc2eca517e4d75022e10)
+++ src/libcfa/concurrency/kernel	(revision b227f6896f9a2f0cc65768eef401bb62ec7dc754)
@@ -28,7 +28,8 @@
 //-----------------------------------------------------------------------------
 // Locks
-bool try_lock( spinlock * DEBUG_CTX_PARAM2 );
-void lock    ( spinlock * DEBUG_CTX_PARAM2 );
-void unlock  ( spinlock * );
+bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );
+void lock      ( spinlock * DEBUG_CTX_PARAM2 );
+void lock_yield( spinlock * DEBUG_CTX_PARAM2 );
+void unlock    ( spinlock * );
 
 struct signal_once {
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 7bbba7649454f6cfd175bc2eca517e4d75022e10)
+++ src/libcfa/concurrency/kernel.c	(revision b227f6896f9a2f0cc65768eef401bb62ec7dc754)
@@ -605,15 +605,28 @@
 
 bool try_lock( spinlock * this DEBUG_CTX_PARAM2 ) {
-	bool ret = this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
-	LIB_DEBUG_DO( this->prev = caller; )
-	return ret;
+	return this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0;
 }
 
 void lock( spinlock * this DEBUG_CTX_PARAM2 ) {
 	for ( unsigned int i = 1;; i += 1 ) {
-	  	if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) break;
-	}
-	LIB_DEBUG_DO( this->prev = caller; )
-}
+		if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) { break; }
+	}
+	LIB_DEBUG_DO(
+		this->prev_name = caller;
+		this->prev_thrd = this_thread;
+	)
+}
+
+void lock_yield( spinlock * this DEBUG_CTX_PARAM2 ) {
+	for ( unsigned int i = 1;; i += 1 ) {
+		if ( this->lock == 0 && __sync_lock_test_and_set_4( &this->lock, 1 ) == 0 ) { break; }
+		yield();
+	}
+	LIB_DEBUG_DO(
+		this->prev_name = caller;
+		this->prev_thrd = this_thread;
+	)
+}
+
 
 void unlock( spinlock * this ) {
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision 7bbba7649454f6cfd175bc2eca517e4d75022e10)
+++ src/libcfa/concurrency/monitor.c	(revision b227f6896f9a2f0cc65768eef401bb62ec7dc754)
@@ -45,5 +45,5 @@
 extern "C" {
 	void __enter_monitor_desc( monitor_desc * this ) {
-		lock( &this->lock DEBUG_CTX2 );
+		lock_yield( &this->lock DEBUG_CTX2 );
 		thread_desc * thrd = this_thread;
 
@@ -76,5 +76,5 @@
 	//	TODO
 	void __leave_monitor_desc( monitor_desc * this ) {
-		lock( &this->lock DEBUG_CTX2 );
+		lock_yield( &this->lock DEBUG_CTX2 );
 
 		// LIB_DEBUG_PRINT_SAFE("%p Leaving %p (o: %p, r: %i). ", this_thread, this, this->owner, this->recursion);
@@ -104,5 +104,5 @@
 	void __leave_thread_monitor( thread_desc * thrd ) {
 		monitor_desc * this = &thrd->mon;
-		lock( &this->lock DEBUG_CTX2 );
+		lock_yield( &this->lock DEBUG_CTX2 );
 
 		disable_interrupts();
@@ -188,5 +188,5 @@
 // Internal scheduling
 void wait( condition * this, uintptr_t user_info = 0 ) {
-	LIB_DEBUG_PRINT_SAFE("Waiting\n");
+	// LIB_DEBUG_PRINT_SAFE("Waiting\n");
 
 	brand_condition( this );
@@ -201,5 +201,5 @@
 	spinlock *   locks     [ count ];		//We need to pass-in an array of locks to BlockInternal
 
-	LIB_DEBUG_PRINT_SAFE("count %i\n", count);
+	// LIB_DEBUG_PRINT_SAFE("count %i\n", count);
 
 	__condition_node_t waiter = { (thread_desc*)this_thread, count, user_info };
@@ -208,5 +208,5 @@
 	for(int i = 0; i < count; i++) {
 		(&criteria[i]){ this->monitors[i], &waiter };
-		LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
+		// LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
 	}
 
@@ -230,9 +230,9 @@
 	}
 
-	LIB_DEBUG_PRINT_SAFE("Will unblock: ");
+	// LIB_DEBUG_PRINT_SAFE("Will unblock: ");
 	for(int i = 0; i < thread_count; i++) {
-		LIB_DEBUG_PRINT_SAFE("%p ", threads[i]);
-	}
-	LIB_DEBUG_PRINT_SAFE("\n");
+		// LIB_DEBUG_PRINT_SAFE("%p ", threads[i]);
+	}
+	// LIB_DEBUG_PRINT_SAFE("\n");
 
 	// Everything is ready to go to sleep
@@ -251,5 +251,5 @@
 bool signal( condition * this ) {
 	if( is_empty( this ) ) {
-		LIB_DEBUG_PRINT_SAFE("Nothing to signal\n");
+		// LIB_DEBUG_PRINT_SAFE("Nothing to signal\n");
 		return false;
 	}
@@ -277,5 +277,5 @@
 	//Lock all the monitors
 	lock_all( this->monitors, NULL, count );
-	LIB_DEBUG_PRINT_SAFE("Signalling");
+	// LIB_DEBUG_PRINT_SAFE("Signalling");
 
 	//Pop the head of the waiting queue
@@ -285,10 +285,10 @@
 	for(int i = 0; i < count; i++) {
 		__condition_criterion_t * crit = &node->criteria[i];
-		LIB_DEBUG_PRINT_SAFE(" %p", crit->target);
+		// LIB_DEBUG_PRINT_SAFE(" %p", crit->target);
 		assert( !crit->ready );
 		push( &crit->target->signal_stack, crit );
 	}
 
-	LIB_DEBUG_PRINT_SAFE("\n");
+	// LIB_DEBUG_PRINT_SAFE("\n");
 
 	//Release
@@ -320,5 +320,5 @@
 	for(int i = 0; i < count; i++) {
 		(&criteria[i]){ this->monitors[i], &waiter };
-		LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
+		// LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
 		push( &criteria[i].target->signal_stack, &criteria[i] );
 	}
@@ -422,5 +422,5 @@
 static inline void lock_all( spinlock ** locks, unsigned short count ) {
 	for( int i = 0; i < count; i++ ) {
-		lock( locks[i] DEBUG_CTX2 );
+		lock_yield( locks[i] DEBUG_CTX2 );
 	}
 }
@@ -429,5 +429,5 @@
 	for( int i = 0; i < count; i++ ) {
 		spinlock * l = &source[i]->lock;
-		lock( l DEBUG_CTX2 );
+		lock_yield( l DEBUG_CTX2 );
 		if(locks) locks[i] = l;
 	}
@@ -472,8 +472,8 @@
 	for(	int i = 0; i < count; i++ ) {
 
-		LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
+		// LIB_DEBUG_PRINT_SAFE( "Checking %p for %p\n", &criteria[i], target );
 		if( &criteria[i] == target ) {
 			criteria[i].ready = true;
-			LIB_DEBUG_PRINT_SAFE( "True\n" );
+			// LIB_DEBUG_PRINT_SAFE( "True\n" );
 		}
 
@@ -481,5 +481,5 @@
 	}
 
-	LIB_DEBUG_PRINT_SAFE( "Runing %i\n", ready2run );
+	// LIB_DEBUG_PRINT_SAFE( "Runing %i\n", ready2run );
 	return ready2run ? node->waiting_thread : NULL;
 }
@@ -488,5 +488,5 @@
 	thread_desc * thrd = this_thread;
 	if( !this->monitors ) {
-		LIB_DEBUG_PRINT_SAFE("Branding\n");
+		// LIB_DEBUG_PRINT_SAFE("Branding\n");
 		assertf( thrd->current_monitors != NULL, "No current monitor to brand condition", thrd->current_monitors );
 		this->monitor_count = thrd->current_monitor_count;
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision 7bbba7649454f6cfd175bc2eca517e4d75022e10)
+++ src/libcfa/concurrency/preemption.c	(revision b227f6896f9a2f0cc65768eef401bb62ec7dc754)
@@ -158,4 +158,6 @@
 //=============================================================================================
 
+LIB_DEBUG_DO( static thread_local void * last_interrupt = 0; )
+
 extern "C" {
 	void disable_interrupts() {
@@ -187,5 +189,12 @@
 
 static inline void signal_unblock( int sig ) {
-	LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Processor : %p unblocking sig %i\n", this_processor, sig );
+	// LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Processor : %p unblocking sig %i\n", this_processor, sig );
+
+	// LIB_DEBUG_DO(
+	// 	sigset_t waiting;
+	// 	sigemptyset(&waiting);
+	// 	sigpending(&waiting);
+	// 	verify( !sigismember(&waiting, sig) );
+	// )
 
 	sigset_t mask;
@@ -217,14 +226,15 @@
 
 void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
-	LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "Ctx Switch IRH %p running %p @ %p\n", this_processor, this_thread, (void *)(cxt->uc_mcontext.gregs[REG_RIP]) );
+	LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "CtxSw IRH %10p running %10p @ %10p\n", this_processor, this_thread, (void *)(cxt->uc_mcontext.gregs[REG_RIP]) );
+	LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[REG_RIP]); )
 
 	if( preemption_ready() ) {
-		LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ctx Switch IRH : Blocking thread %p on %p\n", this_thread, this_processor );
+		// LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ctx Switch IRH : Blocking thread %p on %p\n", this_thread, this_processor );
 		signal_unblock( SIGUSR1 );
 		BlockInternal( (thread_desc*)this_thread );
-		LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ctx Switch IRH : Back\n\n");
+		// LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ctx Switch IRH : Back\n\n");
 	}
 	else {
-		LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ctx Switch IRH : Defering\n" );
+		// LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Ctx Switch IRH : Defering\n" );
 		defer_ctxSwitch();
 		signal_unblock( SIGUSR1 );
@@ -233,7 +243,6 @@
 
 void sigHandler_alarm( __CFA_SIGPARMS__ ) {
-	LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "\nAlarm IRH %p running %p @ %p\n", this_processor, this_thread, (void *)(cxt->uc_mcontext.gregs[REG_RIP]) );
-
-	// if( ((intptr_t)cxt->uc_mcontext.gregs[REG_RIP]) > 0xFFFFFF ) __debug_break();
+	LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO, "\nAlarm IRH %10p running %10p @ %10p\n", this_processor, this_thread, (void *)(cxt->uc_mcontext.gregs[REG_RIP]) );
+	LIB_DEBUG_DO( last_interrupt = (void *)(cxt->uc_mcontext.gregs[REG_RIP]); )
 
 	if( try_lock( &systemProcessor->alarm_lock DEBUG_CTX2 ) ) {
@@ -248,8 +257,8 @@
 
 	if( preemption_ready() && this_processor->pending_preemption ) {
-		LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Alarm IRH : Blocking thread %p on %p\n", this_thread, this_processor );
+		// LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Alarm IRH : Blocking thread %p on %p\n", this_thread, this_processor );
 		this_processor->pending_preemption = false;
 		BlockInternal( (thread_desc*)this_thread );
-		LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Alarm Switch IRH : Back\n\n");
+		// LIB_DEBUG_PRINT_BUFFER_LOCAL( STDERR_FILENO, "Alarm Switch IRH : Back\n\n");
 	}
 }