Index: libcfa/src/concurrency/alarm.cfa
===================================================================
--- libcfa/src/concurrency/alarm.cfa	(revision 3febb2d624d5513f54b3ec586fb1509c3cbf934b)
+++ libcfa/src/concurrency/alarm.cfa	(revision 7d651a66289ee32aed2ad5c25b33322822f36702)
@@ -45,10 +45,10 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period) with( this ) {
+void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period ) with( this ) {
 	this.thrd = thrd;
 	this.alarm = alarm;
 	this.period = period;
 	set = false;
-	type = User;
+	kernel_alarm = false;
 }
 
@@ -58,13 +58,5 @@
 	this.period = period;
 	set = false;
-	type = Kernel;
-}
-void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback ) with( this ) {
-	this.thrd = thrd;
-	this.alarm = alarm;
-	this.period = period;
-	this.callback = callback;
-	set = false;
-	type = Callback;
+	kernel_alarm = true;
 }
 
Index: libcfa/src/concurrency/alarm.hfa
===================================================================
--- libcfa/src/concurrency/alarm.hfa	(revision 3febb2d624d5513f54b3ec586fb1509c3cbf934b)
+++ libcfa/src/concurrency/alarm.hfa	(revision 7d651a66289ee32aed2ad5c25b33322822f36702)
@@ -39,10 +39,4 @@
 //=============================================================================================
 
-enum alarm_type{ Kernel = 0, User = 1, Callback = 2 };
-
-struct alarm_node_t;
-
-typedef void (*Alarm_Callback)(alarm_node_t & );
-
 struct alarm_node_t {
 	Time alarm;				// time when alarm goes off
@@ -56,8 +50,6 @@
 	};
 
-	Alarm_Callback callback;
-
 	bool set		:1;		// whether or not the alarm has be registered
-	enum alarm_type type;		// true if this is not a user defined alarm
+	bool kernel_alarm	:1;		// true if this is not a user defined alarm
 };
 DLISTED_MGD_IMPL_OUT(alarm_node_t)
@@ -65,5 +57,4 @@
 void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period );
 void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
-void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback );
 void ^?{}( alarm_node_t & this );
 
Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision 3febb2d624d5513f54b3ec586fb1509c3cbf934b)
+++ libcfa/src/concurrency/locks.cfa	(revision 7d651a66289ee32aed2ad5c25b33322822f36702)
@@ -15,5 +15,4 @@
 		this.t = t;
 		this.lock = 0p;
-		this.listed = false;
 	}
 
@@ -22,5 +21,4 @@
 		this.info = info;
 		this.lock = 0p;
-		this.listed = false;
 	}
 
@@ -79,10 +77,10 @@
 	if ( owner == kernelTLS.this_thread && !multi_acquisition) {
 		fprintf(stderr, "A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock."); // Possibly throw instead
-    	exit(EXIT_FAILURE);
+		exit(EXIT_FAILURE);
 	} else if ( owner != 0p && owner != kernelTLS.this_thread ) {
 		append( blocked_threads, kernelTLS.this_thread );
 		wait_count++;
 		unlock( lock );
-		park( );
+		park( __cfaabi_dbg_ctx );
 	} else if ( owner == kernelTLS.this_thread && multi_acquisition ) {
 		recursion_count++;
@@ -113,8 +111,8 @@
 	lock( lock __cfaabi_dbg_ctx2 );
 	if ( owner == 0p ){ // no owner implies lock isn't held
-		fprintf( stderr, "There was an attempt to release a lock that isn't held" ); 
+		fprintf( stderr, "There was an attempt to release a lock that isn't held" );
 		return;
 	} else if ( strict_owner && owner != kernelTLS.this_thread ) {
-		fprintf( stderr, "A thread other than the owner attempted to release an owner lock" ); 
+		fprintf( stderr, "A thread other than the owner attempted to release an owner lock" );
 		return;
 	}
@@ -125,5 +123,5 @@
 		recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
 		wait_count--;
-		unpark( thrd );
+		unpark( thrd __cfaabi_dbg_ctx2 );
 	}
 	unlock( lock );
