Index: libcfa/src/bits/locks.hfa
===================================================================
--- libcfa/src/bits/locks.hfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/bits/locks.hfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -37,5 +37,5 @@
 	extern "C" {
 		extern void disable_interrupts() OPTIONAL_THREAD;
-		extern void enable_interrupts_noPoll() OPTIONAL_THREAD;
+		extern void enable_interrupts( bool poll = true ) OPTIONAL_THREAD;
 
 		#ifdef __CFA_DEBUG__
@@ -57,5 +57,5 @@
 			__cfaabi_dbg_record_lock( this, caller );
 		} else {
-			enable_interrupts_noPoll();
+			enable_interrupts( false );
 		}
 		return result;
@@ -90,5 +90,5 @@
 	static inline void unlock( __spinlock_t & this ) {
 		__atomic_clear( &this.lock, __ATOMIC_RELEASE );
-		enable_interrupts_noPoll();
+		enable_interrupts( false );
 	}
 #endif
Index: libcfa/src/concurrency/alarm.cfa
===================================================================
--- libcfa/src/concurrency/alarm.cfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/alarm.cfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -116,5 +116,5 @@
 	unlock( event_kernel->lock );
 	this->set = true;
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
@@ -127,5 +127,5 @@
 	}
 	unlock( event_kernel->lock );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	this->set = false;
 }
Index: libcfa/src/concurrency/clib/cfathread.cfa
===================================================================
--- libcfa/src/concurrency/clib/cfathread.cfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/clib/cfathread.cfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -117,5 +117,5 @@
 
 	this_thrd->state = Ready;
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
Index: libcfa/src/concurrency/invoke.c
===================================================================
--- libcfa/src/concurrency/invoke.c	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/invoke.c	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -34,5 +34,5 @@
 
 extern void disable_interrupts() OPTIONAL_THREAD;
-extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+extern void enable_interrupts( _Bool poll );
 
 void __cfactx_invoke_coroutine(
@@ -82,5 +82,5 @@
 ) {
 	// Officially start the thread by enabling preemption
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts( true );
 
 	// Call the main of the thread
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/io.cfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -244,5 +244,5 @@
 			// Allocation was successful
 			__STATS__( true, io.alloc.fast += 1; )
-			enable_interrupts( __cfaabi_dbg_ctx );
+			enable_interrupts();
 
 			__cfadbg_print_safe(io, "Kernel I/O : fast allocation successful from ring %d\n", ctx->fd);
@@ -256,5 +256,5 @@
 		// Fast path failed, fallback on arbitration
 		__STATS__( true, io.alloc.slow += 1; )
-		enable_interrupts( __cfaabi_dbg_ctx );
+		enable_interrupts();
 
 		$io_arbiter * ioarb = proc->cltr->io.arbiter;
@@ -314,5 +314,5 @@
 			// Mark the instance as no longer in-use, re-enable interrupts and return
 			__STATS__( true, io.submit.fast += 1; )
-			enable_interrupts( __cfaabi_dbg_ctx );
+			enable_interrupts();
 
 			__cfadbg_print_safe(io, "Kernel I/O : submitted on fast path\n");
@@ -322,5 +322,5 @@
 		// Fast path failed, fallback on arbitration
 		__STATS__( true, io.submit.slow += 1; )
-		enable_interrupts( __cfaabi_dbg_ctx );
+		enable_interrupts();
 
 		__cfadbg_print_safe(io, "Kernel I/O : falling back on arbiter for submission\n");
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/kernel.cfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -115,4 +115,5 @@
 static $thread * __next_thread(cluster * this);
 static $thread * __next_thread_slow(cluster * this);
+static inline bool __must_unpark( $thread * thrd ) __attribute((nonnull(1)));
 static void __run_thread(processor * this, $thread * dst);
 static void __wake_one(cluster * cltr);
@@ -130,4 +131,16 @@
 extern void __disable_interrupts_hard();
 extern void __enable_interrupts_hard();
+
+static inline void __disable_interrupts_checked() {
+	/* paranoid */ verify( __preemption_enabled() );
+	disable_interrupts();
+	/* paranoid */ verify( ! __preemption_enabled() );
+}
+
+static inline void __enable_interrupts_checked( bool poll = true ) {
+	/* paranoid */ verify( ! __preemption_enabled() );
+	enable_interrupts( poll );
+	/* paranoid */ verify( __preemption_enabled() );
+}
 
 //=============================================================================================
@@ -452,5 +465,5 @@
 		if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
 			// The thread was preempted, reschedule it and reset the flag
-			__schedule_thread( thrd_dst );
+			schedule_thread$( thrd_dst );
 			break RUNNING;
 		}
@@ -541,4 +554,5 @@
 	/* paranoid */ verify( ! __preemption_enabled() );
 	/* paranoid */ verify( kernelTLS().this_proc_id );
+	/* paranoid */ verify( ready_schedule_islocked());
 	/* paranoid */ verify( thrd );
 	/* paranoid */ verify( thrd->state != Halted );
