uringmachine 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 320cde6219f737bd65911d6b860852e1d706a20d807f68e97a103254d27a6c11
-  data.tar.gz: 2a5c40b6121dd4bc25bcfaf0852d56425f398b43660ccb86d883c5f7b2f68dcc
+  metadata.gz: e14941110d09a575728da68cb038a02334d151f0d384d88ad67a34b21a49d234
+  data.tar.gz: 158299106b117a973163ae480ea4e9827a0cb88eb76b2323da04fd631e8916ca
 SHA512:
-  metadata.gz: b6940030d3f45f731c2b2e8a853193c4ef46e815b84848fc6a310605e00bfd10dd633ff952fc324f33dd4748c82d72379ddf7e91c0c0020006cacf1a2a6a83cb
-  data.tar.gz: 60d92ed67095e67e7a36f329e5131a853dff9f4afde843c8022de88ee3613e97e6f032479ee3090870f6a00804d3863e70968e78e92a1753ced3f8baf0a11df2
+  metadata.gz: f71a5b6b6740fea281df8880511b424a0c759e876e17f79a6b661453416d13c2d9d65e0c53ddee5df066ca92472571ffae8c0e9a4ca4fd745d02705a8645965d
+  data.tar.gz: baa86b9bc0009c69bfe894aae3489d43ed28d1fca44a24a9ddc7cc1625a54de6c17f65731c1a707af561942174f9584554a183a67f8428d5855e799c274db0b6

data/.github/workflows/test.yml

@@ -11,9 +11,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # macos-latest uses arm64, macos-13 uses x86
         os: [ubuntu-latest]
-        ruby: ['3.4', 'head']
+        ruby: ['head']
 
     name: ${{matrix.os}}, ${{matrix.ruby}}
 
@@ -32,5 +31,5 @@ jobs:
     - name: Compile C-extension
       run: bundle exec rake compile
     - name: Run tests
-      # run: bundle exec ruby test/test_um.rb --name test_read_each_raising_2
-      run: bundle exec rake test
+      run: bundle exec ruby test/run.rb --verbose
+      # run: bundle exec rake test

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+# 0.21.0 2025-12-06
+
+- Add `UM#submit`
+- Update liburing
+- Do not release GVL in um_submit if SQ does not need entering the kernel
+- Fix compilation when rb_process_status_new is not available
+- Fix um_futex_wake_transient to submit SQE, fix futex_wait usage
+- Add debug logging for key io_uring interactions
+- Add UM#mark and DEBUG_MARK for debugging specific UM instances
+- Short-circuit zero-length writes
+- Add optional file_offset argument to #read, #write. Add optional len and file_off
+set arguments to #write_async
+- Add support for specifying SQPOLL mode and SQ idle timeout in `UM#initialize`
+- Add support for specifying number of SQ entries in `UM#initialize`
+- Implement global worker pool for blocking operations in fiber scheduler
+- Finish implementing all fiber scheduler hooks
+- Add `UM#select`
+- Add `UM#wakeup`
+- Add `UM#total_op_count`
+
 # 0.20.0 2025-11-26
 
 - Add `UM.pidfd_open`, `UM.pidfd_send_signal` methods

data/TODO.md

@@ -1,43 +1,5 @@
 ## immediate
 
