Index: benchmark/io/readv.cfa
===================================================================
--- benchmark/io/readv.cfa	(revision 08a994e717c46ee688776bb6c7c1bff9109eb2c7)
+++ benchmark/io/readv.cfa	(revision 4385e8b2686d2ed630baceffe83c33adcccf4b41)
@@ -16,8 +16,4 @@
 #include <thread.hfa>
 #include <time.hfa>
-
-#if !defined(HAVE_LINUX_IO_URING_H)
-#warning no io uring
-#endif
 
 extern bool traceHeapOn();
@@ -53,5 +49,5 @@
 	while(__atomic_load_n(&run, __ATOMIC_RELAXED)) {
 		int r = cfa_preadv2(fd, &iov, 1, 0, 0);
-		if(r < 0) abort(strerror(-r));
+		if(r < 0) abort("%s\n", strerror(-r));
 
 		__atomic_fetch_add( &count, 1, __ATOMIC_SEQ_CST );
@@ -63,20 +59,19 @@
 	unsigned long int nthreads = 2;
 	unsigned long int nprocs   = 1;
-
-	printf("Setting local\n");
-	setlocale(LC_NUMERIC, "");
+	int flags = 0;
 
 	arg_loop:
 	for(;;) {
 		static struct option options[] = {
-			{"duration",  required_argument, 0, 'd'},
-			{"nthreads",  required_argument, 0, 't'},
-			{"nprocs",    required_argument, 0, 'p'},
-			{"bufsize",   required_argument, 0, 'b'},
+			{"duration",   required_argument, 0, 'd'},
+			{"nthreads",   required_argument, 0, 't'},
+			{"nprocs",     required_argument, 0, 'p'},
+			{"bufsize",    required_argument, 0, 'b'},
+			{"userthread", no_argument      , 0, 'u'},
 			{0, 0, 0, 0}
 		};
 
 		int idx = 0;
-		int opt = getopt_long(argc, argv, "d:t:p:b:", options, &idx);
+		int opt = getopt_long(argc, argv, "d:t:p:b:u", options, &idx);
 
 		const char * arg = optarg ? optarg : "";
@@ -115,4 +110,7 @@
 				}
 				break;
+			case 'u':
+				flags |= CFA_CLUSTER_IO_POLLER_USER_THREAD;
+				break;
 			// Other cases
 			default: /* ? */
@@ -135,9 +133,9 @@
 	}
 
-	printf("Running %lu threads over %lu processors for %lf seconds\n", nthreads, nprocs, duration);
+	printf("Running %lu threads, reading %lu bytes each, over %lu processors for %lf seconds\n", buflen, nthreads, nprocs, duration);
 
 	{
 		Time start, end;
-		cluster cl = { "IO Cluster" };
+		cluster cl = { "IO Cluster", flags };
 		the_cluster = &cl;
 		#if !defined(__CFA_NO_STATISTICS__)
@@ -161,7 +159,9 @@
 			}
 		}
-		printf("Took %ld ms\n", (end - start)`ms);
+		printf("Took %'ld ms\n", (end - start)`ms);
 		printf("Total reads:      %'zu\n", count);
