event 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5039784abaf0f999187afbed8ca930bf99cf66cc089136da3b3e42ea6831b729
-  data.tar.gz: 712d0693031af7bd93c1da59e5ad716d8be81a895d1d3ea23dca6cf80e42f5d0
+  metadata.gz: 287fe2e9885bd34fd2595c49589c2cfe751799e34f738a18e93f9ccdf13f3ffd
+  data.tar.gz: 88cec8cd2badba810501a9a3aef7309dcb76d87ef0c6029bca147ba2d3eea09e
 SHA512:
-  metadata.gz: 3de44f33a4410d1cf5b52186ac606d1d03f33326f3124e69b50b705ac8840c2f7facc5924378353b2fce55324cbf353fc407bf60f041e6b0b0990d889eaad7dc
-  data.tar.gz: e34bc430b17351ba2210e89c2d3cec4049eafd3e2e8c3297d777c6dfae6cdc9dc9a823b83bf503c4c1a9e7463f74064d0632f1e641cdac9d5034012f76bf50c9
+  metadata.gz: 956801d0c052c06efe6cf126e76472a02f2271d8476a0501f262ab1d71b0e97992fc5bf2ffce33b753f510179ec42f8f5529152d9bd48ed6029b4009ba754d3c
+  data.tar.gz: 3f35bf37920170794733e5b3671aa9e0e1a3a64620dde2209310d5c8143866ce92289c5efe6b9f2010f271b2452b3efdb9bbb3d2c3c72d80cefd847154746355

data/ext/event/backend/epoll.c

