Index: src/libcfa/bits/containers.h
===================================================================
--- src/libcfa/bits/containers.h	(revision 25fcb84f4d4e0dd6a778f8ce5a1bb0777e946a31)
+++ src/libcfa/bits/containers.h	(revision cf5e5b16165096c917c471853af2dd029ccbb3ae)
@@ -186,6 +186,6 @@
 
 	forall(dtype T | is_node(T))
-	static inline bool ?!=?( __queue(T) & this, zero_t zero ) with( this ) {
-		return head != 0;
+	static inline bool ?!=?( __queue(T) & this, zero_t zero ) {
+		return this.head != 0;
 	}
 #endif
@@ -266,4 +266,9 @@
 		__get( node ).prev = NULL;
 	}
+
+	forall(dtype T | sized(T))
+	static inline bool ?!=?( __dllist(T) & this, zero_t zero ) {
+		return this.head != 0;
+	}
 	#undef next
 	#undef prev
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 25fcb84f4d4e0dd6a778f8ce5a1bb0777e946a31)
+++ src/libcfa/concurrency/kernel	(revision cf5e5b16165096c917c471853af2dd029ccbb3ae)
@@ -23,4 +23,5 @@
 extern "C" {
 #include <pthread.h>
+#include <semaphore.h>
 }
 
@@ -131,4 +132,5 @@
 
 	// Idle lock
+	sem_t idleLock;
 
 	// Link lists fields
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 25fcb84f4d4e0dd6a778f8ce5a1bb0777e946a31)
+++ src/libcfa/concurrency/kernel.c	(revision cf5e5b16165096c917c471853af2dd029ccbb3ae)
@@ -143,4 +143,6 @@
 	runner.proc = &this;
 
+	sem_init(&idleLock, 0, 0);
+
 	start( &this );
 }
@@ -156,4 +158,6 @@
 		pthread_join( kernel_thread, NULL );
 	}
+
+	sem_destroy(&idleLock);
 }
 
@@ -289,5 +293,6 @@
 // TODO : find some strategy to put cores to sleep after some time
 void spin(processor * this, unsigned int * spin_count) {
-	(*spin_count)++;
+	// (*spin_count)++;
+	halt(this);
 }
 
@@ -394,6 +399,15 @@
 	with( *thrd->curr_cluster ) {
 		lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+		bool was_empty = !(ready_queue != 0);
 		append( ready_queue, thrd );
 		unlock( ready_queue_lock );
+
+		if( was_empty ) {
+			lock      (proc_list_lock __cfaabi_dbg_ctx2);
+			if(idles) {
+				wake(idles.head);
+			}
+			unlock    (proc_list_lock);
+		}
 	}
 
@@ -639,21 +653,30 @@
 //=============================================================================================
 
-// void halt(processor * this) with( this ) {
-// 	pthread_mutex_lock( &idle.lock );
-
-
-
-// 	// SKULLDUGGERY: Even if spurious wake-up is a thing
-// 	// spuriously waking up a kernel thread is not a big deal
-// 	// if it is very rare.
-// 	pthread_cond_wait( &idle.cond, &idle.lock);
-// 	pthread_mutex_unlock( &idle.lock );
-// }
-
-// void wake(processor * this) with( this ) {
-// 	pthread_mutex_lock  (&idle.lock);
-// 	pthread_cond_signal (&idle.cond);
-// 	pthread_mutex_unlock(&idle.lock);
-// }
+void halt(processor * this) with( *this ) {
+	with( *cltr ) {
+		lock      (proc_list_lock __cfaabi_dbg_ctx2);
+		remove    (procs, *this);
+		push_front(idles, *this);
+		unlock    (proc_list_lock);
+	}
+
+	__cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
+
+	sem_wait(&idleLock);
+
+	__cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
+
+	with( *cltr ) {
+		lock      (proc_list_lock __cfaabi_dbg_ctx2);
+		remove    (idles, *this);
+		push_front(procs, *this);
+		unlock    (proc_list_lock);
+	}
+}
+
+void wake(processor * this) {
+	__cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
+	sem_post(&this->idleLock);
+}
 
 //=============================================================================================
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision 25fcb84f4d4e0dd6a778f8ce5a1bb0777e946a31)
+++ src/libcfa/concurrency/kernel_private.h	(revision cf5e5b16165096c917c471853af2dd029ccbb3ae)
@@ -57,4 +57,6 @@
 void runThread(processor * this, thread_desc * dst);
 void finishRunning(processor * this);
+void halt(processor * this);
+void wake(processor * this);
 void terminate(processor * this);
 void spin(processor * this, unsigned int * spin_count);
Index: src/libcfa/concurrency/mutex.c
===================================================================
--- src/libcfa/concurrency/mutex.c	(revision 25fcb84f4d4e0dd6a778f8ce5a1bb0777e946a31)
+++ src/libcfa/concurrency/mutex.c	(revision cf5e5b16165096c917c471853af2dd029ccbb3ae)
@@ -167,4 +167,5 @@
 	}
 	BlockInternal( __unlock );
+	lock(l);
 }
 
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision 25fcb84f4d4e0dd6a778f8ce5a1bb0777e946a31)
+++ src/libcfa/concurrency/preemption.c	(revision cf5e5b16165096c917c471853af2dd029ccbb3ae)
@@ -266,4 +266,5 @@
 void terminate(processor * this) {
 	this->do_terminate = true;
+	wake(this);
 	sigval_t value = { PREEMPT_TERMINATE };
 	pthread_sigqueue( this->kernel_thread, SIGUSR1, value );