Index: src/libcfa/concurrency/coroutine.c
===================================================================
--- src/libcfa/concurrency/coroutine.c	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
+++ src/libcfa/concurrency/coroutine.c	(revision cfaf9beb67593b36a3927861cb7bb364983f7938)
@@ -99,5 +99,5 @@
 // Wrapper for co
 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
-	verify( preemption.enabled || this_processor->do_terminate );
+	verify( preemption_state.enabled || this_processor->do_terminate );
 	disable_interrupts();
 
@@ -117,5 +117,5 @@
 
 	enable_interrupts( __cfaabi_dbg_ctx );
-	verify( preemption.enabled || this_processor->do_terminate );
+	verify( preemption_state.enabled || this_processor->do_terminate );
 } //ctxSwitchDirect
 
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
+++ src/libcfa/concurrency/kernel	(revision cfaf9beb67593b36a3927861cb7bb364983f7938)
@@ -19,4 +19,5 @@
 
 #include "invoke.h"
+#include "bits/cfatime.h"
 
 extern "C" {
@@ -48,6 +49,8 @@
 
 	// Preemption rate on this cluster
-	unsigned long long int preemption;
+	__cfa_time_t preemption_rate;
 };
+
+extern __cfa_time_t default_preemption();
 
 void ?{} (cluster & this);
Index: src/libcfa/concurrency/kernel.c
===================================================================
--- src/libcfa/concurrency/kernel.c	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
+++ src/libcfa/concurrency/kernel.c	(revision cfaf9beb67593b36a3927861cb7bb364983f7938)
@@ -60,5 +60,5 @@
 // volatile thread_local unsigned short disable_preempt_count = 1;
 
-volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 };
+volatile thread_local __cfa_kernel_preemption_state_t preemption_state = { false, false, 1 };
 
 //-----------------------------------------------------------------------------
@@ -180,5 +180,5 @@
 	ready_queue_lock{};
 
-	preemption = default_preemption();
+	preemption_rate = default_preemption();
 }
 
@@ -209,9 +209,9 @@
 			if(readyThread)
 			{
-				verify( !preemption.enabled );
+				verify( !preemption_state.enabled );
 
 				runThread(this, readyThread);
 
-				verify( !preemption.enabled );
+				verify( !preemption_state.enabled );
 
 				//Some actions need to be taken from the kernel
@@ -262,5 +262,5 @@
 void finishRunning(processor * this) with( this->finish ) {
 	if( action_code == Release ) {
-		verify( !preemption.enabled );
+		verify( !preemption_state.enabled );
 		unlock( *lock );
 	}
@@ -269,10 +269,10 @@
 	}
 	else if( action_code == Release_Schedule ) {
-		verify( !preemption.enabled );
+		verify( !preemption_state.enabled );
 		unlock( *lock );
 		ScheduleThread( thrd );
 	}
 	else if( action_code == Release_Multi ) {
-		verify( !preemption.enabled );
+		verify( !preemption_state.enabled );
 		for(int i = 0; i < lock_count; i++) {
 			unlock( *locks[i] );
@@ -306,6 +306,6 @@
 	this_coroutine = NULL;
 	this_thread = NULL;
-	preemption.enabled = false;
-	preemption.disable_count = 1;
+	preemption_state.enabled = false;
+	preemption_state.disable_count = 1;
 	// SKULLDUGGERY: We want to create a context for the processor coroutine
 	// which is needed for the 2-step context switch. However, there is no reason
@@ -351,10 +351,10 @@
 	coroutine_desc * dst = get_coroutine(*this->runner);
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	create_stack(&dst->stack, dst->stack.size);
 	CtxStart(this->runner, CtxInvokeCoroutine);
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	dst->last = src;
@@ -382,5 +382,5 @@
 	src->state = Active;
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 }
 
@@ -392,5 +392,5 @@
 	verify( thrd->self_cor.state != Halted );
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
@@ -402,13 +402,13 @@
 	}
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 }
 
 thread_desc * nextThread(cluster * this) with( *this ) {
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	lock( ready_queue_lock __cfaabi_dbg_ctx2 );
 	thread_desc * head = pop_head( ready_queue );
 	unlock( ready_queue_lock );
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	return head;
 }
@@ -416,7 +416,7 @@
 void BlockInternal() {
 	disable_interrupts();
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	returnToKernel();
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	enable_interrupts( __cfaabi_dbg_ctx );
 }
@@ -427,7 +427,7 @@
 	this_processor->finish.lock        = lock;
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	returnToKernel();
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	enable_interrupts( __cfaabi_dbg_ctx );
@@ -439,7 +439,7 @@
 	this_processor->finish.thrd        = thrd;
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	returnToKernel();
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	enable_interrupts( __cfaabi_dbg_ctx );
@@ -453,7 +453,7 @@
 	this_processor->finish.thrd        = thrd;
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	returnToKernel();
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	enable_interrupts( __cfaabi_dbg_ctx );
@@ -466,7 +466,7 @@
 	this_processor->finish.lock_count  = count;
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	returnToKernel();
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	enable_interrupts( __cfaabi_dbg_ctx );
@@ -481,7 +481,7 @@
 	this_processor->finish.thrd_count  = thrd_count;
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	returnToKernel();
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	enable_interrupts( __cfaabi_dbg_ctx );
@@ -489,5 +489,5 @@
 
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	this_processor->finish.action_code = thrd ? Release_Schedule : Release;
 	this_processor->finish.lock        = lock;
@@ -503,5 +503,5 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	__cfaabi_dbg_print_safe("Kernel : Starting\n");
 