@@ -0,0 +1,206 @@
+// 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 "kqueue.h"
+
+#include <sys/epoll.h>
+#include <time.h>
+#include <errno.h>
+
+static VALUE Event_Backend_EPoll = Qnil;
+static ID id_fileno, id_transfer;
+
+static const int READABLE = 1, PRIORITY = 2, WRITABLE = 4;
+
+static const unsigned EPOLL_MAX_EVENTS = 1024;
+
+struct Event_Backend_EPoll {
+	VALUE loop;
+	int descriptor;
+};
+
+void Event_Backend_EPoll_Type_mark(void *_data)
+{
+	struct Event_Backend_EPoll *data = _data;
+	rb_gc_mark(data->loop);
+}
+
+void Event_Backend_EPoll_Type_free(void *_data)
+{
+	struct Event_Backend_EPoll *data = _data;
+	
+	if (data->descriptor >= 0) {
+		close(data->descriptor);
+	}
+	
+	free(data);
+}
+
+size_t Event_Backend_EPoll_Type_size(const void *data)
+{
+	return sizeof(struct Event_Backend_EPoll);
+}
+
+static const rb_data_type_t Event_Backend_EPoll_Type = {
+	.wrap_struct_name = "Event::Backend::EPoll",
+	.function = {
+		.dmark = Event_Backend_EPoll_Type_mark,
+		.dfree = Event_Backend_EPoll_Type_free,
+		.dsize = Event_Backend_EPoll_Type_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE Event_Backend_EPoll_allocate(VALUE self) {
+	struct Event_Backend_EPoll *data = NULL;
+	VALUE instance = TypedData_Make_Struct(self, struct Event_Backend_EPoll, &Event_Backend_EPoll_Type, data);
+	
+	data->loop = Qnil;
+	data->descriptor = -1;
+	
+	return instance;
+}
+
+VALUE Event_Backend_EPoll_initialize(VALUE self, VALUE loop) {
+	struct Event_Backend_EPoll *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_EPoll, &Event_Backend_EPoll_Type, data);
+	
+	data->loop = loop;
+	int result = epoll_create1(EPOLL_CLOEXEC);
+	
+	if (result == -1) {
+		rb_sys_fail("epoll_create");
+	} else {
+		data->descriptor = result;
+		
+		rb_update_max_fd(data->descriptor);
+	}
+	
+	return self;
+}
+
+VALUE Event_Backend_EPoll_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE events) {
+	struct Event_Backend_EPoll *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_EPoll, &Event_Backend_EPoll_Type, data);
+	
+	struct epoll_event event = {0};
+	
+	int descriptor = NUM2INT(rb_funcall(io, id_fileno, 0));
+	int duplicate = -1;
+	
+	int mask = NUM2INT(events);
+	
+	if (mask & READABLE) {
+		event.events |= EPOLLIN;
+	}
+	
+	if (mask & PRIORITY) {
+		event.events |= EPOLLPRI;
+	}
+	
+	if (mask & WRITABLE) {
+		event.events |= EPOLLOUT;
+	}
+	
+	event.events |= EPOLLRDHUP;
+	event.events |= EPOLLONESHOT;
+	
+	event.data.ptr = (void*)fiber;
+	
+	// A better approach is to batch all changes:
+	int result = epoll_ctl(data->descriptor, EPOLL_CTL_ADD, descriptor, &event);;
+	
+	if (result == -1 && errno == EEXIST) {
+		// The file descriptor was already inserted into epoll.
+		duplicate = descriptor = dup(descriptor);
+		
+		rb_update_max_fd(duplicate);
+		
+		if (descriptor == -1)
+			rb_sys_fail("dup");
+		
+		result = epoll_ctl(data->descriptor, EPOLL_CTL_ADD, descriptor, &event);;
+	}
+	
+	if (result == -1) {
+		rb_sys_fail("epoll_ctl");
+	}
+	
+	rb_funcall(data->loop, id_transfer, 0);
+	
+	if (duplicate >= 0) {
+		close(duplicate);
+	}
+	
+	return Qnil;
+}
+
+static
+int make_timeout(VALUE duration) {
+	if (duration == Qnil) {
+		return -1;
+	}
+	
+	if (FIXNUM_P(duration)) {
+		return NUM2LONG(duration) * 1000L;
+	}
+	
+	else if (RB_FLOAT_TYPE_P(duration)) {
+		double value = RFLOAT_VALUE(duration);
+		
+		return value * 1000;
+	}
+	
+	rb_raise(rb_eRuntimeError, "unable to convert timeout");
+}
+
+VALUE Event_Backend_EPoll_select(VALUE self, VALUE duration) {
+	struct Event_Backend_EPoll *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_EPoll, &Event_Backend_EPoll_Type, data);
+	
+	struct epoll_event events[EPOLL_MAX_EVENTS];
+	
+	int count = epoll_wait(data->descriptor, events, EPOLL_MAX_EVENTS, make_timeout(duration));
+	
+	if (count == -1) {
+		rb_sys_fail("epoll_wait");
+	}
+	
+	for (int i = 0; i < count; i += 1) {
+		VALUE fiber = (VALUE)events[i].data.ptr;
+		rb_funcall(fiber, id_transfer, 0);
+	}
+	
+	return INT2NUM(count);
+}
+
+void Init_Event_Backend_EPoll(VALUE Event_Backend) {
+	id_fileno = rb_intern("fileno");
+	id_transfer = rb_intern("transfer");
+	
+	Event_Backend_EPoll = rb_define_class_under(Event_Backend, "EPoll", rb_cObject);
+	
+	rb_define_alloc_func(Event_Backend_EPoll, Event_Backend_EPoll_allocate);
+	rb_define_method(Event_Backend_EPoll, "initialize", Event_Backend_EPoll_initialize, 1);
+	
+	rb_define_method(Event_Backend_EPoll, "io_wait", Event_Backend_EPoll_io_wait, 3);
+	rb_define_method(Event_Backend_EPoll, "select", Event_Backend_EPoll_select, 1);
+}

data/ext/event/backend/epoll.h

@@ -0,0 +1,25 @@
+// 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.
+
+#pragma once
+
+#define EVENT_BACKEND_EPOLL
+
+void Init_Event_Backend_EPoll(VALUE Event_Backend);

data/ext/event/backend/kqueue.c

