uringmachine 0.20.0 → 0.21.0

data/ext/um/um.h

@@ -4,12 +4,20 @@
 #include <ruby.h>
 #include <liburing.h>
 
+
 // debugging
+enum {
+  // set to 1 to enable debug logging
+  DEBUG = 0
+};
+
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
 #define INSPECT(str, obj) { printf(str); VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf(": %s\n", StringValueCStr(s)); }
 #define CALLER() rb_funcall(rb_mKernel, rb_intern("caller"), 0)
 #define TRACE_CALLER() INSPECT("caller: ", CALLER())
 #define TRACE_FREE(ptr) //printf("Free %p %s:%d\n", ptr, __FILE__, __LINE__)
+#define DEBUG_MARK(machine, markv, msg) \
+  if (machine->mark == markv) printf("%s\n", msg);
 
 // branching
 #ifndef unlikely
@@ -23,7 +31,7 @@
 #define IO_BUFFER_P(buffer) \
   (TYPE(buffer) == RUBY_T_DATA) && rb_obj_is_instance_of(buffer, rb_cIOBuffer)
 
-enum op_kind {
+enum um_op_kind {
   OP_TIMEOUT,
   OP_SCHEDULE,
 
@@ -62,12 +70,17 @@ enum op_kind {
   OP_SLEEP_MULTISHOT
 };
 
-#define OP_F_COMPLETED        (1U << 0) // op is completed (set on each CQE for multishot ops)
-#define OP_F_TRANSIENT        (1U << 1) // op is heap allocated
-#define OP_F_ASYNC            (1U << 2) // op belongs to an AsyncOp
-#define OP_F_IGNORE_CANCELED  (1U << 3) // CQE with -ECANCEL should be ignored
-#define OP_F_MULTISHOT        (1U << 4) // op is multishot
-#define OP_F_FREE_ON_COMPLETE (1U << 5) // op should be freed on receiving CQE
+#define OP_F_COMPLETED        (1U <<  0) // op is completed (set on each CQE for multishot ops)
+#define OP_F_TRANSIENT        (1U <<  1) // op is heap allocated
+#define OP_F_ASYNC            (1U <<  2) // op belongs to an AsyncOp
+#define OP_F_CANCELED         (1U <<  3) // op is cancelled
+#define OP_F_IGNORE_CANCELED  (1U <<  4) // CQE with -ECANCEL should be ignored
+#define OP_F_MULTISHOT        (1U <<  5) // op is multishot
+#define OP_F_FREE_ON_COMPLETE (1U <<  6) // op should be freed on receiving CQE
+#define OP_F_RUNQUEUE_SKIP    (1U <<  7) // runqueue entry should be skipped
+#define OP_F_SELECT_POLLIN    (1U <<  8) // select POLLIN
+#define OP_F_SELECT_POLLOUT   (1U <<  9) // select POLLOUT
+#define OP_F_SELECT_POLLPRI   (1U << 10) // select POLLPRI
 
 struct um_op_result {
   __s32 res;
@@ -79,8 +92,8 @@ struct um_op {
   struct um_op *prev;
   struct um_op *next;
 
-  enum op_kind kind;
-  unsigned flags;
+  enum um_op_kind kind;
+  uint flags;
 
   VALUE fiber;
   VALUE value;
@@ -88,7 +101,7 @@ struct um_op {
 
   struct um_op_result result;
   struct um_op_result *multishot_result_tail;
-  unsigned multishot_result_count;
+  uint multishot_result_count;
 
   struct __kernel_timespec ts; // used for timeout operation
 };
@@ -117,12 +130,18 @@ struct um {
 
   struct io_uring ring;
 
-  unsigned int    ring_initialized;
-  unsigned int    unsubmitted_count;
-  unsigned int    pending_count;
+  uint ring_initialized; // is the ring initialized successfully
+  uint mark; // used to mark instances for debugging
+
+  uint unsubmitted_count; // number of unsubmitted SQEs pending
+  uint pending_count; // number of pending operations (i.e. not yet completed)
+  uint buffer_ring_count; // number of registered buffer rings
+  ulong total_op_count; // total number of operations submitted since ring was initialized
+  
+  uint entries; // number of entries in SQ
+  uint sqpoll_mode; // SQPOLL mode enabled
 
   struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
-  unsigned int buffer_ring_count;
 
   struct um_op *transient_head;
   struct um_op *runqueue_head;
@@ -184,9 +203,10 @@ extern VALUE cAsyncOp;
 extern VALUE eStreamRESPError;
 
 struct um *um_get_machine(VALUE self);
-void um_setup(VALUE self, struct um *machine);
+void um_setup(VALUE self, struct um *machine, uint entries, uint sqpoll_timeout_msec);
 void um_teardown(struct um *machine);
 
+const char * um_op_kind_name(enum um_op_kind kind);
 struct um_op *um_op_alloc(struct um *machine);
 void um_op_free(struct um *machine, struct um_op *op);
 void um_op_clear(struct um *machine, struct um_op *op);
@@ -210,9 +230,9 @@ double um_timestamp_to_double(__s64 tv_sec, __u32 tv_nsec);
 int um_value_is_exception_p(VALUE v);
 VALUE um_raise_exception(VALUE v);
 
-#define RAISE_IF_EXCEPTION(v) if (um_value_is_exception_p(v)) { um_raise_exception(v); }
+#define RAISE_IF_EXCEPTION(v) if (unlikely(um_value_is_exception_p(v))) { um_raise_exception(v); }
 
-void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags);
+void um_prep_op(struct um *machine, struct um_op *op, enum um_op_kind kind, unsigned flags);
 void um_raise_on_error_result(int result);
 void um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size);
 void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs);
@@ -223,9 +243,11 @@ void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings);
 
 struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op);
 
