Index: src/benchmark/Makefile.am
===================================================================
--- src/benchmark/Makefile.am	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/benchmark/Makefile.am	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -43,5 +43,5 @@
 
 %.runquiet :
-	@+make $(basename $@)
+	@+make $(basename $@) CFLAGS="-w"
 	@taskset -c 1 ./a.out
 	@rm -f a.out
Index: src/benchmark/Makefile.in
===================================================================
--- src/benchmark/Makefile.in	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/benchmark/Makefile.in	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -459,5 +459,5 @@
 
 %.runquiet :
-	@+make $(basename $@)
+	@+make $(basename $@) CFLAGS="-w"
 	@taskset -c 1 ./a.out
 	@rm -f a.out
Index: src/libcfa/bits/containers.h
===================================================================
--- src/libcfa/bits/containers.h	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/libcfa/bits/containers.h	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -191,20 +191,18 @@
 //-----------------------------------------------------------------------------
 #ifdef __cforall
-	trait is_db_node(dtype T) {
-		T*& get_next( T& );
-		T*& get_prev( T& );
-	};
-#endif
-
-#ifdef __cforall
-	forall(dtype TYPE | is_db_node(TYPE))
+	forall(dtype TYPE | sized(TYPE))
 	#define T TYPE
-#else
-	#define T void
+	#define __getter_t * [T * & next, T * & prev] ( T & )
+#else
+	typedef void (*__generit_c_getter_t)();
+	#define T void
+	#define __getter_t __generit_c_getter_t
 #endif
 struct __dllist {
 	T * head;
-};
-#undef T
+	__getter_t __get;
+};
+#undef T
+#undef __getter_t
 
 #ifdef __cforall
@@ -216,46 +214,51 @@
 #ifdef __cforall
 
-	forall(dtype T | is_db_node(T))
-	static inline void ?{}( __dllist(T) & this ) with( this ) {
-		head{ NULL };
-	}
-
-	// forall(dtype T | is_db_node(T) | sized(T))
-	// static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
-	// 	if ( head ) {
-	// 		get_next( node ) = head;
-	// 		get_prev( node ) = get_prev( *head );
-	// 		// inserted node must be consistent before it is seen
-	// 		// prevent code movement across barrier
-	// 		asm( "" : : : "memory" );
-	// 		get_prev( *head ) = node;
-	// 		T & prev = *get_prev( node );
-	// 		get_next( prev ) = node;
-	// 	}
-	// 	else {
-	// 		get_next( node ) = &node;
-	// 		get_prev( node ) = &node;
-	// 	}
-
-	// 	// prevent code movement across barrier
-	// 	asm( "" : : : "memory" );
-	// 	head = val;
-	// }
-
-	// forall(dtype T | is_db_node(T) | sized(T))
-	// static inline T * remove( __dllist(T) & this, T & node ) with( this ) {
-	// 	if ( &node == head ) {
-	// 		if ( get_next( *head ) == head ) {
-	// 			head = NULL;
-	// 		}
-	// 		else {
-	// 			head = get_next( *head );
-	// 		}
-	// 	}
-	// 	get_prev( *get_next( node ) ) = get_prev( node );
-	// 	get_next( *get_prev( node ) ) = get_next( node );
-	// 	get_next( node ) = NULL;
-	// 	get_prev( node ) = NULL;
-	// }
+	forall(dtype T | sized(T))
+	static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
+		this.head{ NULL };
+		this.__get = __get;
+	}
+
+	#define _next .0
+	#define _prev .1
+	forall(dtype T | sized(T))
+	static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
+		if ( head ) {
+			__get( node )_next = head;
+			__get( node )_prev = __get( *head )_prev;
+			// inserted node must be consistent before it is seen
+			// prevent code movement across barrier
+			asm( "" : : : "memory" );
+			__get( *head )_prev = &node;
+			T & prev = *__get( node )_prev;
+			__get( prev )_next = &node;
+		}
+		else {
+			__get( node )_next = &node;
+			__get( node )_prev = &node;
+		}
+
+		// prevent code movement across barrier
+		asm( "" : : : "memory" );
+		head = &node;
+	}
+
+	forall(dtype T | sized(T))
+	static inline void remove( __dllist(T) & this, T & node ) with( this ) {
+		if ( &node == head ) {
+			if ( __get( *head )_next == head ) {
+				head = NULL;
+			}
+			else {
+				head = __get( *head )_next;
+			}
+		}
+		__get( *__get( node )_next )_prev = __get( node )_prev;
+		__get( *__get( node )_prev )_next = __get( node )_next;
+		__get( node )_next = NULL;
+		__get( node )_prev = NULL;
+	}
+	#undef _next
+	#undef _prev
 #endif
 
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/libcfa/concurrency/invoke.h	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -136,9 +136,8 @@
 		struct thread_desc * next;
 