-- make a reproducer for segfault on timeout, spin lots of fibers where a timeout
-  wraps a #shift call (from an empty queue).
-- see also: https://mensfeld.pl/2025/11/ruby-ffi-gc-bug-hash-becomes-string/
-
-Analysis:
-
-- The segfault is related to timeouts
-- Looking at process_runqueue_op (um.c):
-
-  ```c
-  inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
-    VALUE fiber = op->fiber;
-    VALUE value = op->value;
-
-    // on timeout, the op flags are changed to turn on OP_F_TRANSIENT
-    if (unlikely(op->flags & OP_F_TRANSIENT))
-      // here the op is freed, so the value is not visible to the GC anymoore
-      um_op_free(machine, op);
-
-    // if a GC occurs here, we risk a segfault
-
-    // value is used
-    return rb_fiber_transfer(fiber, 1, &value);
-  }
-  ```
-
-- So, a possible solution is to put a `RB_GC_GUARD` after the `return`.
-- But first, I want to be able to reproduce it. We can start by setting
-  `GC.stress = true` on tests and see if we segfault.
-
-## FiberScheduler implementation
-
-Some resources:
-
-- https://github.com/socketry/async/blob/main/context/getting-started.md
-- https://github.com/socketry/async/blob/main/context/scheduler.md
-- https://github.com/socketry/async/blob/main/lib/async/scheduler.rb#L28
-
 ## useful concurrency tools
 
 - debounce

data/examples/bm_queue.rb

@@ -5,11 +5,12 @@ require 'bundler/inline'
 gemfile do
   source 'https://rubygems.org'
   gem 'uringmachine', path: '..'
+  gem 'benchmark'
   gem 'benchmark-ips'
 end
 
 require 'benchmark/ips'
-require 'uringmachine'
+require_relative '../lib/uringmachine'
 
 COUNT = 1000
 NUM_PRODUCERS = 8

data/examples/bm_write.rb

@@ -11,7 +11,7 @@ end
 require 'benchmark'
 require 'uringmachine'
 
-ITERATIONS = 100000
+ITERATIONS = 10000
 BUF = ('*' * 8192).freeze
 FN = '/tmp/bm_write'
 
@@ -47,6 +47,9 @@ ensure
   fio.close
 end
 
+run_io_write(1)
+run_um_write(1)
+
 Benchmark.bm do |x|
   [1, 2, 4, 8].each do |c|
     x.report("IO (#{c} threads)")     { run_io_write(c) }

data/ext/um/extconf.rb

@@ -49,7 +49,7 @@ if !find_library('uring', nil, File.join(liburing_path, 'src'))
   raise "Couldn't find liburing.a"
 end
 
-have_func("rb_process_status_new")
+have_func("&rb_process_status_new")
 
 $defs << "-DUM_KERNEL_VERSION=#{config[:kernel_version]}"
 $defs << '-DHAVE_IO_URING_PREP_BIND'            if config[:prep_bind]

data/ext/um/um.c

@@ -1,25 +1,34 @@
-#include <float.h>
 #include "um.h"
+#include <float.h>
 #include <ruby/thread.h>
+#include <assert.h>
+#include <poll.h>
+
+#define DEFAULT_ENTRIES 4096
+
+inline void prepare_io_uring_params(struct io_uring_params *params, uint sqpoll_timeout_msec) {
+  memset(params, 0, sizeof(struct io_uring_params));
+  params->flags = IORING_SETUP_SUBMIT_ALL;
+  if (sqpoll_timeout_msec) {
+    params->flags |= IORING_SETUP_SQPOLL;
+    params->sq_thread_idle = sqpoll_timeout_msec;
+  }
+  else
+    params->flags |= IORING_SETUP_COOP_TASKRUN;
+}
 
