Index: src/libcfa/bits/locks.h
===================================================================
--- src/libcfa/bits/locks.h	(revision a43c5619b7cbd0dac2d19b62a219a285ebbded72)
+++ src/libcfa/bits/locks.h	(revision 29f9e20c3cabdb3ee724c7e3c4b6cc97003758c9)
@@ -126,11 +126,11 @@
 
 	struct __bin_sem_t {
-		int_fast8_t     counter;
-		pthread_mutex_t lock;
-		pthread_cond_t  cond;
+		bool     		signaled;
+		pthread_mutex_t 	lock;
+		pthread_cond_t  	cond;
 	};
 
 	static inline void ?{}(__bin_sem_t & this) with( this ) {
-		counter = 0;
+		signaled = false;
 		pthread_mutex_init(&lock, NULL);
 		pthread_cond_init (&cond, NULL);
@@ -145,8 +145,8 @@
 		verify(__cfaabi_dbg_in_kernel());
 		pthread_mutex_lock(&lock);
-		if(counter != 0) {   // this must be a loop, not if!
-			pthread_cond_wait(&cond, &lock);
-		}
-		counter = 1;
+			if(!signaled) {   // this must be a loop, not if!
+				pthread_cond_wait(&cond, &lock);
+			}
+			signaled = false;
 		pthread_mutex_unlock(&lock);
 	}
@@ -154,10 +154,12 @@
 	static inline void post(__bin_sem_t & this) with( this ) {
 		verify(__cfaabi_dbg_in_kernel());
+
 		pthread_mutex_lock(&lock);
-		bool needs_signal = counter == 0;
-		counter = 1;
+			bool needs_signal = !signaled;
+			signaled = true;
 		pthread_mutex_unlock(&lock);
-		if (!needs_signal)
+
+		if (needs_signal)
 			pthread_cond_signal(&cond);
-		}
+	}
 #endif
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision a43c5619b7cbd0dac2d19b62a219a285ebbded72)
+++ src/libcfa/concurrency/kernel	(revision 29f9e20c3cabdb3ee724c7e3c4b6cc97003758c9)
@@ -113,4 +113,18 @@
 	pthread_t kernel_thread;
 
+	// RunThread data
+	// Action to do after a thread is ran
+	struct FinishAction finish;
+
+	// Preemption data
+	// Node which is added in the discrete event simulaiton
+	struct alarm_node_t * preemption_alarm;
+
+	// If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
+	bool pending_preemption;
+
+	// Idle lock
+	__bin_sem_t idleLock;
+
 	// Termination
 	// Set to true to notify the processor should terminate
@@ -119,19 +133,4 @@
 	// Termination synchronisation
 	semaphore terminated;
-
-	// RunThread data
-	// Action to do after a thread is ran
-	struct FinishAction finish;
-
-	// Preemption data
-	// Node which is added in the discrete event simulaiton
-	struct alarm_node_t * preemption_alarm;
-
-	// If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
-	bool pending_preemption;
-
-	// Idle lock
-	sem_t idleLock;
-	// __bin_sem_t idleLock;
 
 	// Link lists fields
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision a43c5619b7cbd0dac2d19b62a219a285ebbded72)
+++ src/libcfa/concurrency/kernel.c	(revision 29f9e20c3cabdb3ee724c7e3c4b6cc97003758c9)
@@ -147,5 +147,5 @@
 	runner.proc = &this;
 
-	sem_init(&idleLock, 0, 0);
+	idleLock{};
 
 	start( &this );
@@ -155,13 +155,13 @@
 	if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
 		__cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-		terminate(&this);
-		verify( __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
-		verify( kernelTLS.this_processor != &this);
+
+		__atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
+		wake( &this );
+
 		P( terminated );
 		verify( kernelTLS.this_processor != &this);
-		pthread_join( kernel_thread, NULL );
-	}
-
-	sem_destroy(&idleLock);
+	}
+
+	pthread_join( kernel_thread, NULL );
 }
 
@@ -295,11 +295,4 @@
 }
 
