Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 78da4abe22e69798ee3738623dc9a2d99e34d207)
+++ libcfa/src/concurrency/io.cfa	(revision d60d30ef3cbda3a4010ce92c21dcd3ce89fb6684)
@@ -17,6 +17,6 @@
 
 #if defined(__CFA_DEBUG__)
-	#define __CFA_DEBUG_PRINT_IO__
-	#define __CFA_DEBUG_PRINT_IO_CORE__
+	// #define __CFA_DEBUG_PRINT_IO__
+	// #define __CFA_DEBUG_PRINT_IO_CORE__
 #endif
 
@@ -83,4 +83,5 @@
 //=============================================================================================
 	static int __io_uring_enter( struct $io_context & ctx, unsigned to_submit, bool get ) {
+		__STATS__( false, io.calls.count++; )
 		bool need_sys_to_submit = false;
 		bool need_sys_to_complete = false;
@@ -109,4 +110,5 @@
 		if( need_sys_to_submit || need_sys_to_complete ) {
 			__cfadbg_print_safe(io_core, "Kernel I/O : IO_URING enter %d %u %u\n", ctx.fd, to_submit, flags);
+			__STATS__( false, io.calls.blocks++; )
 			ret = syscall( __NR_io_uring_enter, ctx.fd, to_submit, 0, flags, (sigset_t *)0p, _NSIG / 8);
 			__cfadbg_print_safe(io_core, "Kernel I/O : IO_URING %d returned %d\n", ctx.fd, ret);
@@ -124,5 +126,5 @@
 	static inline __u32 __release_sqes( struct $io_context & );
 
-	static [int, bool] __drain_io( & struct  $io_context ctx ) {
+	static bool __drain_io( struct  $io_context & ctx ) {
 		unsigned to_submit = __flush( ctx );
 		int ret = __io_uring_enter( ctx, to_submit, true );
@@ -132,5 +134,7 @@
 			case EINTR:
 			case EBUSY:
-				return [0, true];
+				// Update statistics
+				__STATS__( false, io.calls.errors.busy ++; )
+				return true;
 				break;
 			default:
@@ -141,11 +145,5 @@
 		// update statistics
 		if (to_submit > 0) {
-			__STATS__( false,
-				if( to_submit > 0 ) {
-					io.submit_q.submit_avg.rdy += to_submit;
-					io.submit_q.submit_avg.csm += ret;
-					io.submit_q.submit_avg.cnt += 1;
-				}
-			)
+			__STATS__( false, io.calls.submitted += ret; )
 			/* paranoid */ verify( ctx.sq.to_submit <= *ctx.sq.num );
 
@@ -170,9 +168,11 @@
 		// Nothing was new return 0
 		if (head == tail) {
-			return [0, to_submit > 0];
+			return ctx.sq.to_submit > 0;
 		}
 
 		__u32 count = tail - head;
 		/* paranoid */ verify( count != 0 );
+		__STATS__( false, io.calls.submitted += count; )
+
 		for(i; count) {
 			unsigned idx = (head + i) & mask;
@@ -195,5 +195,5 @@
 		__atomic_store_n( ctx.cq.head, head + count, __ATOMIC_SEQ_CST );
 
-		return [count, count > 0 || to_submit > 0];
+		return count > 0 || to_submit > 0;
 	}
 
@@ -212,15 +212,7 @@
 
 			// Drain the io
-			int count;
-			bool again;
-			[count, again] = __drain_io( this );
+			bool again = __drain_io( this );
 
 			if(!again) reset--;
-
-			// Update statistics
-			__STATS__( false,
-				io.complete_q.completed_avg.val += count;
-				io.complete_q.completed_avg.cnt += 1;
-			)
 
 			// If we got something, just yield and check again
@@ -241,5 +233,5 @@
 
 			__STATS__( false,
-				io.complete_q.blocks += 1;
+				io.calls.blocks += 1;
 			)
 			__cfadbg_print_safe(io_core, "Kernel I/O : Parking io poller %d (%p)\n", this.fd, &this);
@@ -342,4 +334,5 @@
 				// Mark the instance as no longer in-use and re-enable interrupts
 				__atomic_store_n( &proc->io.lock, false, __ATOMIC_RELEASE );
+				__STATS__( true, io.alloc.fast += 1; )
 				enable_interrupts( __cfaabi_dbg_ctx );
 
@@ -350,8 +343,10 @@
 			}
 			// The fast path failed, fallback
+			__STATS__( true, io.alloc.fail += 1; )
 		}
 
 		// Fast path failed, fallback on arbitration
 		__atomic_store_n( &proc->io.lock, false, __ATOMIC_RELEASE );
+		__STATS__( true, io.alloc.slow += 1; )
 		enable_interrupts( __cfaabi_dbg_ctx );
 
@@ -409,4 +404,5 @@
 			// Mark the instance as no longer in-use, re-enable interrupts and return
 			__atomic_store_n( &proc->io.lock, false, __ATOMIC_RELEASE );
+			__STATS__( true, io.submit.fast += 1; )
 			enable_interrupts( __cfaabi_dbg_ctx );
 
@@ -417,4 +413,5 @@
 		// Fast path failed, fallback on arbitration
 		__atomic_store_n( &proc->io.lock, false, __ATOMIC_RELEASE );
+		__STATS__( true, io.submit.slow += 1; )
 		enable_interrupts( __cfaabi_dbg_ctx );
 
@@ -556,4 +553,6 @@
 			__revoke( this, c );
 
+			__STATS__( false, io.alloc.revoke += 1; )
+
 			if(__alloc(c, idxs, want)) {
 				__assign( this, c, proc);
@@ -564,4 +563,6 @@
 		__cfadbg_print_safe(io, "Kernel I/O : waiting for available resources\n");
 
+		__STATS__( false, io.alloc.block += 1; )
+
 		// No one has any resources left, wait for something to finish
 		// Mark as pending
@@ -626,4 +627,6 @@
 	static void __ioarbiter_flush( $io_arbiter & mutex this, $io_context * ctx ) {
 		/* paranoid */ verify( &this == ctx->arbiter );
+
+		__STATS__( false, io.flush.external += 1; )
 
 		__revoke( this, ctx );
Index: libcfa/src/concurrency/stats.cfa
===================================================================
--- libcfa/src/concurrency/stats.cfa	(revision 78da4abe22e69798ee3738623dc9a2d99e34d207)
+++ libcfa/src/concurrency/stats.cfa	(revision d60d30ef3cbda3a4010ce92c21dcd3ce89fb6684)
@@ -25,19 +25,17 @@
 
 		#if defined(CFA_HAVE_LINUX_IO_URING_H)
-			stats->io.submit_q.submit_avg.rdy = 0;
-			stats->io.submit_q.submit_avg.csm = 0;
-			stats->io.submit_q.submit_avg.cnt = 0;
-			stats->io.submit_q.look_avg.val   = 0;
-			stats->io.submit_q.look_avg.cnt   = 0;
-			stats->io.submit_q.look_avg.block = 0;
-			stats->io.submit_q.alloc_avg.val   = 0;
-			stats->io.submit_q.alloc_avg.cnt   = 0;
-			stats->io.submit_q.alloc_avg.block = 0;
-			stats->io.submit_q.helped = 0;
-			stats->io.submit_q.leader = 0;
-			stats->io.submit_q.busy   = 0;
-			stats->io.complete_q.completed_avg.val = 0;
-			stats->io.complete_q.completed_avg.cnt = 0;
-			stats->io.complete_q.blocks = 0;
+			stats->io.alloc.fast        = 0;
+			stats->io.alloc.slow        = 0;
+			stats->io.alloc.fail        = 0;
+			stats->io.alloc.revoke      = 0;
+			stats->io.alloc.block       = 0;
+			stats->io.submit.fast       = 0;
+			stats->io.submit.slow       = 0;
+			stats->io.flush.external    = 0;
+			stats->io.calls.count       = 0;
+			stats->io.calls.submitted   = 0;
+			stats->io.calls.completed   = 0;
+			stats->io.calls.blocks      = 0;
+			stats->io.calls.errors.busy = 0;
 		#endif
 	}
@@ -60,20 +58,17 @@
 
 		#if defined(CFA_HAVE_LINUX_IO_URING_H)
-			__atomic_fetch_add( &cltr->io.submit_q.submit_avg.rdy     , proc->io.submit_q.submit_avg.rdy     , __ATOMIC_SEQ_CST ); proc->io.submit_q.submit_avg.rdy      = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.submit_avg.csm     , proc->io.submit_q.submit_avg.csm     , __ATOMIC_SEQ_CST ); proc->io.submit_q.submit_avg.csm      = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.submit_avg.avl     , proc->io.submit_q.submit_avg.avl     , __ATOMIC_SEQ_CST ); proc->io.submit_q.submit_avg.avl      = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.submit_avg.cnt     , proc->io.submit_q.submit_avg.cnt     , __ATOMIC_SEQ_CST ); proc->io.submit_q.submit_avg.cnt      = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.look_avg.val       , proc->io.submit_q.look_avg.val       , __ATOMIC_SEQ_CST ); proc->io.submit_q.look_avg.val        = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.look_avg.cnt       , proc->io.submit_q.look_avg.cnt       , __ATOMIC_SEQ_CST ); proc->io.submit_q.look_avg.cnt        = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.look_avg.block     , proc->io.submit_q.look_avg.block     , __ATOMIC_SEQ_CST ); proc->io.submit_q.look_avg.block      = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.alloc_avg.val      , proc->io.submit_q.alloc_avg.val      , __ATOMIC_SEQ_CST ); proc->io.submit_q.alloc_avg.val       = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.alloc_avg.cnt      , proc->io.submit_q.alloc_avg.cnt      , __ATOMIC_SEQ_CST ); proc->io.submit_q.alloc_avg.cnt       = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.alloc_avg.block    , proc->io.submit_q.alloc_avg.block    , __ATOMIC_SEQ_CST ); proc->io.submit_q.alloc_avg.block     = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.helped             , proc->io.submit_q.helped             , __ATOMIC_SEQ_CST ); proc->io.submit_q.helped              = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.leader             , proc->io.submit_q.leader             , __ATOMIC_SEQ_CST ); proc->io.submit_q.leader              = 0;
-			__atomic_fetch_add( &cltr->io.submit_q.busy               , proc->io.submit_q.busy               , __ATOMIC_SEQ_CST ); proc->io.submit_q.busy                = 0;
-			__atomic_fetch_add( &cltr->io.complete_q.completed_avg.val, proc->io.complete_q.completed_avg.val, __ATOMIC_SEQ_CST ); proc->io.complete_q.completed_avg.val = 0;
-			__atomic_fetch_add( &cltr->io.complete_q.completed_avg.cnt, proc->io.complete_q.completed_avg.cnt, __ATOMIC_SEQ_CST ); proc->io.complete_q.completed_avg.cnt = 0;
-			__atomic_fetch_add( &cltr->io.complete_q.blocks           , proc->io.complete_q.blocks           , __ATOMIC_SEQ_CST ); proc->io.complete_q.blocks            = 0;
+			__atomic_fetch_add( &cltr->io.alloc.fast       , proc->io.alloc.fast       , __ATOMIC_SEQ_CST ); proc->io.alloc.fast        = 0;
+			__atomic_fetch_add( &cltr->io.alloc.slow       , proc->io.alloc.slow       , __ATOMIC_SEQ_CST ); proc->io.alloc.slow        = 0;
+			__atomic_fetch_add( &cltr->io.alloc.fail       , proc->io.alloc.fail       , __ATOMIC_SEQ_CST ); proc->io.alloc.fail        = 0;
+			__atomic_fetch_add( &cltr->io.alloc.revoke     , proc->io.alloc.revoke     , __ATOMIC_SEQ_CST ); proc->io.alloc.revoke      = 0;
+			__atomic_fetch_add( &cltr->io.alloc.block      , proc->io.alloc.block      , __ATOMIC_SEQ_CST ); proc->io.alloc.block       = 0;
+			__atomic_fetch_add( &cltr->io.submit.fast      , proc->io.submit.fast      , __ATOMIC_SEQ_CST ); proc->io.submit.fast       = 0;
+			__atomic_fetch_add( &cltr->io.submit.slow      , proc->io.submit.slow      , __ATOMIC_SEQ_CST ); proc->io.submit.slow       = 0;
+			__atomic_fetch_add( &cltr->io.flush.external   , proc->io.flush.external   , __ATOMIC_SEQ_CST ); proc->io.flush.external    = 0;
+			__atomic_fetch_add( &cltr->io.calls.count      , proc->io.calls.count      , __ATOMIC_SEQ_CST ); proc->io.calls.count       = 0;
+			__atomic_fetch_add( &cltr->io.calls.submitted  , proc->io.calls.submitted  , __ATOMIC_SEQ_CST ); proc->io.calls.submitted   = 0;
+			__atomic_fetch_add( &cltr->io.calls.completed  , proc->io.calls.completed  , __ATOMIC_SEQ_CST ); proc->io.calls.completed   = 0;
+			__atomic_fetch_add( &cltr->io.calls.blocks     , proc->io.calls.blocks     , __ATOMIC_SEQ_CST ); proc->io.calls.blocks      = 0;
+			__atomic_fetch_add( &cltr->io.calls.errors.busy, proc->io.calls.errors.busy, __ATOMIC_SEQ_CST ); proc->io.calls.errors.busy = 0;
 		#endif
 	}