@@ -560,13 +574,12 @@
 	__STATS(bool outside = thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
 
-	ready_schedule_lock();
-		// push the thread to the cluster ready-queue
-		push( cl, thrd );
-
-		// variable thrd is no longer safe to use
-
-		// wake the cluster using the save variable.
-		__wake_one( cl );
-	ready_schedule_unlock();
+	// push the thread to the cluster ready-queue
+	push( cl, thrd );
+
+	// variable thrd is no longer safe to use
+	thrd = 0xdeaddeaddeaddeadp;
+
+	// wake the cluster using the save variable.
+	__wake_one( cl );
 
 	#if !defined(__CFA_NO_STATISTICS__)
@@ -585,5 +598,12 @@
 	#endif
 
-	/* paranoid */ verify( ! __preemption_enabled() );
+	/* paranoid */ verify( ready_schedule_islocked());
+	/* paranoid */ verify( ! __preemption_enabled() );
+}
+
+void schedule_thread$( $thread * thrd ) {
+	ready_schedule_lock();
+		__schedule_thread( thrd );
+	ready_schedule_unlock();
 }
 
@@ -623,32 +643,14 @@
 }
 
-void unpark( $thread * thrd ) {
-	if( !thrd ) return;
-
+static inline bool __must_unpark( $thread * thrd ) {
 	int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
 	switch(old_ticket) {
 		case TICKET_RUNNING:
 			// Wake won the race, the thread will reschedule/rerun itself
-			break;
+			return false;
 		case TICKET_BLOCKED:
 			/* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
 			/* paranoid */ verify( thrd->state == Blocked );
-
-			{
-				/* paranoid */ verify( publicTLS_get(this_proc_id) );
-				disable_interrupts();
-
-				/* paranoid */ verify( ! __preemption_enabled() );
-
-				// Wake lost the race,
-				__schedule_thread( thrd );
-
-				/* paranoid */ verify( ! __preemption_enabled() );
-
-				enable_interrupts_noPoll();
-				/* paranoid */ verify( publicTLS_get(this_proc_id) );
-			}
-
-			break;
+			return true;
 		default:
 			// This makes no sense, something is wrong abort
@@ -657,15 +659,20 @@
 }
 
+void unpark( $thread * thrd ) {
+	if( !thrd ) return;
+
+	if(__must_unpark(thrd)) {
+		disable_interrupts();
+			// Wake lost the race,
+			schedule_thread$( thrd );
+		enable_interrupts(false);
+	}
+}
+
 void park( void ) {
-	/* paranoid */ verify( __preemption_enabled() );
-	disable_interrupts();
-	/* paranoid */ verify( ! __preemption_enabled() );
-	/* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
-
-	returnToKernel();
-
-	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts( __cfaabi_dbg_ctx );
-	/* paranoid */ verify( __preemption_enabled() );
+	__disable_interrupts_checked();
+		/* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
+		returnToKernel();
+	__enable_interrupts_checked();
 
 }
@@ -707,26 +714,19 @@
 // KERNEL ONLY
 bool force_yield( __Preemption_Reason reason ) {
-	/* paranoid */ verify( __preemption_enabled() );
-	disable_interrupts();
-	/* paranoid */ verify( ! __preemption_enabled() );
-
-	$thread * thrd = kernelTLS().this_thread;
-	/* paranoid */ verify(thrd->state == Active);
-
-	// SKULLDUGGERY: It is possible that we are preempting this thread just before
-	// it was going to park itself. If that is the case and it is already using the
-	// intrusive fields then we can't use them to preempt the thread
-	// If that is the case, abandon the preemption.
-	bool preempted = false;
-	if(thrd->link.next == 0p) {
-		preempted = true;
-		thrd->preempted = reason;
-		returnToKernel();
-	}
-
-	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts_noPoll();
-	/* paranoid */ verify( __preemption_enabled() );
-
+	__disable_interrupts_checked();
+		$thread * thrd = kernelTLS().this_thread;
+		/* paranoid */ verify(thrd->state == Active);
+
+		// SKULLDUGGERY: It is possible that we are preempting this thread just before
+		// it was going to park itself. If that is the case and it is already using the
+		// intrusive fields then we can't use them to preempt the thread
+		// If that is the case, abandon the preemption.
+		bool preempted = false;
+		if(thrd->link.next == 0p) {
+			preempted = true;
+			thrd->preempted = reason;
+			returnToKernel();
+		}
+	__enable_interrupts_checked( false );
 	return preempted;
 }
@@ -773,10 +773,10 @@
 	__cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
 
-	disable_interrupts();
+	__disable_interrupts_checked();
 		/* paranoid */ verify( ! __preemption_enabled() );
 		eventfd_t val;
 		val = 1;
 		eventfd_write( this->idle, val );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	__enable_interrupts_checked();
 }
 
Index: libcfa/src/concurrency/kernel/fwd.hfa
===================================================================
--- libcfa/src/concurrency/kernel/fwd.hfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/kernel/fwd.hfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -108,6 +108,5 @@
 
 	extern void disable_interrupts();
-	extern void enable_interrupts_noPoll();
-	extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+	extern void enable_interrupts( bool poll = false );
 
 	extern "Cforall" {
@@ -403,5 +402,5 @@
 					__VA_ARGS__ \
 				} \
-				if( !(in_kernel) ) enable_interrupts( __cfaabi_dbg_ctx ); \
+				if( !(in_kernel) ) enable_interrupts(); \
 			}
 		#else
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -225,5 +225,5 @@
 	// Add the main thread to the ready queue
 	// once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
