Index: libcfa/src/bits/locks.hfa
===================================================================
--- libcfa/src/bits/locks.hfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/bits/locks.hfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -37,5 +37,5 @@
 	extern "C" {
 		extern void disable_interrupts() OPTIONAL_THREAD;
-		extern void enable_interrupts_noPoll() OPTIONAL_THREAD;
+		extern void enable_interrupts( bool poll = true ) OPTIONAL_THREAD;
 
 		#ifdef __CFA_DEBUG__
@@ -57,5 +57,5 @@
 			__cfaabi_dbg_record_lock( this, caller );
 		} else {
-			enable_interrupts_noPoll();
+			enable_interrupts( false );
 		}
 		return result;
@@ -90,5 +90,5 @@
 	static inline void unlock( __spinlock_t & this ) {
 		__atomic_clear( &this.lock, __ATOMIC_RELEASE );
-		enable_interrupts_noPoll();
+		enable_interrupts( false );
 	}
 #endif
Index: libcfa/src/concurrency/alarm.cfa
===================================================================
--- libcfa/src/concurrency/alarm.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/alarm.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -116,5 +116,5 @@
 	unlock( event_kernel->lock );
 	this->set = true;
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
@@ -127,5 +127,5 @@
 	}
 	unlock( event_kernel->lock );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	this->set = false;
 }
Index: libcfa/src/concurrency/clib/cfathread.cfa
===================================================================
--- libcfa/src/concurrency/clib/cfathread.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/clib/cfathread.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -117,5 +117,5 @@
 
 	this_thrd->state = Ready;
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
Index: libcfa/src/concurrency/future.hfa
===================================================================
--- libcfa/src/concurrency/future.hfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/future.hfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -37,5 +37,5 @@
 
 		// Fulfil the future, returns whether or not someone was unblocked