+uint um_submit(struct um *machine);
 VALUE um_fiber_switch(struct um *machine);
 VALUE um_await(struct um *machine);
-void um_submit_cancel_op(struct um *machine, struct um_op *op);
+VALUE um_wakeup(struct um *machine);
+void um_cancel_op(struct um *machine, struct um_op *op);
 void um_cancel_and_wait(struct um *machine, struct um_op *op);
 int um_check_completion(struct um *machine, struct um_op *op);
 
@@ -236,17 +258,22 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class);
 
 VALUE um_sleep(struct um *machine, double duration);
 VALUE um_periodically(struct um *machine, double interval);
-VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t buffer_offset);
+VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t buffer_offset, __u64 file_offset);
 size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
-VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len);
-VALUE um_write_async(struct um *machine, int fd, VALUE buffer);
+VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
+VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
 VALUE um_close(struct um *machine, int fd);
 VALUE um_close_async(struct um *machine, int fd);
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode);
 VALUE um_poll(struct um *machine, int fd, unsigned mask);
+VALUE um_select(struct um *machine, VALUE rfds, VALUE wfds, VALUE efds);
 VALUE um_waitid(struct um *machine, int idtype, int id, int options);
+
+#ifdef HAVE_RB_PROCESS_STATUS_NEW
 VALUE um_waitid_status(struct um *machine, int idtype, int id, int options);
+#endif
+
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask);
 
 VALUE um_accept(struct um *machine, int fd);

data/ext/um/um_async_op.c

@@ -36,5 +36,5 @@ VALUE um_async_op_await(struct um_async_op *async_op) {
 }
 
 void um_async_op_cancel(struct um_async_op *async_op) {
-  um_submit_cancel_op(async_op->machine, async_op->op);
+  um_cancel_op(async_op->machine, async_op->op);
 }

data/ext/um/um_class.c

@@ -54,9 +54,33 @@ inline struct um *um_get_machine(VALUE self) {
   return um;
 }
 
