Index: libcfa/src/concurrency/io/call.cfa.in
===================================================================
--- libcfa/src/concurrency/io/call.cfa.in	(revision 4c4d854944a52f7271cb7d0d7c8cc51899a121cc)
+++ libcfa/src/concurrency/io/call.cfa.in	(revision dddb3dd01058a6f0eb621887f1bc9675d616a840)
@@ -75,5 +75,5 @@
 
 	extern struct $io_context * cfa_io_allocate(struct io_uring_sqe * out_sqes[], __u32 out_idxs[], __u32 want)  __attribute__((nonnull (1,2)));
-	extern void cfa_io_submit( struct $io_context * in_ctx, __u32 in_idxs[], __u32 have ) __attribute__((nonnull (1,2)));
+	extern void cfa_io_submit( struct $io_context * in_ctx, __u32 in_idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1,2)));
 #endif
 
@@ -185,5 +185,5 @@
 		return ', '.join(args_a)
 
-AsyncTemplate = """inline void async_{name}(io_future_t & future, {params}, int submit_flags) {{
+AsyncTemplate = """inline void async_{name}(io_future_t & future, {params}, __u64 submit_flags) {{
 	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_{op})
 		ssize_t res = {name}({args});
@@ -216,9 +216,9 @@
 
 		verify( sqe->user_data == (__u64)(uintptr_t)&future );
-		cfa_io_submit( ctx, &idx, 1 );
+		cfa_io_submit( ctx, &idx, 1, 0 != (submit_flags & CFA_IO_LAZY) );
 	#endif
 }}"""
 
-SyncTemplate = """{ret} cfa_{name}({params}, int submit_flags) {{
+SyncTemplate = """{ret} cfa_{name}({params}, __u64 submit_flags) {{
 	io_future_t future;
 
@@ -388,8 +388,8 @@
 	if c.define:
 		print("""#if defined({define})
-	{ret} cfa_{name}({params}, int submit_flags);
+	{ret} cfa_{name}({params}, __u64 submit_flags);
 #endif""".format(define=c.define,ret=c.ret, name=c.name, params=c.params))
 	else:
-		print("{ret} cfa_{name}({params}, int submit_flags);"
+		print("{ret} cfa_{name}({params}, __u64 submit_flags);"
 		.format(ret=c.ret, name=c.name, params=c.params))
 
@@ -399,8 +399,8 @@
 	if c.define:
 		print("""#if defined({define})
-	void async_{name}(io_future_t & future, {params}, int submit_flags);
+	void async_{name}(io_future_t & future, {params}, __u64 submit_flags);
 #endif""".format(define=c.define,name=c.name, params=c.params))
 	else:
-		print("void async_{name}(io_future_t & future, {params}, int submit_flags);"
+		print("void async_{name}(io_future_t & future, {params}, __u64 submit_flags);"
 		.format(name=c.name, params=c.params))
 print("\n")
Index: libcfa/src/concurrency/io/setup.cfa
===================================================================
--- libcfa/src/concurrency/io/setup.cfa	(revision 4c4d854944a52f7271cb7d0d7c8cc51899a121cc)
+++ libcfa/src/concurrency/io/setup.cfa	(revision dddb3dd01058a6f0eb621887f1bc9675d616a840)
@@ -26,12 +26,4 @@
 
 #if !defined(CFA_HAVE_LINUX_IO_URING_H)
-	void __kernel_io_startup() {
-		// Nothing to do without io_uring
-	}
-
-	void __kernel_io_shutdown() {
-		// Nothing to do without io_uring
-	}
-
 	void ?{}(io_context_params & this) {}
 
@@ -97,118 +89,10 @@
 
 //=============================================================================================
-// I/O Startup / Shutdown logic + Master Poller
-//=============================================================================================
-
-	// IO Master poller loop forward
-	static void * iopoll_loop( __attribute__((unused)) void * args );
-
-	static struct {
-		      pthread_t  thrd;    // pthread handle to io poller thread
-		      void *     stack;   // pthread stack for io poller thread
-		      int        epollfd; // file descriptor to the epoll instance
-		volatile     bool run;     // Whether or not to continue
-		volatile     bool stopped; // Whether the poller has finished running
-		volatile uint64_t epoch;   // Epoch used for memory reclamation
-	} iopoll;
-
-	void __kernel_io_startup(void) {
-		__cfadbg_print_safe(io_core, "Kernel : Creating EPOLL instance\n" );
-
-		iopoll.epollfd = epoll_create1(0);
-		if (iopoll.epollfd == -1) {
-			abort( "internal error, epoll_create1\n");
-		}
-
-		__cfadbg_print_safe(io_core, "Kernel : Starting io poller thread\n" );
-
-		iopoll.stack   = __create_pthread( &iopoll.thrd, iopoll_loop, 0p );
-		iopoll.run     = true;
-		iopoll.stopped = false;
-		iopoll.epoch   = 0;
-	}
-
-	void __kernel_io_shutdown(void) {
-		// Notify the io poller thread of the shutdown
-		iopoll.run = false;
-		sigval val = { 1 };
-		pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
-
-		// Wait for the io poller thread to finish
-
-		__destroy_pthread( iopoll.thrd, iopoll.stack, 0p );
-
-		int ret = close(iopoll.epollfd);
-		if (ret == -1) {
-			abort( "internal error, close epoll\n");
-		}
-
-		// Io polling is now fully stopped
-
-		__cfadbg_print_safe(io_core, "Kernel : IO poller stopped\n" );
-	}
-
-	static void * iopoll_loop( __attribute__((unused)) void * args ) {
-		__processor_id_t id;
-		id.full_proc = false;
-		id.id = doregister(&id);
-		__cfaabi_tls.this_proc_id = &id;
-		__cfadbg_print_safe(io_core, "Kernel : IO poller thread starting\n" );
-
-		// Block signals to control when they arrive
-		sigset_t mask;
-		sigfillset(&mask);
-		if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
-		abort( "internal error, pthread_sigmask" );
-		}
-
-		sigdelset( &mask, SIGUSR1 );
-
-		// Create sufficient events
-		struct epoll_event events[10];
-		// Main loop
-		while( iopoll.run ) {
-			__cfadbg_print_safe(io_core, "Kernel I/O - epoll : waiting on io_uring contexts\n");
-
-			// increment the epoch to notify any deleters we are starting a new cycle
-			__atomic_fetch_add(&iopoll.epoch, 1, __ATOMIC_SEQ_CST);
-
-			// Wait for events
-			int nfds = epoll_pwait( iopoll.epollfd, events, 10, -1, &mask );
-
-			__cfadbg_print_safe(io_core, "Kernel I/O - epoll : %d io contexts events, waking up\n", nfds);
-
-			// Check if an error occured
-			if (nfds == -1) {
-				if( errno == EINTR ) continue;
-				abort( "internal error, pthread_sigmask" );
-			}
-
-			for(i; nfds) {
-				$io_context * io_ctx = ($io_context *)(uintptr_t)events[i].data.u64;
-				/* paranoid */ verify( io_ctx );
-				__cfadbg_print_safe(io_core, "Kernel I/O - epoll : Unparking io poller %d (%p)\n", io_ctx->fd, io_ctx);
-				#if !defined( __CFA_NO_STATISTICS__ )
-					__cfaabi_tls.this_stats = io_ctx->self.curr_cluster->stats;
-				#endif
-
-				eventfd_t v;
-				eventfd_read(io_ctx->efd, &v);
-
-				post( io_ctx->sem );
-			}
-		}
-
-		__atomic_store_n(&iopoll.stopped, true, __ATOMIC_SEQ_CST);
-
-		__cfadbg_print_safe(io_core, "Kernel : IO poller thread stopping\n" );
-		unregister(&id);
-		return 0p;
-	}
-
-//=============================================================================================
 // I/O Context Constrution/Destruction
 //=============================================================================================
 
-	static void __io_uring_setup ( $io_context & this, const io_context_params & params_in );
+
+
+	static void __io_uring_setup ( $io_context & this, const io_context_params & params_in, int procfd );
 	static void __io_uring_teardown( $io_context & this );
 	static void __epoll_register($io_context & ctx);
@@ -217,28 +101,16 @@
 	void __ioarbiter_unregister( $io_arbiter & mutex, $io_context & ctx );
 
-	void ?{}($io_context & this, struct cluster & cl) {
-		(this.self){ "IO Poller", cl };
+	void ?{}($io_context & this, processor * proc, struct cluster & cl) {
+		/* paranoid */ verify( cl.io.arbiter );
+		this.proc = proc;
+		this.arbiter = cl.io.arbiter;
 		this.ext_sq.empty = true;
-		this.revoked = true;
-		__io_uring_setup( this, cl.io.params );
+		(this.ext_sq.blocked){};
+		__io_uring_setup( this, cl.io.params, proc->idle );
 		__cfadbg_print_safe(io_core, "Kernel I/O : Created ring for io_context %u (%p)\n", this.fd, &this);
-
-		__epoll_register(this);
-
-		__ioarbiter_register(*cl.io.arbiter, this);
-
-		__thrd_start( this, main );
-		__cfadbg_print_safe(io_core, "Kernel I/O : Started poller thread for io_context %u\n", this.fd);
-	}
-
-	void ^?{}($io_context & mutex this) {
+	}
+
+	void ^?{}($io_context & this) {
 		__cfadbg_print_safe(io_core, "Kernel I/O : tearing down io_context %u\n", this.fd);
-
-		^(this.self){};
-		__cfadbg_print_safe(io_core, "Kernel I/O : Stopped poller thread for io_context %u\n", this.fd);
-
-		__ioarbiter_unregister(*this.arbiter, this);
-
-		__epoll_unregister(this);
 
 		__io_uring_teardown( this );
@@ -246,22 +118,8 @@
 	}
 
-	void ?{}(io_context & this, struct cluster & cl) {
-		// this.ctx = new(cl);
-		this.ctx = alloc();
-		(*this.ctx){ cl };
-
-		__cfadbg_print_safe(io_core, "Kernel I/O : io_context %u ready\n", this.ctx->fd);
-	}
-
-	void ^?{}(io_context & this) {
-		post( this.ctx->sem );
-
-		delete(this.ctx);
-	}
-
 	extern void __disable_interrupts_hard();
 	extern void __enable_interrupts_hard();
 
-	static void __io_uring_setup( $io_context & this, const io_context_params & params_in ) {
+	static void __io_uring_setup( $io_context & this, const io_context_params & params_in, int procfd ) {
 		// Step 1 : call to setup
 		struct io_uring_params params;
@@ -339,5 +197,4 @@
 		sq.dropped     = (         __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.dropped);
 
-		sq.kring.ready = 0;
 		sq.kring.released = 0;
 
@@ -362,12 +219,9 @@
 		// io_uring_register is so f*cking slow on some machine that it
 		// will never succeed if preemption isn't hard blocked
+		__cfadbg_print_safe(io_core, "Kernel I/O : registering %d for completion with ring %d\n", procfd, fd);
+
 		__disable_interrupts_hard();
 
-		int efd = eventfd(0, 0);
-		if (efd < 0) {
-			abort("KERNEL ERROR: IO_URING EVENTFD - %s\n", strerror(errno));
-		}
-
-		int ret = syscall( __NR_io_uring_register, fd, IORING_REGISTER_EVENTFD, &efd, 1);
+		int ret = syscall( __NR_io_uring_register, fd, IORING_REGISTER_EVENTFD, &procfd, 1);
 		if (ret < 0) {
 			abort("KERNEL ERROR: IO_URING EVENTFD REGISTER - %s\n", strerror(errno));
@@ -375,4 +229,6 @@
 
 		__enable_interrupts_hard();
+
+		__cfadbg_print_safe(io_core, "Kernel I/O : registered %d for completion with ring %d\n", procfd, fd);
 
 		// some paranoid checks
@@ -390,5 +246,4 @@
 		this.ring_flags = 0;
 		this.fd         = fd;
-		this.efd        = efd;
 	}
 
@@ -411,49 +266,57 @@
 		// close the file descriptor
 		close(this.fd);
-		close(this.efd);
 
 		free( this.sq.free_ring.array ); // Maybe null, doesn't matter
 	}
 
+	void __cfa_io_start( processor * proc ) {
+		proc->io.ctx = alloc();
+		(*proc->io.ctx){proc, *proc->cltr};
+	}
+	void __cfa_io_stop ( processor * proc ) {
+		^(*proc->io.ctx){};
+		free(proc->io.ctx);
+	}
+
 //=============================================================================================
 // I/O Context Sleep
 //=============================================================================================
-	static inline void __epoll_ctl($io_context & ctx, int op, const char * error) {
-		struct epoll_event ev;
-		ev.events = EPOLLIN | EPOLLONESHOT;
-		ev.data.u64 = (__u64)&ctx;
-		int ret = epoll_ctl(iopoll.epollfd, op, ctx.efd, &ev);
-		if (ret < 0) {
-			abort( "KERNEL ERROR: EPOLL %s - (%d) %s\n", error, (int)errno, strerror(errno) );
-		}
-	}
-
-	static void __epoll_register($io_context & ctx) {
-		__epoll_ctl(ctx, EPOLL_CTL_ADD, "ADD");
-	}
-
-	static void __epoll_unregister($io_context & ctx) {
-		// Read the current epoch so we know when to stop
-		size_t curr = __atomic_load_n(&iopoll.epoch, __ATOMIC_SEQ_CST);
-
-		// Remove the fd from the iopoller
-		__epoll_ctl(ctx, EPOLL_CTL_DEL, "REMOVE");
-
-		// Notify the io poller thread of the shutdown
-		iopoll.run = false;
-		sigval val = { 1 };
-		pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
-
-		// Make sure all this is done
-		__atomic_thread_fence(__ATOMIC_SEQ_CST);
-
-		// Wait for the next epoch
-		while(curr == iopoll.epoch && !iopoll.stopped) Pause();
-	}
-
-	void __ioctx_prepare_block($io_context & ctx) {
-		__cfadbg_print_safe(io_core, "Kernel I/O - epoll : Re-arming io poller %d (%p)\n", ctx.fd, &ctx);
-		__epoll_ctl(ctx, EPOLL_CTL_MOD, "REARM");
-	}
+	// static inline void __epoll_ctl($io_context & ctx, int op, const char * error) {
+	// 	struct epoll_event ev;
+	// 	ev.events = EPOLLIN | EPOLLONESHOT;
+	// 	ev.data.u64 = (__u64)&ctx;
+	// 	int ret = epoll_ctl(iopoll.epollfd, op, ctx.efd, &ev);
+	// 	if (ret < 0) {
+	// 		abort( "KERNEL ERROR: EPOLL %s - (%d) %s\n", error, (int)errno, strerror(errno) );
+	// 	}
+	// }
+
+	// static void __epoll_register($io_context & ctx) {
+	// 	__epoll_ctl(ctx, EPOLL_CTL_ADD, "ADD");
+	// }
+
+	// static void __epoll_unregister($io_context & ctx) {
+	// 	// Read the current epoch so we know when to stop
+	// 	size_t curr = __atomic_load_n(&iopoll.epoch, __ATOMIC_SEQ_CST);
+
+	// 	// Remove the fd from the iopoller
+	// 	__epoll_ctl(ctx, EPOLL_CTL_DEL, "REMOVE");
+
+	// 	// Notify the io poller thread of the shutdown
+	// 	iopoll.run = false;
+	// 	sigval val = { 1 };
+	// 	pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
+
+	// 	// Make sure all this is done
+	// 	__atomic_thread_fence(__ATOMIC_SEQ_CST);
+
+	// 	// Wait for the next epoch
+	// 	while(curr == iopoll.epoch && !iopoll.stopped) Pause();
+	// }
+
+	// void __ioctx_prepare_block($io_context & ctx) {
+	// 	__cfadbg_print_safe(io_core, "Kernel I/O - epoll : Re-arming io poller %d (%p)\n", ctx.fd, &ctx);
+	// 	__epoll_ctl(ctx, EPOLL_CTL_MOD, "REARM");
+	// }
 
 
@@ -466,6 +329,6 @@
 
 	void ^?{}( $io_arbiter & mutex this ) {
-		/* paranoid */ verify( empty(this.assigned) );
-		/* paranoid */ verify( empty(this.available) );
+		// /* paranoid */ verify( empty(this.assigned) );
+		// /* paranoid */ verify( empty(this.available) );
 		/* paranoid */ verify( is_empty(this.pending.blocked) );
 	}
Index: libcfa/src/concurrency/io/types.hfa
===================================================================
--- libcfa/src/concurrency/io/types.hfa	(revision 4c4d854944a52f7271cb7d0d7c8cc51899a121cc)
+++ libcfa/src/concurrency/io/types.hfa	(revision dddb3dd01058a6f0eb621887f1bc9675d616a840)
@@ -38,5 +38,4 @@
 			volatile __u32 * head;	 // one passed last index consumed by the kernel
 			volatile __u32 * tail;   // one passed last index visible to the kernel
-			volatile __u32 ready;    // one passed last index added to array ()
 			volatile __u32 released; // one passed last index released back to the free list
 
@@ -97,10 +96,6 @@
 
 	struct __attribute__((aligned(128))) $io_context {
-		inline Seqable;
-
-		volatile bool revoked;
+		$io_arbiter * arbiter;
 		processor * proc;
-
-		$io_arbiter * arbiter;
 
 		struct {
@@ -113,16 +108,5 @@
 		__u32 ring_flags;
 		int fd;
-		int efd;
-
-		single_sem sem;
-		$thread self;
 	};
-
-	void main( $io_context & this );
-	static inline $thread  * get_thread ( $io_context & this ) __attribute__((const)) { return &this.self; }
-	static inline $monitor * get_monitor( $io_context & this ) __attribute__((const)) { return &this.self.self_mon; }
-	static inline $io_context *& Back( $io_context * n ) { return ($io_context *)Back( (Seqable *)n ); }
-	static inline $io_context *& Next( $io_context * n ) { return ($io_context *)Next( (Colable *)n ); }
-	void ^?{}( $io_context & mutex this );
 
 	monitor __attribute__((aligned(128))) $io_arbiter {
@@ -132,8 +116,4 @@
 			volatile bool flag;
 		} pending;
-
-		Sequence($io_context) assigned;
-
-		Sequence($io_context) available;
 	};
 
@@ -167,5 +147,5 @@
 	#endif
 
-	void __ioctx_prepare_block($io_context & ctx);
+	// void __ioctx_prepare_block($io_context & ctx);
 #endif