@@ -152,8 +150,5 @@
 		owner = t;
 		if ( multi_acquisition ) recursion_count = 1;
-		#if !defined( __CFA_NO_STATISTICS__ )
-			kernelTLS.this_stats = t->curr_cluster->stats;
-		#endif
-		unpark( t );
+		unpark( t __cfaabi_dbg_ctx2 );
 		unlock( lock );
 	}
@@ -163,7 +158,7 @@
     lock( lock __cfaabi_dbg_ctx2 );
 	if ( owner == 0p ){ // no owner implies lock isn't held
-		fprintf( stderr, "A lock that is not held was passed to a synchronization lock" ); 
+		fprintf( stderr, "A lock that is not held was passed to a synchronization lock" );
 	} else if ( strict_owner && owner != kernelTLS.this_thread ) {
-		fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" ); 
+		fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" );
 	} else {
 		$thread * thrd = pop_head( blocked_threads );
@@ -171,5 +166,5 @@
 		recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
 		wait_count--;
-		unpark( thrd );
+		unpark( thrd __cfaabi_dbg_ctx2 );
 	}
 	unlock( lock );
@@ -180,5 +175,7 @@
 ///////////////////////////////////////////////////////////////////
 
-// This is temporary until an inheritance bug is fixed
+// In an ideal world this may not be necessary
+// Is it possible for nominal inheritance to inherit traits??
+// If that occurs we would avoid all this extra code
 
 void lock( mutex_lock & this ){
@@ -231,37 +228,21 @@
 
 ///////////////////////////////////////////////////////////////////
-//// condition variable
+//// Synchronization Locks
 ///////////////////////////////////////////////////////////////////
 
 forall(dtype L | is_blocking_lock(L)) {
-
-	void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
-    	// This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
-	    lock( cond->lock __cfaabi_dbg_ctx2 );
-	    if ( (*i)->listed ) {			// is thread on queue
-	    	info_thread(L) * copy = *i;
-			remove( cond->blocked_threads, i );		 //remove this thread O(1)
-			cond->wait_count--;
-			if( !copy->lock ) {
-				unlock( cond->lock );
-				#if !defined( __CFA_NO_STATISTICS__ )
-					kernelTLS.this_stats = copy->t->curr_cluster->stats;
-				#endif
-				unpark( copy->t );
-	    	} else {
-	    		add_(*copy->lock, copy->t);			// call lock's add_
-	    	}
-	    }
-	    unlock( cond->lock );
-	}
-
-	void alarm_node_wrap_cast( alarm_node_t & a ) {
-		timeout_handler( (alarm_node_wrap(L) &)a );
-	}
-
-	void ?{}( condition_variable(L) & this ){
+	void ?{}( synchronization_lock(L) & this, bool reacquire_after_signal ){
 		this.lock{};
 		this.blocked_threads{};
 		this.count = 0;
+		this.reacquire_after_signal = reacquire_after_signal;
+	}
+
+	void ^?{}( synchronization_lock(L) & this ){
+		// default
+	}
+
+	void ?{}( condition_variable(L) & this ){
+		((synchronization_lock(L) &)this){ true };
 	}
 
@@ -270,23 +251,23 @@
 	}
 
-	void ?{}( alarm_node_wrap(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback ) {
-		this.alarm_node{ thrd, alarm, period, callback };
-	}
-
-	void ^?{}( alarm_node_wrap(L) & this ) {
-		// default
-	}
-
-	bool notify_one( condition_variable(L) & this ) with( this ) {
+	void ?{}( thread_queue(L) & this ){
+		((synchronization_lock(L) &)this){ false };
+	}
+
+	void ^?{}( thread_queue(L) & this ){
+		// default
+	}
+
+	bool notify_one( synchronization_lock(L) & this ) with( this ) {
 		lock( lock __cfaabi_dbg_ctx2 );
 		bool ret = !!blocked_threads;
 		info_thread(L) * popped = pop_head( blocked_threads );
-		popped->listed = false;
 		if(popped != 0p) {
-			count--;
-			if (popped->lock) {
+			if( reacquire_after_signal ){
 				add_(*popped->lock, popped->t);
 			} else {
-				unpark(popped->t);
+				unpark(
+					popped->t __cfaabi_dbg_ctx2
+				);
 			}
 		}
@@ -295,16 +276,16 @@
 	}
 
-	bool notify_all( condition_variable(L) & this ) with(this) {
+	bool notify_all( synchronization_lock(L) & this ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
 		bool ret = blocked_threads ? true : false;
 		while( blocked_threads ) {
 			info_thread(L) * popped = pop_head( blocked_threads );
-			popped->listed = false;
 			if(popped != 0p){
-				count--;
-				if (popped->lock) {
+				if( reacquire_after_signal ){
 					add_(*popped->lock, popped->t);
 				} else {
-					unpark(popped->t);
+					unpark(
+						popped->t __cfaabi_dbg_ctx2
+					);
 				}
 			}
@@ -314,127 +295,134 @@
 	}
 
-	uintptr_t front( condition_variable(L) & this ) with(this) {
-		if(!blocked_threads) return NULL;
-		return peek(blocked_threads)->info;
-	}
-
-	bool empty( condition_variable(L) & this ) with(this) {
+	uintptr_t front( synchronization_lock(L) & this ) with(this) {
+		return (*peek(blocked_threads)).info;
+	}
+
+	bool empty( synchronization_lock(L) & this ) with(this) {
 		return blocked_threads ? false : true;
 	}
 
-	int counter( condition_variable(L) & this ) with(this) {
+	int counter( synchronization_lock(L) & this ) with(this) {
 		return count;
 	}
 
-	// helper for wait()'s' without a timeout
-	void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
+	void queue_info_thread( synchronization_lock(L) & this, info_thread(L) & i ) with(this) {
+		lock( lock __cfaabi_dbg_ctx2 );
+		append( blocked_threads, &i );
+		count++;
+		unlock( lock );
+		park( __cfaabi_dbg_ctx );
+	}
+
+
+	void wait( synchronization_lock(L) & this ) with(this) {
+		info_thread( L ) i = { kernelTLS.this_thread };
+		queue_info_thread( this, i );
+	}
+
+	void wait( synchronization_lock(L) & this, uintptr_t info ) with(this) {
+		info_thread( L ) i = { kernelTLS.this_thread, info };
+		queue_info_thread( this, i );
+	}
+	// I still need to implement the time delay wait routines
+	bool wait( synchronization_lock(L) & this, Duration duration ) with(this) {
+		timeval tv = { time(0) };
+		Time t = { tv };
+		return wait( this, t + duration );
+	}
+
+	bool wait( synchronization_lock(L) & this, uintptr_t info, Duration duration ) with(this) {
+		// TODO: ADD INFO
+		return wait( this, duration );
+	}
+
+	bool wait( synchronization_lock(L) & this, Time time ) with(this) {
+		return false; //default
+	}
+
+	bool wait( synchronization_lock(L) & this, uintptr_t info, Time time ) with(this) {
+		// TODO: ADD INFO
+		return wait( this, time );
+	}
+
+	void queue_info_thread_unlock( synchronization_lock(L) & this, L & l, info_thread(L) & i ) with(this) {
 		lock( lock __cfaabi_dbg_ctx2 );
 		append( this.blocked_threads, &i );
 		count++;
-		i.listed = true;
-		size_t recursion_count;
-		if (i.lock) {
-			recursion_count = get_recursion_count(*i.lock);
-			remove_( *i.lock );
-		}
-		
-		unlock( lock );
-		park( ); // blocks here
-
-		if (i.lock) set_recursion_count(*i.lock, recursion_count); // resets recursion count here after waking
-	}
-
-	// helper for wait()'s' with a timeout
-	void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Time t ) with(this) {
-		lock( lock __cfaabi_dbg_ctx2 );
-
-		info_thread(L) * queue_ptr = &info;
-
-		alarm_node_wrap(L) node_wrap = { info.t, t, 0`s, alarm_node_wrap_cast };
-		node_wrap.cond = &this;
-		node_wrap.i = &queue_ptr;
-
-		register_self( &node_wrap.alarm_node );
-
-		append( blocked_threads, queue_ptr );
-		info.listed = true;
-		count++;
-
-		size_t recursion_count;
-		if (info.lock) {
-			recursion_count = get_recursion_count(*info.lock);
-			remove_( *info.lock );
-		}
-
-		unlock( lock );
-		park();
-
-		if (info.lock) set_recursion_count(*info.lock, recursion_count);
-	}
-
-	void wait( condition_variable(L) & this ) with(this) {
-		info_thread( L ) i = { kernelTLS.this_thread };
-		queue_info_thread( this, i );
-	}
-
-	void wait( condition_variable(L) & this, uintptr_t info ) with(this) {
-		info_thread( L ) i = { kernelTLS.this_thread, info };
-		queue_info_thread( this, i );
-	}
-	
-	void wait( condition_variable(L) & this, Duration duration ) with(this) {
-		info_thread( L ) i = { kernelTLS.this_thread };
-		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-	}
-
-	void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
-		info_thread( L ) i = { kernelTLS.this_thread, info };
-		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-	}
-
-	void wait( condition_variable(L) & this, Time time ) with(this) {
-		info_thread( L ) i = { kernelTLS.this_thread };
-		queue_info_thread_timeout(this, i, time);
-	}
-
-	void wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
-		info_thread( L ) i = { kernelTLS.this_thread, info };
-		queue_info_thread_timeout(this, i, time);
-	}
-
-	void wait( condition_variable(L) & this, L & l ) with(this) {
+		i.lock = &l;
+		size_t recursion_count = get_recursion_count(l);
+		remove_( l );
+		unlock( lock );
+		park( __cfaabi_dbg_ctx ); // blocks here
+
+		set_recursion_count(l, recursion_count); // resets recursion count here after waking
+	}
+
+	void wait( synchronization_lock(L) & this, L & l ) with(this) {
 		info_thread(L) i = { kernelTLS.this_thread };
-		i.lock = &l;
-		queue_info_thread( this, i );
-	}
-
-	void wait( condition_variable(L) & this, L & l, uintptr_t info ) with(this) {
+		queue_info_thread_unlock( this, l, i );
+	}
+
+	void wait( synchronization_lock(L) & this, L & l, uintptr_t info ) with(this) {
 		info_thread(L) i = { kernelTLS.this_thread, info };
-		i.lock = &l;
-		queue_info_thread( this, i );
-	}
-	
-	void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
-		info_thread(L) i = { kernelTLS.this_thread };
-		i.lock = &l;
-		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-	}
-	
-	void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
-		info_thread(L) i = { kernelTLS.this_thread, info };
-		i.lock = &l;
-		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-	}
-	
-	void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
-		info_thread(L) i = { kernelTLS.this_thread };
-		i.lock = &l;
-		queue_info_thread_timeout(this, i, time );
-	}
-	
-	void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
-		info_thread(L) i = { kernelTLS.this_thread, info };
-		i.lock = &l;
-		queue_info_thread_timeout(this, i, time );
-	}
-}
+		queue_info_thread_unlock( this, l, i );
+	}
+
+	bool wait( synchronization_lock(L) & this, L & l, Duration duration ) with(this) {
+		timeval tv = { time(0) };
+		Time t = { tv };
+		return wait( this, l, t + duration );
+	}
+
+	bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
+		// TODO: ADD INFO
+		return wait( this, l, duration );
+	}
+
+	bool wait( synchronization_lock(L) & this, L & l, Time time ) with(this) {
+		return false; //default
+	}
+
+	bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Time time ) with(this) {
+		// TODO: ADD INFO
+		return wait( this, l, time );
+	}
+}
+
+///////////////////////////////////////////////////////////////////
+//// condition lock alternative approach
+///////////////////////////////////////////////////////////////////
+
+// the solution below is less efficient but does not require the lock to have a specific add/remove routine
+
+///////////////////////////////////////////////////////////////////
+//// is_simple_lock
+///////////////////////////////////////////////////////////////////
+
+forall(dtype L | is_simple_lock(L)) {
+	void ?{}( condition_lock(L) & this ){
+		// default
+	}
+
+	void ^?{}( condition_lock(L) & this ){
+		// default
+	}
+
+	bool notify_one( condition_lock(L) & this ) with(this) {
+		return notify_one( c_var );
+	}
+
+	bool notify_all( condition_lock(L) & this ) with(this) {
+		return notify_all( c_var );
+	}
+
+	void wait( condition_lock(L) & this, L & l ) with(this) {
+		lock( m_lock );
+		size_t recursion = get_recursion_count( l );
+		unlock( l );
+		wait( c_var, m_lock );
+		lock( l );
+		set_recursion_count( l , recursion );
+		unlock( m_lock );
+	}
+}
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision 3febb2d624d5513f54b3ec586fb1509c3cbf934b)
+++ libcfa/src/concurrency/locks.hfa	(revision 7d651a66289ee32aed2ad5c25b33322822f36702)
@@ -1,4 +1,2 @@
-#pragma once
-
 #include <stdbool.h>
 
@@ -12,5 +10,4 @@
 #include "time.hfa"
 #include <sys/time.h>
-#include "alarm.hfa"
 
 ///////////////////////////////////////////////////////////////////
@@ -35,5 +32,4 @@
 		info_thread(L) * next;
 		L * lock;
-		bool listed;					// true if info_thread is on queue, false otherwise;
 	};
 
@@ -123,5 +119,5 @@
 ///////////////////////////////////////////////////////////////////
 forall(dtype L | is_blocking_lock(L)) {
-	struct condition_variable {
+	struct synchronization_lock {
 		// Spin lock used for mutual exclusion
 		__spinlock_t lock;
@@ -132,45 +128,84 @@
 		// Count of current blocked threads
 		int count;
-	};
+
+		// If true threads will reacquire the lock they block on upon waking
+		bool reacquire_after_signal;
+	};
+
+	struct condition_variable {
+		inline synchronization_lock(L);
+	};
+
+	struct thread_queue {
+		inline synchronization_lock(L);
+	};
+
+
+	void ?{}( synchronization_lock(L) & this, bool multi_acquisition, bool strict_owner );
+	void ^?{}( synchronization_lock(L) & this );
 
 	void ?{}( condition_variable(L) & this );
 	void ^?{}( condition_variable(L) & this );
 
-	struct alarm_node_wrap {
-		alarm_node_t alarm_node;
-
-		condition_variable(L) * cond;
-
-		info_thread(L) ** i;
-	};
-
-	void ?{}( alarm_node_wrap(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback );
-	void ^?{}( alarm_node_wrap(L) & this );
-
-	void alarm_node_callback( alarm_node_wrap(L) & this );
-
-	void alarm_node_wrap_cast( alarm_node_t & a );
-
-	bool notify_one( condition_variable(L) & this );
-	bool notify_all( condition_variable(L) & this );
-
-	uintptr_t front( condition_variable(L) & this );
-
-	bool empty( condition_variable(L) & this );
-	int counter( condition_variable(L) & this );
-
-	// TODO: look into changing timout routines to return bool showing if signalled or woken by kernel
-	void wait( condition_variable(L) & this );
-	void wait( condition_variable(L) & this, uintptr_t info );
-	void wait( condition_variable(L) & this, Duration duration );
-	void wait( condition_variable(L) & this, uintptr_t info, Duration duration );
-	void wait( condition_variable(L) & this, Time time );
-	void wait( condition_variable(L) & this, uintptr_t info, Time time );
-
-	void wait( condition_variable(L) & this, L & l );
-	void wait( condition_variable(L) & this, L & l, uintptr_t info );
-	void wait( condition_variable(L) & this, L & l, Duration duration );
-	void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
-	void wait( condition_variable(L) & this, L & l, Time time );
-	void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
+	void ?{}( thread_queue(L) & this );
+	void ^?{}( thread_queue(L) & this );
+
+	bool notify_one( synchronization_lock(L) & this );
+	bool notify_all( synchronization_lock(L) & this );
+
+	uintptr_t front( synchronization_lock(L) & this );
+
+	bool empty( synchronization_lock(L) & this );
+	int counter( synchronization_lock(L) & this );
+
+	// wait functions that are not passed a mutex lock
+	void wait( synchronization_lock(L) & this );
+	void wait( synchronization_lock(L) & this, uintptr_t info );
+	bool wait( synchronization_lock(L) & this, Duration duration );
+	bool wait( synchronization_lock(L) & this, uintptr_t info, Duration duration );
+	bool wait( synchronization_lock(L) & this, Time time );
+	bool wait( synchronization_lock(L) & this, uintptr_t info, Time time );
+
+	// wait functions that are passed a lock
+	bool notify_one( synchronization_lock(L) & this, L & l );
+	bool notify_all( synchronization_lock(L) & this, L & l );
+
+	void wait( synchronization_lock(L) & this, L & l );
+	void wait( synchronization_lock(L) & this, L & l, uintptr_t info );
+	bool wait( synchronization_lock(L) & this, L & l, Duration duration );
+	bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Duration duration );
+	bool wait( synchronization_lock(L) & this, L & l, Time time );
+	bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Time time );
 }
+
+///////////////////////////////////////////////////////////////////
+//// condition lock alternative approach
+///////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////
+//// is_simple_lock
+///////////////////////////////////////////////////////////////////
+
+trait is_simple_lock(dtype L | sized(L)) {
+	void lock( L & );		// For synchronization locks to use when acquiring
+	void unlock( L & );    // For synchronization locks to use when releasing
+	size_t get_recursion_count( L & ); // to get recursion count for cond lock to reset after waking
+	void set_recursion_count( L &, size_t recursion ); // to set recursion count after getting signalled;
+};
+
+forall(dtype L | is_simple_lock(L)) {
+	struct condition_lock {
+		// Spin lock used for mutual exclusion
+		mutex_lock m_lock;
+
+		condition_variable( mutex_lock ) c_var;
+	};
+
+	void ?{}( condition_lock(L) & this );
+	void ^?{}( condition_lock(L) & this );
+
+	bool notify_one( condition_lock(L) & this );
+	bool notify_all( condition_lock(L) & this );
+	void wait( condition_lock(L) & this, L & l );
+}
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision 3febb2d624d5513f54b3ec586fb1509c3cbf934b)
+++ libcfa/src/concurrency/preemption.cfa	(revision 7d651a66289ee32aed2ad5c25b33322822f36702)
@@ -105,12 +105,9 @@
 
 		// Check if this is a kernel
-		if( node->type == Kernel ) {
+		if( node->kernel_alarm ) {
 			preempt( node->proc );
 		}
-		else if( node->type == User ) {
+		else {
 			timeout( node->thrd );
-		}
-		else {
-			node->callback(*node);
 		}
 