-		__cfaabi_dbg_debug_do(
-			// instrusive link field for debugging
-			struct thread_desc * dbg_next;
-			struct thread_desc * dbg_prev;
-		)
+		struct {
+			struct thread_desc * next;
+			struct thread_desc * prev;
+		} node;
      };
 
@@ -147,4 +146,8 @@
 		static inline thread_desc * & get_next( thread_desc & this ) {
 			return this.next;
+		}
+
+		static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
+			return this.node.[next, prev];
 		}
 
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/libcfa/concurrency/kernel	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -40,34 +40,7 @@
 
 //-----------------------------------------------------------------------------
-// Cluster
-struct cluster {
-	// Ready queue locks
-	__spinlock_t ready_queue_lock;
+// Processor
+extern struct cluster * mainCluster;
 
-	// Ready queue for threads
-	__queue_t(thread_desc) ready_queue;
-
-	// Name of the cluster
-	const char * name;
-
-	// Preemption rate on this cluster
-	Duration preemption_rate;
-
-	// List of idle processors
-	// __dllist_t(struct processor) idles;
-};
-
-extern struct cluster * mainCluster;
-extern Duration default_preemption();
-
-void ?{} (cluster & this, const char * name, Duration preemption_rate);
-void ^?{}(cluster & this);
-
-static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
-static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
-static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
-
-//-----------------------------------------------------------------------------
-// Processor
 enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule };
 
@@ -101,5 +74,5 @@
 
 	// Cluster from which to get threads
-	cluster * cltr;
+	struct cluster * cltr;
 
 	// Name of the processor
@@ -127,8 +100,11 @@
 	bool pending_preemption;
 
+	// Idle lock
+
+	// Link lists fields
 	struct {
-		pthread_mutex_t lock;
-		pthread_cond_t  cond;
-	} idle;
+		struct processor * next;
+		struct processor * prev;
+	} node;
 
 #ifdef __CFA_DEBUG__
@@ -138,10 +114,53 @@
 };
 
-void  ?{}(processor & this, const char * name, cluster & cltr);
+void  ?{}(processor & this, const char * name, struct cluster & cltr);
 void ^?{}(processor & this);
 
 static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
-static inline void  ?{}(processor & this, cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
+static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
 static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
+
+static inline [processor *&, processor *& ] __get( processor & this ) {
+	return this.node.[next, prev];
+}
+
+//-----------------------------------------------------------------------------
+// Cluster
+struct cluster {
+	// Ready queue locks
+	__spinlock_t ready_queue_lock;
+
+	// Ready queue for threads
+	__queue_t(thread_desc) ready_queue;
+
+	// Name of the cluster
+	const char * name;
+
+	// Preemption rate on this cluster
+	Duration preemption_rate;
+
+	// List of processors
+	__spinlock_t proc_list_lock;
+	__dllist_t(struct processor) procs;
+	__dllist_t(struct processor) idles;
+
+	// Link lists fields
+	struct {
+		cluster * next;
+		cluster * prev;
+	} node;
+};
+extern Duration default_preemption();
+
+void ?{} (cluster & this, const char * name, Duration preemption_rate);
+void ^?{}(cluster & this);
+
+static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
+static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
+static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
+
+static inline [cluster *&, cluster *& ] __get( cluster & this ) {
+	return this.node.[next, prev];
+}
 
 // Local Variables: //
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/libcfa/concurrency/kernel.c	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -49,4 +49,7 @@
 thread_desc * mainThread;
 
+struct { __dllist_t(thread_desc) list; __spinlock_t lock; } global_threads ;
+struct { __dllist_t(cluster    ) list; __spinlock_t lock; } global_clusters;
+
 //-----------------------------------------------------------------------------
 // Global state
@@ -117,9 +120,8 @@
 	self_mon_p = &self_mon;
 	next = NULL;
-	__cfaabi_dbg_debug_do(
-		dbg_next = NULL;
-		dbg_prev = NULL;
-		__cfaabi_dbg_thread_register(&this);
-	)
+
+	node.next = NULL;
+	node.prev = NULL;
+	doregister(this);
 
 	monitors{ &self_mon_p, 1, (fptr_t)0 };
@@ -167,8 +169,13 @@
 	ready_queue{};
 	ready_queue_lock{};
+
+	procs{ __get };
+	idles{ __get };
+
+	doregister(this);
 }
 
 void ^?{}(cluster & this) {
-
+	unregister(this);
 }
 
