event 0.7.0 → 0.9.0

data/ext/event/{backend → selector}/kqueue.h

@@ -22,6 +22,6 @@
 
 #include <ruby.h>
 
-#define EVENT_BACKEND_KQUEUE
+#define EVENT_SELECTOR_KQUEUE
 
-void Init_Event_Backend_KQueue(VALUE Event_Backend);
+void Init_Event_Selector_KQueue(VALUE Event_Selector);

data/ext/event/selector/selector.c

@@ -0,0 +1,285 @@
+// Copyright, 2021, by Samuel G. D. Williams. <http://www.codeotaku.com>
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#include "selector.h"
+#include <fcntl.h>
+
+static ID id_transfer, id_alive_p;
+
+VALUE Event_Selector_fiber_transfer(VALUE fiber, int argc, VALUE *argv) {
+	// TODO Consider introducing something like `rb_fiber_scheduler_transfer(...)`.
+#ifdef HAVE__RB_FIBER_TRANSFER
+	if (RTEST(rb_fiber_alive_p(fiber))) {
+		return rb_fiber_transfer(fiber, argc, argv);
+	}
+#else
+	if (RTEST(rb_funcall(fiber, id_alive_p, 0))) {
+		return rb_funcallv(fiber, id_transfer, argc, argv);
+	}
+#endif
+	
+	return Qnil;
+}
+
+#ifndef HAVE__RB_FIBER_RAISE
+static ID id_raise;
+
+VALUE Event_Selector_fiber_raise(VALUE fiber, int argc, VALUE *argv) {
+	return rb_funcallv(fiber, id_raise, argc, argv);
+}
+#endif
+
+#ifndef HAVE_RB_FIBER_CURRENT
+static ID id_current;
+
+static VALUE rb_fiber_current() {
+	return rb_funcall(rb_cFiber, id_current, 0);
+}
+#endif
+
+
+#ifndef HAVE_RB_IO_DESCRIPTOR
+static ID id_fileno;
+
+int Event_Selector_io_descriptor(VALUE io) {
+	return RB_NUM2INT(rb_funcall(io, id_fileno, 0));
+}
+#endif
+
+#ifndef HAVE_RB_PROCESS_STATUS_WAIT
+static ID id_wait;
+static VALUE rb_Process_Status = Qnil;
+
+VALUE Event_Selector_process_status_wait(rb_pid_t pid)
+{
+	return rb_funcall(rb_Process_Status, id_wait, 2, PIDT2NUM(pid), INT2NUM(WNOHANG));
+}
+#endif
+
+int Event_Selector_nonblock_set(int file_descriptor)
+{
+	int flags = fcntl(file_descriptor, F_GETFL, 0);
+	
+	if (!(flags & O_NONBLOCK)) {
+		fcntl(file_descriptor, F_SETFL, flags | O_NONBLOCK);
+	}
+	
+	return flags;
+}
+
+void Event_Selector_nonblock_restore(int file_descriptor, int flags)
+{
+	if (!(flags & O_NONBLOCK)) {
+		fcntl(file_descriptor, F_SETFL, flags & ~flags);
+	}
+}
+
+void Init_Event_Selector(VALUE Event_Selector) {
+	id_transfer = rb_intern("transfer");
+	id_alive_p = rb_intern("alive?");
+	
+#ifndef HAVE__RB_FIBER_RAISE
+	id_raise = rb_intern("raise");
+#endif
+	
+#ifndef HAVE_RB_FIBER_CURRENT
+	id_current = rb_intern("current");
+#endif
+	
+#ifndef HAVE_RB_IO_DESCRIPTOR
+	id_fileno = rb_intern("fileno");
+#endif
+	
+#ifndef HAVE_RB_PROCESS_STATUS_WAIT
+	id_wait = rb_intern("wait");
+	rb_Process_Status = rb_const_get_at(rb_mProcess, rb_intern("Status"));
+#endif
+}
+
+struct wait_and_transfer_arguments {
+	int argc;
+	VALUE *argv;
+	
+	struct Event_Selector *backend;
+	struct Event_Selector_Queue *waiting;
+};
+
+static void queue_pop(struct Event_Selector *backend, struct Event_Selector_Queue *waiting) {
+	if (waiting->behind) {
+		waiting->behind->infront = waiting->infront;
+	} else {
+		backend->waiting = waiting->infront;
+	}
+	
+	if (waiting->infront) {
+		waiting->infront->behind = waiting->behind;
+	} else {
+		backend->ready = waiting->behind;
+	}
+}
+
+static void queue_push(struct Event_Selector *backend, struct Event_Selector_Queue *waiting) {
+	if (backend->waiting) {
+		backend->waiting->behind = waiting;
+		waiting->infront = backend->waiting;
+	} else {
+		backend->ready = waiting;
+	}
+	
+	backend->waiting = waiting;
+}
+
+static VALUE wait_and_transfer(VALUE _arguments) {
+	struct wait_and_transfer_arguments *arguments = (struct wait_and_transfer_arguments *)_arguments;
+	
+	VALUE fiber = arguments->argv[0];
+	int argc = arguments->argc - 1;
+	VALUE *argv = arguments->argv + 1;
+	
+	return Event_Selector_fiber_transfer(fiber, argc, argv);
+}
+
+static VALUE wait_and_transfer_ensure(VALUE _arguments) {
+	struct wait_and_transfer_arguments *arguments = (struct wait_and_transfer_arguments *)_arguments;
+	
+	queue_pop(arguments->backend, arguments->waiting);
+	
+	return Qnil;
+}
+
+VALUE Event_Selector_resume(struct Event_Selector *backend, int argc, VALUE *argv)
+{
+	rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+	
+	struct Event_Selector_Queue waiting = {
+		.behind = NULL,
+		.infront = NULL,
+		.flags = EVENT_SELECTOR_QUEUE_FIBER,
+		.fiber = rb_fiber_current()
+	};
+	
+	queue_push(backend, &waiting);
+	
+	struct wait_and_transfer_arguments arguments = {
+		.argc = argc,
+		.argv = argv,
+		.backend = backend,
+		.waiting = &waiting,
+	};
+	
+	return rb_ensure(wait_and_transfer, (VALUE)&arguments, wait_and_transfer_ensure, (VALUE)&arguments);
+}
+
+static VALUE wait_and_raise(VALUE _arguments) {
+	struct wait_and_transfer_arguments *arguments = (struct wait_and_transfer_arguments *)_arguments;
+	
+	VALUE fiber = arguments->argv[0];
+	int argc = arguments->argc - 1;
+	VALUE *argv = arguments->argv + 1;
+	
+	return Event_Selector_fiber_raise(fiber, argc, argv);
+}
+
+VALUE Event_Selector_wait_and_raise(struct Event_Selector *backend, int argc, VALUE *argv)
+{
+	rb_check_arity(argc, 2, UNLIMITED_ARGUMENTS);
+	
+	struct Event_Selector_Queue waiting = {
+		.behind = NULL,
+		.infront = NULL,
+		.flags = EVENT_SELECTOR_QUEUE_FIBER,
+		.fiber = rb_fiber_current()
+	};
+	
+	queue_push(backend, &waiting);
+	
+	struct wait_and_transfer_arguments arguments = {
+		.argc = argc,
+		.argv = argv,
+		.backend = backend,
+		.waiting = &waiting,
+	};
+	
+	return rb_ensure(wait_and_raise, (VALUE)&arguments, wait_and_transfer_ensure, (VALUE)&arguments);
+}
+
+void Event_Selector_queue_push(struct Event_Selector *backend, VALUE fiber)
+{
+	struct Event_Selector_Queue *waiting = malloc(sizeof(struct Event_Selector_Queue));
+	
+	waiting->behind = NULL;
+	waiting->infront = NULL;
+	waiting->flags = EVENT_SELECTOR_QUEUE_INTERNAL;
+	waiting->fiber = fiber;
+	
+	queue_push(backend, waiting);
+}
+
+static inline
+void Event_Selector_queue_pop(struct Event_Selector *backend, struct Event_Selector_Queue *ready)
+{
+	if (ready->flags & EVENT_SELECTOR_QUEUE_FIBER) {
+		Event_Selector_fiber_transfer(ready->fiber, 0, NULL);
+	} else {
+		VALUE fiber = ready->fiber;
+		queue_pop(backend, ready);
+		free(ready);
+		
+		if (RTEST(rb_funcall(fiber, id_alive_p, 0))) {
+			rb_funcall(fiber, id_transfer, 0);
+		}
+	}
+}
+
+int Event_Selector_queue_flush(struct Event_Selector *backend)
+{
+	int count = 0;
+	
+	// Get the current tail and head of the queue:
+	struct Event_Selector_Queue *waiting = backend->waiting;
+	
+	// Process from head to tail in order:
+	// During this, more items may be appended to tail.
+	while (backend->ready) {
+		struct Event_Selector_Queue *ready = backend->ready;
+		
+		count += 1;
+		Event_Selector_queue_pop(backend, ready);
+		
+		if (ready == waiting) break;
+	}
+	
+	return count;
+}
+
+void Event_Selector_elapsed_time(struct timespec* start, struct timespec* stop, struct timespec *duration)
+{
+	if ((stop->tv_nsec - start->tv_nsec) < 0) {
+		duration->tv_sec = stop->tv_sec - start->tv_sec - 1;
+		duration->tv_nsec = stop->tv_nsec - start->tv_nsec + 1000000000;
+	} else {
+		duration->tv_sec = stop->tv_sec - start->tv_sec;
+		duration->tv_nsec = stop->tv_nsec - start->tv_nsec;
+	}
+}
+
+void Event_Selector_current_time(struct timespec *time) {
+	clock_gettime(CLOCK_MONOTONIC, time);
+}