@@ -0,0 +1,196 @@
+// 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 "kqueue.h"
+
+#include <sys/event.h>
+#include <sys/ioctl.h>
+#include <time.h>
+
+static VALUE Event_Backend_KQueue = Qnil;
+static ID id_fileno, id_transfer;
+
+static const int READABLE = 1, PRIORITY = 2, WRITABLE = 4;
+
+static const unsigned KQUEUE_MAX_EVENTS = 1024;
+
+struct Event_Backend_KQueue {
+	VALUE loop;
+	int descriptor;
+};
+
+void Event_Backend_KQueue_Type_mark(void *_data)
+{
+	struct Event_Backend_KQueue *data = _data;
+	rb_gc_mark(data->loop);
+}
+
+void Event_Backend_KQueue_Type_free(void *_data)
+{
+	struct Event_Backend_KQueue *data = _data;
+	
+	if (data->descriptor >= 0) {
+		close(data->descriptor);
+	}
+	
+	free(data);
+}
+
+size_t Event_Backend_KQueue_Type_size(const void *data)
+{
+	return sizeof(struct Event_Backend_KQueue);
+}
+
+static const rb_data_type_t Event_Backend_KQueue_Type = {
+	.wrap_struct_name = "Event::Backend::KQueue",
+	.function = {
+		.dmark = Event_Backend_KQueue_Type_mark,
+		.dfree = Event_Backend_KQueue_Type_free,
+		.dsize = Event_Backend_KQueue_Type_size,
+	},
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE Event_Backend_KQueue_allocate(VALUE self) {
+	struct Event_Backend_KQueue *data = NULL;
+	VALUE instance = TypedData_Make_Struct(self, struct Event_Backend_KQueue, &Event_Backend_KQueue_Type, data);
+	
+	data->loop = Qnil;
+	data->descriptor = -1;
+	
+	return instance;
+}
+
+VALUE Event_Backend_KQueue_initialize(VALUE self, VALUE loop) {
+	struct Event_Backend_KQueue *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_KQueue, &Event_Backend_KQueue_Type, data);
+	
+	data->loop = loop;
+	int result = kqueue();
+	
+	if (result == -1) {
+		rb_sys_fail("kqueue");
+	} else {
+		ioctl(result, FIOCLEX);
+		data->descriptor = result;
+		
+		rb_update_max_fd(data->descriptor);
+	}
+	
+	return self;
+}
+
+VALUE Event_Backend_KQueue_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE events) {
+	struct Event_Backend_KQueue *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_KQueue, &Event_Backend_KQueue_Type, data);
+	
+	struct kevent event;
+	u_short flags = 0;
+	
+	int descriptor = NUM2INT(rb_funcall(io, id_fileno, 0));
+	
+	int mask = NUM2INT(events);
+	
+	if (mask & READABLE) {
+		flags |= EVFILT_READ;
+	}
+	
+	if (mask & PRIORITY) {
+		flags |= EV_OOBAND;
+	}
+	
+	if (mask & WRITABLE) {
+		flags |= EVFILT_WRITE;
+	}
+
+	EV_SET(&event, descriptor, flags, EV_ADD|EV_ENABLE|EV_ONESHOT, 0, 0, (void*)fiber);
+	
+	// A better approach is to batch all changes:
+	int result = kevent(data->descriptor, &event, 1, NULL, 0, NULL);
+	
+	if (result == -1) {
+		rb_sys_fail("kevent");
+	}
+	
+	rb_funcall(data->loop, id_transfer, 0);
+	
+	return Qnil;
+}
+
+static
+struct timespec * make_timeout(VALUE duration, struct timespec * storage) {
+	if (duration == Qnil) {
+		return NULL;
+	}
+	
+	if (FIXNUM_P(duration)) {
+		storage->tv_sec = NUM2TIMET(duration);
+		storage->tv_nsec = 0;
+		
+		return storage;
+	}
+	
+	else if (RB_FLOAT_TYPE_P(duration)) {
+		double value = RFLOAT_VALUE(duration);
+		time_t seconds = duration;
+		
+		storage->tv_sec = seconds;
+		storage->tv_nsec = (value - seconds) * 1000000000L;
+		
+		return storage;
+	}
+	
+	rb_raise(rb_eRuntimeError, "unable to convert timeout");
+}
+
+VALUE Event_Backend_KQueue_select(VALUE self, VALUE duration) {
+	struct Event_Backend_KQueue *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_KQueue, &Event_Backend_KQueue_Type, data);
+	
+	struct kevent events[KQUEUE_MAX_EVENTS];
+	struct timespec storage;
+	
+	int count = kevent(data->descriptor, NULL, 0, events, KQUEUE_MAX_EVENTS, make_timeout(duration, &storage));
+	
+	if (count == -1) {
+		rb_sys_fail("kevent");
+	}
+	
+	for (int i = 0; i < count; i += 1) {
+		VALUE fiber = (VALUE)events[i].udata;
+		rb_funcall(fiber, id_transfer, 0);
+	}
+	
+	return INT2NUM(count);
+}
+
+void Init_Event_Backend_KQueue(VALUE Event_Backend) {
+	id_fileno = rb_intern("fileno");
+	id_transfer = rb_intern("transfer");
+	
+	Event_Backend_KQueue = rb_define_class_under(Event_Backend, "KQueue", rb_cObject);
+	
+	rb_define_alloc_func(Event_Backend_KQueue, Event_Backend_KQueue_allocate);
+	rb_define_method(Event_Backend_KQueue, "initialize", Event_Backend_KQueue_initialize, 1);
+	
+	rb_define_method(Event_Backend_KQueue, "io_wait", Event_Backend_KQueue_io_wait, 3);
+	rb_define_method(Event_Backend_KQueue, "select", Event_Backend_KQueue_select, 1);
+}