@@ -182,4 +189,6 @@
 
 	__cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
+
+	doregister(this->cltr, this);
 
 	{
@@ -215,4 +224,6 @@
 		__cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
 	}
+
+	unregister(this->cltr, this);
 
 	V( this->terminated );
@@ -512,4 +523,9 @@
 	__cfaabi_dbg_print_safe("Kernel : Starting\n");
 
+	global_threads. list{ __get };
+	global_threads. lock{};
+	global_clusters.list{ __get };
+	global_clusters.lock{};
+
 	// Initialize the main cluster
 	mainCluster = (cluster *)&storage_mainCluster;
@@ -639,5 +655,4 @@
 
 static __spinlock_t kernel_abort_lock;
-static __spinlock_t kernel_debug_lock;
 static bool kernel_abort_called = false;
 
@@ -648,18 +663,17 @@
 
 	// first task to abort ?
-	if ( ! kernel_abort_called ) {			// not first task to abort ?
+	if ( kernel_abort_called ) {			// not first task to abort ?
+		unlock( kernel_abort_lock );
+
+		sigset_t mask;
+		sigemptyset( &mask );
+		sigaddset( &mask, SIGALRM );		// block SIGALRM signals
+		sigsuspend( &mask );			// block the processor to prevent further damage during abort
+		_exit( EXIT_FAILURE );			// if processor unblocks before it is killed, terminate it
+	}
+	else {
 		kernel_abort_called = true;
 		unlock( kernel_abort_lock );
 	}
-	else {
-		unlock( kernel_abort_lock );
-
-		sigset_t mask;
-		sigemptyset( &mask );
-		sigaddset( &mask, SIGALRM );			// block SIGALRM signals
-		sigaddset( &mask, SIGUSR1 );			// block SIGUSR1 signals
-		sigsuspend( &mask );				// block the processor to prevent further damage during abort
-		_exit( EXIT_FAILURE );				// if processor unblocks before it is killed, terminate it
-	}
 
 	return kernelTLS.this_thread;
@@ -669,13 +683,18 @@
 	thread_desc * thrd = kernel_data;
 
-	int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
-	__cfaabi_dbg_bits_write( abort_text, len );
-
-	if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) {
-		len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine );
+	if(thrd) {
+		int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
 		__cfaabi_dbg_bits_write( abort_text, len );
+
+		if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) {
+			len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine );
+			__cfaabi_dbg_bits_write( abort_text, len );
+		}
+		else {
+			__cfaabi_dbg_bits_write( ".\n", 2 );
+		}
 	}
 	else {
-		__cfaabi_dbg_bits_write( ".\n", 2 );
+		int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
 	}
 }
@@ -684,4 +703,6 @@
 	return get_coroutine(kernelTLS.this_thread) == get_coroutine(mainThread) ? 4 : 2;
 }
