event 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5039784abaf0f999187afbed8ca930bf99cf66cc089136da3b3e42ea6831b729
-  data.tar.gz: 712d0693031af7bd93c1da59e5ad716d8be81a895d1d3ea23dca6cf80e42f5d0
+  metadata.gz: 0e30a246aa5197439b7c1d9511cd158b56b7f4965ef18a5eaee6057832d5bf8f
+  data.tar.gz: d579312da337ed20caf61f0fd6be719874a90b2f43860cc7315244abc59f11e0
 SHA512:
-  metadata.gz: 3de44f33a4410d1cf5b52186ac606d1d03f33326f3124e69b50b705ac8840c2f7facc5924378353b2fce55324cbf353fc407bf60f041e6b0b0990d889eaad7dc
-  data.tar.gz: e34bc430b17351ba2210e89c2d3cec4049eafd3e2e8c3297d777c6dfae6cdc9dc9a823b83bf503c4c1a9e7463f74064d0632f1e641cdac9d5034012f76bf50c9
+  metadata.gz: b183345fc94fd11872fd10b0401f87330b5334a016c43f4ffe6113c8a4c1f43c89a7eaba6319ff1530dd0f5364cb0a47843781abb45c233f4f9e619f837cdb8e
+  data.tar.gz: d702a3aa9ae7792a4d689a9afe23b5c99e93823b59b50de7058b1ff1ffd983b7bba30931b5581397deca8bc11726248c46516e7c933331fdb8c25feaeed7793e

data/ext/event/backend/backend.h

@@ -0,0 +1,29 @@
+// 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.
+
+enum Event {
+	READABLE = 1,
+	PRIORITY = 2,
+	WRITABLE = 4,
+	ERROR = 8,
+	HANGUP = 16
+};
+
+#include <ruby/thread.h>

data/ext/event/backend/epoll.c