data/ext/event/backend/kqueue.h

@@ -0,0 +1,27 @@
+// 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.
+
+#pragma once
+
+#include <ruby.h>
+
+#define EVENT_BACKEND_KQUEUE
+
+void Init_Event_Backend_KQueue(VALUE Event_Backend);

data/ext/event/backend/uring.c

@@ -0,0 +1,288 @@
+// 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 "uring.h"
+
+#include <liburing.h>
+#include <time.h>
+
+static VALUE Event_Backend_URing = Qnil;
+static ID id_fileno, id_transfer;
+
+static const int READABLE = 1, PRIORITY = 2, WRITABLE = 4;
+
+static const int URING_ENTRIES = 1024;
+static const int URING_MAX_EVENTS = 1024;
+
+struct Event_Backend_URing {
+	VALUE loop;
+	struct io_uring* ring;
+};
+
+void Event_Backend_URing_Type_mark(void *_data)
+{
+	struct Event_Backend_URing *data = _data;
+	rb_gc_mark(data->loop);
+}
+
+void Event_Backend_URing_Type_free(void *_data)
+{
+	struct Event_Backend_URing *data = _data;
+	
+	if (data->ring) {
+		io_uring_queue_exit(data->ring);
+		xfree(data->ring);
+	}
+	
+	free(data);
+}
+
+size_t Event_Backend_URing_Type_size(const void *data)
+{
+	return sizeof(struct Event_Backend_URing);
+}
+
+static const rb_data_type_t Event_Backend_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,
+	},
+	.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);
+	
+	data->loop = Qnil;
+	data->ring = NULL;
+	
+	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);
+	
+	data->loop = loop;
+	data->ring = xmalloc(sizeof(struct io_uring));
+	
+	int result = io_uring_queue_init(URING_ENTRIES, data->ring, 0);
+	
+	if (result == -1) {
+		rb_sys_fail("io_uring_queue_init");
+	}
+	
+	return self;
+}
+
+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);
+	
+	int descriptor = NUM2INT(rb_funcall(io, id_fileno, 0));
+	struct io_uring_sqe *sqe = io_uring_get_sqe(data->ring);
+	
+	int mask = NUM2INT(events);
+	short flags = 0;
+	
+	if (mask & READABLE) {
+		flags |= POLL_IN;
+	}
+	
+	if (mask & PRIORITY) {
+		flags |= POLL_PRI;
+	}
+	
+	if (mask & WRITABLE) {
+		flags |= POLL_OUT;
+	}
+
+	// fprintf(stderr, "poll_add(%p, %d, %d)\n", sqe, descriptor, flags);
+
+	io_uring_prep_poll_add(sqe, descriptor, flags);
+	io_uring_sqe_set_data(sqe, (void*)fiber);
+	io_uring_submit(data->ring);
+	
+	// fprintf(stderr, "count = %d, errno = %d\n", count, errno);
+
+	rb_funcall(data->loop, id_transfer, 0);
+	
+	return Qnil;
+}
+
+static
+struct __kernel_timespec * make_timeout(VALUE duration, struct __kernel_timespec *storage) {
+	if (duration == Qnil) {
+		return NULL;
+	}
+	
+	if (FIXNUM_P(duration)) {
+		storage->tv_sec = NUM2TIMET(duration);
+		storage->tv_nsec = 0;
+		
+		return storage;
+	}
+	
+	else if (RB_FLOAT_TYPE_P(duration)) {
+		double value = RFLOAT_VALUE(duration);
+		time_t seconds = duration;
+		
+		storage->tv_sec = seconds;
+		storage->tv_nsec = (value - seconds) * 1000000000L;
+		
+		return storage;
+	}
+	
+	rb_raise(rb_eRuntimeError, "unable to convert timeout");
+}
+
+inline static
+void resize_to_capacity(VALUE string, size_t offset, size_t length) {
+	size_t current_length = RSTRING_LEN(string);
+	long difference = (long)(offset + length) - (long)current_length;
+
+	difference += 1;
+
+	if (difference > 0) {
+		rb_str_modify_expand(string, difference);
+	} else {
+		rb_str_modify(string);
+	}
+}
+
+inline static
+void resize_to_fit(VALUE string, size_t offset, size_t length) {
+	size_t current_length = RSTRING_LEN(string);
+
+	if (current_length < (offset + length)) {
+		rb_str_set_len(string, offset + length);
+	}
+}
+
+VALUE Event_Backend_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
+	struct Event_Backend_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+
+	resize_to_capacity(buffer, NUM2SIZET(offset), NUM2SIZET(length));
+
+	int descriptor = NUM2INT(rb_funcall(io, id_fileno, 0));
+	struct io_uring_sqe *sqe = io_uring_get_sqe(data->ring);
+
+	struct iovec iovecs[1];
+	iovecs[0].iov_base = RSTRING_PTR(buffer) + NUM2SIZET(offset);
+	iovecs[0].iov_len = NUM2SIZET(length);
+
+	io_uring_prep_readv(sqe, descriptor, iovecs, 1, 0);
+	io_uring_sqe_set_data(sqe, (void*)fiber);
+	io_uring_submit(data->ring);
+	
+	int result = NUM2INT(rb_funcall(data->loop, id_transfer, 0));
+
+	if (result < 0) {
+		rb_syserr_fail(-result, strerror(-result));
+	}
+
+	resize_to_fit(buffer, NUM2SIZET(offset), (size_t)result);
+
+	return INT2NUM(result);
+}
+
+VALUE Event_Backend_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE offset, VALUE length) {
+	struct Event_Backend_URing *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_URing, &Event_Backend_URing_Type, data);
+
+	if ((size_t)RSTRING_LEN(buffer) < NUM2SIZET(offset) + NUM2SIZET(length)) {
+		rb_raise(rb_eRuntimeError, "invalid offset/length exceeds bounds of buffer");
+	}
+
+	int descriptor = NUM2INT(rb_funcall(io, id_fileno, 0));
+	struct io_uring_sqe *sqe = io_uring_get_sqe(data->ring);
+
+	struct iovec iovecs[1];
+	iovecs[0].iov_base = RSTRING_PTR(buffer) + NUM2SIZET(offset);
+	iovecs[0].iov_len = NUM2SIZET(length);
+
+	io_uring_prep_writev(sqe, descriptor, iovecs, 1, 0);
+	io_uring_sqe_set_data(sqe, (void*)fiber);
+	io_uring_submit(data->ring);
+	
+	int result = NUM2INT(rb_funcall(data->loop, id_transfer, 0));
+
+	if (result < 0) {
+		rb_syserr_fail(-result, strerror(-result));
+	}
+
+	return INT2NUM(result);
+}
+
+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);
+	
+	struct io_uring_cqe *cqes[URING_MAX_EVENTS];
+	struct __kernel_timespec storage;
+
+	if (duration != Qnil) {
+		int result = io_uring_wait_cqe_timeout(data->ring, cqes, make_timeout(duration, &storage));
+		
+		if (result == -ETIME) {
+			// Timeout.
+		} else if (result < 0) {
+			rb_syserr_fail(-result, strerror(-result));
+		}
+	}
+	
+	int count = io_uring_peek_batch_cqe(data->ring, cqes, URING_MAX_EVENTS);
+	
+	if (count == -1) {
+		rb_sys_fail("io_uring_peek_batch_cqe");
+	}
+	
+	for (int i = 0; i < count; i += 1) {
+		VALUE fiber = (VALUE)io_uring_cqe_get_data(cqes[i]);
+		VALUE result = INT2NUM(cqes[i]->res);
+
+		io_uring_cqe_seen(data->ring, cqes[i]);
+		
+		rb_funcall(fiber, id_transfer, 1, result);
+	}
+	
+	return INT2NUM(count);
+}
+
+void Init_Event_Backend_URing(VALUE Event_Backend) {
+	id_fileno = rb_intern("fileno");
+	id_transfer = rb_intern("transfer");
+	
+	Event_Backend_URing = rb_define_class_under(Event_Backend, "URing", rb_cObject);
+	
+	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, "io_wait", Event_Backend_URing_io_wait, 3);
+	rb_define_method(Event_Backend_URing, "select", Event_Backend_URing_select, 1);
+
+	rb_define_method(Event_Backend_URing, "io_read", Event_Backend_URing_io_read, 5);
+	rb_define_method(Event_Backend_URing, "io_write", Event_Backend_URing_io_write, 5);
+}

