uringmachine 0.20.0 → 0.22.0

data/ext/um/um.c

@@ -1,25 +1,35 @@
-#include <float.h>
 #include "um.h"
+#include <float.h>
 #include <ruby/thread.h>
+#include <assert.h>
+#include <poll.h>
+
+#define DEFAULT_SIZE 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 size, uint sqpoll_timeout_msec) {
   memset(machine, 0, sizeof(struct um));
 
   RB_OBJ_WRITE(self, &machine->self, self);
+  RB_OBJ_WRITE(self, &machine->pending_fibers, rb_hash_new());
 
-  unsigned prepared_limit = 4096;
-  unsigned flags = IORING_SETUP_SUBMIT_ALL | IORING_SETUP_COOP_TASKRUN;
+  machine->size = (size > 0) ? size : DEFAULT_SIZE;
+  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->size, &machine->ring, &params);
+  if (ret) rb_syserr_fail(-ret, strerror(-ret));
   machine->ring_initialized = 1;
 }
 
@@ -39,10 +49,16 @@ inline void um_teardown(struct um *machine) {
 }
 
 inline struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op) {
+  DEBUG_PRINTF("-> %p um_get_sqe: op %p kind=%s unsubmitted=%d pending=%d total=%lu\n",
+    &machine->ring, op, um_op_kind_name(op ? op->kind : OP_UNDEFINED),
+    machine->metrics.ops_unsubmitted, machine->metrics.ops_pending, machine->metrics.total_ops
+  );
+
   struct io_uring_sqe *sqe;
   sqe = io_uring_get_sqe(&machine->ring);
   if (likely(sqe)) goto done;
 
+  fprintf(stderr, "!!!Failed to get SQE\n");
   um_raise_internal_error("Failed to get SQE");
 
   // TODO: retry getting SQE?
@@ -56,22 +72,78 @@ inline struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op) {
 done:
   sqe->user_data = (long long)op;
   sqe->flags = 0;
-  machine->unsubmitted_count++;
-  if (op) machine->pending_count++;
+  machine->metrics.ops_unsubmitted++;
+  if (op) {
+    machine->metrics.ops_pending++;
+    machine->metrics.total_ops++;
+  }
   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) {
+  DEBUG_PRINTF("-> %p um_submit: unsubmitted=%d pending=%d total=%lu\n",
+    &machine->ring, machine->metrics.ops_unsubmitted, machine->metrics.ops_pending,
+    machine->metrics.total_ops
+  );
+  if (!machine->metrics.ops_unsubmitted) {
+    DEBUG_PRINTF("<- %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);
+
+  DEBUG_PRINTF("<- %p um_submit: result=%d\n", &machine->ring, ctx.result);
+
+  if (ctx.result < 0)
+    rb_syserr_fail(-ctx.result, strerror(-ctx.result));
+
+  machine->metrics.ops_unsubmitted = 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) {
+      DEBUG_PRINTF("<- %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->metrics.ops_pending
+      );
+    }
+    else {
+      DEBUG_PRINTF("<- %p um_process_cqe: op NULL cqe_res %d cqe_flags %d pending %d\n",
+        &machine->ring, cqe->res, cqe->flags, machine->metrics.ops_pending
+      );
+    }
+  }
   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
-  // );
+    machine->metrics.ops_pending--;
 
   if (op->flags & OP_F_FREE_ON_COMPLETE) {
     if (op->flags & OP_F_TRANSIENT)
@@ -81,9 +153,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 +181,10 @@ static inline int cq_ring_needs_flush(struct io_uring *ring) {
 }
 
 static inline int um_process_ready_cqes(struct um *machine) {
+  DEBUG_PRINTF("-> %p um_process_ready_cqes: unsubmitted=%d pending=%d total=%lu\n",
+    &machine->ring, machine->metrics.ops_unsubmitted, machine->metrics.ops_pending, machine->metrics.total_ops
+  );
+
   unsigned total_count = 0;
 iterate:
   bool overflow_checked = false;
@@ -124,12 +201,19 @@ 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);
+    DEBUG_PRINTF("-> %p io_uring_enter\n", &machine->ring);
+    int ret = io_uring_enter(machine->ring.ring_fd, 0, 0, IORING_ENTER_GETEVENTS, NULL);
+    DEBUG_PRINTF("<- %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:
+  DEBUG_PRINTF("<- %p um_process_ready_cqes: total_processed=%u\n", &machine->ring, total_count);
+
   return total_count;
 }
 
@@ -142,28 +226,61 @@ 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 (ctx->machine->metrics.ops_unsubmitted) {
+    DEBUG_PRINTF("-> %p io_uring_submit_and_wait_timeout: unsubmitted=%d pending=%d total=%lu\n",
+      &ctx->machine->ring, ctx->machine->metrics.ops_unsubmitted, ctx->machine->metrics.ops_pending,
+      ctx->machine->metrics.total_ops
+    );
 
     // 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->metrics.ops_unsubmitted = 0;
+    DEBUG_PRINTF("<- %p io_uring_submit_and_wait_timeout: result=%d\n", &ctx->machine->ring, ret);
+    ctx->result = (ret > 0 && !ctx->cqe) ? -EINTR : ret;
   }
-  else
+  else {
+    DEBUG_PRINTF("-> %p io_uring_wait_cqes: unsubmitted=%d pending=%d total=%lu\n",
+      &ctx->machine->ring, ctx->machine->metrics.ops_unsubmitted, ctx->machine->metrics.ops_pending,
+      ctx->machine->metrics.total_ops
+    );
     ctx->result = io_uring_wait_cqes(&ctx->machine->ring, &ctx->cqe, ctx->wait_nr, NULL, NULL);
+    DEBUG_PRINTF("<- %p io_uring_wait_cqes: result=%d\n", &ctx->machine->ring, ctx->result);
+  }
   return NULL;
 }
 
+inline void um_profile_wait_cqe_pre(struct um *machine, double *time_monotonic0, VALUE *fiber) {
+  // *fiber = rb_fiber_current();
+  *time_monotonic0 = um_get_time_monotonic();
+  // double time_cpu = um_get_time_cpu();
+  // double elapsed = time_cpu - machine->metrics.time_last_cpu;
+  // um_update_fiber_time_run(fiber, time_monotonic0, elapsed);
+  // machine->metrics.time_last_cpu = time_cpu;
+}
+
+inline void um_profile_wait_cqe_post(struct um *machine, double time_monotonic0, VALUE fiber) {
+  // double time_cpu = um_get_time_cpu();
+  double elapsed = um_get_time_monotonic() - time_monotonic0;
+  // um_update_fiber_last_time(fiber, cpu_time1);
+  machine->metrics.time_total_wait += elapsed;
+  // machine->metrics.time_last_cpu = time_cpu;
+}
+
 // Waits for the given minimum number of completion entries. The wait_nr is
 // either 1 - where we wait for at least one CQE to be ready, or 0, where we
 // don't wait, and just process any CQEs that already ready.
 static inline void um_wait_for_and_process_ready_cqes(struct um *machine, int wait_nr) {
   struct wait_for_cqe_ctx ctx = { .machine = machine, .cqe = NULL, .wait_nr = wait_nr };
+  machine->metrics.total_waits++;
+  double time_monotonic0 = 0.0;
+  VALUE fiber;
+  if (machine->profile_mode) um_profile_wait_cqe_pre(machine, &time_monotonic0, &fiber);
   rb_thread_call_without_gvl(um_wait_for_cqe_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  if (machine->profile_mode) um_profile_wait_cqe_post(machine, time_monotonic0, fiber);
 
   if (unlikely(ctx.result < 0)) {
     // the internal calls to (maybe submit) and wait for cqes may fail with:
@@ -187,23 +304,42 @@ static inline void um_wait_for_and_process_ready_cqes(struct um *machine, int wa
   }
 }
 
+inline void um_profile_switch(struct um *machine, VALUE next_fiber) {
+  // *current_fiber = rb_fiber_current();
+  // double time_cpu = um_get_time_cpu();
+  // double elapsed = time_cpu - machine->metrics.time_last_cpu;
+  // um_update_fiber_time_run(cur_fiber, time_cpu, elapsed);
+  // um_update_fiber_time_wait(next_fiber, time_cpu);
+  // machine->metrics.time_last_cpu = time_cpu;
+}
+
 inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
+  DEBUG_PRINTF("-> %p process_runqueue_op: op %p\n", &machine->ring, op);
+
+  machine->metrics.total_switches++;
   VALUE fiber = op->fiber;
   VALUE value = op->value;
 
   if (unlikely(op->flags & OP_F_TRANSIENT))
     um_op_free(machine, op);
 
+  if (machine->profile_mode) um_profile_switch(machine, fiber);
   VALUE ret = rb_fiber_transfer(fiber, 1, &value);
   RB_GC_GUARD(value);
   RB_GC_GUARD(ret);
   return ret;
 }
 
-inline VALUE um_fiber_switch(struct um *machine) {
+inline VALUE um_switch(struct um *machine) {
+  DEBUG_PRINTF("-> %p um_switch: unsubmitted=%d pending=%d total=%lu\n",
+    &machine->ring, machine->metrics.ops_unsubmitted, machine->metrics.ops_pending,
+    machine->metrics.total_ops
+  );
   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
@@ -212,7 +348,7 @@ inline VALUE um_fiber_switch(struct um *machine) {
       // is the op a snooze op and is this the same fiber as the current one?
       if (unlikely(op->kind == OP_SCHEDULE && op->fiber == rb_fiber_current())) {
         //  are there any pending ops (i.e. waiting for completion)?
-        if (machine->pending_count > 0) {
+        if (machine->metrics.ops_pending > 0) {
           // if yes, process completions, get runqueue head, put original op
           // back on runqueue.
           // um_process_ready_cqes(machine);
@@ -231,17 +367,28 @@ inline VALUE um_fiber_switch(struct um *machine) {
   }
 }
 
-void um_submit_cancel_op(struct um *machine, struct um_op *op) {
+inline VALUE um_yield(struct um *machine) {
+  VALUE fiber = rb_fiber_current();
+  rb_hash_aset(machine->pending_fibers, fiber, Qtrue);
+  VALUE ret = um_switch(machine);
+  rb_hash_delete(machine->pending_fibers, fiber);
+  return ret;
+}
+
+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_fiber_switch(machine);
-    if (um_op_completed_p(op)) break;
+  um_cancel_op(machine, op);
+
+  VALUE fiber = rb_fiber_current();
+  rb_hash_aset(machine->pending_fibers, fiber, Qtrue);
+  while (!um_op_completed_p(op)) {
+    um_switch(machine);
   }
+  rb_hash_delete(machine->pending_fibers, fiber);
 }
 
 inline int um_check_completion(struct um *machine, struct um_op *op) {
@@ -254,14 +401,14 @@ inline int um_check_completion(struct um *machine, struct um_op *op) {
   return 1;
 }
 
-inline VALUE um_await(struct um *machine) {
-  VALUE ret = um_fiber_switch(machine);
-  RAISE_IF_EXCEPTION(ret);
-  RB_GC_GUARD(ret);
-  return ret;
+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 op_kind kind, unsigned flags) {
+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 +446,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);
   }
@@ -339,7 +486,8 @@ VALUE um_sleep(struct um *machine, double duration) {
   op.ts = um_double_to_timespec(duration);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_timeout(sqe, &op.ts, 0, 0);
-  VALUE ret = um_fiber_switch(machine);
+
+  VALUE ret = um_yield(machine);
 
   if (!um_op_completed_p(&op))
     um_cancel_and_wait(machine, &op);
@@ -353,14 +501,15 @@ 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_yield(machine);
 
-  VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op)) {
     um_update_read_buffer(machine, buffer, buffer_offset, op.result.res, op.result.flags);
     ret = INT2NUM(op.result.res);
@@ -378,10 +527,10 @@ size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_read(sqe, fd, buffer, maxlen, -1);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op)) {
     return op.result.res;
-
   }
 
   RAISE_IF_EXCEPTION(ret);
@@ -389,19 +538,21 @@ 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_yield(machine);
 
-  VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -410,19 +561,19 @@ 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) {
-  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);
-
+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->value, buffer);
 
   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;
@@ -434,7 +585,8 @@ VALUE um_close(struct um *machine, int fd) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_close(sqe, fd);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(fd);
 
@@ -446,9 +598,6 @@ VALUE um_close(struct um *machine, int fd) {
 VALUE um_close_async(struct um *machine, int fd) {
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_CLOSE_ASYNC, OP_F_FREE_ON_COMPLETE);
-  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
-  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
-  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_close(sqe, fd);
@@ -462,7 +611,8 @@ VALUE um_accept(struct um *machine, int fd) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_accept(sqe, fd, NULL, NULL, 0);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -477,7 +627,8 @@ VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint fla
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_socket(sqe, domain, type, protocol, flags);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -492,7 +643,8 @@ VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, sockle
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_connect(sqe, fd, addr, addrlen);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -513,7 +665,8 @@ VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags) {
 
   io_uring_prep_send(sqe, fd, base, len, flags);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -533,7 +686,8 @@ VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings) {
 	sqe->flags |= IOSQE_BUFFER_SELECT;
 	sqe->buf_group = bgid;
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -550,7 +704,8 @@ VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags
 
   io_uring_prep_recv(sqe, fd, ptr, maxlen, flags);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op)) {
     um_update_read_buffer(machine, buffer, 0, op.result.res, op.result.flags);
     ret = INT2NUM(op.result.res);
@@ -567,7 +722,8 @@ VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrl
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_bind(sqe, fd, addr, addrlen);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -582,7 +738,8 @@ VALUE um_listen(struct um *machine, int fd, int backlog) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_listen(sqe, fd, backlog);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -600,7 +757,8 @@ VALUE um_getsockopt(struct um *machine, int fd, int level, int opt) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_cmd_sock(sqe, SOCKET_URING_OP_GETSOCKOPT, fd, level, opt, &value, sizeof(value));
 
-  ret = um_fiber_switch(machine);
+  ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(value);
 
@@ -617,7 +775,8 @@ VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_cmd_sock(sqe, SOCKET_URING_OP_SETSOCKOPT, fd, level, opt, &value, sizeof(value));
 
-  ret = um_fiber_switch(machine);
+  ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -634,7 +793,8 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_shutdown(sqe, fd, how);
 
-  ret = um_fiber_switch(machine);
+  ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -646,9 +806,6 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
 VALUE um_shutdown_async(struct um *machine, int fd, int how) {
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_SHUTDOWN_ASYNC, OP_F_FREE_ON_COMPLETE);
-  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
-  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
-  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_shutdown(sqe, fd, how);
@@ -662,7 +819,8 @@ VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_open(sqe, StringValueCStr(pathname), flags, mode);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -677,15 +835,127 @@ VALUE um_poll(struct um *machine, int fd, unsigned mask) {
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_poll_add(sqe, fd, mask);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
+  RB_GC_GUARD(op.fiber);
+  RB_GC_GUARD(op.value);
   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_yield(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_yield(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);
@@ -694,7 +964,8 @@ VALUE um_waitid(struct um *machine, int idtype, int id, int options) {
   siginfo_t infop;
   io_uring_prep_waitid(sqe, idtype, id, &infop, options, 0);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -706,8 +977,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);
@@ -715,7 +986,7 @@ VALUE um_waitid_status(struct um *machine, int idtype, int id, int options) {
   siginfo_t infop;
   io_uring_prep_waitid(sqe, idtype, id, &infop, options | WNOWAIT, 0);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -723,10 +994,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)
 
@@ -763,7 +1032,8 @@ VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned in
   memset(&stat, 0, sizeof(stat));
   io_uring_prep_statx(sqe, dirfd, path_ptr, flags, mask, &stat);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -783,7 +1053,7 @@ VALUE accept_each_start(VALUE arg) {
   io_uring_prep_multishot_accept(sqe, ctx->fd, NULL, NULL, 0);
 
   while (true) {
-    VALUE ret = um_fiber_switch(ctx->machine);
+    VALUE ret = um_yield(ctx->machine);
     if (!um_op_completed_p(ctx->op)) {
       RAISE_IF_EXCEPTION(ret);
       return ret;
@@ -825,6 +1095,8 @@ VALUE multishot_complete(VALUE arg) {
   if (ctx->read_buf)
     free(ctx->read_buf);
 
+  rb_hash_delete(ctx->machine->pending_fibers, ctx->op->fiber);
+
   return Qnil;
 }
 
@@ -847,7 +1119,7 @@ int um_read_each_singleshot_loop(struct op_ctx *ctx) {
     struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
     io_uring_prep_read(sqe, ctx->fd, ctx->read_buf, ctx->read_maxlen, -1);
 
-    VALUE ret = um_fiber_switch(ctx->machine);
+    VALUE ret = um_yield(ctx->machine);
     if (um_op_completed_p(ctx->op)) {
       um_raise_on_error_result(ctx->op->result.res);
       if (!ctx->op->result.res) return total;
@@ -908,7 +1180,7 @@ VALUE read_recv_each_start(VALUE arg) {
   int total = 0;
 
   while (true) {
-    VALUE ret = um_fiber_switch(ctx->machine);
+    VALUE ret = um_yield(ctx->machine);
     if (!um_op_completed_p(ctx->op)) {
       RAISE_IF_EXCEPTION(ret);
       return ret;
@@ -959,7 +1231,7 @@ VALUE periodically_start(VALUE arg) {
   io_uring_prep_timeout(sqe, &ctx->ts, 0, IORING_TIMEOUT_MULTISHOT);
 
   while (true) {
-    VALUE ret = um_fiber_switch(ctx->machine);
+    VALUE ret = um_switch(ctx->machine);
     if (!um_op_completed_p(ctx->op)) {
       RAISE_IF_EXCEPTION(ret);
       return ret;
@@ -995,3 +1267,40 @@ VALUE um_periodically(struct um *machine, double interval) {
   struct op_ctx ctx = { .machine = machine, .op = &op, .ts = op.ts, .read_buf = NULL };
   return rb_ensure(periodically_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
+
+extern VALUE SYM_size;
+extern VALUE SYM_total_ops;
+extern VALUE SYM_total_switches;
+extern VALUE SYM_total_waits;
+extern VALUE SYM_ops_pending;
+extern VALUE SYM_ops_unsubmitted;
+extern VALUE SYM_ops_runqueue;
+extern VALUE SYM_ops_free;
+extern VALUE SYM_ops_transient;
+extern VALUE SYM_time_total_cpu;
+extern VALUE SYM_time_total_wait;
+
+VALUE um_metrics(struct um *machine, struct um_metrics *metrics) {
+  VALUE hash = rb_hash_new();
+
+  rb_hash_aset(hash, SYM_size,            UINT2NUM(machine->size));
+
+  rb_hash_aset(hash, SYM_total_ops,       ULONG2NUM(metrics->total_ops));
+  rb_hash_aset(hash, SYM_total_switches,  ULONG2NUM(metrics->total_switches));
+  rb_hash_aset(hash, SYM_total_waits,     ULONG2NUM(metrics->total_waits));
+
+  rb_hash_aset(hash, SYM_ops_pending,     UINT2NUM(metrics->ops_pending));
+  rb_hash_aset(hash, SYM_ops_unsubmitted, UINT2NUM(metrics->ops_unsubmitted));
+  rb_hash_aset(hash, SYM_ops_runqueue,    UINT2NUM(metrics->ops_runqueue));
+  rb_hash_aset(hash, SYM_ops_free,        UINT2NUM(metrics->ops_free));
+  rb_hash_aset(hash, SYM_ops_transient,   UINT2NUM(metrics->ops_transient));
+
+  if (machine->profile_mode) {
+    double total_cpu = um_get_time_cpu() - metrics->time_first_cpu;
+    rb_hash_aset(hash, SYM_time_total_cpu,  DBL2NUM(total_cpu));
+    rb_hash_aset(hash, SYM_time_total_wait, DBL2NUM(metrics->time_total_wait));
+  }
+
+  return hash;
+  RB_GC_GUARD(hash);
+}