data/ext/event/selector/selector.h

@@ -0,0 +1,123 @@
+// Copyright, 2021, by Samuel G. D. Williams. <http://www.codeotaku.com>
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <ruby/io.h>
+
+#ifdef HAVE_RUBY_IO_BUFFER_H
+#include <ruby/io/buffer.h>
+#endif
+
+#include <time.h>
+
+enum Event {
+	EVENT_READABLE = 1,
+	EVENT_PRIORITY = 2,
+	EVENT_WRITABLE = 4,
+	EVENT_ERROR = 8,
+	EVENT_HANGUP = 16
+};
+
+void Init_Event_Selector();
+
+VALUE Event_Selector_fiber_transfer(VALUE fiber, int argc, VALUE *argv);
+
+#ifdef HAVE__RB_FIBER_RAISE
+#define Event_Selector_fiber_raise(fiber, argc, argv) rb_fiber_raise(fiber, argc, argv)
+#else
+VALUE Event_Selector_fiber_raise(VALUE fiber, int argc, VALUE *argv);
+#endif
+
+#ifdef HAVE_RB_IO_DESCRIPTOR
+#define Event_Selector_io_descriptor(io) rb_io_descriptor(io)
+#else
+int Event_Selector_io_descriptor(VALUE io);
+#endif
+
+#ifdef HAVE_RB_PROCESS_STATUS_WAIT
+#define Event_Selector_process_status_wait(pid) rb_process_status_wait(pid)
+#else
+VALUE Event_Selector_process_status_wait(rb_pid_t pid);
+#endif
+
+int Event_Selector_nonblock_set(int file_descriptor);
+void Event_Selector_nonblock_restore(int file_descriptor, int flags);
+
+enum Event_Selector_Queue_Flags {
+	EVENT_SELECTOR_QUEUE_FIBER = 1,
+	EVENT_SELECTOR_QUEUE_INTERNAL = 2,
+};
+
+struct Event_Selector_Queue {
+	struct Event_Selector_Queue *behind;
+	struct Event_Selector_Queue *infront;
+	
+	enum Event_Selector_Queue_Flags flags;
+	
+	VALUE fiber;
+};
+
+struct Event_Selector {
+	VALUE loop;
+	
+	struct Event_Selector_Queue *free;
+	
+	// Append to waiting.
+	struct Event_Selector_Queue *waiting;
+	// Process from ready.
+	struct Event_Selector_Queue *ready;
+};
+
+static inline
+void Event_Selector_initialize(struct Event_Selector *backend, VALUE loop) {
+	backend->loop = loop;
+	backend->waiting = NULL;
+	backend->ready = NULL;
+}
+
+static inline
+void Event_Selector_mark(struct Event_Selector *backend) {
+	rb_gc_mark(backend->loop);
+	
+	struct Event_Selector_Queue *ready = backend->ready;
+	while (ready) {
+		rb_gc_mark(ready->fiber);
+		ready = ready->behind;
+	}
+}
+
+VALUE Event_Selector_resume(struct Event_Selector *backend, int argc, VALUE *argv);
+VALUE Event_Selector_wait_and_raise(struct Event_Selector *backend, int argc, VALUE *argv);
+
+static inline
+VALUE Event_Selector_yield(struct Event_Selector *backend)
+{
+	return Event_Selector_resume(backend, 1, &backend->loop);
+}
+
+void Event_Selector_queue_push(struct Event_Selector *backend, VALUE fiber);
+int Event_Selector_queue_flush(struct Event_Selector *backend);
+
+void Event_Selector_elapsed_time(struct timespec* start, struct timespec* stop, struct timespec *duration);
+void Event_Selector_current_time(struct timespec *time);
+
+#define PRINTF_TIMESPEC "%lld.%.9ld"
+#define PRINTF_TIMESPEC_ARGS(ts) (long long)((ts).tv_sec), (ts).tv_nsec