@@ -0,0 +1,309 @@
+// 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 "backend.h"
+
+#include <sys/epoll.h>
+#include <time.h>
+#include <errno.h>
+
+static VALUE Event_Backend_EPoll = Qnil;
+static ID id_fileno, id_transfer;
+
+enum {EPOLL_MAX_EVENTS = 64};
+
+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);
+}
+
+static
+void close_internal(struct Event_Backend_EPoll *data) {
+	if (data->descriptor >= 0) {
+		close(data->descriptor);
+		data->descriptor = -1;
+	}
+}
+
+void Event_Backend_EPoll_Type_free(void *_data)
+{
+	struct Event_Backend_EPoll *data = _data;
+	
+	close_internal(data);
+	
+	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_close(VALUE self) {
+	struct Event_Backend_EPoll *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_EPoll, &Event_Backend_EPoll_Type, data);
+	
+	close_internal(data);
+	
+	return Qnil;
+}
+
+static inline
+uint32_t epoll_flags_from_events(int events) {
+	uint32_t flags = 0;
+	
+	if (events & READABLE) flags |= EPOLLIN;
+	if (events & PRIORITY) flags |= EPOLLPRI;
+	if (events & WRITABLE) flags |= EPOLLOUT;
+	
+	flags |= EPOLLRDHUP;
+	flags |= EPOLLONESHOT;
+	
+	return flags;
+}
+
+static inline
+int events_from_epoll_flags(uint32_t flags) {
+	int events = 0;
+	
+	if (flags & EPOLLIN) events |= READABLE;
+	if (flags & EPOLLPRI) events |= PRIORITY;
+	if (flags & EPOLLOUT) events |= WRITABLE;
+	
+	return events;
+}
+
+struct io_wait_arguments {
+	struct Event_Backend_EPoll *data;
+	int descriptor;
+	int duplicate;
+};
+
+static
+VALUE io_wait_ensure(VALUE _arguments) {
+	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
+	
+	if (arguments->duplicate >= 0) {
+		epoll_ctl(arguments->data->descriptor, EPOLL_CTL_DEL, arguments->duplicate, NULL);
+		
+		close(arguments->duplicate);
+	} else {
+		epoll_ctl(arguments->data->descriptor, EPOLL_CTL_DEL, arguments->descriptor, NULL);
+	}
+	
+	return Qnil;
+};
+
+static
+VALUE io_wait_transfer(VALUE _arguments) {
+	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
+	
+	VALUE result = rb_funcall(arguments->data->loop, id_transfer, 0);
+	
+	return INT2NUM(events_from_epoll_flags(NUM2INT(result)));
+};
+
+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;
+	
+	event.events = epoll_flags_from_events(NUM2INT(events));
+	event.data.ptr = (void*)fiber;
+	
+	// fprintf(stderr, "<- fiber=%p descriptor=%d\n", (void*)fiber, descriptor);
+	
+	// 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");
+	}
+	
+	struct io_wait_arguments io_wait_arguments = {
+		.data = data,
+		.descriptor = descriptor,
+		.duplicate = duplicate
+	};
+	
+	return rb_ensure(io_wait_transfer, (VALUE)&io_wait_arguments, io_wait_ensure, (VALUE)&io_wait_arguments);
+}
+
+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");
+}
+
+struct select_arguments {
+	struct Event_Backend_EPoll *data;
+	
+	int count;
+	struct epoll_event events[EPOLL_MAX_EVENTS];
+	
+	int timeout;
+};
+
+static
+void * select_internal(void *_arguments) {
+	struct select_arguments * arguments = (struct select_arguments *)_arguments;
+	
+	arguments->count = epoll_wait(arguments->data->descriptor, arguments->events, EPOLL_MAX_EVENTS, arguments->timeout);
+	
+	return NULL;
+}
+
+static
+void select_internal_without_gvl(struct select_arguments *arguments) {
+	rb_thread_call_without_gvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+	
+	if (arguments->count == -1) {
+		rb_sys_fail("select_internal_without_gvl:epoll_wait");
+	}
+}
+
+static
+void select_internal_with_gvl(struct select_arguments *arguments) {
+	select_internal((void *)arguments);
+	
+	if (arguments->count == -1) {
+		rb_sys_fail("select_internal_with_gvl:epoll_wait");
+	}
+}
+
+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 select_arguments arguments = {
+		.data = data,
+		.timeout = 0
+	};
+	
+	select_internal_without_gvl(&arguments);
+	
+	if (arguments.count == 0) {
+		arguments.timeout = make_timeout(duration);
+		
+		if (arguments.timeout != 0) {
+			select_internal_with_gvl(&arguments);
+		}
+	}
+	
+	for (int i = 0; i < arguments.count; i += 1) {
+		VALUE fiber = (VALUE)arguments.events[i].data.ptr;
+		VALUE result = INT2NUM(arguments.events[i].events);
+		
+		// fprintf(stderr, "-> fiber=%p descriptor=%d\n", (void*)fiber, events[i].data.fd);
+		
+		rb_funcall(fiber, id_transfer, 1, result);
+	}
+	
+	return INT2NUM(arguments.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, "close", Event_Backend_EPoll_close, 0);
+	
+	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,346 @@
+// 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 "backend.h"
+
+#include <sys/event.h>
+#include <sys/ioctl.h>
+#include <time.h>
+
+static VALUE Event_Backend_KQueue = Qnil;
+static ID id_fileno, id_transfer;
+
+enum {KQUEUE_MAX_EVENTS = 64};
+
+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);
+}
+
+static
+void close_internal(struct Event_Backend_KQueue *data) {
+	if (data->descriptor >= 0) {
+		close(data->descriptor);
+		data->descriptor = -1;
+	}
+}
+
+void Event_Backend_KQueue_Type_free(void *_data)
+{
+	struct Event_Backend_KQueue *data = _data;
+	
+	close_internal(data);
+	
+	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_close(VALUE self) {
+	struct Event_Backend_KQueue *data = NULL;
+	TypedData_Get_Struct(self, struct Event_Backend_KQueue, &Event_Backend_KQueue_Type, data);
+	
+	close_internal(data);
+	
+	return Qnil;
+}
+
+static
+int io_add_filters(int descriptor, int ident, int events, VALUE fiber) {
+	int count = 0;
+	struct kevent kevents[2] = {0};
+	
+	if (events & READABLE) {
+		kevents[count].ident = ident;
+		kevents[count].filter = EVFILT_READ;
+		kevents[count].flags = EV_ADD | EV_ENABLE | EV_ONESHOT;
+		kevents[count].udata = (void*)fiber;
+		
+// #ifdef EV_OOBAND
+// 		if (events & PRIORITY) {
+// 			kevents[count].flags |= EV_OOBAND;
+// 		}
+// #endif
+		
+		count++;
+	}
+	
+	if (events & WRITABLE) {
+		kevents[count].ident = ident;
+		kevents[count].filter = EVFILT_WRITE;
+		kevents[count].flags = EV_ADD | EV_ENABLE | EV_ONESHOT;
+		kevents[count].udata = (void*)fiber;
+		count++;
+	}
+	
+	int result = kevent(descriptor, kevents, count, NULL, 0, NULL);
+	
+	if (result == -1) {
+		rb_sys_fail("kevent(register)");
+	}
+	
+	return events;
+}
+
+static
+void io_remove_filters(int descriptor, int ident, int events) {
+	int count = 0;
+	struct kevent kevents[2] = {0};
+	
+	if (events & READABLE) {
+		kevents[count].ident = ident;
+		kevents[count].filter = EVFILT_READ;
+		kevents[count].flags = EV_DELETE;
+		
+		count++;
+	}
+	
+	if (events & WRITABLE) {
+		kevents[count].ident = ident;
+		kevents[count].filter = EVFILT_WRITE;
+		kevents[count].flags = EV_DELETE;
+		count++;
+	}
+	
+	// Ignore the result.
+	kevent(descriptor, kevents, count, NULL, 0, NULL);
+}
+
+struct io_wait_arguments {
+	struct Event_Backend_KQueue *data;
+	int events;
+	int descriptor;
+};
+
+static
+VALUE io_wait_rescue(VALUE _arguments, VALUE exception) {
+	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
+	
+	io_remove_filters(arguments->data->descriptor, arguments->descriptor, arguments->events);
+	
+	rb_exc_raise(exception);
+};
+
+static inline
+int events_from_kqueue_filter(int filter) {
+	if (filter == EVFILT_READ) return READABLE;
+	if (filter == EVFILT_WRITE) return WRITABLE;
+	
+	return 0;
+}
+
+static
+VALUE io_wait_transfer(VALUE _arguments) {
+	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
+	
+	VALUE result = rb_funcall(arguments->data->loop, id_transfer, 0);
+	
+	return INT2NUM(events_from_kqueue_filter(NUM2INT(result)));
+};
+
+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);
+	
+	int descriptor = NUM2INT(rb_funcall(io, id_fileno, 0));
+	
+	struct io_wait_arguments io_wait_arguments = {
+		.events = io_add_filters(data->descriptor, descriptor, NUM2INT(events), fiber),
+		.data = data,
+		.descriptor = descriptor,
+	};
+	
+	return rb_rescue(io_wait_transfer, (VALUE)&io_wait_arguments, io_wait_rescue, (VALUE)&io_wait_arguments);
+}
+
+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 = value;
+		
+		storage->tv_sec = seconds;
+		storage->tv_nsec = (value - seconds) * 1000000000L;
+		
+		return storage;
+	}
+	
+	rb_raise(rb_eRuntimeError, "unable to convert timeout");
+}
+
+static
+int timeout_nonblocking(struct timespec * timespec) {
+	return timespec && timespec->tv_sec == 0 && timespec->tv_nsec == 0;
+}
+
+struct select_arguments {
+	struct Event_Backend_KQueue *data;
+	
+	int count;
+	struct kevent events[KQUEUE_MAX_EVENTS];
+	
+	struct timespec storage;
+	struct timespec *timeout;
+};
+
+static
+void * select_internal(void *_arguments) {
+	struct select_arguments * arguments = (struct select_arguments *)_arguments;
+	
+	arguments->count = kevent(arguments->data->descriptor, NULL, 0, arguments->events, arguments->count, arguments->timeout);
+	
+	return NULL;
+}
+
+static
+void select_internal_without_gvl(struct select_arguments *arguments) {
+	rb_thread_call_without_gvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+	
+	if (arguments->count == -1) {
+		rb_sys_fail("select_internal_without_gvl:kevent");
+	}
+}
+
+static
+void select_internal_with_gvl(struct select_arguments *arguments) {
+	select_internal((void *)arguments);
+	
+	if (arguments->count == -1) {
+		rb_sys_fail("select_internal_with_gvl:kevent");
+	}
+}
+
+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 select_arguments arguments = {
+		.data = data,
+		.count = KQUEUE_MAX_EVENTS,
+		.storage = {
+			.tv_sec = 0,
+			.tv_nsec = 0
+		}
+	};
+	
+	// We break this implementation into two parts.
+	// (1) count = kevent(..., timeout = 0)
+	// (2) without gvl: kevent(..., timeout = 0) if count == 0 and timeout != 0
+	// This allows us to avoid releasing and reacquiring the GVL.
+	// Non-comprehensive testing shows this gives a 1.5x speedup.
+	arguments.timeout = &arguments.storage;
+	
+	// First do the syscall with no timeout to get any immediately available events:
+	select_internal_with_gvl(&arguments);
+	
+	// If there were no pending events, if we have a timeout, wait for more events:
+	if (arguments.count == 0) {
+		arguments.timeout = make_timeout(duration, &arguments.storage);
+		
+		if (!timeout_nonblocking(arguments.timeout)) {
+			arguments.count = KQUEUE_MAX_EVENTS;
+			
+			select_internal_without_gvl(&arguments);
+		}
+	}
+	
+	for (int i = 0; i < arguments.count; i += 1) {
+		VALUE fiber = (VALUE)arguments.events[i].udata;
+		VALUE result = INT2NUM(arguments.events[i].filter);
+		rb_funcall(fiber, id_transfer, 1, result);
+	}
+	
+	return INT2NUM(arguments.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, "initialize", Event_Backend_KQueue_close, 0);
+	
+	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);
+}