Index: libcfa/src/concurrency/io/setup.cfa
===================================================================
--- libcfa/src/concurrency/io/setup.cfa	(revision ea3fa256725d034fc7810b7fc6e633e42137e2d1)
+++ libcfa/src/concurrency/io/setup.cfa	(revision 82f791f1d2c7e5f856d24903cbf18c05302e9ccb)
@@ -149,4 +149,5 @@
 		id.full_proc = false;
 		id.id = doregister(&id);
+		kernelTLS.this_proc_id = &id;
 		__cfaabi_dbg_print_safe( "Kernel : IO poller thread starting\n" );
 
@@ -180,5 +181,5 @@
 					kernelTLS.this_stats = io_ctx->self.curr_cluster->stats;
 				#endif
-				__post( io_ctx->sem, &id );
+				post( io_ctx->sem );
 			}
 		}
@@ -235,5 +236,5 @@
 			if( thrd.state == Ready || thrd.preempted != __NO_PREEMPTION ) {
 
-				ready_schedule_lock( (struct __processor_id_t *)active_processor() );
+				ready_schedule_lock();
 
 					// This is the tricky case
@@ -253,5 +254,5 @@
 					thrd.preempted = __NO_PREEMPTION;
 
-				ready_schedule_unlock( (struct __processor_id_t *)active_processor() );
+				ready_schedule_unlock();
 
 				// Pretend like the thread was blocked all along
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision ea3fa256725d034fc7810b7fc6e633e42137e2d1)
+++ libcfa/src/concurrency/kernel.cfa	(revision 82f791f1d2c7e5f856d24903cbf18c05302e9ccb)
@@ -108,5 +108,5 @@
 static $thread * __next_thread_slow(cluster * this);
 static void __run_thread(processor * this, $thread * dst);
-static void __wake_one(struct __processor_id_t * id, cluster * cltr);
+static void __wake_one(cluster * cltr);
 
 static void push  (__cluster_idles & idles, processor & proc);
@@ -282,5 +282,5 @@
 		if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
 			// The thread was preempted, reschedule it and reset the flag
-			__schedule_thread( (__processor_id_t*)this, thrd_dst );
+			__schedule_thread( thrd_dst );
 			break RUNNING;
 		}
@@ -358,8 +358,9 @@
 // Scheduler routines
 // KERNEL ONLY