+
+static __spinlock_t kernel_debug_lock;
 
 extern "C" {
@@ -738,36 +759,45 @@
 
 //-----------------------------------------------------------------------------
+// Global Queues
+void doregister( thread_desc & thrd ) {
+	// lock      ( global_thread.lock );
+	// push_front( global_thread.list, thrd );
+	// unlock    ( global_thread.lock );
+}
+
+void unregister( thread_desc & thrd ) {
+	// lock  ( global_thread.lock );
+	// remove( global_thread.list, thrd );
+	// unlock( global_thread.lock );
+}
+
+void doregister( cluster     & cltr ) {
+	// lock      ( global_cluster.lock );
+	// push_front( global_cluster.list, cltr );
+	// unlock    ( global_cluster.lock );
+}
+
+void unregister( cluster     & cltr ) {
+	// lock  ( global_cluster.lock );
+	// remove( global_cluster.list, cltr );
+	// unlock( global_cluster.lock );
+}
+
+
+void doregister( cluster * cltr, processor * proc ) {
+	// lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+	// push_front(cltr->procs, *proc);
+	// unlock    (cltr->proc_list_lock);
+}
+
+void unregister( cluster * cltr, processor * proc ) {
+	// lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+	// remove(cltr->procs, *proc );
+	// unlock(cltr->proc_list_lock);
+}
+
+//-----------------------------------------------------------------------------
 // Debug
 __cfaabi_dbg_debug_do(
-	struct {
-		thread_desc * tail;
-	} __cfaabi_dbg_thread_list = { NULL };
-
-	void __cfaabi_dbg_thread_register( thread_desc * thrd ) {
-		if( !__cfaabi_dbg_thread_list.tail ) {
-			__cfaabi_dbg_thread_list.tail = thrd;
-			return;
-		}
-		__cfaabi_dbg_thread_list.tail->dbg_next = thrd;
-		thrd->dbg_prev = __cfaabi_dbg_thread_list.tail;
-		__cfaabi_dbg_thread_list.tail = thrd;
-	}
-
-	void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) {
-		thread_desc * prev = thrd->dbg_prev;
-		thread_desc * next = thrd->dbg_next;
-
-		if( next ) { next->dbg_prev = prev; }
-		else       {
-			assert( __cfaabi_dbg_thread_list.tail == thrd );
-			__cfaabi_dbg_thread_list.tail = prev;
-		}
-
-		if( prev ) { prev->dbg_next = next; }
-
-		thrd->dbg_prev = NULL;
-		thrd->dbg_next = NULL;
-	}
-
 	void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
 		this.prev_name = prev_name;
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/libcfa/concurrency/kernel_private.h	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -100,4 +100,14 @@
 #define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
 
+
+void doregister( struct thread_desc & thrd );
+void unregister( struct thread_desc & thrd );
+
+void doregister( struct cluster     & cltr );
+void unregister( struct cluster     & cltr );
+
+void doregister( struct cluster * cltr, struct processor * proc );
+void unregister( struct cluster * cltr, struct processor * proc );
+
 // Local Variables: //
 // mode: c //
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/libcfa/concurrency/preemption.c	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -357,10 +357,11 @@
 	// Block sigalrms to control when they arrive
 	sigset_t mask;
+	sigfillset(&mask);
+	if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
+	    abort( "internal error, pthread_sigmask" );
+	}
+
 	sigemptyset( &mask );
 	sigaddset( &mask, SIGALRM );
-
-	if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
-	    abort( "internal error, pthread_sigmask" );
-	}
 
 	// Main loop
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/libcfa/concurrency/thread.c	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -39,9 +39,8 @@
 	curr_cluster = &cl;
 	next = NULL;
-	__cfaabi_dbg_debug_do(
-		dbg_next = NULL;
-		dbg_prev = NULL;
-		__cfaabi_dbg_thread_register(&this);
-	)
+
+	node.next = NULL;
+	node.prev = NULL;
+	doregister(this);
 
 	monitors{ &self_mon_p, 1, (fptr_t)0 };
@@ -49,4 +48,5 @@
 
 void ^?{}(thread_desc& this) with( this ) {
+	unregister(this);
 	^self_cor{};
 }
Index: src/libcfa/interpose.c
===================================================================
--- src/libcfa/interpose.c	(revision 1dbc8590c4f714a4270ed019e554d5a255dcfc27)
+++ src/libcfa/interpose.c	(revision 2b22e050a040534a42376c447bd5e00f7cb3425d)
@@ -98,11 +98,12 @@
 #pragma GCC diagnostic pop
 
-		__cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO ); // Failure handler
-		__cfaabi_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO ); // Failure handler
-		__cfaabi_sigaction( SIGILL , sigHandler_ill  , SA_SIGINFO ); // Failure handler
-		__cfaabi_sigaction( SIGFPE , sigHandler_fpe  , SA_SIGINFO ); // Failure handler
-		__cfaabi_sigaction( SIGABRT, sigHandler_abort, SA_SIGINFO ); // Failure handler
-		__cfaabi_sigaction( SIGTERM, sigHandler_term , SA_SIGINFO ); // Failure handler
-		__cfaabi_sigaction( SIGINT , sigHandler_term , SA_SIGINFO ); // Failure handler
+		// Failure handler
+		__cfaabi_sigaction( SIGSEGV, sigHandler_segv , SA_SIGINFO );
+		__cfaabi_sigaction( SIGBUS , sigHandler_segv , SA_SIGINFO );
+		__cfaabi_sigaction( SIGILL , sigHandler_ill  , SA_SIGINFO );
+		__cfaabi_sigaction( SIGFPE , sigHandler_fpe  , SA_SIGINFO );
+		__cfaabi_sigaction( SIGABRT, sigHandler_abort, SA_SIGINFO | SA_RESETHAND);
+		__cfaabi_sigaction( SIGTERM, sigHandler_term , SA_SIGINFO );
+		__cfaabi_sigaction( SIGINT , sigHandler_term , SA_SIGINFO );
 	}
 }