@@ -123,50 +118,47 @@
 		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			if( flags & CFA_STATS_IO ) {
-				double avgrdy = ((double)io.submit_q.submit_avg.rdy) / io.submit_q.submit_avg.cnt;
-				double avgcsm = ((double)io.submit_q.submit_avg.csm) / io.submit_q.submit_avg.cnt;
+				uint64_t total_allocs = io.alloc.fast + io.alloc.slow;
+				double avgfasta = ((double)io.alloc.fast) / total_allocs;
 
-				double lavgv = 0;
-				double lavgb = 0;
-				if(io.submit_q.look_avg.cnt != 0) {
-					lavgv = ((double)io.submit_q.look_avg.val  ) / io.submit_q.look_avg.cnt;
-					lavgb = ((double)io.submit_q.look_avg.block) / io.submit_q.look_avg.cnt;
-				}
+				uint64_t total_submits = io.submit.fast + io.submit.slow;
+				double avgfasts = ((double)io.submit.fast) / total_submits;
 
-				double aavgv = 0;
-				double aavgb = 0;
-				if(io.submit_q.alloc_avg.cnt != 0) {
-					aavgv = ((double)io.submit_q.alloc_avg.val  ) / io.submit_q.alloc_avg.cnt;
-					aavgb = ((double)io.submit_q.alloc_avg.block) / io.submit_q.alloc_avg.cnt;
-				}
+				double avgsubs = ((double)io.calls.submitted) / io.calls.count;
+				double avgcomp = ((double)io.calls.completed) / io.calls.count;
 
 				__cfaabi_bits_print_safe( STDOUT_FILENO,
 					"----- %s \"%s\" (%p) - I/O Stats -----\n"
-					"- total submit calls     : %'15" PRIu64 "\n"
-					"- avg ready entries      : %'18.2lf\n"
-					"- avg submitted entries  : %'18.2lf\n"
-					"- total helped entries   : %'15" PRIu64 "\n"
-					"- total leader entries   : %'15" PRIu64 "\n"
-					"- total busy submit      : %'15" PRIu64 "\n"
-					"- total ready search     : %'15" PRIu64 "\n"
-					"- avg ready search len   : %'18.2lf\n"
-					"- avg ready search block : %'18.2lf\n"
-					"- total alloc search     : %'15" PRIu64 "\n"
-					"- avg alloc search len   : %'18.2lf\n"
-					"- avg alloc search block : %'18.2lf\n"
-					"- total wait calls       : %'15" PRIu64 "\n"
-					"- avg completion/wait    : %'18.2lf\n"
-					"- total completion blocks: %'15" PRIu64 "\n"
+					"- total allocations      : %'15" PRIu64 "\n"
+					"-     fast allocations   : %'15" PRIu64 " (%'18.2lf) \n"
+					"-     fast enomem        : %'15" PRIu64 "\n"
+					"-     slow allocations   : %'15" PRIu64 "\n"
+					"-     revokes for alloc  : %'15" PRIu64 "\n"
+					"-     blocks  for alloc  : %'15" PRIu64 "\n"
+					"- total submits          : %'15" PRIu64 "\n"
+					"-     fast submits       : %'15" PRIu64 " (%'18.2lf) \n"
+					"-     slow submits       : %'15" PRIu64 "\n"
+					"- flush external submits : %'15" PRIu64 "\n"
+					"- io_uring_enter calls   : %'15" PRIu64 "\n"
+					"-     submits            : %'15" PRIu64 " (%'18.2lf) \n"
+					"-     completes          : %'15" PRIu64 " (%'18.2lf) \n"
+					"-     blocking calls     : %'15" PRIu64 "\n"
+					"- io_uring_enter EBUSYs  : %'15" PRIu64 "\n"
 					"\n"
 					, type,  name, id
-					, io.submit_q.submit_avg.cnt
-					, avgrdy, avgcsm
-					, io.submit_q.helped, io.submit_q.leader, io.submit_q.busy
-					, io.submit_q.look_avg.cnt
-					, lavgv, lavgb
-					, io.submit_q.alloc_avg.cnt
-					, aavgv, aavgb
-					, io.complete_q.completed_avg.cnt
-					, ((double)io.complete_q.completed_avg.val) / io.complete_q.completed_avg.cnt
-					, io.complete_q.blocks
+					, total_allocs
+					, io.alloc.fast, avgfasta
+					, io.alloc.fail
+					, io.alloc.slow
+					, io.alloc.revoke
+					, io.alloc.block
+					, total_submits
+					, io.submit.fast, avgfasts
+					, io.submit.slow
+					, io.flush.external
+					, io.calls.count
+					, io.calls.submitted, avgsubs
+					, io.calls.completed, avgcomp
+					, io.calls.blocks
+					, io.calls.errors.busy
 				);
 			}