data/ext/event/{backend → selector}/uring.c

@@ -19,7 +19,7 @@
 // THE SOFTWARE.
 
 #include "uring.h"
-#include "backend.h"
+#include "selector.h"
 
 #include <liburing.h>
 #include <poll.h>
@@ -29,63 +29,60 @@
 
 static const int DEBUG = 0;
 
-// This option controls whether to all `io_uring_submit()` after every operation:
-static const int EARLY_SUBMIT = 1;
-
-static VALUE Event_Backend_URing = Qnil;
+static VALUE Event_Selector_URing = Qnil;
 
 enum {URING_ENTRIES = 64};
 
-struct Event_Backend_URing {
-	struct Event_Backend backend;
+struct Event_Selector_URing {
+	struct Event_Selector backend;
 	struct io_uring ring;
 	size_t pending;
 };
 
-void Event_Backend_URing_Type_mark(void *_data)
+void Event_Selector_URing_Type_mark(void *_data)
 {
-	struct Event_Backend_URing *data = _data;
-	Event_Backend_mark(&data->backend);
+	struct Event_Selector_URing *data = _data;
+	Event_Selector_mark(&data->backend);
 }
 
 static
-void close_internal(struct Event_Backend_URing *data) {
+void close_internal(struct Event_Selector_URing *data) {
 	if (data->ring.ring_fd >= 0) {
 		io_uring_queue_exit(&data->ring);
 		data->ring.ring_fd = -1;
 	}
 }
 
-void Event_Backend_URing_Type_free(void *_data)
+void Event_Selector_URing_Type_free(void *_data)
 {
-	struct Event_Backend_URing *data = _data;
+	struct Event_Selector_URing *data = _data;
 	
 	close_internal(data);
 	
 	free(data);
 }
 
-size_t Event_Backend_URing_Type_size(const void *data)
+size_t Event_Selector_URing_Type_size(const void *data)
 {
-	return sizeof(struct Event_Backend_URing);
+	return sizeof(struct Event_Selector_URing);
 }
 
-static const rb_data_type_t Event_Backend_URing_Type = {
+static const rb_data_type_t Event_Selector_URing_Type = {
 	.wrap_struct_name = "Event::Backend::URing",
 	.function = {
-		.dmark = Event_Backend_URing_Type_mark,
-		.dfree = Event_Backend_URing_Type_free,
-		.dsize = Event_Backend_URing_Type_size,
+		.dmark = Event_Selector_URing_Type_mark,
+		.dfree = Event_Selector_URing_Type_free,
+		.dsize = Event_Selector_URing_Type_size,
 	},
 	.data = NULL,
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
-VALUE Event_Backend_URing_allocate(VALUE self) {
-	struct Event_Backend_URing *data = NULL;
-	VALUE instance = TypedData_Make_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_allocate(VALUE self) {
+	struct Event_Selector_URing *data = NULL;
+	VALUE instance = TypedData_Make_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	Event_Backend_initialize(&data->backend, Qnil);
+	Event_Selector_initialize(&data->backend, Qnil);
 	data->ring.ring_fd = -1;
 	
 	data->pending = 0;
@@ -93,11 +90,11 @@ VALUE Event_Backend_URing_allocate(VALUE self) {
 	return instance;
 }
 
-VALUE Event_Backend_URing_initialize(VALUE self, VALUE loop) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_initialize(VALUE self, VALUE loop) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	Event_Backend_initialize(&data->backend, loop);
+	Event_Selector_initialize(&data->backend, loop);
 	int result = io_uring_queue_init(URING_ENTRIES, &data->ring, 0);
 	
 	if (result < 0) {
@@ -109,44 +106,62 @@ VALUE Event_Backend_URing_initialize(VALUE self, VALUE loop) {
 	return self;
 }
 
-VALUE Event_Backend_URing_close(VALUE self) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_close(VALUE self) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
 	close_internal(data);
 	
 	return Qnil;
 }
 
-VALUE Event_Backend_URing_transfer(VALUE self, VALUE fiber)
+VALUE Event_Selector_URing_resume(int argc, VALUE *argv, VALUE self)
 {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	Event_Backend_wait_and_transfer(&data->backend, fiber);
+	Event_Selector_resume(&data->backend, argc, argv);
 	
 	return Qnil;
 }
 
-VALUE Event_Backend_URing_defer(VALUE self)
+VALUE Event_Selector_URing_yield(VALUE self)
 {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	Event_Backend_defer(&data->backend);
+	Event_Selector_yield(&data->backend);
 	
 	return Qnil;
 }
 
-VALUE Event_Backend_URing_ready_p(VALUE self) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_push(VALUE self, VALUE fiber)
+{
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
+	
+	Event_Selector_queue_push(&data->backend, fiber);
+	
+	return Qnil;
+}
+
+VALUE Event_Selector_URing_raise(int argc, VALUE *argv, VALUE self)
+{
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
+	
+	return Event_Selector_wait_and_raise(&data->backend, argc, argv);
+}
+
+VALUE Event_Selector_URing_ready_p(VALUE self) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
 	return data->backend.ready ? Qtrue : Qfalse;
 }
 
 static
-int io_uring_submit_flush(struct Event_Backend_URing *data) {
+int io_uring_submit_flush(struct Event_Selector_URing *data) {
 	if (data->pending) {
 		if (DEBUG) fprintf(stderr, "io_uring_submit_flush(pending=%ld)\n", data->pending);
 		
@@ -167,7 +182,7 @@ int io_uring_submit_flush(struct Event_Backend_URing *data) {
 }
 
 static
-int io_uring_submit_now(struct Event_Backend_URing *data) {
+int io_uring_submit_now(struct Event_Selector_URing *data) {
 	while (true) {
 		int result = io_uring_submit(&data->ring);
 		
@@ -177,7 +192,7 @@ int io_uring_submit_now(struct Event_Backend_URing *data) {
 		}
 
 		if (result == -EBUSY || result == -EAGAIN) {
-			Event_Backend_defer(&data->backend);
+			Event_Selector_yield(&data->backend);
 		} else {
 			rb_syserr_fail(-result, "io_uring_submit_now");
 		}
@@ -185,15 +200,11 @@ int io_uring_submit_now(struct Event_Backend_URing *data) {
 }
 
 static
-void io_uring_submit_pending(struct Event_Backend_URing *data) {
-	if (EARLY_SUBMIT) {
-		io_uring_submit_now(data);
-	} else {
-		data->pending += 1;
-	}
+void io_uring_submit_pending(struct Event_Selector_URing *data) {
+	data->pending += 1;
 }
 
-struct io_uring_sqe * io_get_sqe(struct Event_Backend_URing *data) {
+struct io_uring_sqe * io_get_sqe(struct Event_Selector_URing *data) {
 	struct io_uring_sqe *sqe = io_uring_get_sqe(&data->ring);
 	
 	while (sqe == NULL) {
@@ -207,7 +218,7 @@ struct io_uring_sqe * io_get_sqe(struct Event_Backend_URing *data) {
 }
 
 struct process_wait_arguments {
-	struct Event_Backend_URing *data;
+	struct Event_Selector_URing *data;
 	pid_t pid;
 	int flags;
 	int descriptor;
@@ -217,9 +228,9 @@ static
 VALUE process_wait_transfer(VALUE _arguments) {
 	struct process_wait_arguments *arguments = (struct process_wait_arguments *)_arguments;
 	
-	Event_Backend_fiber_transfer(arguments->data->backend.loop);
+	Event_Selector_fiber_transfer(arguments->data->backend.loop, 0, NULL);
 	
-	return Event_Backend_process_status_wait(arguments->pid);
+	return Event_Selector_process_status_wait(arguments->pid);
 }
 
 static
@@ -231,9 +242,9 @@ VALUE process_wait_ensure(VALUE _arguments) {
 	return Qnil;
 }
 
-VALUE Event_Backend_URing_process_wait(VALUE self, VALUE fiber, VALUE pid, VALUE flags) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_process_wait(VALUE self, VALUE fiber, VALUE pid, VALUE flags) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
 	struct process_wait_arguments process_wait_arguments = {
 		.data = data,
@@ -246,7 +257,7 @@ VALUE Event_Backend_URing_process_wait(VALUE self, VALUE fiber, VALUE pid, VALUE
 	
 	struct io_uring_sqe *sqe = io_get_sqe(data);
 
-	if (DEBUG) fprintf(stderr, "Event_Backend_URing_process_wait:io_uring_prep_poll_add(%p)\n", (void*)fiber);
+	if (DEBUG) fprintf(stderr, "Event_Selector_URing_process_wait:io_uring_prep_poll_add(%p)\n", (void*)fiber);
 	io_uring_prep_poll_add(sqe, process_wait_arguments.descriptor, POLLIN|POLLHUP|POLLERR);
 	io_uring_sqe_set_data(sqe, (void*)fiber);
 	io_uring_submit_pending(data);
@@ -258,9 +269,9 @@ static inline
 short poll_flags_from_events(int events) {
 	short flags = 0;
 	
-	if (events & READABLE) flags |= POLLIN;
-	if (events & PRIORITY) flags |= POLLPRI;
-	if (events & WRITABLE) flags |= POLLOUT;
+	if (events & EVENT_READABLE) flags |= POLLIN;
+	if (events & EVENT_PRIORITY) flags |= POLLPRI;
+	if (events & EVENT_WRITABLE) flags |= POLLOUT;
 	
 	flags |= POLLERR;
 	flags |= POLLHUP;
@@ -272,15 +283,15 @@ static inline
 int events_from_poll_flags(short flags) {
 	int events = 0;
 	
-	if (flags & POLLIN) events |= READABLE;
-	if (flags & POLLPRI) events |= PRIORITY;
-	if (flags & POLLOUT) events |= WRITABLE;
+	if (flags & POLLIN) events |= EVENT_READABLE;
+	if (flags & POLLPRI) events |= EVENT_PRIORITY;
+	if (flags & POLLOUT) events |= EVENT_WRITABLE;
 	
 	return events;
 }
 
 struct io_wait_arguments {
-	struct Event_Backend_URing *data;
+	struct Event_Selector_URing *data;
 	VALUE fiber;
 	short flags;
 };
@@ -288,24 +299,25 @@ struct io_wait_arguments {
 static
 VALUE io_wait_rescue(VALUE _arguments, VALUE exception) {
 	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
-	struct Event_Backend_URing *data = arguments->data;
+	struct Event_Selector_URing *data = arguments->data;
 	
 	struct io_uring_sqe *sqe = io_get_sqe(data);
 	
 	if (DEBUG) fprintf(stderr, "io_wait_rescue:io_uring_prep_poll_remove(%p)\n", (void*)arguments->fiber);
 	
 	io_uring_prep_poll_remove(sqe, (void*)arguments->fiber);
-	
+	io_uring_submit_now(data);
+
 	rb_exc_raise(exception);
 };
 
 static
 VALUE io_wait_transfer(VALUE _arguments) {
 	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
-	struct Event_Backend_URing *data = arguments->data;
+	struct Event_Selector_URing *data = arguments->data;
 
-	VALUE result = Event_Backend_fiber_transfer(data->backend.loop);
-	if (DEBUG) fprintf(stderr, "io_wait:Event_Backend_fiber_transfer -> %d\n", RB_NUM2INT(result));
+	VALUE result = Event_Selector_fiber_transfer(data->backend.loop, 0, NULL);
+	if (DEBUG) fprintf(stderr, "io_wait:Event_Selector_fiber_transfer -> %d\n", RB_NUM2INT(result));
 
 	// We explicitly filter the resulting events based on the requested events.
 	// In some cases, poll will report events we didn't ask for.
@@ -314,19 +326,21 @@ VALUE io_wait_transfer(VALUE _arguments) {
 	return INT2NUM(events_from_poll_flags(flags));
 };
 
-VALUE Event_Backend_URing_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE events) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE events) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	int descriptor = Event_Backend_io_descriptor(io);
+	int descriptor = Event_Selector_io_descriptor(io);
 	struct io_uring_sqe *sqe = io_get_sqe(data);
 	
 	short flags = poll_flags_from_events(NUM2INT(events));
 	
-	if (DEBUG) fprintf(stderr, "Event_Backend_URing_io_wait:io_uring_prep_poll_add(descriptor=%d, flags=%d, fiber=%p)\n", descriptor, flags, (void*)fiber);
+	if (DEBUG) fprintf(stderr, "Event_Selector_URing_io_wait:io_uring_prep_poll_add(descriptor=%d, flags=%d, fiber=%p)\n", descriptor, flags, (void*)fiber);
 	
 	io_uring_prep_poll_add(sqe, descriptor, flags);
 	io_uring_sqe_set_data(sqe, (void*)fiber);
+	
+	// If we are going to wait, we assume that we are waiting for a while:
 	io_uring_submit_pending(data);
 	
 	struct io_wait_arguments io_wait_arguments = {
@@ -340,26 +354,26 @@ VALUE Event_Backend_URing_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE event
 
 #ifdef HAVE_RUBY_IO_BUFFER_H
 
-static int io_read(struct Event_Backend_URing *data, VALUE fiber, int descriptor, char *buffer, size_t length) {
+static int io_read(struct Event_Selector_URing *data, VALUE fiber, int descriptor, char *buffer, size_t length) {
 	struct io_uring_sqe *sqe = io_get_sqe(data);
 
 	if (DEBUG) fprintf(stderr, "io_read:io_uring_prep_read(fiber=%p)\n", (void*)fiber);
 
 	io_uring_prep_read(sqe, descriptor, buffer, length, 0);
 	io_uring_sqe_set_data(sqe, (void*)fiber);
-	io_uring_submit_pending(data);
+	io_uring_submit_now(data);
 	
-	VALUE result = Event_Backend_fiber_transfer(data->backend.loop);
-	if (DEBUG) fprintf(stderr, "io_read:Event_Backend_fiber_transfer -> %d\n", RB_NUM2INT(result));
+	VALUE result = Event_Selector_fiber_transfer(data->backend.loop, 0, NULL);
+	if (DEBUG) fprintf(stderr, "io_read:Event_Selector_fiber_transfer -> %d\n", RB_NUM2INT(result));
 
 	return RB_NUM2INT(result);
 }
 
-VALUE Event_Backend_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	int descriptor = Event_Backend_io_descriptor(io);
+	int descriptor = Event_Selector_io_descriptor(io);
 	
 	void *base;
 	size_t size;
@@ -379,7 +393,7 @@ VALUE Event_Backend_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffe
 			if ((size_t)result >= length) break;
 			length -= result;
 		} else if (-result == EAGAIN || -result == EWOULDBLOCK) {
-			Event_Backend_URing_io_wait(self, fiber, io, RB_INT2NUM(READABLE));
+			Event_Selector_URing_io_wait(self, fiber, io, RB_INT2NUM(EVENT_READABLE));
 		} else {
 			rb_syserr_fail(-result, strerror(-result));
 		}
@@ -389,7 +403,7 @@ VALUE Event_Backend_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffe
 }
 
 static
-int io_write(struct Event_Backend_URing *data, VALUE fiber, int descriptor, char *buffer, size_t length) {
+int io_write(struct Event_Selector_URing *data, VALUE fiber, int descriptor, char *buffer, size_t length) {
 	struct io_uring_sqe *sqe = io_get_sqe(data);
 	
 	if (DEBUG) fprintf(stderr, "io_write:io_uring_prep_write(fiber=%p)\n", (void*)fiber);
@@ -398,17 +412,17 @@ int io_write(struct Event_Backend_URing *data, VALUE fiber, int descriptor, char
 	io_uring_sqe_set_data(sqe, (void*)fiber);
 	io_uring_submit_pending(data);
 	
-	int result = RB_NUM2INT(Event_Backend_fiber_transfer(data->backend.loop));
-	if (DEBUG) fprintf(stderr, "io_write:Event_Backend_fiber_transfer -> %d\n", result);
+	int result = RB_NUM2INT(Event_Selector_fiber_transfer(data->backend.loop, 0, NULL));
+	if (DEBUG) fprintf(stderr, "io_write:Event_Selector_fiber_transfer -> %d\n", result);
 
 	return result;
 }
 
-VALUE Event_Backend_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	int descriptor = Event_Backend_io_descriptor(io);
+	int descriptor = Event_Selector_io_descriptor(io);
 	
 	const void *base;
 	size_t size;
@@ -429,7 +443,7 @@ VALUE Event_Backend_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buff
 			if ((size_t)result >= length) break;
 			length -= result;
 		} else if (-result == EAGAIN || -result == EWOULDBLOCK) {
-			Event_Backend_URing_io_wait(self, fiber, io, RB_INT2NUM(WRITABLE));
+			Event_Selector_URing_io_wait(self, fiber, io, RB_INT2NUM(EVENT_WRITABLE));
 		} else {
 			rb_syserr_fail(-result, strerror(-result));
 		}
@@ -440,23 +454,20 @@ VALUE Event_Backend_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buff
 
 #endif
 
-static const int ASYNC_CLOSE = 2;
+static const int ASYNC_CLOSE = 1;
 
-VALUE Event_Backend_URing_io_close(VALUE self, VALUE io) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_io_close(VALUE self, VALUE io) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	int descriptor = Event_Backend_io_descriptor(io);
+	int descriptor = Event_Selector_io_descriptor(io);
 
 	if (ASYNC_CLOSE) {
 		struct io_uring_sqe *sqe = io_get_sqe(data);
 		
 		io_uring_prep_close(sqe, descriptor);
 		io_uring_sqe_set_data(sqe, NULL);
-		if (ASYNC_CLOSE == 1)
-			io_uring_submit_now(data);
-		else if (ASYNC_CLOSE == 2)
-			io_uring_submit_pending(data);
+		io_uring_submit_now(data);
 	} else {
 		close(descriptor);
 	}
@@ -497,7 +508,7 @@ int timeout_nonblocking(struct __kernel_timespec *timespec) {
 }
 
 struct select_arguments {
-	struct Event_Backend_URing *data;
+	struct Event_Selector_URing *data;
 	
 	int result;
 	
@@ -552,34 +563,29 @@ unsigned select_process_completions(struct io_uring *ring) {
 		VALUE result = RB_INT2NUM(cqe->res);
 		
 		if (DEBUG) fprintf(stderr, "cqe res=%d user_data=%p\n", cqe->res, (void*)cqe->user_data);
-
+		
 		io_uring_cq_advance(ring, 1);
-
-		Event_Backend_fiber_transfer_result(fiber, result);
+		
+		Event_Selector_fiber_transfer(fiber, 1, &result);
 	}
 	
 	// io_uring_cq_advance(ring, completed);
-
+	
 	if (DEBUG) fprintf(stderr, "select_process_completions(completed=%d)\n", completed);
-
+	
 	return completed;
 }
 
-VALUE Event_Backend_URing_select(VALUE self, VALUE duration) {
-	struct Event_Backend_URing *data = NULL;
-	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+VALUE Event_Selector_URing_select(VALUE self, VALUE duration) {
+	struct Event_Selector_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Selector_URing, &Event_Selector_URing_Type, data);
 	
-	Event_Backend_ready_pop(&data->backend);
+	int ready = Event_Selector_queue_flush(&data->backend);
 	
-	int result = 0;
-
-	// There can only be events waiting if we have been submitting them early:
-	if (EARLY_SUBMIT) {
-		result = select_process_completions(&data->ring);
-	}
+	int result = select_process_completions(&data->ring);
 
-	// If we aren't submitting events early, we need to submit them and/or wait for them:
-	if (result == 0) {
+	// If the ready list was empty and we didn't process any completions:
+	if (!ready && result == 0) {
 		// We might need to wait for events:
 		struct select_arguments arguments = {
 			.data = data,
@@ -603,25 +609,30 @@ VALUE Event_Backend_URing_select(VALUE self, VALUE duration) {
 	return RB_INT2NUM(result);
 }
 
-void Init_Event_Backend_URing(VALUE Event_Backend) {
-	Event_Backend_URing = rb_define_class_under(Event_Backend, "URing", rb_cObject);
+void Init_Event_Selector_URing(VALUE Event_Selector) {
+	Event_Selector_URing = rb_define_class_under(Event_Selector, "URing", rb_cObject);
+	
+	rb_define_alloc_func(Event_Selector_URing, Event_Selector_URing_allocate);
+	rb_define_method(Event_Selector_URing, "initialize", Event_Selector_URing_initialize, 1);
+	
+	rb_define_method(Event_Selector_URing, "resume", Event_Selector_URing_resume, -1);
+	rb_define_method(Event_Selector_URing, "yield", Event_Selector_URing_yield, 0);
+	rb_define_method(Event_Selector_URing, "push", Event_Selector_URing_push, 1);
+	rb_define_method(Event_Selector_URing, "raise", Event_Selector_URing_raise, -1);
+	
+	rb_define_method(Event_Selector_URing, "ready?", Event_Selector_URing_ready_p, 0);
 	
-	rb_define_alloc_func(Event_Backend_URing, Event_Backend_URing_allocate);
-	rb_define_method(Event_Backend_URing, "initialize", Event_Backend_URing_initialize, 1);
-	rb_define_method(Event_Backend_URing, "transfer", Event_Backend_URing_transfer, 1);
-	rb_define_method(Event_Backend_URing, "defer", Event_Backend_URing_defer, 0);
-	rb_define_method(Event_Backend_URing, "ready?", Event_Backend_URing_ready_p, 0);
-	rb_define_method(Event_Backend_URing, "select", Event_Backend_URing_select, 1);
-	rb_define_method(Event_Backend_URing, "close", Event_Backend_URing_close, 0);
+	rb_define_method(Event_Selector_URing, "select", Event_Selector_URing_select, 1);
+	rb_define_method(Event_Selector_URing, "close", Event_Selector_URing_close, 0);
 	
-	rb_define_method(Event_Backend_URing, "io_wait", Event_Backend_URing_io_wait, 3);
+	rb_define_method(Event_Selector_URing, "io_wait", Event_Selector_URing_io_wait, 3);
 	
 #ifdef HAVE_RUBY_IO_BUFFER_H
-	rb_define_method(Event_Backend_URing, "io_read", Event_Backend_URing_io_read, 4);
-	rb_define_method(Event_Backend_URing, "io_write", Event_Backend_URing_io_write, 4);
+	rb_define_method(Event_Selector_URing, "io_read", Event_Selector_URing_io_read, 4);
+	rb_define_method(Event_Selector_URing, "io_write", Event_Selector_URing_io_write, 4);
 #endif
 	
-	rb_define_method(Event_Backend_URing, "io_close", Event_Backend_URing_io_close, 1);
+	rb_define_method(Event_Selector_URing, "io_close", Event_Selector_URing_io_close, 1);
 	
-	rb_define_method(Event_Backend_URing, "process_wait", Event_Backend_URing_process_wait, 3);
+	rb_define_method(Event_Selector_URing, "process_wait", Event_Selector_URing_process_wait, 3);
 }