data/ext/event/backend/uring.h

@@ -0,0 +1,27 @@
+// 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.
+
+#pragma once
+
+#include <ruby.h>
+
+#define EVENT_BACKEND_URING
+
+void Init_Event_Backend_URing(VALUE Event_Backend);

data/ext/event/event.c

@@ -0,0 +1,46 @@
+// 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 "event.h"
+
+VALUE Event = Qnil;
+VALUE Event_Backend = Qnil;
+
+void Init_event()
+{
+	#ifdef HAVE_RB_EXT_RACTOR_SAFE
+	rb_ext_ractor_safe(true);
+	#endif
+	
+	Event = rb_define_module("Event");
+	Event_Backend = rb_define_module_under(Event, "Backend");
+	
+	#ifdef EVENT_BACKEND_URING
+	Init_Event_Backend_URing(Event_Backend);
+	#endif
+	
+	#ifdef EVENT_BACKEND_EPOLL
+	Init_Event_Backend_EPoll(Event_Backend);
+	#endif
+	
+	#ifdef EVENT_BACKEND_KQUEUE
+	Init_Event_Backend_KQueue(Event_Backend);
+	#endif
+}

data/ext/event/event.h

@@ -0,0 +1,39 @@
+// 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.
+
+#pragma once
+
+#include <ruby.h>
+
+#include "extconf.h"
+
+void Init_event();
+
+#if HAVE_LIBURING_H
+#include "backend/uring.h"
+#endif
+
+#if HAVE_SYS_EPOLL_H
+#include "backend/epoll.h"
+#endif
+
+#if HAVE_SYS_EVENT_H
+#include "backend/kqueue.h"
+#endif