@@ -548,7 +548,7 @@
 	__cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
 
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 	enable_interrupts( __cfaabi_dbg_ctx );
-	verify( preemption.enabled );
+	verify( preemption_state.enabled );
 }
 
@@ -556,7 +556,7 @@
 	__cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
-	verify( preemption.enabled );
+	verify( preemption_state.enabled );
 	disable_interrupts();
-	verify( !preemption.enabled );
+	verify( !preemption_state.enabled );
 
 	// SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
Index: src/libcfa/concurrency/kernel_private.h
===================================================================
--- src/libcfa/concurrency/kernel_private.h	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
+++ src/libcfa/concurrency/kernel_private.h	(revision cfaf9beb67593b36a3927861cb7bb364983f7938)
@@ -78,5 +78,5 @@
 // extern volatile thread_local unsigned short disable_preempt_count;
 
-struct __cfa_kernel_preemption_data_t {
+struct __cfa_kernel_preemption_state_t {
 	bool enabled;
 	bool in_progress;
@@ -84,5 +84,5 @@
 };
 
-extern volatile thread_local __cfa_kernel_preemption_data_t preemption;
+extern volatile thread_local __cfa_kernel_preemption_state_t preemption_state;
 
 //-----------------------------------------------------------------------------
Index: src/libcfa/concurrency/preemption.c
===================================================================
--- src/libcfa/concurrency/preemption.c	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
+++ src/libcfa/concurrency/preemption.c	(revision cfaf9beb67593b36a3927861cb7bb364983f7938)
@@ -23,11 +23,12 @@
 }
 
+#include "bits/cfatime.h"
 #include "bits/signal.h"
 
-//TODO move to defaults
-#define __CFA_DEFAULT_PREEMPTION__ 10000
-
-//TODO move to defaults
-__attribute__((weak)) unsigned int default_preemption() {
+#if !defined(__CFA_DEFAULT_PREEMPTION__)
+#define __CFA_DEFAULT_PREEMPTION__ 10`cfa_ms
+#endif
+
+__cfa_time_t default_preemption() __attribute__((weak)) {
 	return __CFA_DEFAULT_PREEMPTION__;
 }
@@ -149,7 +150,7 @@
 	// Disable interrupts by incrementing the counter
 	void disable_interrupts() {
-		preemption.enabled = false;
-		__attribute__((unused)) unsigned short new_val = preemption.disable_count + 1;
-		preemption.disable_count = new_val;
+		preemption_state.enabled = false;
+		__attribute__((unused)) unsigned short new_val = preemption_state.disable_count + 1;
+		preemption_state.disable_count = new_val;
 		verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
 	}
@@ -161,11 +162,11 @@
 		thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
 
-		unsigned short prev = preemption.disable_count;
-		preemption.disable_count -= 1;
+		unsigned short prev = preemption_state.disable_count;
+		preemption_state.disable_count -= 1;
 		verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
 
 		// Check if we need to prempt the thread because an interrupt was missed
 		if( prev == 1 ) {
-			preemption.enabled = true;
+			preemption_state.enabled = true;
 			if( proc->pending_preemption ) {
 				proc->pending_preemption = false;
@@ -181,9 +182,9 @@
 	// Don't execute any pending CtxSwitch even if counter reaches 0
 	void enable_interrupts_noPoll() {
-		unsigned short prev = preemption.disable_count;
-		preemption.disable_count -= 1;
+		unsigned short prev = preemption_state.disable_count;
+		preemption_state.disable_count -= 1;
 		verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
 		if( prev == 1 ) {
-			preemption.enabled = true;
+			preemption_state.enabled = true;
 		}
 	}
@@ -235,5 +236,5 @@
 // If false : preemption is unsafe and marked as pending
 static inline bool preemption_ready() {
-	bool ready = preemption.enabled && !preemption.in_progress; // Check if preemption is safe
+	bool ready = preemption_state.enabled && !preemption_state.in_progress; // Check if preemption is safe
 	this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
 	return ready;
@@ -250,6 +251,6 @@
 
 	// Start with preemption disabled until ready
-	preemption.enabled = false;
-	preemption.disable_count = 1;
+	preemption_state.enabled = false;
+	preemption_state.disable_count = 1;
 
 	// Initialize the event kernel
@@ -294,5 +295,5 @@
 	this.proc->preemption_alarm = &this.alarm;
 
-	update_preemption( this.proc, from_us(this.proc->cltr->preemption) );
+	update_preemption( this.proc, this.proc->cltr->preemption_rate );
 }
 
@@ -330,7 +331,7 @@
 	__cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
 
-	preemption.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
+	preemption_state.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
 	signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
-	preemption.in_progress = false;                     // Clear the in progress flag
+	preemption_state.in_progress = false;                     // Clear the in progress flag
 
 	// Preemption can occur here
Index: src/libcfa/concurrency/preemption.h
===================================================================
--- src/libcfa/concurrency/preemption.h	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
+++ src/libcfa/concurrency/preemption.h	(revision cfaf9beb67593b36a3927861cb7bb364983f7938)
@@ -19,5 +19,4 @@
 #include "kernel_private.h"
 
-__attribute__((weak)) unsigned int default_preemption();
 void kernel_start_preemption();
 void kernel_stop_preemption();
Index: src/libcfa/concurrency/thread.c
===================================================================
--- src/libcfa/concurrency/thread.c	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
+++ src/libcfa/concurrency/thread.c	(revision cfaf9beb67593b36a3927861cb7bb364983f7938)
@@ -98,7 +98,7 @@
 
 void yield( void ) {
-	verify( preemption.enabled );
+	verify( preemption_state.enabled );
 	BlockInternal( this_thread );
-	verify( preemption.enabled );
+	verify( preemption_state.enabled );
 }