-// Handles spinning logic
-// TODO : find some strategy to put cores to sleep after some time
-void spin(processor * this, unsigned int * spin_count) {
-	// (*spin_count)++;
-	halt(this);
-}
-
 // KERNEL_ONLY
 // Context invoker for processors
@@ -408,11 +401,15 @@
 		unlock( ready_queue_lock );
 
-		if( was_empty ) {
+		if(was_empty) {
 			lock      (proc_list_lock __cfaabi_dbg_ctx2);
 			if(idles) {
-				wake(idles.head);
+				wake_fast(idles.head);
 			}
 			unlock    (proc_list_lock);
 		}
+		else if( struct processor * idle = idles.head ) {
+			wake_fast(idle);
+		}
+
 	}
 
@@ -660,5 +657,5 @@
 
 void halt(processor * this) with( *this ) {
-	verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+	// verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
 
 	with( *cltr ) {
@@ -671,15 +668,5 @@
 	__cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
 
-	// #ifdef __CFA_WITH_VERIFY__
-	// 	int sval = 0;
-	// 	sem_getvalue(&this->idleLock, &sval);
-	// 	verifyf(sval < 200, "Binary semaphore reached value %d : \n", sval);
-	// #endif
-
-	verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
-	int __attribute__((unused)) ret = sem_wait(&idleLock);
-	// verifyf(ret >= 0 || errno == EINTR, "Sem_wait returned %d (errno %d : %s\n", ret, errno, strerror(errno));
-
-	// wait( idleLock );
+	wait( idleLock );
 
 	__cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
@@ -691,18 +678,4 @@
 		unlock    (proc_list_lock);
 	}
-}
-
-void wake(processor * this) {
-	__cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
-	int __attribute__((unused)) ret = sem_post(&this->idleLock);
-	// verifyf(ret >= 0 || errno == EINTR, "Sem_post returned %d (errno %d : %s\n", ret, errno, strerror(errno));
-
-	// #ifdef __CFA_WITH_VERIFY__
-	// 	int sval = 0;
-	// 	sem_getvalue(&this->idleLock, &sval);
-	// 	verifyf(sval < 200, "Binary semaphore reached value %d\n", sval);
-	// #endif
-
-	// post( this->idleLock );
 }
 
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision a43c5619b7cbd0dac2d19b62a219a285ebbded72)
+++ src/libcfa/concurrency/kernel_private.h	(revision 29f9e20c3cabdb3ee724c7e3c4b6cc97003758c9)
@@ -58,7 +58,15 @@
 void finishRunning(processor * this);
 void halt(processor * this);
-void wake(processor * this);
-void terminate(processor * this);
-void spin(processor * this, unsigned int * spin_count);
+
+static inline void wake_fast(processor * this) {
+	__cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
+	post( this->idleLock );
+}
+
+static inline void wake(processor * this) {
+	disable_interrupts();
+	wake_fast(this);
+	enable_interrupts( __cfaabi_dbg_ctx );
+}
 
 struct event_kernel_t {
@@ -68,12 +76,4 @@
 
 extern event_kernel_t * event_kernel;
-
-//extern thread_local coroutine_desc * volatile this_coroutine;
-//extern thread_local thread_desc *    volatile this_thread;
-//extern thread_local processor *      volatile this_processor;
-
-// extern volatile thread_local bool preemption_in_progress;
-// extern volatile thread_local bool preemption_enabled;
-// extern volatile thread_local unsigned short disable_preempt_count;
 
 struct __cfa_kernel_preemption_state_t {
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision a43c5619b7cbd0dac2d19b62a219a285ebbded72)
+++ src/libcfa/concurrency/preemption.c	(revision 29f9e20c3cabdb3ee724c7e3c4b6cc97003758c9)
@@ -260,14 +260,4 @@
 static void preempt( processor * this ) {
 	sigval_t value = { PREEMPT_NORMAL };
-	pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
-}
-
-// kill wrapper : signal a processor
-void terminate(processor * this) {
-	disable_interrupts();
-	__atomic_store_n(&this->do_terminate, true, __ATOMIC_SEQ_CST);
-	wake( this );
-	sigval_t value = { PREEMPT_TERMINATE };
-	enable_interrupts( __cfaabi_dbg_ctx );
 	pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
 }