-void __schedule_thread( struct __processor_id_t * id, $thread * thrd ) {
+void __schedule_thread( $thread * thrd ) {
 	/* paranoid */ verify( thrd );
 	/* paranoid */ verify( thrd->state != Halted );
 	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+	/* paranoid */ verify( kernelTLS.this_proc_id );
 	/* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
 	/* paranoid */ 	if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
@@ -374,8 +375,8 @@
 	if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
 
-	ready_schedule_lock  ( id );
+	ready_schedule_lock();
 		push( thrd->curr_cluster, thrd );
-		__wake_one(id, thrd->curr_cluster);
-	ready_schedule_unlock( id );
+		__wake_one(thrd->curr_cluster);
+	ready_schedule_unlock();
 
 	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -384,11 +385,13 @@
 // KERNEL ONLY
 static inline $thread * __next_thread(cluster * this) with( *this ) {
-	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-
-	ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
+	/* paranoid */ verify( kernelTLS.this_proc_id );
+	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+	ready_schedule_lock();
 		$thread * thrd = pop( this );
-	ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
-
-	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+	ready_schedule_unlock();
+
+	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+	/* paranoid */ verify( kernelTLS.this_proc_id );
 	return thrd;
 }
@@ -396,16 +399,24 @@
 // KERNEL ONLY
 static inline $thread * __next_thread_slow(cluster * this) with( *this ) {
-	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-
-	ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
+	/* paranoid */ verify( kernelTLS.this_proc_id );
+	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+	ready_schedule_lock();
 		$thread * thrd = pop_slow( this );
-	ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
-
-	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+	ready_schedule_unlock();
+
+	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+	/* paranoid */ verify( kernelTLS.this_proc_id );
 	return thrd;
 }
 
-// KERNEL ONLY unpark with out disabling interrupts
-void __unpark(  struct __processor_id_t * id, $thread * thrd ) {
+void unpark( $thread * thrd ) {
+	if( !thrd ) return;
+
+	/* paranoid */ verify( kernelTLS.this_proc_id );
+	bool full = kernelTLS.this_proc_id->full_proc;
+	if(full) disable_interrupts();
+
+	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 	int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
 	switch(old_ticket) {
@@ -418,5 +429,5 @@
 
 			// Wake lost the race,
-			__schedule_thread( id, thrd );
+			__schedule_thread( thrd );
 			break;
 		default:
@@ -424,12 +435,8 @@
 			abort("Thread %p (%s) has mismatch park/unpark\n", thrd, thrd->self_cor.name);
 	}
-}
-
-void unpark( $thread * thrd ) {
-	if( !thrd ) return;
-
-	disable_interrupts();
-	__unpark( (__processor_id_t*)kernelTLS.this_processor, thrd );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+	if(full) enable_interrupts( __cfaabi_dbg_ctx );
+	/* paranoid */ verify( kernelTLS.this_proc_id );
 }
 
@@ -505,7 +512,7 @@
 //=============================================================================================
 // Wake a thread from the front if there are any
-static void __wake_one(struct __processor_id_t * id, cluster * this) {
-	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-	/* paranoid */ verify( ready_schedule_islocked( id ) );
+static void __wake_one(cluster * this) {
+	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+	/* paranoid */ verify( ready_schedule_islocked() );
 
 	// Check if there is a sleeping processor
@@ -525,5 +532,5 @@
 	#endif
 
-	/* paranoid */ verify( ready_schedule_islocked( id ) );
+	/* paranoid */ verify( ready_schedule_islocked() );
 	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
Index: libcfa/src/concurrency/kernel/fwd.hfa
===================================================================
--- libcfa/src/concurrency/kernel/fwd.hfa	(revision ea3fa256725d034fc7810b7fc6e633e42137e2d1)
+++ libcfa/src/concurrency/kernel/fwd.hfa	(revision 82f791f1d2c7e5f856d24903cbf18c05302e9ccb)
@@ -35,7 +35,8 @@
 	extern "Cforall" {
 		extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-			struct $thread    * volatile this_thread;
-			struct processor  * volatile this_processor;
-			struct __stats_t  * volatile this_stats;
+			struct $thread          * volatile this_thread;
+			struct processor        * volatile this_processor;
+			struct __processor_id_t * volatile this_proc_id;
+			struct __stats_t        * volatile this_stats;
 
 			struct {
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision ea3fa256725d034fc7810b7fc6e633e42137e2d1)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision 82f791f1d2c7e5f856d24903cbf18c05302e9ccb)
@@ -122,4 +122,5 @@
 	NULL,
 	NULL,
+	NULL,
 	{ 1, false, false },
 };
@@ -212,4 +213,5 @@
 	//initialize the global state variables
 	kernelTLS.this_processor = mainProcessor;
+	kernelTLS.this_proc_id   = (__processor_id_t*)mainProcessor;
 	kernelTLS.this_thread    = mainThread;
 
@@ -227,5 +229,5 @@
 	// Add the main thread to the ready queue
 	// once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
-	__schedule_thread((__processor_id_t *)mainProcessor, mainThread);
+	__schedule_thread(mainThread);
 
 	// SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
@@ -324,4 +326,5 @@
 	processor * proc = (processor *) arg;
 	kernelTLS.this_processor = proc;
+	kernelTLS.this_proc_id   = (__processor_id_t*)proc;
 	kernelTLS.this_thread    = 0p;
 	kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision ea3fa256725d034fc7810b7fc6e633e42137e2d1)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision 82f791f1d2c7e5f856d24903cbf18c05302e9ccb)
@@ -33,7 +33,7 @@
 }
 
-void __schedule_thread( struct __processor_id_t *, $thread * )
+void __schedule_thread( $thread * )
 #if defined(NDEBUG) || (!defined(__CFA_DEBUG__) && !defined(__CFA_VERIFY__))
-	__attribute__((nonnull (2)))
+	__attribute__((nonnull (1)))
 #endif
 ;
@@ -63,28 +63,7 @@
 )
 
-// KERNEL ONLY unpark with out disabling interrupts
-void __unpark( struct __processor_id_t *, $thread * thrd );
-
 #define TICKET_BLOCKED (-1) // thread is blocked
 #define TICKET_RUNNING ( 0) // thread is running
 #define TICKET_UNBLOCK ( 1) // thread should ignore next block
-
-static inline bool __post(single_sem & this, struct __processor_id_t * id) {
-	for() {
-		struct $thread * expected = this.ptr;
-		if(expected == 1p) return false;
-		if(expected == 0p) {
-			if(__atomic_compare_exchange_n(&this.ptr, &expected, 1p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-				return false;
-			}
-		}
-		else {
-			if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-				__unpark( id, expected );
-				return true;
-			}
-		}
-	}
-}
 
 //-----------------------------------------------------------------------------
