io-event 1.3.1 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de2b826a00b27006568dad0139dd9d695ce8708882607fd1e1e4c4eda7d727cd
-  data.tar.gz: 3c34946c623e2c03d31c05f7e62283b005d8e8c8d1a6dd78d80a9cf847e7231c
+  metadata.gz: 3362ef0fb1bd825601c2476c06e99d32aa911a4e66b189b1518f40b6246b1ab6
+  data.tar.gz: a41015ab836dd0e28656427001882a87ba26a424395babb81aecd0e6d07d5fdd
 SHA512:
-  metadata.gz: e2f752ea2f36c3cb848b3db0a8f2db62d27cd7a97f1dc1c245a8a094e8bd44368a4bc9bfcef3091d6473d02f2027423ddbdb9adcf9073d1103404408860ae411
-  data.tar.gz: bab17c94312eedabf98144e2363a37e0e9356e264f51108dcde0e0a188249eaa543ba164fe330a7fa3332b623418fe8cd5d3190774e723794b9d0fc121688f26
+  metadata.gz: e1563b616697985daed4bb585bfdeaec00f6dfbaa9f377e99b278a9070f5ee32b475136e0f8f7626e4238a0d623a0bdb745ef03a612ec0de4b7f2eb9ef2f4510
+  data.tar.gz: d061bea14bd722ae77eddc68e81d0c4138a5de1b1b12e6fce22a45bc62391c7bf3d9dd25cf0f876361309b04d9e480a06c9752128103c999a504d01e6ffb78d3

data/ext/io/event/selector/epoll.c

@@ -446,6 +446,7 @@ struct process_wait_arguments {
 	struct IO_Event_Selector_EPoll *selector;
 	struct IO_Event_Selector_EPoll_Waiting *waiting;
 	int pid;
+	int flags;
 	int descriptor;
 };
 