-void um_setup(VALUE self, struct um *machine) {
+void um_setup(VALUE self, struct um *machine, uint entries, uint sqpoll_timeout_msec) {
   memset(machine, 0, sizeof(struct um));
 
   RB_OBJ_WRITE(self, &machine->self, self);
 
-  unsigned prepared_limit = 4096;
-  unsigned flags = IORING_SETUP_SUBMIT_ALL | IORING_SETUP_COOP_TASKRUN;
+  machine->entries = (entries > 0) ? entries : DEFAULT_ENTRIES;
+  machine->sqpoll_mode = !!sqpoll_timeout_msec;
 
-  while (1) {
-    int ret = io_uring_queue_init(prepared_limit, &machine->ring, flags);
-    if (likely(!ret)) break;
-
-    // if ENOMEM is returned, try with half as much entries
-    if (unlikely(ret == -ENOMEM && prepared_limit > 64))
-      prepared_limit = prepared_limit / 2;
-    else
-      rb_syserr_fail(-ret, strerror(-ret));
-  }
+  struct io_uring_params params;
+  prepare_io_uring_params(&params, sqpoll_timeout_msec);
+  int ret = io_uring_queue_init_params(machine->entries, &machine->ring, &params);
+  if (ret) rb_syserr_fail(-ret, strerror(-ret));
   machine->ring_initialized = 1;
 }
 
@@ -39,6 +48,11 @@ inline void um_teardown(struct um *machine) {
 }
 
 inline struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op) {
+  if (DEBUG) fprintf(stderr, "-> %p um_get_sqe: op->kind=%s unsubmitted=%d pending=%d total=%lu\n",
+    &machine->ring, op ? um_op_kind_name(op->kind) : "NULL", machine->unsubmitted_count,
+    machine->pending_count, machine->total_op_count
+  );
+
   struct io_uring_sqe *sqe;
   sqe = io_uring_get_sqe(&machine->ring);
   if (likely(sqe)) goto done;
@@ -57,22 +71,78 @@ done:
   sqe->user_data = (long long)op;
   sqe->flags = 0;
   machine->unsubmitted_count++;
-  if (op) machine->pending_count++;
+  if (op) {
+    machine->pending_count++;
+    machine->total_op_count++;
+  }
   return sqe;
 }
 