@@ -201,7 +180,9 @@
 // Reader side : acquire when using the ready queue to schedule but not
 //  creating/destroying queues
-static inline void ready_schedule_lock( struct __processor_id_t * proc) with(*__scheduler_lock) {
-	unsigned iproc = proc->id;
-	/*paranoid*/ verify(data[iproc].handle == proc);
+static inline void ready_schedule_lock(void) with(*__scheduler_lock) {
+	/*paranoid*/ verify( kernelTLS.this_proc_id );
+
+	unsigned iproc = kernelTLS.this_proc_id->id;
+	/*paranoid*/ verify(data[iproc].handle == kernelTLS.this_proc_id);
 	/*paranoid*/ verify(iproc < ready);
 
@@ -225,7 +206,9 @@
 }
 
-static inline void ready_schedule_unlock( struct __processor_id_t * proc) with(*__scheduler_lock) {
-	unsigned iproc = proc->id;
-	/*paranoid*/ verify(data[iproc].handle == proc);
+static inline void ready_schedule_unlock(void) with(*__scheduler_lock) {
+	/*paranoid*/ verify( kernelTLS.this_proc_id );
+
+	unsigned iproc = kernelTLS.this_proc_id->id;
+	/*paranoid*/ verify(data[iproc].handle == kernelTLS.this_proc_id);
 	/*paranoid*/ verify(iproc < ready);
 	/*paranoid*/ verify(data[iproc].lock);
@@ -239,5 +222,7 @@
 
 #ifdef __CFA_WITH_VERIFY__
-	static inline bool ready_schedule_islocked( struct __processor_id_t * proc) {
+	static inline bool ready_schedule_islocked(void) {
+		/*paranoid*/ verify( kernelTLS.this_proc_id );
+		__processor_id_t * proc = kernelTLS.this_proc_id;
 		return __scheduler_lock->data[proc->id].owned;
 	}
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision ea3fa256725d034fc7810b7fc6e633e42137e2d1)
+++ libcfa/src/concurrency/preemption.cfa	(revision 82f791f1d2c7e5f856d24903cbf18c05302e9ccb)
@@ -38,5 +38,5 @@
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
-static void timeout( struct __processor_id_t * id, $thread * this );
+static void timeout( $thread * this );
 
 // FwdDeclarations : Signal handlers
@@ -91,5 +91,5 @@
 
 // Tick one frame of the Discrete Event Simulation for alarms
-static void tick_preemption( struct __processor_id_t * id ) {
+static void tick_preemption(void) {
 	alarm_node_t * node = 0p;							// Used in the while loop but cannot be declared in the while condition
 	alarm_list_t * alarms = &event_kernel->alarms;		// Local copy for ease of reading
@@ -109,5 +109,5 @@
 		}
 		else {
-			timeout( id, node->thrd );
+			timeout( node->thrd );
 		}
 
@@ -270,9 +270,9 @@
 
 // reserved for future use
-static void timeout( struct __processor_id_t * id, $thread * this ) {
+static void timeout( $thread * this ) {
 	#if !defined( __CFA_NO_STATISTICS__ )
 		kernelTLS.this_stats = this->curr_cluster->stats;
 	#endif
-	__unpark( id, this );
+	unpark( this );
 }
 
@@ -413,4 +413,5 @@
 	id.full_proc = false;
 	id.id = doregister(&id);
+	kernelTLS.this_proc_id = &id;
 
 	// Block sigalrms to control when they arrive
@@ -458,5 +459,5 @@
 			// __cfaabi_dbg_print_safe( "Kernel : Preemption thread tick\n" );
 			lock( event_kernel->lock __cfaabi_dbg_ctx2 );
-			tick_preemption( &id );
+			tick_preemption();
 			unlock( event_kernel->lock );
 			break;
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision ea3fa256725d034fc7810b7fc6e633e42137e2d1)
+++ libcfa/src/concurrency/thread.cfa	(revision 82f791f1d2c7e5f856d24903cbf18c05302e9ccb)
@@ -127,5 +127,5 @@
 	verify( this_thrd->context.SP );
 
-	__schedule_thread( (__processor_id_t *)kernelTLS.this_processor, this_thrd);
+	__schedule_thread( this_thrd );
 	enable_interrupts( __cfaabi_dbg_ctx );
 }