-VALUE UM_initialize(VALUE self) {
+static inline uint get_sqpoll_timeout_msec(VALUE sqpoll_timeout) {
+  switch (TYPE(sqpoll_timeout)) {
+    case T_NIL:
+    case T_FALSE:
+      return 0;
+    case T_FLOAT:
+      return (uint)(NUM2DBL(sqpoll_timeout) * 1000);
+    case T_FIXNUM:
+      return NUM2UINT(sqpoll_timeout) * 1000;
+    case T_TRUE:
+      return 1000;
+    default:
+      rb_raise(eUMError, "Invalid sqpoll_timeout value");
+  }
+}
+
+VALUE UM_initialize(int argc, VALUE *argv, VALUE self) {
   struct um *machine = RTYPEDDATA_DATA(self);
-  um_setup(self, machine);
+  VALUE entries;
+  VALUE sqpoll_timeout;
+  rb_scan_args(argc, argv, "02", &entries, &sqpoll_timeout);
+
+  uint entries_i = NIL_P(entries) ? 0 : NUM2UINT(entries);
+  uint sqpoll_timeout_msec = get_sqpoll_timeout_msec(sqpoll_timeout);
+
+
+  um_setup(self, machine, entries_i, sqpoll_timeout_msec);
   return self;
 }
 
@@ -66,9 +90,25 @@ VALUE UM_setup_buffer_ring(VALUE self, VALUE size, VALUE count) {
   return INT2NUM(bgid);
 }
 
+VALUE UM_entries(VALUE self) {
+  struct um *machine = um_get_machine(self);
+  return UINT2NUM(machine->entries);
+}
+
+VALUE UM_mark_m(VALUE self, VALUE mark) {
+  struct um *machine = um_get_machine(self);
+  machine->mark = NUM2UINT(mark);
+  return self;
+}
+
 VALUE UM_pending_count(VALUE self) {
   struct um *machine = um_get_machine(self);
-  return INT2NUM(machine->pending_count);
+  return UINT2NUM(machine->pending_count);
+}
+
+VALUE UM_total_op_count(VALUE self) {
+  struct um *machine = um_get_machine(self);
+  return UINT2NUM(machine->total_op_count);
 }
 
 VALUE UM_snooze(VALUE self) {
@@ -82,6 +122,17 @@ VALUE UM_yield(VALUE self) {
   return um_await(machine);
 }
 
+VALUE UM_wakeup(VALUE self) {
+  struct um *machine = um_get_machine(self);
+  return um_wakeup(machine);
+}
+
+VALUE UM_submit(VALUE self) {
+  struct um *machine = um_get_machine(self);
+  uint ret = um_submit(machine);
+  return UINT2NUM(ret);
+}
+
 VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
   struct um *machine = um_get_machine(self);
   um_schedule(machine, fiber, value);
@@ -109,12 +160,14 @@ VALUE UM_read(int argc, VALUE *argv, VALUE self) {
   VALUE buffer;
   VALUE maxlen;
   VALUE buffer_offset;
-  rb_scan_args(argc, argv, "22", &fd, &buffer, &maxlen, &buffer_offset);
+  VALUE file_offset;
+  rb_scan_args(argc, argv, "23", &fd, &buffer, &maxlen, &buffer_offset, &file_offset);
 
   ssize_t maxlen_i = NIL_P(maxlen) ? -1 : NUM2INT(maxlen);
   ssize_t buffer_offset_i = NIL_P(buffer_offset) ? 0 : NUM2INT(buffer_offset);
+  __u64 file_offset_i = NIL_P(file_offset) ? (__u64)-1 : NUM2UINT(file_offset);
 
-  return um_read(machine, NUM2INT(fd), buffer, maxlen_i, buffer_offset_i);
+  return um_read(machine, NUM2INT(fd), buffer, maxlen_i, buffer_offset_i, file_offset_i);
 }
 
 VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
@@ -127,15 +180,27 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
   VALUE fd;
   VALUE buffer;
   VALUE len;
-  rb_scan_args(argc, argv, "21", &fd, &buffer, &len);
+  VALUE file_offset;
+  rb_scan_args(argc, argv, "22", &fd, &buffer, &len, &file_offset);
+
+  size_t len_i = NIL_P(len) ? (size_t)-1 : NUM2UINT(len);
+  __u64 file_offset_i = NIL_P(file_offset) ? (__u64)-1 : NUM2UINT(file_offset);
 
-  size_t bytes = NIL_P(len) ? (size_t)-1 : NUM2UINT(len);
-  return um_write(machine, NUM2INT(fd), buffer, bytes);
+  return um_write(machine, NUM2INT(fd), buffer, len_i, file_offset_i);
 }
 
-VALUE UM_write_async(VALUE self, VALUE fd, VALUE buffer) {
+VALUE UM_write_async(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
-  return um_write_async(machine, NUM2INT(fd), buffer);
+  VALUE fd;
+  VALUE buffer;
+  VALUE len;
+  VALUE file_offset;
+  rb_scan_args(argc, argv, "22", &fd, &buffer, &len, &file_offset);
+
+  size_t len_i = NIL_P(len) ? (size_t)-1 : NUM2UINT(len);
+  __u64 file_offset_i = NIL_P(file_offset) ? (__u64)-1 : NUM2UINT(file_offset);
+
+  return um_write_async(machine, NUM2INT(fd), buffer, len_i, file_offset_i);
 }
 
 VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
@@ -330,6 +395,11 @@ VALUE UM_poll(VALUE self, VALUE fd, VALUE mask) {
   return um_poll(machine, NUM2INT(fd), NUM2UINT(mask));
 }
 
+VALUE UM_select(VALUE self, VALUE rfds, VALUE wfds, VALUE efds) {
+  struct um *machine = um_get_machine(self);
+  return um_select(machine, rfds, wfds, efds);
+}
+
 VALUE UM_waitid(VALUE self, VALUE idtype, VALUE id, VALUE options) {
   struct um *machine = um_get_machine(self);
   return um_waitid(machine, NUM2INT(idtype), NUM2INT(id), NUM2INT(options));
@@ -423,8 +493,11 @@ void Init_UM(void) {
   cUM = rb_define_class("UringMachine", rb_cObject);
   rb_define_alloc_func(cUM, UM_allocate);
 
-  rb_define_method(cUM, "initialize", UM_initialize, 0);
+  rb_define_method(cUM, "initialize", UM_initialize, -1);
+  rb_define_method(cUM, "entries", UM_entries, 0);
+  rb_define_method(cUM, "mark", UM_mark_m, 1);
   rb_define_method(cUM, "pending_count", UM_pending_count, 0);
+  rb_define_method(cUM, "total_op_count", UM_total_op_count, 0);
   rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 2);
 
   rb_define_singleton_method(cUM, "pipe", UM_pipe, 0);
@@ -436,11 +509,12 @@ void Init_UM(void) {
   rb_define_singleton_method(cUM, "kernel_version", UM_kernel_version, 0);
   rb_define_singleton_method(cUM, "debug", UM_debug, 1);
 
-
   rb_define_method(cUM, "schedule", UM_schedule, 2);
   rb_define_method(cUM, "snooze", UM_snooze, 0);
   rb_define_method(cUM, "timeout", UM_timeout, 2);
   rb_define_method(cUM, "yield", UM_yield, 0);
+  rb_define_method(cUM, "wakeup", UM_wakeup, 0);
+  rb_define_method(cUM, "submit", UM_submit, 0);
 
   rb_define_method(cUM, "close", UM_close, 1);
   rb_define_method(cUM, "close_async", UM_close_async, 1);
@@ -450,11 +524,13 @@ void Init_UM(void) {
   rb_define_method(cUM, "sleep", UM_sleep, 1);
   rb_define_method(cUM, "periodically", UM_periodically, 1);
   rb_define_method(cUM, "write", UM_write, -1);
-  rb_define_method(cUM, "write_async", UM_write_async, 2);
+  rb_define_method(cUM, "write_async", UM_write_async, -1);
   rb_define_method(cUM, "statx", UM_statx, 4);
 
   rb_define_method(cUM, "poll", UM_poll, 2);
+  rb_define_method(cUM, "select", UM_select, 3);
   rb_define_method(cUM, "waitid", UM_waitid, 3);
+  
   #ifdef HAVE_RB_PROCESS_STATUS_NEW
   rb_define_method(cUM, "waitid_status", UM_waitid_status, 3);
   #endif

data/ext/um/um_op.c

@@ -1,5 +1,42 @@
 #include "um.h"
 
+const char * um_op_kind_name(enum um_op_kind kind) {
+  switch (kind) {
+    case OP_TIMEOUT:            return "OP_TIMEOUT";
+    case OP_SCHEDULE:           return "OP_SCHEDULE";
+    case OP_SLEEP:              return "OP_SLEEP";
+    case OP_OPEN:               return "OP_OPEN";
+    case OP_READ:               return "OP_READ";
+    case OP_WRITE:              return "OP_WRITE";
+    case OP_WRITE_ASYNC:        return "OP_WRITE_ASYNC";
+    case OP_CLOSE:              return "OP_CLOSE";
+    case OP_CLOSE_ASYNC:        return "OP_CLOSE_ASYNC";
+    case OP_STATX:              return "OP_STATX";
+    case OP_ACCEPT:             return "OP_ACCEPT";
+    case OP_RECV:               return "OP_RECV";
+    case OP_SEND:               return "OP_SEND";
+    case OP_SEND_BUNDLE:        return "OP_SEND_BUNDLE";
+    case OP_SOCKET:             return "OP_SOCKET";
+    case OP_CONNECT:            return "OP_CONNECT";
+    case OP_BIND:               return "OP_BIND";
+    case OP_LISTEN:             return "OP_LISTEN";
+    case OP_GETSOCKOPT:         return "OP_GETSOCKOPT";
+    case OP_SETSOCKOPT:         return "OP_SETSOCKOPT";
+    case OP_SHUTDOWN:           return "OP_SHUTDOWN";
+    case OP_SHUTDOWN_ASYNC:     return "OP_SHUTDOWN_ASYNC";
+    case OP_POLL:               return "OP_POLL";
+    case OP_WAITID:             return "OP_WAITID";
+    case OP_FUTEX_WAIT:         return "OP_FUTEX_WAIT";
+    case OP_FUTEX_WAKE:         return "OP_FUTEX_WAKE";
+    case OP_ACCEPT_MULTISHOT:   return "OP_ACCEPT_MULTISHOT";
+    case OP_READ_MULTISHOT:     return "OP_READ_MULTISHOT";
+    case OP_RECV_MULTISHOT:     return "OP_RECV_MULTISHOT";
+    case OP_TIMEOUT_MULTISHOT:  return "OP_TIMEOUT_MULTISHOT";
+    case OP_SLEEP_MULTISHOT:    return "OP_SLEEP_MULTISHOT";
+    default:                    return "UNKNOWN_OP_KIND";
+  }
+}
+
 inline void um_op_clear(struct um *machine, struct um_op *op) {
   memset(op, 0, sizeof(struct um_op));
   op->fiber = Qnil;

data/ext/um/um_sync.c

@@ -4,13 +4,13 @@
 
 #define FUTEX2_SIZE_U32		0x02
 
-void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t expect) {
+// The value argument is the current (known) futex value.
+void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t value) {
   struct um_op op;
   um_prep_op(machine, &op, OP_FUTEX_WAIT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_futex_wait(
-    sqe, (uint32_t *)futex, expect, FUTEX_BITSET_MATCH_ANY,
-		FUTEX2_SIZE_U32, 0
+    sqe, (uint32_t *)futex, value, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
 
   VALUE ret = um_fiber_switch(machine);
@@ -29,10 +29,8 @@ void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
   struct um_op op;
   um_prep_op(machine, &op, OP_FUTEX_WAKE, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
-  // submit futex_wait
   io_uring_prep_futex_wake(
-    sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY,
-		FUTEX2_SIZE_U32, 0
+    sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
 
   VALUE ret = um_fiber_switch(machine);
@@ -45,12 +43,11 @@ void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
 void um_futex_wake_transient(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, NULL);
   io_uring_prep_futex_wake(
-    sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY,
-		FUTEX2_SIZE_U32, 0
+    sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
+  um_submit(machine);
 }
 
-
 #define MUTEX_LOCKED    1
 #define MUTEX_UNLOCKED  0
 
@@ -210,7 +207,6 @@ static inline VALUE um_queue_add(struct um *machine, struct um_queue *queue, VAL
   else          queue_add_tail(queue, value);
 
   queue->count++;
-
   queue->state = QUEUE_READY;
   if (queue->num_waiters)
     um_futex_wake_transient(machine, &queue->state, 1);
@@ -241,10 +237,8 @@ VALUE um_queue_remove_start(VALUE arg) {
     um_futex_wait(ctx->machine, &ctx->queue->state, QUEUE_EMPTY);
   }
 
-  if (ctx->queue->state != QUEUE_READY)
-    um_raise_internal_error("Internal error: queue should be in ready state!");
-  if (!ctx->queue->tail)
-    um_raise_internal_error("Internal error: queue should be in ready state!");
+  assert(ctx->queue->state == QUEUE_READY);
+  assert(ctx->queue->tail);
 
   ctx->queue->count--;
   return (ctx->op == QUEUE_POP ? queue_remove_tail : queue_remove_head)(ctx->queue);

data/grant-2025/journal.md

@@ -205,7 +205,8 @@ Ruby I/O layer. Some interesting warts in the Ruby `IO` implementation:
   I'll see if I can prepare a PR for that to be merged for the Ruby 4.0 release.
 
   For the time being, I've added a `#post_fork` method to the UM fiber scheduler
-  which should be manually called after a fork. (commit 2c7877385869c6acbdd8354e2b2909cff448651b)
+  which should be manually called after a fork. (commit
+  2c7877385869c6acbdd8354e2b2909cff448651b)
 
 - Added two new low-level APIs for waiting on processes, instead of
   `UM#waitpid`, using the io_uring version of `waitid`. The vanilla version
@@ -227,3 +228,126 @@ Ruby I/O layer. Some interesting warts in the Ruby `IO` implementation:
   ...
   pid2, status = machine.waitid(P_PIDFD, fd, UM::WEXITED)
   ```
+
+# 2025-11-28
+
+- On Samuel's suggestions, I've submitted a
+  [PR](https://github.com/ruby/ruby/pull/15342) for adding a
+  `Fiber::Scheduler#process_fork` hook that is automatically invoked after a
+  fork. This is in continuation to the `#post_fork` method. I still have a lot
+  to learn about working with the Ruby core code, but I'm really excited about
+  the possibility of this PR (and the [previous
+  one](https://github.com/ruby/ruby/pull/15213) as well) getting merged in time
+  for the Ruby 4.0 release.
+- Added a bunch of tests for `UM::FiberScheduler`: socket I/O, file I/O, mutex,
+  queue, waiting for threads. In the process I discovered a lots of things that
+  can be improved in the way Ruby invokes the fiber scheduler.
+
+  - For regular files, Ruby assumes file I/O can never be non-blocking (or
+    async), and thus invokes the `#blocking_operation_wait` hook in order to
+    perform the I/O in a separate thread. With io_uring, of course, file I/O
+    *is* asynchronous.
+  - For sockets there are no specialized hooks, like `#socket_send` etc.
+    Instead, Ruby makes the socket fd's non-blocking and invokes `#io_wait` to
+    wait for the socket to be ready.
+
+  I find it interesting how io_uring breaks a lot of assumptions about how I/O
+  should be done.
+
+# 2025-12-03
+
+- Samuel and me continued discussing the behavior of the fiber scheduler after a
+  fork. After talking it through, we decided the best course of action would be
+  to remove the fiber scheduler after a fork, rather than to introduce a
+  `process_fork` hook. This is a safer choice, since a scheduler risks carrying
+  over some of its state across a fork, leading to unexpected behavior.
+
+  Another problem I uncovered is that if a fork is done from a non-blocking
+  fiber, the main fiber of the forked process (which "inherits" the forking
+  fiber) stays in non-blocking mode, which also may lead to unexpected behavior,
+  since the main fiber of all Ruby threads should be in blocking mode.
+
+  So I submitted a new [PR](https://github.com/ruby/ruby/pull/15385) that
+  corrects these two problems.
+
+- I mapped the remaining missing hooks in the UringMachine fiber scheduler
+  implementation, and made the tests more robust by checking that the different
+  scheduler hooks were actually being called.
+
+- Continued implementing the missing fiber scheduler hooks: `#fiber_interrupt`,
+  `#address_resolve`, `#timeout_after`. For the most part, they were simple to
+  implement. I probably spent most of my time figuring out how to test these,
+  rather than implementing them. Most of the hooks involve just a few lines of
+  code, with many of them consisting of a single line of code, calling into the
+  relevant UringMachine low-level API.
+
+- Implemented the `#io_select` hook, which involved implementing a low-level
+  `UM#select` method. This method took some effort to implement, since it needs
+  to handle an arbitrary number of file descriptors to check for readiness. We
+  need to create a separate SQE for each fd we want to poll. When one or more
+  CQEs arrive for polled fd's, we also need to cancel all poll operations that
+  have not completed.
+
+  Since in many cases, `IO.select` is called with just a single IO, I also added
+  a special-case implementation of `UM#select` that specifically handles a
+  single fd.
+
+# 2025-12-04
+
+- Implemented a worker pool for performing blocking operations in the scheduler.
+  Up until now, each scheduler started their own worker thread for performing
+  blocking operations for use in the `#blocking_operation_wait` hook. The new
+  implementation uses a worker thread pool shared by all schedulers, with a
+  worker count limited to CPU count. Workers are started when needed.
+
+  I also added an optional `entries` argument to set the SQE and CQE buffer
+  sizes when starting a new `UringMachine` instance. The default size is 4096
+  SQE entries (liburing by default makes the CQE buffer size double that of the
+  SQE buffer). The blocking operations worker threads specify a value of 4 since
+  they only use their UringMachine instance for popping jobs off the job queue
+  and pushing the blocking operation result back to the scheduler.
+
+- Added support for `file_offset` argument in `UM#read` and `UM#write` in
+  preparation for implementing the `#io_pread` and `#io_pwrite` hooks. The
+  `UM#write_async` API, which permits writing to a file descriptor without
+  waiting for the operation to complete, got support for specifying `length` and
+  `file_offset` arguments as well. In addition, `UM#write` and `UM#write_async`
+  got short-circuit logic for writes with a length of 0.
+
+- Added support for specifying buffer offset in `#io_read` and `#io_write`
+  hooks.
+
+- Added support for timeout in `#block`, `#io_read` and `#io_write` hooks.
+
+# 2025-12-05
+
+- I found and fixed a problem with how `futex_wake` was done in the low-level
+  UringMachine code handling mutexes and queues. This fixed a deadlock in the
+  scheduler background worker pool where clients of the pool where not properly
+  woken after the submitted operation was done.
+
+- I finished work on the `#io_pread` and `#io_pwrite` hooks. Unfortunately, the
+  test for `#io_pwrite` consistently hangs (not on `IO#pwrite` itself, rather on
+  closing the file.) With Samuel's help, hopefully we'll find a solution...
+
+- With those two last hooks, the fiber scheduler implementation is now feature
+  complete! While I have written test cases for the different fiber scheduler
+  hooks, I'd like to add more tests - and especially tests that exercise
+  multiple hooks, tests with high concurrency, and integration tests where I
+  check how the fiber scheduler plays with Ruby APIs like `Net::HTTP` and the
+  `socket` API in general.
+
+# 2025-12-06
+
+- Samuel has found the issue with pwrite (it turns out the the `#io_pwrite` hook was being invoked with the GVL released), and [fixed it](https://github.com/ruby/ruby/pull/15428). So now `#pwrite` works correctly with a fiber scheduler!
+
+- I followed Samuel's suggestion and incorporated some debug logging into the
+  extension code interfacing with liburing, in order to facilitate debugging
+  when issues are encountered.
+
+- Added support for [SQPOLL
+  mode](https://unixism.net/loti/tutorial/sq_poll.html) when setting up a
+  UringMachine instance. It's not clear to me what are the performance
+  implications of that, but I'll try to make some time to check this against
+  [TP2](https://github.com/noteflakes/tp2), a UringMachine-based web server I'm
+  currently using in a bunch of projects.