-		printf("Reads per second: %'lf\n", ((double)count) / (end - start)`s);
+		printf("Reads per second: %'.2lf\n", ((double)count) / (end - start)`s);
+		printf("Total read size:  %'zu\n", buflen * count);
+		printf("Bytes per second: %'.2lf\n", ((double)count * buflen) / (end - start)`s);
 	}
 
Index: libcfa/prelude/defines.hfa.in
===================================================================
--- libcfa/prelude/defines.hfa.in	(revision 08a994e717c46ee688776bb6c7c1bff9109eb2c7)
+++ libcfa/prelude/defines.hfa.in	(revision 4385e8b2686d2ed630baceffe83c33adcccf4b41)
@@ -19,4 +19,3 @@
 #undef HAVE_PWRITEV2
 
-// #define __CFA_IO_POLLING_USER__
-// #define __CFA_IO_POLLING_KERNEL__
+#undef __CFA_NO_STATISTICS__
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 08a994e717c46ee688776bb6c7c1bff9109eb2c7)
+++ libcfa/src/concurrency/io.cfa	(revision 4385e8b2686d2ed630baceffe83c33adcccf4b41)
@@ -20,5 +20,5 @@
 
 #if !defined(HAVE_LINUX_IO_URING_H)
-	void __kernel_io_startup( cluster &, bool ) {
+	void __kernel_io_startup( cluster &, int, bool ) {
 		// Nothing to do without io_uring
 	}
@@ -86,19 +86,122 @@
 	#endif
 
-	#if defined(__CFA_IO_POLLING_USER__)
-		void ?{}( __io_poller_fast & this, struct cluster & cltr ) {
-			this.ring = &cltr.io;
-			(this.thrd){ "Fast I/O Poller", cltr };
-		}
-		void ^?{}( __io_poller_fast & mutex this );
-      	void main( __io_poller_fast & this );
-      	static inline $thread * get_thread( __io_poller_fast & this ) { return &this.thrd; }
-		void ^?{}( __io_poller_fast & mutex this ) {}
-	#endif
+	// Fast poller user-thread
+	// Not using the "thread" keyword because we want to control
+	// more carefully when to start/stop it
+	struct __io_poller_fast {
+		struct __io_data * ring;
+		bool waiting;
+		$thread thrd;
+	};
+
+	void ?{}( __io_poller_fast & this, struct cluster & cltr ) {
+		this.ring = cltr.io;
+		this.waiting = true;
+		(this.thrd){ "Fast I/O Poller", cltr };
+	}
+	void ^?{}( __io_poller_fast & mutex this );
+	void main( __io_poller_fast & this );
+	static inline $thread * get_thread( __io_poller_fast & this ) { return &this.thrd; }
+	void ^?{}( __io_poller_fast & mutex this ) {}
+
+	struct __submition_data {
+		// Head and tail of the ring (associated with array)
+		volatile uint32_t * head;
+		volatile uint32_t * tail;
+
+		// The actual kernel ring which uses head/tail
+		// indexes into the sqes arrays
+		uint32_t * array;
+
+		// number of entries and mask to go with it
+		const uint32_t * num;
+		const uint32_t * mask;
+
+		// Submission flags (Not sure what for)
+		uint32_t * flags;
+
+		// number of sqes not submitted (whatever that means)
+		uint32_t * dropped;
+
+		// Like head/tail but not seen by the kernel
+		volatile uint32_t alloc;
+		volatile uint32_t ready;
+
+		__spinlock_t lock;
+
+		// A buffer of sqes (not the actual ring)
+		struct io_uring_sqe * sqes;
+
+		// The location and size of the mmaped area
+		void * ring_ptr;
+		size_t ring_sz;
+
+		// Statistics
+		#if !defined(__CFA_NO_STATISTICS__)
+			struct {
+				struct {
+					volatile unsigned long long int val;
+					volatile unsigned long long int cnt;
+					volatile unsigned long long int block;
+				} submit_avg;
+			} stats;
+		#endif
+	};
+
+	struct __completion_data {
+		// Head and tail of the ring
+		volatile uint32_t * head;
+		volatile uint32_t * tail;
+
+		// number of entries and mask to go with it
+		const uint32_t * mask;
+		const uint32_t * num;
+
+		// number of cqes not submitted (whatever that means)
+		uint32_t * overflow;
+
+		// the kernel ring
+		struct io_uring_cqe * cqes;
+
+		// The location and size of the mmaped area
+		void * ring_ptr;
+		size_t ring_sz;
+
+		// Statistics
+		#if !defined(__CFA_NO_STATISTICS__)
+			struct {
+				struct {
+					unsigned long long int val;
+					unsigned long long int slow_cnt;
+					unsigned long long int fast_cnt;
+				} completed_avg;
+			} stats;
+		#endif
+	};
+
+	struct __io_data {
+		struct __submition_data submit_q;
+		struct __completion_data completion_q;
+		uint32_t ring_flags;
+		int cltr_flags;
+		int fd;
+		semaphore submit;
+		volatile bool done;
+		struct {
+			struct {
+				void * stack;
+				pthread_t kthrd;
+			} slow;
+			__io_poller_fast fast;
+			__bin_sem_t sem;
+		} poller;
+	};
 
 //=============================================================================================
 // I/O Startup / Shutdown logic
 //=============================================================================================
-	void __kernel_io_startup( cluster & this, bool main_cluster ) {
+	void __kernel_io_startup( cluster & this, int io_flags, bool main_cluster ) {
+		this.io = malloc();
+
 		// Step 1 : call to setup
 		struct io_uring_params params;
@@ -113,7 +216,7 @@
 
 		// Step 2 : mmap result
-		memset(&this.io, 0, sizeof(struct io_ring));
-		struct io_uring_sq & sq = this.io.submit_q;
-		struct io_uring_cq & cq = this.io.completion_q;
+		memset( this.io, 0, sizeof(struct __io_data) );
+		struct __submition_data  & sq = this.io->submit_q;
+		struct __completion_data & cq = this.io->completion_q;
 
 		// calculate the right ring size
@@ -193,15 +296,18 @@
 
 		// Update the global ring info
-		this.io.flags = params.flags;
-		this.io.fd    = fd;
-		this.io.done  = false;
-		(this.io.submit){ min(*sq.num, *cq.num) };
+		this.io->ring_flags = params.flags;
+		this.io->cltr_flags = io_flags;
+		this.io->fd         = fd;
+		this.io->done       = false;
+		(this.io->submit){ min(*sq.num, *cq.num) };
 
 		// Initialize statistics
 		#if !defined(__CFA_NO_STATISTICS__)
-			this.io.submit_q.stats.submit_avg.val = 0;
-			this.io.submit_q.stats.submit_avg.cnt = 0;
-			this.io.completion_q.stats.completed_avg.val = 0;
-			this.io.completion_q.stats.completed_avg.cnt = 0;
+			this.io->submit_q.stats.submit_avg.val   = 0;
+			this.io->submit_q.stats.submit_avg.cnt   = 0;
+			this.io->submit_q.stats.submit_avg.block = 0;
+			this.io->completion_q.stats.completed_avg.val = 0;
+			this.io->completion_q.stats.completed_avg.slow_cnt = 0;
+			this.io->completion_q.stats.completed_avg.fast_cnt = 0;
 		#endif
 
@@ -212,13 +318,13 @@
 
 	void __kernel_io_finish_start( cluster & this ) {
-		#if defined(__CFA_IO_POLLING_USER__)
+		if( this.io->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) {
 			__cfadbg_print_safe(io_core, "Kernel I/O : Creating fast poller for cluter %p\n", &this);
-			(this.io.poller.fast){ this };
-			__thrd_start( this.io.poller.fast, main );
-		#endif
+			(this.io->poller.fast){ this };
+			__thrd_start( this.io->poller.fast, main );
+		}
 
 		// Create the poller thread
 		__cfadbg_print_safe(io_core, "Kernel I/O : Creating slow poller for cluter %p\n", &this);
-		this.io.poller.slow.stack = __create_pthread( &this.io.poller.slow.kthrd, __io_poller_slow, &this );
+		this.io->poller.slow.stack = __create_pthread( &this.io->poller.slow.kthrd, __io_poller_slow, &this );
 	}
 
@@ -226,27 +332,66 @@
 		__cfadbg_print_safe(io_core, "Kernel I/O : Stopping pollers for cluster\n", &this);
 		// Notify the poller thread of the shutdown
-		__atomic_store_n(&this.io.done, true, __ATOMIC_SEQ_CST);
+		__atomic_store_n(&this.io->done, true, __ATOMIC_SEQ_CST);
 
 		// Stop the IO Poller
 		sigval val = { 1 };
-		pthread_sigqueue( this.io.poller.slow.kthrd, SIGUSR1, val );
-		#if defined(__CFA_IO_POLLING_USER__)
-			post( this.io.poller.sem );
-		#endif
+		pthread_sigqueue( this.io->poller.slow.kthrd, SIGUSR1, val );
+		post( this.io->poller.sem );
 
 		// Wait for the poller thread to finish
-		pthread_join( this.io.poller.slow.kthrd, 0p );
-		free( this.io.poller.slow.stack );
+		pthread_join( this.io->poller.slow.kthrd, 0p );
+		free( this.io->poller.slow.stack );
 
 		__cfadbg_print_safe(io_core, "Kernel I/O : Slow poller stopped for cluster\n", &this);
 
-		#if defined(__CFA_IO_POLLING_USER__)
+		if( this.io->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) {
+			with( this.io->poller.fast ) {
+				/* paranoid */ verify( waiting ); // The thread shouldn't be in a system call
+				/* paranoid */ verify( this.procs.head == 0p || &this == mainCluster );
+				/* paranoid */ verify( this.idles.head == 0p || &this == mainCluster );
+
+				// We need to adjust the clean-up based on where the thread is
+				if( thrd.preempted != __NO_PREEMPTION ) {
+
+					// This is the tricky case
+					// The thread was preempted and now it is on the ready queue
+					/* paranoid */ verify( thrd.state == Active );           // The thread better be in this state
+					/* paranoid */ verify( thrd.next == 1p );                // The thread should be the last on the list
+					/* paranoid */ verify( this.ready_queue.head == &thrd ); // The thread should be the only thing on the list
+
+					// Remove the thread from the ready queue of this cluster
+					this.ready_queue.head = 1p;
+					thrd.next = 0p;
+
+					// Fixup the thread state
+					thrd.state = Blocked;
+					thrd.preempted = __NO_PREEMPTION;
+
+					// Pretend like the thread was blocked all along
+				}
+				// !!! This is not an else if !!!
+				if( thrd.state == Blocked ) {
+
+					// This is the "easy case"
+					// The thread is parked and can easily be moved to active cluster
+					verify( thrd.curr_cluster != active_cluster() || thrd.curr_cluster == mainCluster );
+					thrd.curr_cluster = active_cluster();
+
 			// unpark the fast io_poller
-			unpark( &this.io.poller.fast.thrd __cfaabi_dbg_ctx2 );
-
-			^(this.io.poller.fast){};
+					unpark( &thrd __cfaabi_dbg_ctx2 );
+				}
+				else {
+
+					// The thread is in a weird state
+					// I don't know what to do here
+					abort("Fast poller thread is in unexpected state, cannot clean-up correctly\n");
+				}
+
+			}
+
+			^(this.io->poller.fast){};
 
 			__cfadbg_print_safe(io_core, "Kernel I/O : Fast poller stopped for cluster\n", &this);
-		#endif
+		}
 	}
 
@@ -259,21 +404,26 @@
 		#if !defined(__CFA_NO_STATISTICS__)
 			if(this.print_stats) {
-				__cfaabi_bits_print_safe( STDERR_FILENO,
-					"----- I/O uRing Stats -----\n"
-					"- total submit calls  : %llu\n"
-					"- avg submit          : %lf\n"
-					"- total wait calls    : %llu\n"
-					"- avg completion/wait : %lf\n",
-					this.io.submit_q.stats.submit_avg.cnt,
-					((double)this.io.submit_q.stats.submit_avg.val) / this.io.submit_q.stats.submit_avg.cnt,
-					this.io.completion_q.stats.completed_avg.cnt,
-					((double)this.io.completion_q.stats.completed_avg.val) / this.io.completion_q.stats.completed_avg.cnt
-				);
+				with(this.io->submit_q.stats, this.io->completion_q.stats) {
+					__cfaabi_bits_print_safe( STDERR_FILENO,
+						"----- I/O uRing Stats -----\n"
+						"- total submit calls  : %'llu\n"
+						"- avg submit          : %'.2lf\n"
+						"- pre-submit block %%  : %'.2lf\n"
+						"- total wait calls    : %'llu (%'llu slow, %'llu fast)\n"
+						"- avg completion/wait : %'.2lf\n",
+						submit_avg.cnt,
+						((double)submit_avg.val) / submit_avg.cnt,
+						(100.0 * submit_avg.block) / submit_avg.cnt,
+						completed_avg.slow_cnt + completed_avg.fast_cnt,
+						completed_avg.slow_cnt,  completed_avg.fast_cnt,
+						((double)completed_avg.val) / (completed_avg.slow_cnt + completed_avg.fast_cnt)
+					);
+				}
 			}
 		#endif
 
 		// Shutdown the io rings
-		struct io_uring_sq & sq = this.io.submit_q;
-		struct io_uring_cq & cq = this.io.completion_q;
+		struct __submition_data  & sq = this.io->submit_q;
+		struct __completion_data & cq = this.io->completion_q;
 
 		// unmap the submit queue entries
@@ -289,5 +439,7 @@
 
 		// close the file descriptor
-		close(this.io.fd);
+		close(this.io->fd);
+
+		free( this.io );
 	}
 
@@ -302,5 +454,5 @@
 	// Process a single completion message from the io_uring
 	// This is NOT thread-safe
-	static int __drain_io( struct io_ring & ring, sigset_t * mask, int waitcnt, bool in_kernel ) {
+	static int __drain_io( struct __io_data & ring, sigset_t * mask, int waitcnt, bool in_kernel ) {
 		int ret = syscall( __NR_io_uring_enter, ring.fd, 0, waitcnt, IORING_ENTER_GETEVENTS, mask, _NSIG / 8);
 		if( ret < 0 ) {
@@ -320,7 +472,4 @@
 		// Nothing was new return 0
 		if (head == tail) {
-			#if !defined(__CFA_NO_STATISTICS__)
-				ring.completion_q.stats.completed_avg.cnt += 1;
-			#endif
 			return 0;
 		}
@@ -348,10 +497,4 @@
 		__atomic_fetch_add( ring.completion_q.head, count, __ATOMIC_RELAXED );
 
-		// Update statistics
-		#if !defined(__CFA_NO_STATISTICS__)
-			ring.completion_q.stats.completed_avg.val += count;
-			ring.completion_q.stats.completed_avg.cnt += 1;
-		#endif
-
 		return count;
 	}
@@ -359,5 +502,5 @@
 	static void * __io_poller_slow( void * arg ) {
 		cluster * cltr = (cluster *)arg;
-		struct io_ring & ring = cltr->io;
+		struct __io_data & ring = *cltr->io;
 
 		sigset_t mask;
@@ -372,10 +515,18 @@
 		verify( (*ring.completion_q.head) == (*ring.completion_q.tail) );
 
-		while(!__atomic_load_n(&ring.done, __ATOMIC_SEQ_CST)) {
-			#if defined(__CFA_IO_POLLING_USER__)
-
+		__cfadbg_print_safe(io_core, "Kernel I/O : Slow poller for ring %p ready\n", &ring);
+
+		if( ring.cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD ) {
+			while(!__atomic_load_n(&ring.done, __ATOMIC_SEQ_CST)) {
 				// In the user-thread approach drain and if anything was drained,
 				// batton pass to the user-thread
 				int count = __drain_io( ring, &mask, 1, true );
+
+				// Update statistics
+				#if !defined(__CFA_NO_STATISTICS__)
+					ring.completion_q.stats.completed_avg.val += count;
+					ring.completion_q.stats.completed_avg.slow_cnt += 1;
+				#endif
+
 				if(count > 0) {
 					__cfadbg_print_safe(io_core, "Kernel I/O : Moving to ring %p to fast poller\n", &ring);
@@ -383,37 +534,63 @@
 					wait( ring.poller.sem );
 				}
-
-			#else
-
+			}
+		}
+		else {
+			while(!__atomic_load_n(&ring.done, __ATOMIC_SEQ_CST)) {
 				//In the naive approach, just poll the io completion queue directly
-				__drain_io( ring, &mask, 1, true );
-
+				int count = __drain_io( ring, &mask, 1, true );
+
+				// Update statistics
+				#if !defined(__CFA_NO_STATISTICS__)
+					ring.completion_q.stats.completed_avg.val += count;
+					ring.completion_q.stats.completed_avg.slow_cnt += 1;
+				#endif
+			}
+		}
+
+		__cfadbg_print_safe(io_core, "Kernel I/O : Slow poller for ring %p stopping\n", &ring);
+
+		return 0p;
+	}
+
+	void main( __io_poller_fast & this ) {
+		verify( this.ring->cltr_flags & CFA_CLUSTER_IO_POLLER_USER_THREAD );
+
+		// Start parked
+		park( __cfaabi_dbg_ctx );
+
+		__cfadbg_print_safe(io_core, "Kernel I/O : Fast poller for ring %p ready\n", &this.ring);
+
+		int reset = 0;
+
+		// Then loop until we need to start
+		while(!__atomic_load_n(&this.ring->done, __ATOMIC_SEQ_CST)) {
+			// Drain the io
+			this.waiting = false;
+			int count = __drain_io( *this.ring, 0p, 0, false );
+			reset += count > 0 ? 1 : 0;
+
+			// Update statistics
+			#if !defined(__CFA_NO_STATISTICS__)
+				this.ring->completion_q.stats.completed_avg.val += count;
+				this.ring->completion_q.stats.completed_avg.fast_cnt += 1;
 			#endif
-		}
-
-		return 0p;
-	}
-
-	#if defined(__CFA_IO_POLLING_USER__)
-		void main( __io_poller_fast & this ) {
-			// Start parked
-			park( __cfaabi_dbg_ctx );
-
-			// Then loop until we need to start
-			while(!__atomic_load_n(&this.ring->done, __ATOMIC_SEQ_CST)) {
-				// Drain the io
-				if(0 > __drain_io( *this.ring, 0p, 0, false )) {
-					// If we got something, just yield and check again
-					yield();
-				}
-				else {
-					// We didn't get anything baton pass to the slow poller
-					__cfadbg_print_safe(io_core, "Kernel I/O : Moving to ring %p to slow poller\n", &this.ring);
-					post( this.ring->poller.sem );
-					park( __cfaabi_dbg_ctx );
-				}
+
+			this.waiting = true;
+			if(reset < 5) {
+				// If we got something, just yield and check again
+				yield();
 			}
-		}
-	#endif
+			else {
+				// We didn't get anything baton pass to the slow poller
+				__cfadbg_print_safe(io_core, "Kernel I/O : Moving to ring %p to slow poller\n", &this.ring);
+				post( this.ring->poller.sem );
+				park( __cfaabi_dbg_ctx );
+				reset = 0;
+			}
+		}
+
+		__cfadbg_print_safe(io_core, "Kernel I/O : Fast poller for ring %p stopping\n", &this.ring);
+	}
 
 //=============================================================================================
@@ -445,7 +622,10 @@
 //
 
-	static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct io_ring & ring ) {
+	static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct __io_data & ring ) {
 		// Wait for a spot to be available
-		P(ring.submit);
+		__attribute__((unused)) bool blocked = P(ring.submit);
+		#if !defined(__CFA_NO_STATISTICS__)
+			__atomic_fetch_add( &ring.submit_q.stats.submit_avg.block, blocked ? 1ul64 : 0ul64, __ATOMIC_RELAXED );
+		#endif
 
 		// Allocate the sqe
@@ -463,5 +643,5 @@
 	}
 
-	static inline void __submit( struct io_ring & ring, uint32_t idx ) {
+	static inline void __submit( struct __io_data & ring, uint32_t idx ) {
 		// get mutual exclusion
 		lock(ring.submit_q.lock __cfaabi_dbg_ctx2);
@@ -524,5 +704,5 @@
 
 	#define __submit_prelude \
-		struct io_ring & ring = active_cluster()->io; \
+		struct __io_data & ring = *active_cluster()->io; \
 		struct io_uring_sqe * sqe; \
 		uint32_t idx; \
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 08a994e717c46ee688776bb6c7c1bff9109eb2c7)
+++ libcfa/src/concurrency/kernel.cfa	(revision 4385e8b2686d2ed630baceffe83c33adcccf4b41)
@@ -254,5 +254,5 @@
 }
 
-void ?{}(cluster & this, const char name[], Duration preemption_rate) with( this ) {
+void ?{}(cluster & this, const char name[], Duration preemption_rate, int io_flags) with( this ) {
 	this.name = name;
 	this.preemption_rate = preemption_rate;
@@ -268,5 +268,5 @@
 	threads{ __get };
 
-	__kernel_io_startup( this, &this == mainCluster );
+	__kernel_io_startup( this, io_flags, &this == mainCluster );
 
 	doregister(this);
@@ -987,5 +987,5 @@
 void ^?{}(semaphore & this) {}
 
-void P(semaphore & this) with( this ){
+bool P(semaphore & this) with( this ){
 	lock( lock __cfaabi_dbg_ctx2 );
 	count -= 1;
@@ -997,7 +997,9 @@
 		unlock( lock );
 		park( __cfaabi_dbg_ctx );
+		return true;
 	}
 	else {
 	    unlock( lock );
+	    return false;
 	}
 }
Index: libcfa/src/concurrency/kernel.hfa
===================================================================
--- libcfa/src/concurrency/kernel.hfa	(revision 08a994e717c46ee688776bb6c7c1bff9109eb2c7)
+++ libcfa/src/concurrency/kernel.hfa	(revision 4385e8b2686d2ed630baceffe83c33adcccf4b41)
@@ -38,5 +38,5 @@
 void  ?{}(semaphore & this, int count = 1);
 void ^?{}(semaphore & this);
-void   P (semaphore & this);
+bool   P (semaphore & this);
 bool   V (semaphore & this);
 bool   V (semaphore & this, unsigned count);
@@ -114,104 +114,8 @@
 //-----------------------------------------------------------------------------
 // I/O
-#if defined(HAVE_LINUX_IO_URING_H)
-struct io_uring_sq {
-	// Head and tail of the ring (associated with array)
-	volatile uint32_t * head;
-	volatile uint32_t * tail;
+struct __io_data;
 
-	// The actual kernel ring which uses head/tail
-	// indexes into the sqes arrays
-	uint32_t * array;
-
-	// number of entries and mask to go with it
-	const uint32_t * num;
-	const uint32_t * mask;
-
-	// Submission flags (Not sure what for)
-	uint32_t * flags;
-
-	// number of sqes not submitted (whatever that means)
-	uint32_t * dropped;
-
-	// Like head/tail but not seen by the kernel
-	volatile uint32_t alloc;
-	volatile uint32_t ready;
-
-	__spinlock_t lock;
-
-	// A buffer of sqes (not the actual ring)
-	struct io_uring_sqe * sqes;
-
-	// The location and size of the mmaped area
-	void * ring_ptr;
-	size_t ring_sz;
-
-	// Statistics
-	#if !defined(__CFA_NO_STATISTICS__)
-		struct {
-			struct {
-				unsigned long long int val;
-				unsigned long long int cnt;
-			} submit_avg;
-		} stats;
-	#endif
-};
-
-struct io_uring_cq {
-	// Head and tail of the ring
-	volatile uint32_t * head;
-	volatile uint32_t * tail;
-
-	// number of entries and mask to go with it
-	const uint32_t * mask;
-	const uint32_t * num;
-
-	// number of cqes not submitted (whatever that means)
-	uint32_t * overflow;
-
-	// the kernel ring
-	struct io_uring_cqe * cqes;
-
-	// The location and size of the mmaped area
-	void * ring_ptr;
-	size_t ring_sz;
-
-	// Statistics
-	#if !defined(__CFA_NO_STATISTICS__)
-		struct {
-			struct {
-				unsigned long long int val;
-				unsigned long long int cnt;
-			} completed_avg;
-		} stats;
-	#endif
-};
-
-#if defined(__CFA_IO_POLLING_USER__)
-	struct __io_poller_fast {
-		struct io_ring * ring;
-		$thread thrd;
-	};
-#endif
-
-struct io_ring {
-	struct io_uring_sq submit_q;
-	struct io_uring_cq completion_q;
-	uint32_t flags;
-	int fd;
-	semaphore submit;
-	volatile bool done;
-	struct {
-		struct {
-			void * stack;
-			pthread_t kthrd;
-		} slow;
-		#if defined(__CFA_IO_POLLING_USER__)
-			__io_poller_fast fast;
-			__bin_sem_t sem;
-		#endif
-	} poller;
-};
-#endif
+#define CFA_CLUSTER_IO_POLLER_USER_THREAD 1 << 0
+// #define CFA_CLUSTER_IO_POLLER_KERNEL_SIDE 1 << 1
 
 //-----------------------------------------------------------------------------
@@ -247,7 +151,5 @@
 	} node;
 
-	#if defined(HAVE_LINUX_IO_URING_H)
-		struct io_ring io;
-	#endif
+	struct __io_data * io;
 
 	#if !defined(__CFA_NO_STATISTICS__)
@@ -257,10 +159,13 @@
 extern Duration default_preemption();
 
-void ?{} (cluster & this, const char name[], Duration preemption_rate);
+void ?{} (cluster & this, const char name[], Duration preemption_rate, int flags);
 void ^?{}(cluster & this);
 
-static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
-static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
-static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
+static inline void ?{} (cluster & this)                                      { this{"Anonymous Cluster", default_preemption(), 0}; }
+static inline void ?{} (cluster & this, Duration preemption_rate)            { this{"Anonymous Cluster", preemption_rate, 0}; }
+static inline void ?{} (cluster & this, const char name[])                   { this{name, default_preemption(), 0}; }
+static inline void ?{} (cluster & this, int flags)                           { this{"Anonymous Cluster", default_preemption(), flags}; }
+static inline void ?{} (cluster & this, Duration preemption_rate, int flags) { this{"Anonymous Cluster", preemption_rate, flags}; }
+static inline void ?{} (cluster & this, const char name[], int flags)        { this{name, default_preemption(), flags}; }
 
 static inline [cluster *&, cluster *& ] __get( cluster & this ) __attribute__((const)) { return this.node.[next, prev]; }
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision 08a994e717c46ee688776bb6c7c1bff9109eb2c7)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision 4385e8b2686d2ed630baceffe83c33adcccf4b41)
@@ -59,4 +59,6 @@
 extern volatile thread_local __cfa_kernel_preemption_state_t preemption_state __attribute__ ((tls_model ( "initial-exec" )));
 
+extern cluster * mainCluster;
+
 //-----------------------------------------------------------------------------
 // Threads
@@ -75,5 +77,5 @@
 //-----------------------------------------------------------------------------
 // I/O
-void __kernel_io_startup     ( cluster &, bool );
+void __kernel_io_startup     ( cluster &, int, bool );
 void __kernel_io_finish_start( cluster & );
 void __kernel_io_prepare_stop( cluster & );
Index: libcfa/src/startup.cfa
===================================================================
--- libcfa/src/startup.cfa	(revision 08a994e717c46ee688776bb6c7c1bff9109eb2c7)
+++ libcfa/src/startup.cfa	(revision 4385e8b2686d2ed630baceffe83c33adcccf4b41)
@@ -14,5 +14,6 @@
 //
 
-#include <time.h>										// tzset
+#include <time.h>	         // tzset
+#include <locale.h>        // setlocale
 #include "startup.hfa"
 
@@ -21,4 +22,5 @@
     void __cfaabi_appready_startup( void ) {
 		tzset();										// initialize time global variables
+		setlocale(LC_NUMERIC, "");
 		#ifdef __CFA_DEBUG__
 		extern void heapAppStart();