+struct um_submit_ctx {
+  struct um *machine;
+  int result;
+};
+
+// adapted from liburing/src/queue.c
+static inline bool sq_ring_needs_enter(struct um *machine) {
+  if (machine->sqpoll_mode) {
+	  io_uring_smp_mb();
+  	if (unlikely(IO_URING_READ_ONCE(*machine->ring.sq.kflags) & IORING_SQ_NEED_WAKEUP))
+	  	return true;
+  }
+  return true;
+}
+
+void *um_submit_without_gvl(void *ptr) {
+  struct um_submit_ctx *ctx = ptr;
+  ctx->result = io_uring_submit(&ctx->machine->ring);
+  return NULL;
+}
+
+inline uint um_submit(struct um *machine) {
+  if (DEBUG) fprintf(stderr, "-> %p um_submit: unsubmitted=%d pending=%d total=%lu\n",
+    &machine->ring, machine->unsubmitted_count, machine->pending_count, machine->total_op_count
+  );
+  if (!machine->unsubmitted_count) {
+    if (DEBUG) fprintf(stderr, "<- %p um_submit: no unsubmitted SQEs, early return\n",
+      &machine->ring
+    );
+    return 0;
+  }
+ 
+  struct um_submit_ctx ctx = { .machine = machine };
+  if (sq_ring_needs_enter(machine))
+    rb_thread_call_without_gvl(um_submit_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  else 
+    ctx.result = io_uring_submit(&machine->ring);
+
+  if (DEBUG) fprintf(stderr, "<- %p um_submit: result=%d\n",
+    &machine->ring, ctx.result
+  );
+
+  if (ctx.result < 0)
+    rb_syserr_fail(-ctx.result, strerror(-ctx.result));
+
+  machine->unsubmitted_count = 0;
+  return ctx.result;
+}
+
 static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe) {
   struct um_op *op = (struct um_op *)cqe->user_data;
+  if (DEBUG) {
+    if (op) fprintf(stderr, "<- %p um_process_cqe: op %p kind %s flags %d cqe_res %d cqe_flags %d pending %d\n",
+      &machine->ring, op, um_op_kind_name(op->kind), op->flags, cqe->res, cqe->flags, machine->pending_count
+    );
+    else fprintf(stderr, "<- %p um_process_cqe: op NULL cqe_res %d cqe_flags %d pending %d\n",
+      &machine->ring, cqe->res, cqe->flags, machine->pending_count
+    );
+  }
   if (unlikely(!op)) return;
 
+
   if (!(cqe->flags & IORING_CQE_F_MORE))
     machine->pending_count--;
 
-  // printf(
-  //   ":process_cqe op %p kind %d flags %d cqe_res %d cqe_flags %d pending %d\n",
-  //   op, op->kind, op->flags, cqe->res, cqe->flags, machine->pending_count
-  // );
-
   if (op->flags & OP_F_FREE_ON_COMPLETE) {
     if (op->flags & OP_F_TRANSIENT)
       um_op_transient_remove(machine, op);
@@ -81,9 +151,10 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
     return;
   }
 
+  op->flags |= OP_F_COMPLETED;
   if (unlikely((cqe->res == -ECANCELED) && (op->flags & OP_F_IGNORE_CANCELED))) return;
+  if (unlikely(op->flags & OP_F_CANCELED)) return;
 
-  op->flags |= OP_F_COMPLETED;
   if (op->flags & OP_F_TRANSIENT)
     um_op_transient_remove(machine, op);
 
@@ -108,6 +179,10 @@ static inline int cq_ring_needs_flush(struct io_uring *ring) {
 }
 
 static inline int um_process_ready_cqes(struct um *machine) {
+  if (DEBUG) fprintf(stderr, "-> %p um_process_ready_cqes: unsubmitted=%d pending=%d total=%lu\n",
+    &machine->ring, machine->unsubmitted_count, machine->pending_count, machine->total_op_count
+  );
+
   unsigned total_count = 0;
 iterate:
   bool overflow_checked = false;
@@ -124,12 +199,21 @@ iterate:
   if (overflow_checked) goto done;
 
   if (cq_ring_needs_flush(&machine->ring)) {
-    io_uring_enter(machine->ring.ring_fd, 0, 0, IORING_ENTER_GETEVENTS, NULL);
+    if (DEBUG) fprintf(stderr, "-> %p io_uring_enter\n", &machine->ring);
+    int ret = io_uring_enter(machine->ring.ring_fd, 0, 0, IORING_ENTER_GETEVENTS, NULL);
+    if (DEBUG) fprintf(stderr, "<- %p io_uring_enter: result=%d\n", &machine->ring, ret);
+    if (ret < 0)
+      rb_syserr_fail(-ret, strerror(-ret));
+
     overflow_checked = true;
     goto iterate;
   }
 
 done:
+  if (DEBUG) fprintf(stderr, "<- %p um_process_ready_cqes: total_processed=%u\n",
+    &machine->ring, total_count
+  );
+
   return total_count;
 }
 
@@ -143,18 +227,33 @@ struct wait_for_cqe_ctx {
 void *um_wait_for_cqe_without_gvl(void *ptr) {
   struct wait_for_cqe_ctx *ctx = ptr;
   if (ctx->machine->unsubmitted_count) {
-    ctx->machine->unsubmitted_count = 0;
+    if (DEBUG) fprintf(stderr, "-> %p io_uring_submit_and_wait_timeout: unsubmitted=%d pending=%d total=%lu\n",
+      &ctx->machine->ring, ctx->machine->unsubmitted_count, ctx->machine->pending_count,
+      ctx->machine->total_op_count
+    );
 
     // Attn: The io_uring_submit_and_wait_timeout will not return -EINTR if
     // interrupted with a signal. We can detect this by testing ctx->cqe for
     // NULL.
     //
     // https://github.com/axboe/liburing/issues/1280
-    int res = io_uring_submit_and_wait_timeout(&ctx->machine->ring, &ctx->cqe, ctx->wait_nr, NULL, NULL);
-    ctx->result = (res > 0 && !ctx->cqe) ? -EINTR : res;
+    int ret = io_uring_submit_and_wait_timeout(&ctx->machine->ring, &ctx->cqe, ctx->wait_nr, NULL, NULL);
+    ctx->machine->unsubmitted_count = 0;
+    if (DEBUG) fprintf(stderr, "<- %p io_uring_submit_and_wait_timeout: result=%d\n",
+      &ctx->machine->ring, ret
+    );
+    ctx->result = (ret > 0 && !ctx->cqe) ? -EINTR : ret;
   }
-  else
+  else {
+    if (DEBUG) fprintf(stderr, "-> %p io_uring_wait_cqes: unsubmitted=%d pending=%d total=%lu\n",
+      &ctx->machine->ring, ctx->machine->unsubmitted_count, ctx->machine->pending_count,
+      ctx->machine->total_op_count
+    );
     ctx->result = io_uring_wait_cqes(&ctx->machine->ring, &ctx->cqe, ctx->wait_nr, NULL, NULL);
+    if (DEBUG) fprintf(stderr, "<- %p io_uring_wait_cqes: result=%d\n",
+      &ctx->machine->ring, ctx->result
+    );
+  }
   return NULL;
 }
 
@@ -201,9 +300,14 @@ inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
 }
 
 inline VALUE um_fiber_switch(struct um *machine) {
+  if (DEBUG) fprintf(stderr, "-> %p um_fiber_switch: unsubmitted=%d pending=%d total=%lu\n",
+    &machine->ring, machine->unsubmitted_count, machine->pending_count, machine->total_op_count
+  );
   while (true) {
     struct um_op *op = um_runqueue_shift(machine);
     if (op) {
+      if (unlikely(op->flags & OP_F_RUNQUEUE_SKIP)) continue;
+
       // in case of a snooze, we need to prevent a situation where completions
       // are not processed because the runqueue is never empty. Theoretically,
       // we can still have a situation where multiple fibers are all doing a
@@ -231,16 +335,15 @@ inline VALUE um_fiber_switch(struct um *machine) {
   }
 }
 
-void um_submit_cancel_op(struct um *machine, struct um_op *op) {
+void um_cancel_op(struct um *machine, struct um_op *op) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, NULL);
   io_uring_prep_cancel64(sqe, (long long)op, 0);
 }
 
 inline void um_cancel_and_wait(struct um *machine, struct um_op *op) {
-  um_submit_cancel_op(machine, op);
-  while (true) {
+  um_cancel_op(machine, op);
+  while (!um_op_completed_p(op)) {
     um_fiber_switch(machine);
-    if (um_op_completed_p(op)) break;
   }
 }
 
@@ -261,7 +364,14 @@ inline VALUE um_await(struct um *machine) {
   return ret;
 }
 
-inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags) {
+VALUE um_wakeup(struct um *machine) {
+  struct io_uring_sqe *sqe = um_get_sqe(machine, NULL);
+  io_uring_prep_nop(sqe);
+  io_uring_submit(&machine->ring);
+  return Qnil;
+}
+
+inline void um_prep_op(struct um *machine, struct um_op *op, enum um_op_kind kind, unsigned flags) {
   memset(op, 0, sizeof(struct um_op));
   op->kind = kind;
   op->flags = flags;
@@ -299,7 +409,7 @@ VALUE um_timeout_complete(VALUE arg) {
   struct op_ctx *ctx = (struct op_ctx *)arg;
 
   if (!um_op_completed_p(ctx->op)) {
-    um_submit_cancel_op(ctx->machine, ctx->op);
+    um_cancel_op(ctx->machine, ctx->op);
     ctx->op->flags |= OP_F_TRANSIENT | OP_F_IGNORE_CANCELED;
     um_op_transient_add(ctx->machine, ctx->op);
   }
@@ -353,12 +463,12 @@ VALUE um_sleep(struct um *machine, double duration) {
   return ret;
 }
 
-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) {
   struct um_op op;
   um_prep_op(machine, &op, OP_READ, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   void *ptr = um_prepare_read_buffer(buffer, maxlen, buffer_offset);
-  io_uring_prep_read(sqe, fd, ptr, maxlen, -1);
+  io_uring_prep_read(sqe, fd, ptr, maxlen, file_offset);
 
   VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op)) {
@@ -389,17 +499,18 @@ size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen) {
   return 0;
 }
 
-VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len) {
-  struct um_op op;
-  um_prep_op(machine, &op, OP_WRITE, 0);
-  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
-
+VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset) {
   const void *base;
   size_t size;
   um_get_buffer_bytes_for_writing(buffer, &base, &size);
   if ((len == (size_t)-1) || (len > size)) len = size;
+  if (unlikely(!len)) return INT2NUM(0);
+
+  struct um_op op;
+  um_prep_op(machine, &op, OP_WRITE, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
 
-  io_uring_prep_write(sqe, fd, base, len, -1);
+  io_uring_prep_write(sqe, fd, base, len, file_offset);
 
   VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))
@@ -410,19 +521,22 @@ VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len) {
   return ret;
 }
 
-VALUE um_write_async(struct um *machine, int fd, VALUE buffer) {
+VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset) {
+  const void *base;
+  size_t size;
+  um_get_buffer_bytes_for_writing(buffer, &base, &size);
+  if ((len == (size_t)-1) || (len > size)) len = size;
+  if (unlikely(!len)) return INT2NUM(0);
+
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_WRITE_ASYNC, OP_F_TRANSIENT | OP_F_FREE_ON_COMPLETE);
   RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
   RB_OBJ_WRITE(machine->self, &op->value, buffer);
   RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
-  const void *base;
-  size_t size;
-  um_get_buffer_bytes_for_writing(buffer, &base, &size);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-  io_uring_prep_write(sqe, fd, base, size, -1);
+  io_uring_prep_write(sqe, fd, base, len, file_offset);
   um_op_transient_add(machine, op);
 
   return buffer;
@@ -686,6 +800,114 @@ VALUE um_poll(struct um *machine, int fd, unsigned mask) {
   return ret;
 }
 
+static inline void prepare_select_poll_ops(struct um *machine, uint *idx, struct um_op *ops, VALUE fds, uint len, uint flags, uint event) {
+  for (uint i = 0; i < len; i++) {
+    struct um_op *op = ops + ((*idx)++);
+    um_prep_op(machine, op, OP_POLL, flags | OP_F_IGNORE_CANCELED);
+    struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+    VALUE fd = rb_ary_entry(fds, i);
+    RB_OBJ_WRITE(machine->self, &op->value, fd);
+    io_uring_prep_poll_add(sqe, NUM2INT(fd), event);
+  }
+}
+
+VALUE um_select_single(struct um *machine, VALUE rfds, VALUE wfds, VALUE efds, uint rfds_len, uint wfds_len, uint efds_len) {
+  struct um_op op;
+  uint idx = 0;
+  if (rfds_len)
+    prepare_select_poll_ops(machine, &idx, &op, rfds, rfds_len, OP_F_SELECT_POLLIN, POLLIN);
+  else if (wfds_len)
+    prepare_select_poll_ops(machine, &idx, &op, wfds, wfds_len, OP_F_SELECT_POLLOUT, POLLOUT);
+  else if (efds_len)
+    prepare_select_poll_ops(machine, &idx, &op, efds, efds_len, OP_F_SELECT_POLLPRI, POLLPRI);
+  assert(idx == 1);
+
+  VALUE ret = um_fiber_switch(machine);
+  um_check_completion(machine, &op);
+  RAISE_IF_EXCEPTION(ret);
+
+  if (op.flags & OP_F_SELECT_POLLIN)
+    return rb_ary_new3(3, rb_ary_new3(1, ret), rb_ary_new(), rb_ary_new());
+  else if (op.flags & OP_F_SELECT_POLLOUT)
+    return rb_ary_new3(3, rb_ary_new(), rb_ary_new3(1, ret), rb_ary_new());
+  else
+    return rb_ary_new3(3, rb_ary_new(), rb_ary_new(), rb_ary_new3(1, ret));
+
+  RB_GC_GUARD(ret);
+}
+
+VALUE um_select(struct um *machine, VALUE rfds, VALUE wfds, VALUE efds) {
+  uint rfds_len = RARRAY_LEN(rfds);
+  uint wfds_len = RARRAY_LEN(wfds);
+  uint efds_len = RARRAY_LEN(efds);
+  uint total_len = rfds_len + wfds_len + efds_len;
+  if (total_len == 1)
+    return um_select_single(machine, rfds, wfds, efds, rfds_len, wfds_len, efds_len);
+
+  if (unlikely(!total_len))
+    return rb_ary_new3(3, rb_ary_new(), rb_ary_new(), rb_ary_new());
+
+  struct um_op *ops = malloc(sizeof(struct um_op) * total_len);
+  uint idx = 0;
+  prepare_select_poll_ops(machine, &idx, ops, rfds, rfds_len, OP_F_SELECT_POLLIN, POLLIN);
+  prepare_select_poll_ops(machine, &idx, ops, wfds, wfds_len, OP_F_SELECT_POLLOUT, POLLOUT);
+  prepare_select_poll_ops(machine, &idx, ops, efds, efds_len, OP_F_SELECT_POLLPRI, POLLPRI);
+  assert(idx == total_len);
+
+  VALUE ret = um_fiber_switch(machine);
+  if (unlikely(um_value_is_exception_p(ret))) {
+    free(ops);
+    um_raise_exception(ret);
+  }
+
+  VALUE rfds_out = rb_ary_new();
+  VALUE wfds_out = rb_ary_new();
+  VALUE efds_out = rb_ary_new();
+
+  int error_code = 0;
+  uint pending = total_len;
+  for (uint i = 0; i < total_len; i++) {
+    if (um_op_completed_p(&ops[i])) {
+      ops[i].flags |= OP_F_RUNQUEUE_SKIP;
+      pending--;
+
+      if (unlikely((ops[i].result.res < 0) && !error_code)) {
+        error_code = ops[i].result.res;
+      }
+      else {
+        if (ops[i].flags & OP_F_SELECT_POLLIN)  rb_ary_push(rfds_out, ops[i].value);
+        if (ops[i].flags & OP_F_SELECT_POLLOUT) rb_ary_push(wfds_out, ops[i].value);
+        if (ops[i].flags & OP_F_SELECT_POLLPRI) rb_ary_push(efds_out, ops[i].value);
+      }
+    }
+    else {
+      ops[i].flags |= OP_F_CANCELED;
+      um_cancel_op(machine, &ops[i]);
+    }
+  }
+
+  while (pending) {
+    um_wait_for_and_process_ready_cqes(machine, 0);
+
+    for (uint i = 0; i < total_len; i++) {
+      struct um_op *op = ops + i;
+      if (op->flags & OP_F_CANCELED && um_op_completed_p(op)) {
+        pending--;
+      }
+    }
+  }
+  free(ops);
+
+  if (error_code)
+    um_raise_on_error_result(error_code);
+
+  return rb_ary_new3(3, rfds_out, wfds_out, efds_out);
+
+  RB_GC_GUARD(rfds_out);
+  RB_GC_GUARD(wfds_out);
+  RB_GC_GUARD(efds_out);
+}
+
 VALUE um_waitid(struct um *machine, int idtype, int id, int options) {
   struct um_op op;
   um_prep_op(machine, &op, OP_WAITID, 0);
@@ -706,8 +928,8 @@ VALUE um_waitid(struct um *machine, int idtype, int id, int options) {
   );
 }
 
-VALUE um_waitid_status(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) {
   struct um_op op;
   um_prep_op(machine, &op, OP_WAITID, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
@@ -723,10 +945,8 @@ VALUE um_waitid_status(struct um *machine, int idtype, int id, int options) {
   RB_GC_GUARD(ret);
 
   return rb_process_status_new(infop.si_pid, (infop.si_status & 0xff) << 8, 0);
-#else
-  rb_raise(rb_eNotImpError, "Missing rb_process_status_new");
-#endif
 }
+#endif
 
 #define hash_set(h, sym, v) rb_hash_aset(h, ID2SYM(rb_intern(sym)), v)