data/ext/event/extconf.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+# 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.
+
+require 'mkmf'
+
+gem_name = File.basename(__dir__)
+extension_name = 'event'
+
+# The destination
+dir_config(extension_name)
+
+$srcs = ["event.c"]
+$VPATH << "$(srcdir)/backend"
+
+if have_library('uring') and have_header('liburing.h')
+	$srcs << "backend/uring.c"
+end
+
+if have_header('sys/epoll.h')
+	$srcs << "backend/epoll.c"
+end
+
+if have_header('sys/event.h')
+	$srcs << "backend/kqueue.c"
+end
+
+create_header
+
+# Generate the makefile to compile the native binary into `lib`:
+create_makefile(File.join(gem_name, extension_name))

data/lib/event.rb

@@ -18,4 +18,19 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require "event/version"
+require_relative 'event/version'
+require_relative 'event/backend/select'
+
+module Event
+	# These constants are the same as those defined in IO.
+	
+	READABLE = 1
+	PRIORITY = 2
+	WRITABLE = 4
+end
+
+begin
+	require_relative '../ext/event/event'
+rescue LoadError
+	# Ignore.
+end

data/lib/event/backend/select.rb

@@ -18,12 +18,10 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require "event/version"
-
 module Event
 	module Backend
 		class Select