@@ -456,7 +457,7 @@ VALUE process_wait_transfer(VALUE _arguments) {
 	IO_Event_Selector_fiber_transfer(arguments->selector->backend.loop, 0, NULL);
 	
 	if (arguments->waiting->ready) {
-		return IO_Event_Selector_process_status_wait(arguments->pid);
+		return IO_Event_Selector_process_status_wait(arguments->pid, arguments->flags);
 	} else {
 		return Qfalse;
 	}
@@ -480,7 +481,7 @@ VALUE IO_Event_Selector_EPoll_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	TypedData_Get_Struct(self, struct IO_Event_Selector_EPoll, &IO_Event_Selector_EPoll_Type, selector);
 	
 	pid_t pid = NUM2PIDT(_pid);
-	// int flags = NUM2INT(_flags);
+	int flags = NUM2INT(_flags);
 	
 	int descriptor = pidfd_open(pid, 0);
 	
@@ -506,6 +507,7 @@ VALUE IO_Event_Selector_EPoll_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	struct process_wait_arguments process_wait_arguments = {
 		.selector = selector,
 		.pid = pid,
+		.flags = flags,
 		.descriptor = descriptor,
 		.waiting = &waiting,
 	};
@@ -802,9 +804,11 @@ struct select_arguments {
 	
 	int count;
 	struct epoll_event events[EPOLL_MAX_EVENTS];
-
+	
 	struct timespec * timeout;
 	struct timespec storage;
+	
+	struct IO_Event_List saved;
 };
 
 static int make_timeout_ms(struct timespec * timeout) {
@@ -881,7 +885,7 @@ void select_internal_with_gvl(struct select_arguments *arguments) {
 }
 
 static
-int IO_Event_Selector_EPoll_handle(struct IO_Event_Selector_EPoll *selector, const struct epoll_event *event)
+int IO_Event_Selector_EPoll_handle(struct IO_Event_Selector_EPoll *selector, const struct epoll_event *event, struct IO_Event_List *saved)
 {
 	int descriptor = event->data.fd;
 	
@@ -891,29 +895,32 @@ int IO_Event_Selector_EPoll_handle(struct IO_Event_Selector_EPoll *selector, con
 	struct IO_Event_Selector_EPoll_Descriptor *epoll_descriptor = IO_Event_Selector_EPoll_Descriptor_lookup(selector, descriptor);
 	struct IO_Event_List *list = &epoll_descriptor->list;
 	struct IO_Event_List *node = list->tail;
-	struct IO_Event_List saved = {NULL, NULL};
 	
 	// Reset the events back to 0 so that we can re-arm if necessary:
 	epoll_descriptor->waiting_events = 0;
 	
+	if (DEBUG) fprintf(stderr, "IO_Event_Selector_EPoll_handle: descriptor=%d, ready_events=%d epoll_descriptor=%p\n", descriptor, ready_events, epoll_descriptor);
+	
 	// It's possible (but unlikely) that the address of list will changing during iteration.
 	while (node != list) {
+		if (DEBUG) fprintf(stderr, "IO_Event_Selector_EPoll_handle: node=%p list=%p type=%p\n", node, list, node->type);
+		
 		struct IO_Event_Selector_EPoll_Waiting *waiting = (struct IO_Event_Selector_EPoll_Waiting *)node;
 		
 		// Compute the intersection of the events we are waiting for and the events that occured:
 		enum IO_Event matching_events = waiting->events & ready_events;
 		
-		if (DEBUG) fprintf(stderr, "IO_Event_Selector_EPoll_handle: descriptor=%d, ready_events=%d, matching_events=%d\n", descriptor, ready_events, matching_events);
+		if (DEBUG) fprintf(stderr, "IO_Event_Selector_EPoll_handle: descriptor=%d, ready_events=%d, waiting_events=%d, matching_events=%d\n", descriptor, ready_events, waiting->events, matching_events);
 		
 		if (matching_events) {
-			IO_Event_List_append(node, &saved);
+			IO_Event_List_append(node, saved);
 			
 			// Resume the fiber:
 			waiting->ready = matching_events;
 			IO_Event_Selector_fiber_transfer(waiting->fiber, 0, NULL);
 			
-			node = saved.tail;
-			IO_Event_List_pop(&saved);
+			node = saved->tail;
+			IO_Event_List_pop(saved);
 		} else {
 			// We are still waiting for the events:
 			epoll_descriptor->waiting_events |= waiting->events;
@@ -924,6 +931,36 @@ int IO_Event_Selector_EPoll_handle(struct IO_Event_Selector_EPoll *selector, con
 	return IO_Event_Selector_EPoll_Descriptor_update(selector, epoll_descriptor->io, descriptor, epoll_descriptor);
 }
 
+static
+VALUE select_handle_events(VALUE _arguments)
+{
+	struct select_arguments *arguments = (struct select_arguments *)_arguments;
+	struct IO_Event_Selector_EPoll *selector = arguments->selector;
+	
+	for (int i = 0; i < arguments->count; i += 1) {
+		const struct epoll_event *event = &arguments->events[i];
+		if (DEBUG) fprintf(stderr, "-> fd=%d events=%d\n", event->data.fd, event->events);
+		
+		if (event->data.fd >= 0) {
+			IO_Event_Selector_EPoll_handle(selector, event, &arguments->saved);
+		} else {
+			IO_Event_Interrupt_clear(&selector->interrupt);
+		}
+	}
+	
+	return INT2NUM(arguments->count);
+}
+
+static
+VALUE select_handle_events_ensure(VALUE _arguments)
+{
+	struct select_arguments *arguments = (struct select_arguments *)_arguments;
+	
+	IO_Event_List_free(&arguments->saved);
+	
+	return Qnil;
+}
+
 // TODO This function is not re-entrant and we should document and assert as such.
 VALUE IO_Event_Selector_EPoll_select(VALUE self, VALUE duration) {
 	struct IO_Event_Selector_EPoll *selector = NULL;
@@ -937,6 +974,7 @@ VALUE IO_Event_Selector_EPoll_select(VALUE self, VALUE duration) {
 			.tv_sec = 0,
 			.tv_nsec = 0
 		},
+		.saved = {},
 	};
 
 	arguments.timeout = &arguments.storage;
@@ -958,18 +996,11 @@ VALUE IO_Event_Selector_EPoll_select(VALUE self, VALUE duration) {
 		}
 	}
 	
-	for (int i = 0; i < arguments.count; i += 1) {
-		const struct epoll_event *event = &arguments.events[i];
-		if (DEBUG) fprintf(stderr, "-> ptr=%p events=%d\n", event->data.ptr, event->events);
-		
-		if (event->data.fd >= 0) {
-			IO_Event_Selector_EPoll_handle(selector, event);
-		} else {
-			IO_Event_Interrupt_clear(&selector->interrupt);
-		}
+	if (arguments.count) {
+		return rb_ensure(select_handle_events, (VALUE)&arguments, select_handle_events_ensure, (VALUE)&arguments);
+	} else {
+		return RB_INT2NUM(0);
 	}
-	
-	return INT2NUM(arguments.count);
 }
 
 VALUE IO_Event_Selector_EPoll_wakeup(VALUE self) {

data/ext/io/event/selector/kqueue.c

@@ -433,6 +433,7 @@ struct process_wait_arguments {
 	struct IO_Event_Selector_KQueue *selector;
 	struct IO_Event_Selector_KQueue_Waiting *waiting;
 	pid_t pid;
+	int flags;
 };
 
 static
@@ -461,7 +462,7 @@ VALUE process_wait_transfer(VALUE _arguments) {
 	
 	if (arguments->waiting->ready) {
 		process_prewait(arguments->pid);
-		return IO_Event_Selector_process_status_wait(arguments->pid);
+		return IO_Event_Selector_process_status_wait(arguments->pid, arguments->flags);
 	} else {
 		return Qfalse;
 	}
@@ -483,6 +484,7 @@ VALUE IO_Event_Selector_KQueue_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
 	pid_t pid = NUM2PIDT(_pid);
+	int flags = NUM2INT(_flags);
 	
 	struct IO_Event_Selector_KQueue_Waiting waiting = {
 		.list = {.type = &IO_Event_Selector_KQueue_process_wait_list_type},
@@ -494,6 +496,7 @@ VALUE IO_Event_Selector_KQueue_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 		.selector = selector,
 		.waiting = &waiting,
 		.pid = pid,
+		.flags = flags,
 	};
 	
 	int result = IO_Event_Selector_KQueue_Waiting_register(selector, pid, &waiting);
@@ -502,7 +505,7 @@ VALUE IO_Event_Selector_KQueue_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 		if (errno == ESRCH) {
 			process_prewait(pid);
 			
-			return IO_Event_Selector_process_status_wait(pid);
+			return IO_Event_Selector_process_status_wait(pid, flags);
 		}
 		
 		rb_sys_fail("IO_Event_Selector_KQueue_process_wait:IO_Event_Selector_KQueue_Waiting_register");
@@ -818,6 +821,8 @@ struct select_arguments {
 	
 	struct timespec storage;
 	struct timespec *timeout;
+	
+	struct IO_Event_List saved;
 };
 
 static
@@ -859,7 +864,7 @@ void select_internal_with_gvl(struct select_arguments *arguments) {
 }
 
 static
-int IO_Event_Selector_KQueue_handle(struct IO_Event_Selector_KQueue *selector, uintptr_t identifier, struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor)
+int IO_Event_Selector_KQueue_handle(struct IO_Event_Selector_KQueue *selector, uintptr_t identifier, struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor, struct IO_Event_List *saved)
 {
 	// This is the mask of all events that occured for the given descriptor:
 	enum IO_Event ready_events = kqueue_descriptor->ready_events;
@@ -874,7 +879,6 @@ int IO_Event_Selector_KQueue_handle(struct IO_Event_Selector_KQueue *selector, u
 	
 	struct IO_Event_List *list = &kqueue_descriptor->list;
 	struct IO_Event_List *node = list->tail;
-	struct IO_Event_List saved = {NULL, NULL};
 	
 	// Reset the events back to 0 so that we can re-arm if necessary:
 	kqueue_descriptor->waiting_events = 0;
@@ -888,13 +892,13 @@ int IO_Event_Selector_KQueue_handle(struct IO_Event_Selector_KQueue *selector, u
 		if (DEBUG) fprintf(stderr, "IO_Event_Selector_KQueue_handle: identifier=%lu, ready_events=%d, matching_events=%d\n", identifier, ready_events, matching_events);
 		
 		if (matching_events) {
-			IO_Event_List_append(node, &saved);
+			IO_Event_List_append(node, saved);
 			
 			waiting->ready = matching_events;
 			IO_Event_Selector_fiber_transfer(waiting->fiber, 0, NULL);
 			
-			node = saved.tail;
-			IO_Event_List_pop(&saved);
+			node = saved->tail;
+			IO_Event_List_pop(saved);
 		} else {
 			kqueue_descriptor->waiting_events |= waiting->events;
 			node = node->tail;
@@ -904,6 +908,43 @@ int IO_Event_Selector_KQueue_handle(struct IO_Event_Selector_KQueue *selector, u
 	return IO_Event_Selector_KQueue_Descriptor_update(selector, identifier, kqueue_descriptor);
 }
 
+static
+VALUE select_handle_events(VALUE _arguments)
+{
+	struct select_arguments *arguments = (struct select_arguments *)_arguments;
+	struct IO_Event_Selector_KQueue *selector = arguments->selector;
+	
+	for (int i = 0; i < arguments->count; i += 1) {
+		if (arguments->events[i].udata) {
+			struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = arguments->events[i].udata;
+			kqueue_descriptor->ready_events |= events_from_kevent_filter(arguments->events[i].filter);
+		}
+	}
+	
+	for (int i = 0; i < arguments->count; i += 1) {
+		if (arguments->events[i].udata) {
+			struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = arguments->events[i].udata;
+			IO_Event_Selector_KQueue_handle(selector, arguments->events[i].ident, kqueue_descriptor, &arguments->saved);
+		} else {
+#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+			IO_Event_Interrupt_clear(&selector->interrupt);
+#endif
+		}
+	}
+	
+	return RB_INT2NUM(arguments->count);
+}
+
+static
+VALUE select_handle_events_ensure(VALUE _arguments)
+{
+	struct select_arguments *arguments = (struct select_arguments *)_arguments;
+	
+	IO_Event_List_free(&arguments->saved);
+	
+	return Qnil;
+}
+
 VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 	struct IO_Event_Selector_KQueue *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
@@ -916,7 +957,8 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 		.storage = {
 			.tv_sec = 0,
 			.tv_nsec = 0
-		}
+		},
+		.saved = {},
 	};
 	
 	arguments.timeout = &arguments.storage;
@@ -948,25 +990,11 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 		}
 	}
 	
-	for (int i = 0; i < arguments.count; i += 1) {
-		if (arguments.events[i].udata) {
-			struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = arguments.events[i].udata;
-			kqueue_descriptor->ready_events |= events_from_kevent_filter(arguments.events[i].filter);
-		}
-	}
-	
-	for (int i = 0; i < arguments.count; i += 1) {
-		if (arguments.events[i].udata) {
-			struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = arguments.events[i].udata;
-			IO_Event_Selector_KQueue_handle(selector, arguments.events[i].ident, kqueue_descriptor);
-		} else {
-#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
-			IO_Event_Interrupt_clear(&selector->interrupt);
-#endif
-		}
+	if (arguments.count) {
+		return rb_ensure(select_handle_events, (VALUE)&arguments, select_handle_events_ensure, (VALUE)&arguments);
+	} else {
+		return RB_INT2NUM(0);
 	}
-	
-	return RB_INT2NUM(arguments.count);
 }
 
 VALUE IO_Event_Selector_KQueue_wakeup(VALUE self) {

data/ext/io/event/selector/list.h

@@ -21,6 +21,7 @@ inline static void IO_Event_List_initialize(struct IO_Event_List *list)
 inline static void IO_Event_List_clear(struct IO_Event_List *list)
 {
 	list->head = list->tail = NULL;
+	list->type = 0;
 }
 
 // Append an item to the end of the list.
@@ -64,7 +65,7 @@ inline static void IO_Event_List_pop(struct IO_Event_List *node)
 
 inline static void IO_Event_List_free(struct IO_Event_List *node)
 {
-	if (node->head != node->tail) {
+	if (node->head && node->tail) {
 		IO_Event_List_pop(node);
 	}
 }

data/ext/io/event/selector/selector.c

@@ -25,10 +25,6 @@ static const int DEBUG = 0;
 
 static ID id_transfer, id_alive_p;
 
-#ifndef HAVE_RB_PROCESS_STATUS_WAIT
-static VALUE process_wnohang;
-#endif
-
 VALUE IO_Event_Selector_fiber_transfer(VALUE fiber, int argc, VALUE *argv) {
 	// TODO Consider introducing something like `rb_fiber_scheduler_transfer(...)`.
 #ifdef HAVE__RB_FIBER_TRANSFER
@@ -76,9 +72,9 @@ int IO_Event_Selector_io_descriptor(VALUE io) {
 static ID id_wait;
 static VALUE rb_Process_Status = Qnil;
 
-VALUE IO_Event_Selector_process_status_wait(rb_pid_t pid)
+VALUE IO_Event_Selector_process_status_wait(rb_pid_t pid, int flags)
 {
-	return rb_funcall(rb_Process_Status, id_wait, 2, PIDT2NUM(pid), process_wnohang);
+	return rb_funcall(rb_Process_Status, id_wait, 2, PIDT2NUM(pid), INT2NUM(flags | WNOHANG));
 }
 #endif
 
@@ -157,7 +153,6 @@ void Init_IO_Event_Selector(VALUE IO_Event_Selector) {
 	
 #ifndef HAVE_RB_PROCESS_STATUS_WAIT
 	id_wait = rb_intern("wait");
-	process_wnohang = rb_const_get(rb_mProcess, rb_intern("WNOHANG"));
 	rb_Process_Status = rb_const_get_at(rb_mProcess, rb_intern("Status"));
 	rb_gc_register_mark_object(rb_Process_Status);
 #endif

data/ext/io/event/selector/selector.h

@@ -66,10 +66,11 @@ VALUE IO_Event_Selector_fiber_raise(VALUE fiber, int argc, VALUE *argv);
 int IO_Event_Selector_io_descriptor(VALUE io);
 #endif
 
+// Reap a process without hanging.
 #ifdef HAVE_RB_PROCESS_STATUS_WAIT
-#define IO_Event_Selector_process_status_wait(pid) rb_process_status_wait(pid)
+#define IO_Event_Selector_process_status_wait(pid, flags) rb_process_status_wait(pid, flags | WNOHANG)
 #else
-VALUE IO_Event_Selector_process_status_wait(rb_pid_t pid);
+VALUE IO_Event_Selector_process_status_wait(rb_pid_t pid, int flags);
 #endif
 
 int IO_Event_Selector_nonblock_set(int file_descriptor);

data/ext/io/event/selector/uring.c

@@ -326,6 +326,32 @@ VALUE IO_Event_Selector_URing_ready_p(VALUE self) {
 
 #pragma mark - Submission Queue
 
+static
+void IO_Event_Selector_URing_dump_completion_queue(struct IO_Event_Selector_URing *selector)
+{
+	struct io_uring *ring = &selector->ring;
+	unsigned head;
+	struct io_uring_cqe *cqe;
+	
+	if (DEBUG) {
+		int first = 1;
+		io_uring_for_each_cqe(ring, head, cqe) {
+			if (!first) {
+				fprintf(stderr, ", ");
+			}
+			else {
+				fprintf(stderr, "CQ: [");
+				first = 0;
+			}
+			
+			fprintf(stderr, "%d:%p", (int)cqe->res, (void*)cqe->user_data);
+		}
+		if (!first) {
+			fprintf(stderr, "]\n");
+		}
+	}
+}
+
 // Flush the submission queue if pending operations are present.
 static
 int io_uring_submit_flush(struct IO_Event_Selector_URing *selector) {
@@ -345,19 +371,24 @@ int io_uring_submit_flush(struct IO_Event_Selector_URing *selector) {
 		return result;
 	}
 	
+	if (DEBUG) {
+		IO_Event_Selector_URing_dump_completion_queue(selector);
+	}
+	
 	return 0;
 }
 
 // Immediately flush the submission queue, yielding to the event loop if it was not successful.
 static
 int io_uring_submit_now(struct IO_Event_Selector_URing *selector) {
-	if (DEBUG && selector->pending) fprintf(stderr, "io_uring_submit_now(pending=%ld)\n", selector->pending);
-
+	if (DEBUG) fprintf(stderr, "io_uring_submit_now(pending=%ld)\n", selector->pending);
+	
 	while (true) {
 		int result = io_uring_submit(&selector->ring);
 		
 		if (result >= 0) {
 			selector->pending = 0;
+			if (DEBUG) IO_Event_Selector_URing_dump_completion_queue(selector);
 			return result;
 		}
 		
@@ -369,12 +400,6 @@ int io_uring_submit_now(struct IO_Event_Selector_URing *selector) {
 	}
 }
 
-static
-void IO_Event_Selector_URing_submit_sqe(struct io_uring_sqe *sqe)
-{
-	if (DEBUG) fprintf(stderr, "IO_Event_Selector_URing_submit_sqe(%p): user_data=%p opcode=%d\n", sqe, (void*)sqe->user_data, sqe->opcode);
-}
-
 // Submit a pending operation. This does not submit the operation immediately, but instead defers it to the next call to `io_uring_submit_flush` or `io_uring_submit_now`. This is useful for operations that are not urgent, but should be used with care as it can lead to a deadlock if the submission queue is not flushed.
 static
 void io_uring_submit_pending(struct IO_Event_Selector_URing *selector) {
@@ -403,6 +428,7 @@ struct process_wait_arguments {
 	struct IO_Event_Selector_URing_Waiting *waiting;
 	
 	pid_t pid;
+	int flags;
 	int descriptor;
 };
 
@@ -413,7 +439,7 @@ VALUE process_wait_transfer(VALUE _arguments) {
 	IO_Event_Selector_fiber_transfer(arguments->selector->backend.loop, 0, NULL);
 	
 	if (arguments->waiting->result) {
-		return IO_Event_Selector_process_status_wait(arguments->pid);
+		return IO_Event_Selector_process_status_wait(arguments->pid, arguments->flags);
 	} else {
 		return Qfalse;
 	}
@@ -435,6 +461,7 @@ VALUE IO_Event_Selector_URing_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
 	pid_t pid = NUM2PIDT(_pid);
+	int flags = NUM2INT(_flags);
 	
 	int descriptor = pidfd_open(pid, 0);
 	if (descriptor < 0) {
@@ -452,15 +479,14 @@ VALUE IO_Event_Selector_URing_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 		.selector = selector,
 		.waiting = &waiting,
 		.pid = pid,
+		.flags = flags,
 		.descriptor = descriptor,
 	};
 	
-	struct io_uring_sqe *sqe = io_get_sqe(selector);
-	
 	if (DEBUG) fprintf(stderr, "IO_Event_Selector_URing_process_wait:io_uring_prep_poll_add(%p)\n", (void*)fiber);
+	struct io_uring_sqe *sqe = io_get_sqe(selector);
 	io_uring_prep_poll_add(sqe, descriptor, POLLIN|POLLHUP|POLLERR);
 	io_uring_sqe_set_data(sqe, completion);
-	IO_Event_Selector_URing_submit_sqe(sqe);
 	io_uring_submit_pending(selector);
 	
 	return rb_ensure(process_wait_transfer, (VALUE)&process_wait_arguments, process_wait_ensure, (VALUE)&process_wait_arguments);
@@ -504,14 +530,12 @@ static
 VALUE io_wait_ensure(VALUE _arguments) {
 	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
 	
-	if (DEBUG) fprintf(stderr, "io_wait_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
-	
 	// If the operation is still in progress, cancel it:
 	if (arguments->waiting->completion) {
+		if (DEBUG) fprintf(stderr, "io_wait_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
 		struct io_uring_sqe *sqe = io_get_sqe(arguments->selector);
 		io_uring_prep_cancel(sqe, (void*)arguments->waiting->completion, 0);
 		io_uring_sqe_set_data(sqe, NULL);
-		IO_Event_Selector_URing_submit_sqe(sqe);
 		io_uring_submit_now(arguments->selector);
 	}
 	
@@ -543,23 +567,20 @@ VALUE IO_Event_Selector_URing_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE e
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
 	int descriptor = IO_Event_Selector_io_descriptor(io);
-	struct io_uring_sqe *sqe = io_get_sqe(selector);
 	
 	short flags = poll_flags_from_events(NUM2INT(events));
 	
 	if (DEBUG) fprintf(stderr, "IO_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);
-	
 	struct IO_Event_Selector_URing_Waiting waiting = {
 		.fiber = fiber,
 	};
 	
 	struct IO_Event_Selector_URing_Completion *completion = IO_Event_Selector_URing_Completion_acquire(selector, &waiting);
 	
+	struct io_uring_sqe *sqe = io_get_sqe(selector);
+	io_uring_prep_poll_add(sqe, descriptor, flags);
 	io_uring_sqe_set_data(sqe, completion);
-	IO_Event_Selector_URing_submit_sqe(sqe);
-	
 	// If we are going to wait, we assume that we are waiting for a while:
 	io_uring_submit_pending(selector);
 	
@@ -607,13 +628,12 @@ io_read_submit(VALUE _arguments)
 {
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	struct IO_Event_Selector_URing *selector = arguments->selector;
-	struct io_uring_sqe *sqe = io_get_sqe(selector);
 	
 	if (DEBUG) fprintf(stderr, "io_read_submit:io_uring_prep_read(waiting=%p, completion=%p, descriptor=%d, buffer=%p, length=%ld)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion, arguments->descriptor, arguments->buffer, arguments->length);
 	
+	struct io_uring_sqe *sqe = io_get_sqe(selector);
 	io_uring_prep_read(sqe, arguments->descriptor, arguments->buffer, arguments->length, io_seekable(arguments->descriptor));
 	io_uring_sqe_set_data(sqe, arguments->waiting->completion);
-	IO_Event_Selector_URing_submit_sqe(sqe);
 	io_uring_submit_now(selector);
 	
 	IO_Event_Selector_fiber_transfer(selector->backend.loop, 0, NULL);
@@ -627,15 +647,12 @@ io_read_ensure(VALUE _arguments)
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	struct IO_Event_Selector_URing *selector = arguments->selector;
 	
-	struct io_uring_sqe *sqe = io_get_sqe(selector);
-	
-	if (DEBUG) fprintf(stderr, "io_read_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
-	
 	// If the operation is still in progress, cancel it:
 	if (arguments->waiting->completion) {
+		if (DEBUG) fprintf(stderr, "io_read_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
+		struct io_uring_sqe *sqe = io_get_sqe(selector);
 		io_uring_prep_cancel(sqe, (void*)arguments->waiting->completion, 0);
 		io_uring_sqe_set_data(sqe, NULL);
-		IO_Event_Selector_URing_submit_sqe(sqe);
 		io_uring_submit_now(selector);
 	}
 	
@@ -732,13 +749,11 @@ io_write_submit(VALUE _argument)
 	struct io_write_arguments *arguments = (struct io_write_arguments*)_argument;
 	struct IO_Event_Selector_URing *selector = arguments->selector;
 	
-	struct io_uring_sqe *sqe = io_get_sqe(selector);
-	
 	if (DEBUG) fprintf(stderr, "io_write_submit:io_uring_prep_write(waiting=%p, completion=%p, descriptor=%d, buffer=%p, length=%ld)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion, arguments->descriptor, arguments->buffer, arguments->length);
 	
+	struct io_uring_sqe *sqe = io_get_sqe(selector);
 	io_uring_prep_write(sqe, arguments->descriptor, arguments->buffer, arguments->length, io_seekable(arguments->descriptor));
 	io_uring_sqe_set_data(sqe, arguments->waiting->completion);
-	IO_Event_Selector_URing_submit_sqe(sqe);
 	io_uring_submit_pending(selector);
 	
 	IO_Event_Selector_fiber_transfer(selector->backend.loop, 0, NULL);
@@ -752,15 +767,12 @@ io_write_ensure(VALUE _argument)
 	struct io_write_arguments *arguments = (struct io_write_arguments*)_argument;
 	struct IO_Event_Selector_URing *selector = arguments->selector;
 	
-	struct io_uring_sqe *sqe = io_get_sqe(selector);
-	
-	if (DEBUG) fprintf(stderr, "io_write_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
-	
 	// If the operation is still in progress, cancel it:
 	if (arguments->waiting->completion) {
+		if (DEBUG) fprintf(stderr, "io_write_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
+		struct io_uring_sqe *sqe = io_get_sqe(selector);
 		io_uring_prep_cancel(sqe, (void*)arguments->waiting->completion, 0);
 		io_uring_sqe_set_data(sqe, NULL);
-		IO_Event_Selector_URing_submit_sqe(sqe);
 		io_uring_submit_now(selector);
 	}
 	
@@ -859,10 +871,8 @@ VALUE IO_Event_Selector_URing_io_close(VALUE self, VALUE io) {
 
 	if (ASYNC_CLOSE) {
 		struct io_uring_sqe *sqe = io_get_sqe(selector);
-		
 		io_uring_prep_close(sqe, descriptor);
 		io_uring_sqe_set_data(sqe, NULL);
-		IO_Event_Selector_URing_submit_sqe(sqe);
 		io_uring_submit_now(selector);
 	} else {
 		close(descriptor);
@@ -953,7 +963,10 @@ unsigned select_process_completions(struct IO_Event_Selector_URing *selector) {
 	unsigned head;
 	struct io_uring_cqe *cqe;
 	
-	if (DEBUG) fprintf(stderr, "select_process_completions...\n");
+	if (DEBUG) {
+		fprintf(stderr, "select_process_completions: selector=%p\n", (void*)selector);
+		IO_Event_Selector_URing_dump_completion_queue(selector);
+	}
 	
 	io_uring_for_each_cqe(ring, head, cqe) {
 		if (DEBUG) fprintf(stderr, "select_process_completions: cqe res=%d user_data=%p\n", cqe->res, (void*)cqe->user_data);
@@ -976,15 +989,15 @@ unsigned select_process_completions(struct IO_Event_Selector_URing *selector) {
 			waiting->flags = cqe->flags;
 		}
 		
+		io_uring_cq_advance(ring, 1);
+		// This marks the waiting operation as "complete":
+		IO_Event_Selector_URing_Completion_release(selector, completion);
+		
 		if (waiting && waiting->fiber) {
 			assert(waiting->result != -ECANCELED);
 			
 			IO_Event_Selector_fiber_transfer(waiting->fiber, 0, NULL);
 		}
-		
-		// This marks the waiting operation as "complete":
-		IO_Event_Selector_URing_Completion_release(selector, completion);
-		io_uring_cq_advance(ring, 1);
 	}
 	
 	if (DEBUG && completed > 0) fprintf(stderr, "select_process_completions(completed=%d)\n", completed);

data/lib/io/event/selector/select.rb

@@ -160,7 +160,66 @@ module IO::Event
 				errno == EAGAIN or errno == EWOULDBLOCK
 			end
 			
-			if Support.fiber_scheduler_v2?
+			if Support.fiber_scheduler_v3?
+				# Ruby 3.3+, full IO::Buffer support.
+				
+				# @parameter length [Integer] The minimum number of bytes to read.
+				# @parameter offset [Integer] The offset into the buffer to read to.
+				def io_read(fiber, io, buffer, length, offset = 0)
+					total = 0
+					
+					Selector.nonblock(io) do
+						while true
+							result = Fiber.blocking{buffer.read(io, 0, offset)}
+							
+							if result < 0
+								if again?(result)
+									self.io_wait(fiber, io, IO::READABLE)
+								else
+									return result
+								end
+							elsif result == 0
+								break
+							else
+								total += result
+								break if total >= length
+								offset += result
+							end
+						end
+					end
+					
+					return total
+				end
+				
+				# @parameter length [Integer] The minimum number of bytes to write.
+				# @parameter offset [Integer] The offset into the buffer to write from.
+				def io_write(fiber, io, buffer, length, offset = 0)
+					total = 0
+					
+					Selector.nonblock(io) do
+						while true
+							result = Fiber.blocking{buffer.write(io, 0, offset)}
+							
+							if result < 0
+								if again?(result)
+									self.io_wait(fiber, io, IO::READABLE)
+								else
+									return result
+								end
+							elsif result == 0
+								break result
+							else
+								total += result
+								break if total >= length
+								offset += result
+							end
+						end
+					end
+					
+					return total
+				end
+			elsif Support.fiber_scheduler_v2?
+				# Ruby 3.2, most IO::Buffer support, but slightly clunky read/write methods.
 				def io_read(fiber, io, buffer, length, offset = 0)
 					total = 0
 					
@@ -219,8 +278,11 @@ module IO::Event
 					return total
 				end
 			elsif Support.fiber_scheduler_v1?
+				# Ruby <= 3.1, limited IO::Buffer support.
 				def io_read(fiber, _io, buffer, length, offset = 0)
+					# We need to avoid any internal buffering, so we use a duplicated IO object:
 					io = IO.for_fd(_io.fileno, autoclose: false)
+					
 					total = 0
 					
 					maximum_size = buffer.size - offset
@@ -261,7 +323,9 @@ module IO::Event
 				end
 				
 				def io_write(fiber, _io, buffer, length, offset = 0)
+					# We need to avoid any internal buffering, so we use a duplicated IO object:
 					io = IO.for_fd(_io.fileno, autoclose: false)
+					
 					total = 0
 					
 					maximum_size = buffer.size - offset

data/lib/io/event/support.rb

@@ -17,6 +17,17 @@ class IO
 			def self.fiber_scheduler_v2?
 				IO.const_defined?(:Buffer) and Fiber.respond_to?(:blocking) and IO::Buffer.instance_method(:read).arity == -1
 			end
+			
+			def self.fiber_scheduler_v3?
+				if fiber_scheduler_v2?
+					begin
+						IO::Buffer.new.slice(0, 0).write(STDOUT)
+						return true
+					rescue
+						return false
+					end
+				end
+			end
 		end
 	end
 end

data/lib/io/event/version.rb

@@ -5,6 +5,6 @@
 
 class IO
 	module Event
-		VERSION = "1.3.1"
+		VERSION = "1.3.3"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.3
 platform: ruby
 authors:
 - Samuel Williams
@@ -42,7 +42,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2023-08-23 00:00:00.000000000 Z
+date: 2023-10-24 00:00:00.000000000 Z
 dependencies: []
 description:
 email: