uringmachine 0.21.0 → 0.22.0

data/ext/um/um.c

@@ -4,7 +4,7 @@
 #include <assert.h>
 #include <poll.h>
 
-#define DEFAULT_ENTRIES 4096
+#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));
@@ -17,17 +17,18 @@ inline void prepare_io_uring_params(struct io_uring_params *params, uint sqpoll_
     params->flags |= IORING_SETUP_COOP_TASKRUN;
 }
 
-void um_setup(VALUE self, struct um *machine, uint entries, uint sqpoll_timeout_msec) {
+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());
 
-  machine->entries = (entries > 0) ? entries : DEFAULT_ENTRIES;
+  machine->size = (size > 0) ? size : DEFAULT_SIZE;
   machine->sqpoll_mode = !!sqpoll_timeout_msec;
 
   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);
+  int ret = io_uring_queue_init_params(machine->size, &machine->ring, &params);
   if (ret) rb_syserr_fail(-ret, strerror(-ret));
   machine->ring_initialized = 1;
 }
@@ -48,15 +49,16 @@ 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
+  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?
@@ -70,10 +72,10 @@ 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++;
+  machine->metrics.ops_unsubmitted++;
   if (op) {
-    machine->pending_count++;
-    machine->total_op_count++;
+    machine->metrics.ops_pending++;
+    machine->metrics.total_ops++;
   }
   return sqe;
 }
@@ -100,48 +102,48 @@ void *um_submit_without_gvl(void *ptr) {
 }
 
 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
+  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->unsubmitted_count) {
-    if (DEBUG) fprintf(stderr, "<- %p um_submit: no unsubmitted SQEs, early return\n",
-      &machine->ring
-    );
+  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 
+  else
     ctx.result = io_uring_submit(&machine->ring);
 
-  if (DEBUG) fprintf(stderr, "<- %p um_submit: result=%d\n",
-    &machine->ring, ctx.result
-  );
+  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->unsubmitted_count = 0;
+  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) 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 (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--;
+    machine->metrics.ops_pending--;
 
   if (op->flags & OP_F_FREE_ON_COMPLETE) {
     if (op->flags & OP_F_TRANSIENT)
@@ -179,8 +181,8 @@ 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
+  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;
@@ -199,9 +201,9 @@ iterate:
   if (overflow_checked) goto done;
 
   if (cq_ring_needs_flush(&machine->ring)) {
-    if (DEBUG) fprintf(stderr, "-> %p io_uring_enter\n", &machine->ring);
+    DEBUG_PRINTF("-> %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);
+    DEBUG_PRINTF("<- %p io_uring_enter: result=%d\n", &machine->ring, ret);
     if (ret < 0)
       rb_syserr_fail(-ret, strerror(-ret));
 
@@ -210,9 +212,7 @@ iterate:
   }
 
 done:
-  if (DEBUG) fprintf(stderr, "<- %p um_process_ready_cqes: total_processed=%u\n",
-    &machine->ring, total_count
-  );
+  DEBUG_PRINTF("<- %p um_process_ready_cqes: total_processed=%u\n", &machine->ring, total_count);
 
   return total_count;
 }
@@ -226,10 +226,10 @@ 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) {
-    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
+  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
@@ -238,31 +238,49 @@ void *um_wait_for_cqe_without_gvl(void *ptr) {
     //
     // https://github.com/axboe/liburing/issues/1280
     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->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 {
-    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
+    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);
-    if (DEBUG) fprintf(stderr, "<- %p io_uring_wait_cqes: result=%d\n",
-      &ctx->machine->ring, ctx->result
-    );
+    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:
@@ -286,22 +304,36 @@ 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) {
-  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
+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);
@@ -316,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);
@@ -335,6 +367,14 @@ inline VALUE um_fiber_switch(struct um *machine) {
   }
 }
 
+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);
@@ -342,9 +382,13 @@ void um_cancel_op(struct um *machine, struct um_op *op) {
 
 inline void um_cancel_and_wait(struct um *machine, struct um_op *op) {
   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_fiber_switch(machine);
+    um_switch(machine);
   }
+  rb_hash_delete(machine->pending_fibers, fiber);
 }
 
 inline int um_check_completion(struct um *machine, struct um_op *op) {
@@ -357,13 +401,6 @@ 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);
@@ -449,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);
@@ -470,7 +508,8 @@ VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t b
   void *ptr = um_prepare_read_buffer(buffer, maxlen, buffer_offset);
   io_uring_prep_read(sqe, fd, ptr, maxlen, file_offset);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(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);
@@ -488,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);
@@ -512,7 +551,8 @@ VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_
 
   io_uring_prep_write(sqe, fd, base, len, file_offset);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
@@ -530,10 +570,7 @@ VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64
 
   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);
-
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_write(sqe, fd, base, len, file_offset);
@@ -548,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);
 
@@ -560,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);
@@ -576,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);
 
@@ -591,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);
 
@@ -606,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);
 
@@ -627,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);
 
@@ -647,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);
 
@@ -664,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);
@@ -681,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);
 
@@ -696,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);
 
@@ -714,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);
 
@@ -731,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);
 
@@ -748,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);
 
@@ -760,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);
@@ -776,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);
 
@@ -791,12 +835,15 @@ 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;
 }
 
@@ -822,7 +869,8 @@ VALUE um_select_single(struct um *machine, VALUE rfds, VALUE wfds, VALUE efds, u
     prepare_select_poll_ops(machine, &idx, &op, efds, efds_len, OP_F_SELECT_POLLPRI, POLLPRI);
   assert(idx == 1);
 
-  VALUE ret = um_fiber_switch(machine);
+  VALUE ret = um_yield(machine);
+
   um_check_completion(machine, &op);
   RAISE_IF_EXCEPTION(ret);
 
@@ -854,7 +902,7 @@ VALUE um_select(struct um *machine, VALUE rfds, VALUE wfds, VALUE efds) {
   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);
+  VALUE ret = um_yield(machine);
   if (unlikely(um_value_is_exception_p(ret))) {
     free(ops);
     um_raise_exception(ret);
@@ -916,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);
 
@@ -937,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);
 
@@ -983,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);
 
@@ -1003,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;
@@ -1045,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;
 }
 
@@ -1067,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;
@@ -1128,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;
@@ -1179,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;
@@ -1215,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);
+}