-			def initialize(loop = Fiber.current)
+			def initialize(loop)
 				@loop = loop
 				
 				@readable = {}
@@ -31,11 +29,11 @@ module Event
 			end
 			
 			def io_wait(fiber, io, events)
-				if (events & IO::READABLE) > 0 or (events & IO::PRIORITY) > 0
+				if (events & READABLE) > 0 or (events & PRIORITY) > 0
 					@readable[io] = fiber
 				end
 				
-				if (events & IO::WRITABLE) > 0
+				if (events & WRITABLE) > 0
 					@writable[io] = fiber
 				end
 				
@@ -47,12 +45,12 @@ module Event
 				
 				ready = {}
 				
-				readable.each do |io|
+				readable&.each do |io|
 					fiber = @readable.delete(io)
 					ready[fiber] = true
 				end
 				
-				writable.each do |io|
+				writable&.each do |io|
 					fiber = @writable.delete(io)
 					ready[fiber] = true
 				end

data/lib/event/debug/selector.rb

@@ -0,0 +1,99 @@
+# 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.
+
+require "event/version"
+
+module Event
+	module Debug
+		class Selector
+			def initialize(selector)
+				@selector = selector
+				
+				@readable = {}
+				@writable = {}
+				@priority = {}
+			end
+			
+			def io_wait(fiber, io, events)
+				register_readable(fiber, io, events)
+			end
+			
+			def select(duration = nil)
+				@selector.select(duration)
+			end
+			
+			private
+			
+			def register_readable(fiber, io, events)
+				if (events & READABLE) > 0
+					if @readable.key?(io)
+						raise "Cannot wait for #{io} to become readable from multiple fibers."
+					end
+					
+					begin
+						@readable[io] = fiber
+						
+						register_writable(fiber, io, events)
+					ensure
+						@readable.delete(io)
+					end
+				else
+					register_writable(fiber, io, events)
+				end
+			end
+			
+			def register_writable(fiber, io, events)
+				if (events & WRITABLE) > 0
+					if @writable.key?(io)
+						raise "Cannot wait for #{io} to become writable from multiple fibers."
+					end
+					
+					begin
+						@writable[io] = fiber
+						
+						register_priority(fiber, io, events)
+					ensure
+						@writable.delete(io)
+					end
+				else
+					register_priority(fiber, io, events)
+				end
+			end
+			
+			def register_priority(fiber, io, events)
+				if (events & PRIORITY) > 0
+					if @priority.key?(io)
+						raise "Cannot wait for #{io} to become priority from multiple fibers."
+					end
+					
+					begin
+						@priority[io] = fiber
+						
+						@selector.io_wait(fiber, io, events)
+					ensure
+						@priority.delete(io)
+					end
+				else
+					@selector.io_wait(fiber, io, events)
+				end
+			end
+		end
+	end
+end

data/lib/event/version.rb

@@ -1,3 +1,3 @@
 module Event
-	VERSION = "0.1.1"
+	VERSION = "0.1.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: event
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Samuel Williams
@@ -10,6 +10,20 @@ bindir: bin
 cert_chain: []
 date: 2021-04-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -55,11 +69,22 @@ dependencies:
 description:
 email:
 executables: []
-extensions: []
+extensions:
+- ext/event/extconf.rb
 extra_rdoc_files: []
 files:
+- ext/event/backend/epoll.c
+- ext/event/backend/epoll.h
+- ext/event/backend/kqueue.c
+- ext/event/backend/kqueue.h
+- ext/event/backend/uring.c
+- ext/event/backend/uring.h
+- ext/event/event.c
+- ext/event/event.h
+- ext/event/extconf.rb
 - lib/event.rb
 - lib/event/backend/select.rb
+- lib/event/debug/selector.rb
 - lib/event/selector.rb
 - lib/event/version.rb
 homepage: https://github.com/socketry/event
@@ -81,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: An event loop.