Index: src/libcfa/concurrency/coroutines
===================================================================
--- src/libcfa/concurrency/coroutines	(revision db6f06a9b651d88b1993663fa278245d8bb77626)
+++ src/libcfa/concurrency/coroutines	(revision ee897e4b569553fa2a4e77d3de048d5fbfcba4fb)
@@ -77,5 +77,5 @@
 		"Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
 		src->name, src );
-	assertf( src->last->notHalted,
+	assertf( src->last->state != Halted,
 		"Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n"
 		"Possible cause is terminated coroutine's main routine has already returned.",
@@ -98,5 +98,5 @@
       // not resuming self ?
 	if ( src != dst ) {
-		assertf( dst->notHalted ,
+		assertf( dst->state != Halted ,
 			"Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n"
 			"Possible cause is terminated coroutine's main routine has already returned.",
@@ -116,5 +116,5 @@
       // not resuming self ?
 	if ( src != dst ) {
-		assertf( dst->notHalted ,
+		assertf( dst->state != Halted ,
 			"Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n"
 			"Possible cause is terminated coroutine's main routine has already returned.",
Index: src/libcfa/concurrency/coroutines.c
===================================================================
--- src/libcfa/concurrency/coroutines.c	(revision db6f06a9b651d88b1993663fa278245d8bb77626)
+++ src/libcfa/concurrency/coroutines.c	(revision ee897e4b569553fa2a4e77d3de048d5fbfcba4fb)
@@ -68,5 +68,4 @@
 	this->errno_ = 0;
 	this->state = Start;
-	this->notHalted = true;
 	this->starter = NULL;
 	this->last = NULL;
Index: src/libcfa/concurrency/invoke.c
===================================================================
--- src/libcfa/concurrency/invoke.c	(revision db6f06a9b651d88b1993663fa278245d8bb77626)
+++ src/libcfa/concurrency/invoke.c	(revision ee897e4b569553fa2a4e77d3de048d5fbfcba4fb)
@@ -48,6 +48,5 @@
       main( this );
 
-      cor->state = Halt;
-      cor->notHalted = false;
+      cor->state = Halted;
 
       //Final suspend, should never return
Index: src/libcfa/concurrency/invoke.h
===================================================================
--- src/libcfa/concurrency/invoke.h	(revision db6f06a9b651d88b1993663fa278245d8bb77626)
+++ src/libcfa/concurrency/invoke.h	(revision ee897e4b569553fa2a4e77d3de048d5fbfcba4fb)
@@ -39,8 +39,4 @@
       };
 
-      // struct simple_lock {
-      // 	struct simple_thread_list blocked;
-      // };
-
       struct signal_once {
             volatile bool condition;
@@ -54,7 +50,4 @@
             void append( struct simple_thread_list *, struct thread * );
             struct thread * pop_head( struct simple_thread_list * );
-
-            // void ?{}(simple_lock * this);
-            // void ^?{}(simple_lock * this);
 
             void ?{}(spinlock * this);
@@ -76,5 +69,5 @@
       };
 
-      enum coroutine_state { Start, Inactive, Active, Halt, Primed };
+      enum coroutine_state { Halted, Start, Inactive, Active, Primed };
 
       struct coroutine {
@@ -83,5 +76,4 @@
             int errno_;				// copy of global UNIX variable errno
             enum coroutine_state state;	// current execution status for coroutine
-            bool notHalted;		      // indicate if execuation state is not halted
             struct coroutine *starter;	// first coroutine to resume this one
             struct coroutine *last;		// last coroutine to resume this one
@@ -89,7 +81,7 @@
 
       struct thread {
-            struct coroutine c;
-            signal_once terminated;		// indicate if execuation state is not halted
-            struct thread * next;
+            struct coroutine c;           // coroutine body used to store context
+            struct signal_once terminated;// indicate if execuation state is not halted
+            struct thread * next;         // instrusive link field for threads
       };
 
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision db6f06a9b651d88b1993663fa278245d8bb77626)
+++ src/libcfa/concurrency/kernel.c	(revision ee897e4b569553fa2a4e77d3de048d5fbfcba4fb)
@@ -119,6 +119,5 @@
 	this->name = "Main Thread";
 	this->errno_ = 0;
-	this->state = Inactive;
-	this->notHalted = true;
+	this->state = Start;
 }
 
@@ -287,6 +286,5 @@
 	proc_cor_storage.c.state = Active;
       main( &proc_cor_storage );
-      proc_cor_storage.c.state = Halt;
-      proc_cor_storage.c.notHalted = false;
+      proc_cor_storage.c.state = Halted;
 
 	// Main routine of the core returned, the core is now fully terminated
Index: src/libcfa/concurrency/threads.c
===================================================================
--- src/libcfa/concurrency/threads.c	(revision db6f06a9b651d88b1993663fa278245d8bb77626)
+++ src/libcfa/concurrency/threads.c	(revision ee897e4b569553fa2a4e77d3de048d5fbfcba4fb)
@@ -120,5 +120,5 @@
 extern "C" {
 	void __thread_signal_termination( thread * this ) {
-		this->c.state = Halt;
+		this->c.state = Halted;
 		LIB_DEBUG_PRINTF("Thread end : %p\n", this);
 		signal( &this->terminated );	
Index: src/tests/thread.c
===================================================================
--- src/tests/thread.c	(revision db6f06a9b651d88b1993663fa278245d8bb77626)
+++ src/tests/thread.c	(revision ee897e4b569553fa2a4e77d3de048d5fbfcba4fb)
@@ -4,12 +4,12 @@
 #include <threads>
 
-struct First { thread t; simple_lock* lock; };
-struct Second { thread t; simple_lock* lock; };
+struct First { thread t; signal_once* lock; };
+struct Second { thread t; signal_once* lock; };
 
 DECL_THREAD(First);
 DECL_THREAD(Second);
 
-void ?{}( First * this, simple_lock* lock ) { this->lock = lock; }
-void ?{}( Second * this, simple_lock* lock ) { this->lock = lock; }
+void ?{}( First * this, signal_once* lock ) { this->lock = lock; }
+void ?{}( Second * this, signal_once* lock ) { this->lock = lock; }
 
 void main(First* this) {
@@ -18,9 +18,9 @@
 		yield();
 	}
-	unlock(this->lock);
+	signal(this->lock);
 }
 
 void main(Second* this) {
-	lock(this->lock);	
+	wait(this->lock);
 	for(int i = 0; i < 10; i++) {
 		sout | "Second : Suspend No." | i + 1 | endl;
@@ -31,8 +31,8 @@
 
 int main(int argc, char* argv[]) {
-	simple_lock lock;
+	signal_once lock;
 	sout | "User main begin" | endl;
 	{
-		// processor p;
+		processor p;
 		{
 			scoped(First)  f = { &lock };