-		bool fulfil( future(T) & this, T result ) {
+		$thread * fulfil( future(T) & this, T result ) {
 			this.result = result;
 			return fulfil( (future_t&)this );
@@ -96,5 +96,5 @@
 		bool fulfil( multi_future(T) & this, T result ) {
 			this.result = result;
-			return fulfil( (future_t&)this );
+			return fulfil( (future_t&)this ) != 0p;
 		}
 
Index: libcfa/src/concurrency/invoke.c
===================================================================
--- libcfa/src/concurrency/invoke.c	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/invoke.c	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -34,5 +34,5 @@
 
 extern void disable_interrupts() OPTIONAL_THREAD;
-extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+extern void enable_interrupts( _Bool poll );
 
 void __cfactx_invoke_coroutine(
@@ -82,5 +82,5 @@
 ) {
 	// Officially start the thread by enabling preemption
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts( true );
 
 	// Call the main of the thread
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/io.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -90,5 +90,5 @@
 	static inline __u32 __release_sqes( struct $io_context & );
 
-	void __cfa_io_drain( processor * proc ) {
+	bool __cfa_io_drain( processor * proc ) {
 		/* paranoid */ verify( ! __preemption_enabled() );
 		/* paranoid */ verify( proc );
@@ -104,4 +104,6 @@
 		__STATS__( false, io.calls.drain++; io.calls.completed += count; )
 
+		if(count == 0) return false;
+
 		for(i; count) {
 			unsigned idx = (head + i) & mask;
@@ -124,5 +126,5 @@
 		/* paranoid */ verify( ! __preemption_enabled() );
 
-		return;
+		return true;
 	}
 
@@ -242,5 +244,5 @@
 			// Allocation was successful
 			__STATS__( true, io.alloc.fast += 1; )
-			enable_interrupts( __cfaabi_dbg_ctx );
+			enable_interrupts();
 
 			__cfadbg_print_safe(io, "Kernel I/O : fast allocation successful from ring %d\n", ctx->fd);
@@ -254,5 +256,5 @@
 		// Fast path failed, fallback on arbitration
 		__STATS__( true, io.alloc.slow += 1; )
-		enable_interrupts( __cfaabi_dbg_ctx );
+		enable_interrupts();
 
 		$io_arbiter * ioarb = proc->cltr->io.arbiter;
@@ -312,5 +314,5 @@
 			// Mark the instance as no longer in-use, re-enable interrupts and return
 			__STATS__( true, io.submit.fast += 1; )
-			enable_interrupts( __cfaabi_dbg_ctx );
+			enable_interrupts();
 
 			__cfadbg_print_safe(io, "Kernel I/O : submitted on fast path\n");
@@ -320,5 +322,5 @@
 		// Fast path failed, fallback on arbitration
 		__STATS__( true, io.submit.slow += 1; )
-		enable_interrupts( __cfaabi_dbg_ctx );
+		enable_interrupts();
 
 		__cfadbg_print_safe(io, "Kernel I/O : falling back on arbiter for submission\n");
Index: libcfa/src/concurrency/io/types.hfa
===================================================================
--- libcfa/src/concurrency/io/types.hfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/io/types.hfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -179,7 +179,7 @@
 
 static inline {
-	bool fulfil( io_future_t & this, __s32 result ) {
+	$thread * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) {
 		this.result = result;
-		return fulfil(this.self);
+		return fulfil(this.self, do_unpark);
 	}
 
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/kernel.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -110,4 +110,5 @@
 static $thread * __next_thread(cluster * this);
 static $thread * __next_thread_slow(cluster * this);
+static inline bool __must_unpark( $thread * thrd ) __attribute((nonnull(1)));
 static void __run_thread(processor * this, $thread * dst);
 static void __wake_one(cluster * cltr);
@@ -118,11 +119,23 @@
 
 extern void __cfa_io_start( processor * );
-extern void __cfa_io_drain( processor * );
+extern bool __cfa_io_drain( processor * );
 extern void __cfa_io_flush( processor * );
 extern void __cfa_io_stop ( processor * );
-static inline void __maybe_io_drain( processor * );
+static inline bool __maybe_io_drain( processor * );
 
 extern void __disable_interrupts_hard();
 extern void __enable_interrupts_hard();
+
+static inline void __disable_interrupts_checked() {
+	/* paranoid */ verify( __preemption_enabled() );
+	disable_interrupts();
+	/* paranoid */ verify( ! __preemption_enabled() );
+}
+
+static inline void __enable_interrupts_checked( bool poll = true ) {
+	/* paranoid */ verify( ! __preemption_enabled() );
+	enable_interrupts( poll );
+	/* paranoid */ verify( __preemption_enabled() );
+}
 
 //=============================================================================================
@@ -336,5 +349,5 @@
 		if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
 			// The thread was preempted, reschedule it and reset the flag
-			__schedule_thread( thrd_dst );
+			schedule_thread$( thrd_dst );
 			break RUNNING;
 		}
@@ -426,4 +439,5 @@
 	/* paranoid */ verify( ! __preemption_enabled() );
 	/* paranoid */ verify( kernelTLS().this_proc_id );
+	/* paranoid */ verify( ready_schedule_islocked());
 	/* paranoid */ verify( thrd );
 	/* paranoid */ verify( thrd->state != Halted );
@@ -444,13 +458,12 @@
 	struct cluster * cl = thrd->curr_cluster;
 
-	ready_schedule_lock();
-		// push the thread to the cluster ready-queue
-		push( cl, thrd );
-
-		// variable thrd is no longer safe to use
-
-		// wake the cluster using the save variable.
-		__wake_one( cl );
-	ready_schedule_unlock();
+	// push the thread to the cluster ready-queue
+	push( cl, thrd );
+
+	// variable thrd is no longer safe to use
+	thrd = 0xdeaddeaddeaddeadp;
+
+	// wake the cluster using the save variable.
+	__wake_one( cl );
 
 	#if !defined(__CFA_NO_STATISTICS__)
@@ -465,5 +478,12 @@
 	#endif
 
-	/* paranoid */ verify( ! __preemption_enabled() );
+	/* paranoid */ verify( ready_schedule_islocked());
+	/* paranoid */ verify( ! __preemption_enabled() );
+}
+
+void schedule_thread$( $thread * thrd ) {
+	ready_schedule_lock();
+		__schedule_thread( thrd );
+	ready_schedule_unlock();
 }
 
@@ -496,32 +516,14 @@
 }
 
-void unpark( $thread * thrd ) {
-	if( !thrd ) return;
-
+static inline bool __must_unpark( $thread * thrd ) {
 	int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
 	switch(old_ticket) {
 		case TICKET_RUNNING:
 			// Wake won the race, the thread will reschedule/rerun itself
-			break;
+			return false;
 		case TICKET_BLOCKED:
 			/* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
 			/* paranoid */ verify( thrd->state == Blocked );
-
-			{
-				/* paranoid */ verify( publicTLS_get(this_proc_id) );
-				disable_interrupts();
-
-				/* paranoid */ verify( ! __preemption_enabled() );
-
-				// Wake lost the race,
-				__schedule_thread( thrd );
-
-				/* paranoid */ verify( ! __preemption_enabled() );
-
-				enable_interrupts_noPoll();
-				/* paranoid */ verify( publicTLS_get(this_proc_id) );
-			}
-
-			break;
+			return true;
 		default:
 			// This makes no sense, something is wrong abort
@@ -530,15 +532,20 @@
 }
 
+void unpark( $thread * thrd ) {
+	if( !thrd ) return;
+
+	if(__must_unpark(thrd)) {
+		disable_interrupts();
+			// Wake lost the race,
+			schedule_thread$( thrd );
+		enable_interrupts(false);
+	}
+}
+
 void park( void ) {
-	/* paranoid */ verify( __preemption_enabled() );
-	disable_interrupts();
-	/* paranoid */ verify( ! __preemption_enabled() );
-	/* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
-
-	returnToKernel();
-
-	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts( __cfaabi_dbg_ctx );
-	/* paranoid */ verify( __preemption_enabled() );
+	__disable_interrupts_checked();
+		/* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
+		returnToKernel();
+	__enable_interrupts_checked();
 
 }
@@ -580,26 +587,19 @@
 // KERNEL ONLY
 bool force_yield( __Preemption_Reason reason ) {
-	/* paranoid */ verify( __preemption_enabled() );
-	disable_interrupts();
-	/* paranoid */ verify( ! __preemption_enabled() );
-
-	$thread * thrd = kernelTLS().this_thread;
-	/* paranoid */ verify(thrd->state == Active);
-
-	// SKULLDUGGERY: It is possible that we are preempting this thread just before
-	// it was going to park itself. If that is the case and it is already using the
-	// intrusive fields then we can't use them to preempt the thread
-	// If that is the case, abandon the preemption.
-	bool preempted = false;
-	if(thrd->link.next == 0p) {
-		preempted = true;
-		thrd->preempted = reason;
-		returnToKernel();
-	}
-
-	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts_noPoll();
-	/* paranoid */ verify( __preemption_enabled() );
-
+	__disable_interrupts_checked();
+		$thread * thrd = kernelTLS().this_thread;
+		/* paranoid */ verify(thrd->state == Active);
+
+		// SKULLDUGGERY: It is possible that we are preempting this thread just before
+		// it was going to park itself. If that is the case and it is already using the
+		// intrusive fields then we can't use them to preempt the thread
+		// If that is the case, abandon the preemption.
+		bool preempted = false;
+		if(thrd->link.next == 0p) {
+			preempted = true;
+			thrd->preempted = reason;
+			returnToKernel();
+		}
+	__enable_interrupts_checked( false );
 	return preempted;
 }
@@ -646,10 +646,10 @@
 	__cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
 
-	disable_interrupts();
+	__disable_interrupts_checked();
 		/* paranoid */ verify( ! __preemption_enabled() );
 		eventfd_t val;
 		val = 1;
 		eventfd_write( this->idle, val );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	__enable_interrupts_checked();
 }
 
@@ -743,5 +743,5 @@
 #endif
 
-static inline void __maybe_io_drain( processor * proc ) {
+static inline bool __maybe_io_drain( processor * proc ) {
 	#if defined(CFA_HAVE_LINUX_IO_URING_H)
 		__cfadbg_print_safe(runtime_core, "Kernel : core %p checking io for ring %d\n", proc, proc->io.ctx->fd);
@@ -751,5 +751,6 @@
 		unsigned head = *ctx->cq.head;
 		unsigned tail = *ctx->cq.tail;
-		if(head != tail) __cfa_io_drain( proc );
+		if(head == tail) return false;
+		return __cfa_io_drain( proc );
 	#endif
 }
Index: libcfa/src/concurrency/kernel/fwd.hfa
===================================================================
--- libcfa/src/concurrency/kernel/fwd.hfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/kernel/fwd.hfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -108,6 +108,5 @@
 
 	extern void disable_interrupts();
-	extern void enable_interrupts_noPoll();
-	extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+	extern void enable_interrupts( bool poll = false );
 
 	extern "Cforall" {
@@ -220,9 +219,9 @@
 			// Mark as fulfilled, wake thread if needed
 			// return true if a thread was unparked
-			bool post(oneshot & this) {
+			$thread * post(oneshot & this, bool do_unpark = true) {
 				struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
-				if( got == 0p ) return false;
-				unpark( got );
-				return true;
+				if( got == 0p ) return 0p;
+				if(do_unpark) unpark( got );
+				return got;
 			}
 		}
@@ -336,5 +335,5 @@
 			// from the server side, mark the future as fulfilled
 			// delete it if needed
-			bool fulfil( future_t & this ) {
+			$thread * fulfil( future_t & this, bool do_unpark = true  ) {
 				for() {
 					struct oneshot * expected = this.ptr;
@@ -344,5 +343,5 @@
 						#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
 					#endif
-						if( expected == 3p ) { free( &this ); return false; }
+						if( expected == 3p ) { free( &this ); return 0p; }
 					#if defined(__GNUC__) && __GNUC__ >= 7
 						#pragma GCC diagnostic pop
@@ -356,6 +355,6 @@
 					struct oneshot * want = expected == 0p ? 1p : 2p;
 					if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-						if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return false; }
-						bool ret = post( *expected );
+						if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return 0p; }
+						$thread * ret = post( *expected, do_unpark );
 						__atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
 						return ret;
@@ -403,5 +402,5 @@
 					__VA_ARGS__ \
 				} \
-				if( !(in_kernel) ) enable_interrupts( __cfaabi_dbg_ctx ); \
+				if( !(in_kernel) ) enable_interrupts(); \
 			}
 		#else
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -225,5 +225,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(mainThread);
+	schedule_thread$(mainThread);
 
 	// SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
@@ -238,5 +238,5 @@
 
 	/* paranoid */ verify( ! __preemption_enabled() );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	/* paranoid */ verify( __preemption_enabled() );
 
@@ -530,5 +530,5 @@
 	disable_interrupts();
 		init( this, name, _cltr, initT );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 
 	__cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
@@ -557,5 +557,5 @@
 	disable_interrupts();
 		deinit( this );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 }
 
@@ -595,5 +595,5 @@
 	// Unlock the RWlock
 	ready_mutate_unlock( last_size );
-	enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+	enable_interrupts( false ); // Don't poll, could be in main cluster
 }
 
@@ -610,5 +610,5 @@
 	// Unlock the RWlock
 	ready_mutate_unlock( last_size );
-	enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+	enable_interrupts( false ); // Don't poll, could be in main cluster
 
 	#if !defined(__CFA_NO_STATISTICS__)
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -29,13 +29,8 @@
 extern "C" {
 	void disable_interrupts() OPTIONAL_THREAD;
-	void enable_interrupts_noPoll();
-	void enable_interrupts( __cfaabi_dbg_ctx_param );
-}
-
-void __schedule_thread( $thread * )
-#if defined(NDEBUG) || (!defined(__CFA_DEBUG__) && !defined(__CFA_VERIFY__))
-	__attribute__((nonnull (1)))
-#endif
-;
+	void enable_interrupts( bool poll = true );
+}
+
+void schedule_thread$( $thread * ) __attribute__((nonnull (1)));
 
 extern bool __preemption_enabled();
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/preemption.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -315,8 +315,8 @@
 	// Enable interrupts by decrementing the counter
 	// If counter reaches 0, execute any pending __cfactx_switch
-	void enable_interrupts( __cfaabi_dbg_ctx_param ) {
+	void enable_interrupts( bool poll ) {
 		// Cache the processor now since interrupts can start happening after the atomic store
 		processor   * proc = __cfaabi_tls.this_processor;
-		/* paranoid */ verify( proc );
+		/* paranoid */ verify( !poll || proc );
 
 		with( __cfaabi_tls.preemption_state ){
@@ -340,33 +340,9 @@
 				// Signal the compiler that a fence is needed but only for signal handlers
 				__atomic_signal_fence(__ATOMIC_RELEASE);
-				if( proc->pending_preemption ) {
+				if( poll && proc->pending_preemption ) {
 					proc->pending_preemption = false;
 					force_yield( __POLL_PREEMPTION );
 				}
 			}
-		}
-
-		// For debugging purposes : keep track of the last person to enable the interrupts
-		__cfaabi_dbg_debug_do( proc->last_enable = caller; )
-	}
-
-	// Disable interrupts by incrementint the counter
-	// Don't execute any pending __cfactx_switch even if counter reaches 0
-	void enable_interrupts_noPoll() {
-		unsigned short prev = __cfaabi_tls.preemption_state.disable_count;
-		__cfaabi_tls.preemption_state.disable_count -= 1;
-		// If this triggers someone is enabled already enabled interrupts
-		/* paranoid */ verifyf( prev != 0u, "Incremented from %u\n", prev );
-		if( prev == 1 ) {
-			#if GCC_VERSION > 50000
-				static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
-			#endif
-			// Set enabled flag to true
-			// should be atomic to avoid preemption in the middle of the operation.
-			// use memory order RELAXED since there is no inter-thread on this variable requirements
-			__atomic_store_n(&__cfaabi_tls.preemption_state.enabled, true, __ATOMIC_RELAXED);
-
-			// Signal the compiler that a fence is needed but only for signal handlers
-			__atomic_signal_fence(__ATOMIC_RELEASE);
 		}
 	}
Index: libcfa/src/concurrency/stats.cfa
===================================================================
--- libcfa/src/concurrency/stats.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/stats.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -7,4 +7,5 @@
 #include "bits/locks.hfa"
 #include "stats.hfa"
+#include "strstream.hfa"
 
 #if !defined(__CFA_NO_STATISTICS__)
@@ -118,75 +119,72 @@
 	}
 
+	#define eng3(X) (ws(3, 3, unit(eng( X ))))
+
 	void __print_stats( struct __stats_t * stats, int flags, const char * type, const char * name, void * id ) with( *stats ) {
 
+		char buf[1024];
+		strstream sstr = { buf, 1024 };
+
 		if( flags & CFA_STATS_READY_Q ) {
-			double push_len = ((double)ready.push.local.attempt + ready.push.share.attempt + ready.push.extrn.attempt) / (ready.push.local.success + ready.push.share.success + ready.push.extrn.success);
+
+			sstr | "----- " | type | "\"" | name | "\" (" | "" | id | "" | ") - Ready Q Stats -----";
+
+			uint64_t totalR = ready.pop.local.success + ready.pop.help.success + ready.pop.steal.success + ready.pop.search.success;
+			uint64_t totalS = ready.push.local.success + ready.push.share.success + ready.push.extrn.success;
+			sstr | "- totals   : " | eng3(totalR) | "run," | eng3(totalS) | "schd (" | eng3(ready.push.extrn.success) | "ext," | eng3(ready.threads.migration) | "mig)";
+
+			double push_len = ((double)ready.push.local.attempt + ready.push.share.attempt + ready.push.extrn.attempt) / totalS;
 			double sLcl_len = ready.push.local.success ? ((double)ready.push.local.attempt) / ready.push.local.success : 0;
 			double sOth_len = ready.push.share.success ? ((double)ready.push.share.attempt) / ready.push.share.success : 0;
 			double sExt_len = ready.push.extrn.success ? ((double)ready.push.extrn.attempt) / ready.push.extrn.success : 0;
-
-			uint64_t total = ready.pop.local.success + ready.pop.help.success + ready.pop.steal.success + ready.pop.search.success;
-			double rLcl_pc = (100.0 * (double)ready.pop.local .success) / total;
-			double rHlp_pc = (100.0 * (double)ready.pop.help  .success) / total;
-			double rStl_pc = (100.0 * (double)ready.pop.steal .success) / total;
-			double rSch_pc = (100.0 * (double)ready.pop.search.success) / total;
-
-			__cfaabi_bits_print_safe( STDOUT_FILENO,
-				"----- %s \"%s\" (%p) - Ready Q Stats -----\n"
-				"- totals   : %'3" PRIu64 " run, %'3" PRIu64 " schd (%'" PRIu64 "ext, %'" PRIu64 "mig, %'" PRId64 " )\n"
-				"- push avg : %'3.0lf (l: %'3.2lf/%'" PRIu64 ", s: %'3.2lf/%'" PRIu64 ", e: %'3.2lf : %'" PRIu64 "e)\n"
-				"- local    : %'3.0lf%%: %'3" PRIu64 " (%'3" PRIu64 " try, %'3" PRIu64 " spc, %'3" PRIu64 " lck, %'3" PRIu64 " ept)\n"
-				"- help     : %'3.0lf%%: %'3" PRIu64 " (%'3" PRIu64 " try, %'3" PRIu64 " spc, %'3" PRIu64 " lck, %'3" PRIu64 " ept)\n"
-				"- steal    : %'3.0lf%%: %'3" PRIu64 " (%'3" PRIu64 " try, %'3" PRIu64 " spc, %'3" PRIu64 " lck, %'3" PRIu64 " ept)\n"
-				"- search   : %'3.0lf%%: %'3" PRIu64 " (%'3" PRIu64 " try, %'3" PRIu64 " spc, %'3" PRIu64 " lck, %'3" PRIu64 " ept)\n"
-				"- Idle Slp : %'3" PRIu64 "h, %'3" PRIu64 "c, %'3" PRIu64 "w, %'3" PRIu64 "e\n"
-				"\n"
-				, type, name, id
-				, total
-				, ready.push.local.success + ready.push.share.success + ready.push.extrn.success
-				, ready.push.extrn.success, ready.threads.migration, ready.threads.threads
-				, push_len, sLcl_len, ready.push.local.attempt, sOth_len, ready.push.share.attempt, sExt_len, ready.push.extrn.attempt
-				, rLcl_pc, ready.pop.local .success, ready.pop.local .attempt, ready.pop.local .espec, ready.pop.local .elock, ready.pop.local .eempty
-				, rHlp_pc, ready.pop.help  .success, ready.pop.help  .attempt, ready.pop.help  .espec, ready.pop.help  .elock, ready.pop.help  .eempty
-				, rStl_pc, ready.pop.steal .success, ready.pop.steal .attempt, ready.pop.steal .espec, ready.pop.steal .elock, ready.pop.steal .eempty
-				, rSch_pc, ready.pop.search.success, ready.pop.search.attempt, ready.pop.search.espec, ready.pop.search.elock, ready.pop.search.eempty
-				, ready.sleep.halts, ready.sleep.cancels, ready.sleep.wakes, ready.sleep.exits
-			);
+			sstr | "- push avg : " | ws(3, 3, push_len)
+			     | "- l: " | eng3(ready.push.local.attempt) | " (" | ws(3, 3, sLcl_len) | ")"
+			     | ", s: " | eng3(ready.push.share.attempt) | " (" | ws(3, 3, sOth_len) | ")"
+			     | ", e: " | eng3(ready.push.extrn.attempt) | " (" | ws(3, 3, sExt_len) | ")";
+
+			double rLcl_pc = (100.0 * (double)ready.pop.local .success) / totalR;
+			sstr | "- local    : " | eng3(ready.pop.local .success) | "-"| ws(3, 3, rLcl_pc) | '%'
+			     | " (" | eng3(ready.pop.local .attempt) | " try," | eng3(ready.pop.local .espec) | " spc," | eng3(ready.pop.local .elock) | " lck," | eng3(ready.pop.local .eempty) | " ept)";
+			double rHlp_pc = (100.0 * (double)ready.pop.help  .success) / totalR;
+			sstr | "- help     : " | eng3(ready.pop.help  .success) | "-"| ws(3, 3, rHlp_pc) | '%'
+			     | " (" | eng3(ready.pop.help  .attempt) | " try," | eng3(ready.pop.help  .espec) | " spc," | eng3(ready.pop.help  .elock) | " lck," | eng3(ready.pop.help  .eempty) | " ept)";
+			double rStl_pc = (100.0 * (double)ready.pop.steal .success) / totalR;
+			sstr | "- steal    : " | eng3(ready.pop.steal .success) | "-"| ws(3, 3, rStl_pc) | '%'
+			     | " (" | eng3(ready.pop.steal .attempt) | " try," | eng3(ready.pop.steal .espec) | " spc," | eng3(ready.pop.steal .elock) | " lck," | eng3(ready.pop.steal .eempty) | " ept)";
+			double rSch_pc = (100.0 * (double)ready.pop.search.success) / totalR;
+			sstr | "- search   : " | eng3(ready.pop.search.success) | "-"| ws(3, 3, rSch_pc) | '%'
+			     | " (" | eng3(ready.pop.search.attempt) | " try," | eng3(ready.pop.search.espec) | " spc," | eng3(ready.pop.search.elock) | " lck," | eng3(ready.pop.search.eempty) | " ept)";
+
+			sstr | "- Idle Slp : " | eng3(ready.sleep.halts) | "halt," | eng3(ready.sleep.cancels) | "cancel," | eng3(ready.sleep.wakes) | "wake," | eng3(ready.sleep.exits) | "exit";
+			sstr | nl;
 		}
 
 		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			if( flags & CFA_STATS_IO ) {
+				sstr | "----- " | type | "\"" | name | "\" (" | "" | id | "" | ") - I/O Stats -----";
+
 				uint64_t total_allocs = io.alloc.fast + io.alloc.slow;
-				double avgfasta = ((double)io.alloc.fast) / total_allocs;
+				double avgfasta = (100.0 * (double)io.alloc.fast) / total_allocs;
+				sstr | "- total allocations : " | eng3(io.alloc.fast) | "fast," | eng3(io.alloc.slow) | "slow (" | ws(3, 3, avgfasta) | "%)";
+				sstr | "-     failures      : " | eng3(io.alloc.fail) | "oom, " | eng3(io.alloc.revoke) | "rvk, " | eng3(io.alloc.block) | "blk";
 
 				uint64_t total_submits = io.submit.fast + io.submit.slow;
-				double avgfasts = ((double)io.submit.fast) / total_submits;
+				double avgfasts = (100.0 * (double)io.submit.fast) / total_submits;
+				sstr | "- total submits     : " | eng3(io.submit.fast) | "fast," | eng3(io.submit.slow) | "slow (" | ws(3, 3, avgfasts) | "%)";
+				sstr | "- flush external    : " | eng3(io.flush.external);
+
+				sstr | "- io_uring_enter    : " | eng3(io.calls.flush) | " (" | eng3(io.calls.drain) | ", " | eng3(io.calls.errors.busy) | " EBUSY)";
 
 				double avgsubs = ((double)io.calls.submitted) / io.calls.flush;
 				double avgcomp = ((double)io.calls.completed) / io.calls.drain;
-
-				__cfaabi_bits_print_safe( STDOUT_FILENO,
-					"----- %s \"%s\" (%p) - I/O Stats -----\n"
-					"- total allocations : %'" PRIu64 "f, %'" PRIu64 "s (%'2.2lff) \n"
-					"-     failures      : %'" PRIu64 "oom, %'" PRIu64 "rvk, %'" PRIu64 "blk\n"
-					"- total submits     : %'" PRIu64 "f, %'" PRIu64 "s (%'2.2lf) \n"
-					"- flush external    : %'" PRIu64 "\n"
-					"- io_uring_enter    : %'" PRIu64 " (%'" PRIu64 ", %'" PRIu64 " EBUSY)\n"
-					"-     submits       : %'" PRIu64 " (%'.2lf) \n"
-					"-     completes     : %'" PRIu64 " (%'.2lf) \n"
-					"- poller sleeping   : %'" PRIu64 "\n"
-					"\n"
-					, type,  name, id
-					, io.alloc.fast, io.alloc.slow, avgfasta
-					, io.alloc.fail, io.alloc.revoke, io.alloc.block
-					, io.submit.fast, io.submit.slow, avgfasts
-					, io.flush.external
-					, io.calls.flush, io.calls.drain, io.calls.errors.busy
-					, io.calls.submitted, avgsubs
-					, io.calls.completed, avgcomp
-					, io.poller.sleeps
-				);
+				sstr | "-     submits       : " | eng3(io.calls.submitted) | "(" | ws(3, 3, avgsubs) | "/flush)";
+				sstr | "-     completes     : " | eng3(io.calls.completed) | "(" | ws(3, 3, avgcomp) | "/drain)";
+
+				sstr | "- poller sleeping   : " | eng3(io.poller.sleeps);
+				sstr | nl;
 			}
 		#endif
+
+		if(flags) write( sstr, stdout );
 	}
 
Index: libcfa/src/concurrency/thread.cfa
===================================================================
--- libcfa/src/concurrency/thread.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/concurrency/thread.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -134,6 +134,6 @@
 	/* paranoid */ verify( this_thrd->context.SP );
 
-	__schedule_thread( this_thrd );
-	enable_interrupts( __cfaabi_dbg_ctx );
+	schedule_thread$( this_thrd );
+	enable_interrupts();
 }
 
@@ -168,5 +168,5 @@
 	disable_interrupts();
 	uint64_t ret = __tls_rand();
-	enable_interrupts( __cfaabi_dbg_ctx );
+	enable_interrupts();
 	return ret;
 }
Index: libcfa/src/startup.cfa
===================================================================
--- libcfa/src/startup.cfa	(revision 424dfc4417eaee2a5e3b85b01edecb507bd12e62)
+++ libcfa/src/startup.cfa	(revision aec68b626be82e47f89ad2feda062b0f1c4a568b)
@@ -39,5 +39,5 @@
 
     void disable_interrupts() __attribute__(( weak )) {}
-    void enable_interrupts_noPoll() __attribute__(( weak )) {}
+    void enable_interrupts() __attribute__(( weak )) {}
 } // extern "C"