Index: libcfa/src/concurrency/stats.hfa
===================================================================
--- libcfa/src/concurrency/stats.hfa	(revision 78da4abe22e69798ee3738623dc9a2d99e34d207)
+++ libcfa/src/concurrency/stats.hfa	(revision d60d30ef3cbda3a4010ce92c21dcd3ce89fb6684)
@@ -66,31 +66,26 @@
 		struct __attribute__((aligned(64))) __stats_io_t{
 			struct {
+				volatile uint64_t fast;
+				volatile uint64_t slow;
+				volatile uint64_t fail;
+				volatile uint64_t revoke;
+				volatile uint64_t block;
+			} alloc;
+			struct {
+				volatile uint64_t fast;
+				volatile uint64_t slow;
+			} submit;
+			struct {
+				volatile uint64_t external;
+			} flush;
+			struct {
+				volatile uint64_t count;
+				volatile uint64_t submitted;
+				volatile uint64_t completed;
+				volatile uint64_t blocks;
 				struct {
-					volatile uint64_t rdy;
-					volatile uint64_t csm;
-					volatile uint64_t avl;
-					volatile uint64_t cnt;
-				} submit_avg;
-				struct {
-					volatile uint64_t val;
-					volatile uint64_t cnt;
-					volatile uint64_t block;
-				} look_avg;
-				struct {
-					volatile uint64_t val;
-					volatile uint64_t cnt;
-					volatile uint64_t block;
-				} alloc_avg;
-				volatile uint64_t helped;
-				volatile uint64_t leader;
-				volatile uint64_t busy;
-			} submit_q;
-			struct {
-				struct {
-					volatile uint64_t val;
-					volatile uint64_t cnt;
-				} completed_avg;
-				volatile uint64_t blocks;
-			} complete_q;
+					volatile uint64_t busy;
+				} errors;
+			} calls;
 		};
 	#endif