-	__schedule_thread(mainThread);
+	schedule_thread$(mainThread);
 
 	// SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
@@ -238,5 +238,5 @@
 
 	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	/* paranoid */ verify( __preemption_enabled() );
 
@@ -532,5 +532,5 @@
 	disable_interrupts();
 		init( this, name, _cltr, initT );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 
 	__cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
@@ -559,5 +559,5 @@
 	disable_interrupts();
 		deinit( this );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
@@ -597,5 +597,5 @@
 	// Unlock the RWlock
 	ready_mutate_unlock( last_size );
-	enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+	enable_interrupts( false ); // Don't poll, could be in main cluster
 }
 
@@ -612,5 +612,5 @@
 	// Unlock the RWlock
 	ready_mutate_unlock( last_size );
-	enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+	enable_interrupts( false ); // Don't poll, could be in main cluster
 
 	#if !defined(__CFA_NO_STATISTICS__)
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -29,13 +29,8 @@
 extern "C" {
 	void disable_interrupts() OPTIONAL_THREAD;
-	void enable_interrupts_noPoll();
-	void enable_interrupts( __cfaabi_dbg_ctx_param );
-}
-
-void __schedule_thread( $thread * )
-#if defined(NDEBUG) || (!defined(__CFA_DEBUG__) && !defined(__CFA_VERIFY__))
-	__attribute__((nonnull (1)))
-#endif
-;
+	void enable_interrupts( bool poll = true );
+}
+
+void schedule_thread$( $thread * ) __attribute__((nonnull (1)));
 
 extern bool __preemption_enabled();
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/preemption.cfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -315,8 +315,8 @@
 	// Enable interrupts by decrementing the counter
 	// If counter reaches 0, execute any pending __cfactx_switch
-	void enable_interrupts( __cfaabi_dbg_ctx_param ) {
+	void enable_interrupts( bool poll ) {
 		// Cache the processor now since interrupts can start happening after the atomic store
 		processor   * proc = __cfaabi_tls.this_processor;
-		/* paranoid */ verify( proc );
+		/* paranoid */ verify( !poll || proc );
 
 		with( __cfaabi_tls.preemption_state ){
@@ -340,33 +340,9 @@
 				// Signal the compiler that a fence is needed but only for signal handlers
 				__atomic_signal_fence(__ATOMIC_RELEASE);
-				if( proc->pending_preemption ) {
+				if( poll && proc->pending_preemption ) {
 					proc->pending_preemption = false;
 					force_yield( __POLL_PREEMPTION );
 				}
 			}
-		}
-
-		// For debugging purposes : keep track of the last person to enable the interrupts
-		__cfaabi_dbg_debug_do( proc->last_enable = caller; )
-	}
-
-	// Disable interrupts by incrementint the counter
-	// Don't execute any pending __cfactx_switch even if counter reaches 0
-	void enable_interrupts_noPoll() {
-		unsigned short prev = __cfaabi_tls.preemption_state.disable_count;
-		__cfaabi_tls.preemption_state.disable_count -= 1;
-		// If this triggers someone is enabled already enabled interrupts
-		/* paranoid */ verifyf( prev != 0u, "Incremented from %u\n", prev );
-		if( prev == 1 ) {
-			#if GCC_VERSION > 50000
-				static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
-			#endif
-			// Set enabled flag to true
-			// should be atomic to avoid preemption in the middle of the operation.
-			// use memory order RELAXED since there is no inter-thread on this variable requirements
-			__atomic_store_n(&__cfaabi_tls.preemption_state.enabled, true, __ATOMIC_RELAXED);
-
-			// Signal the compiler that a fence is needed but only for signal handlers
-			__atomic_signal_fence(__ATOMIC_RELEASE);
 		}
 	}
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/concurrency/thread.cfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -136,6 +136,6 @@
 	/* paranoid */ verify( this_thrd->context.SP );
 
-	__schedule_thread( this_thrd );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	schedule_thread$( this_thrd );
+	enable_interrupts();
 }
 
@@ -170,5 +170,5 @@
 	disable_interrupts();
 	uint64_t ret = __tls_rand();
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	return ret;
 }
Index: libcfa/src/startup.cfa
===================================================================
--- libcfa/src/startup.cfa	(revision 89eff25a464816e7b42a749b35250bba33bd53e8)
+++ libcfa/src/startup.cfa	(revision cfff6398bb3300e69fce3706c15f15750c4641db)
@@ -39,5 +39,5 @@
 
     void disable_interrupts() __attribute__(( weak )) {}
-    void enable_interrupts_noPoll() __attribute__(( weak )) {}
+    void enable_interrupts() __attribute__(( weak )) {}
 } // extern "C"