uringmachine 0.1 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2ac86e83825689e22080a04bf37ebfd553134d3209920d16f1ed413418847aa
-  data.tar.gz: a599878fb9a7745069b39efcb60c3610eea525693adadc2236d4ad06cbc9ad83
+  metadata.gz: 7129b3c8605d5734f7152bddb4fa1b6f034fd1de26262eabfbfc2190846967bd
+  data.tar.gz: 902e6663bac65d56e45d67383e2cd3eb0601534ed2b451f4f76b2812ce6125b1
 SHA512:
-  metadata.gz: 21f2236193e8df1799718ec96ffef7f72132fa57b3e61371544d35f1748459f1e2b9bb10a577ca3e9cee8e6666f2675aca4a9bd9f21c9f4923f8be633859cbe3
-  data.tar.gz: 2bfa3c754a5911edb2b9f2437c265fe978db9b39fcc05bce8c3047e81ce051e26a934014313edeb428ee6b40997ce490c50f9459a0e414b9aad2dc75530a31cf
+  metadata.gz: 683db63642ddb5d98c9eb137f8121a8cb8cb0fe44456928fca78cf8e322cebc01078efa71379abcceae1a1889140bf5b39f6ac16348db0b77d9c8a5bb9cf5cd0
+  data.tar.gz: 850dce780030b6102371861805f831299d3ea113f8c02141515afe167b0e49f43a51812a6159a91b6335085b41fcb226713eeb963ae69d208818cb1f3cb303b3

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 2024-10-04 Version 0.3
+
+- Fix race condition affecting `#timeout` and `#sleep`.
+- Add `#accept_each`
+- Add `#accept`
+
+# 2024-10-03 Version 0.2
+
+- Remove old IOU code.
+- Add `#read_each`
+- Add `#read`
+
 # 2024-10-03 Version 0.1
 
 The basic fiber scheduling stuff

data/Rakefile

@@ -26,7 +26,7 @@ CLEAN.include "**/*.o", "**/*.so", "**/*.so.*", "**/*.a", "**/*.bundle", "**/*.j
 
 task :release do
   require_relative './lib/uringmachine/version'
-  version = UM::VERSION
+  version = UringMachine::VERSION
 
   puts 'Building uringmachine...'
   `gem build uringmachine.gemspec`

data/ext/um/um.c

@@ -2,6 +2,54 @@
 #include "ruby/thread.h"
 #include <sys/mman.h>
 
+void um_setup(struct um *machine) {
+  machine->ring_initialized = 0;
+  machine->unsubmitted_count = 0;
+  machine->buffer_ring_count = 0;
+  machine->pending_count = 0;
+  machine->runqueue_head = NULL;
+  machine->runqueue_tail = NULL;
+  machine->op_freelist = NULL;
+  machine->result_freelist = NULL;
+
+  unsigned prepared_limit = 4096;
+  int flags = 0;
+  #ifdef HAVE_IORING_SETUP_SUBMIT_ALL
+  flags |= IORING_SETUP_SUBMIT_ALL;
+  #endif
+  #ifdef HAVE_IORING_SETUP_COOP_TASKRUN
+  flags |= IORING_SETUP_COOP_TASKRUN;
+  #endif
+
+  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));
+  }
+  machine->ring_initialized = 1;
+}
+
+inline void um_teardown(struct um *machine) {
+  if (!machine->ring_initialized) return;
+
+  for (unsigned i = 0; i < machine->buffer_ring_count; i++) {
+    struct buf_ring_descriptor *desc = machine->buffer_rings + i;
+    io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, i);
+    free(desc->buf_base);
+  }
+  machine->buffer_ring_count = 0;
+  io_uring_queue_exit(&machine->ring);
+  machine->ring_initialized = 0;
+
+  um_free_op_linked_list(machine, machine->op_freelist);
+  um_free_op_linked_list(machine, machine->runqueue_head);
+}
+
 static inline struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op) {
   struct io_uring_sqe *sqe;
   sqe = io_uring_get_sqe(&machine->ring);
@@ -24,22 +72,6 @@ done:
   return sqe;
 }
 
-inline void um_cleanup(struct um *machine) {
-  if (!machine->ring_initialized) return;
-
-  for (unsigned i = 0; i < machine->buffer_ring_count; i++) {
-    struct buf_ring_descriptor *desc = machine->buffer_rings + i;
-    io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, i);
-    free(desc->buf_base);
-  }
-  machine->buffer_ring_count = 0;
-  io_uring_queue_exit(&machine->ring);
-  machine->ring_initialized = 0;
-
-  um_free_linked_list(machine->runqueue_head);
-  um_free_linked_list(machine->freelist_head);
-}
-
 struct wait_for_cqe_ctx {
   struct um *machine;
   struct io_uring_cqe *cqe;
@@ -57,26 +89,47 @@ void *um_wait_for_cqe_without_gvl(void *ptr) {
   return NULL;
 }
 
+inline void um_handle_submitted_op_cqe_single(struct um *machine, struct um_op *op, struct io_uring_cqe *cqe) {
+  op->cqe_result = cqe->res;
+  op->cqe_flags = cqe->flags;
+  op->state = OP_completed;
+  um_runqueue_push(machine, op);
+}
+
+inline void um_handle_submitted_op_cqe_multi(struct um *machine, struct um_op *op, struct io_uring_cqe *cqe) {
+  if (!op->results_head) {
+    struct um_op *op2 = um_op_checkout(machine);
+    op2->state = OP_schedule;
+    op2->fiber = op->fiber;
+    op2->resume_value = Qnil;
+    um_runqueue_push(machine, op2);
+  }
+  um_op_result_push(machine, op, cqe->res, cqe->flags);
+
+  if (!(cqe->flags & IORING_CQE_F_MORE))
+    op->state = OP_completed;
+}
+
 inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe) {
   struct um_op *op = (struct um_op *)cqe->user_data;
-  if (!op) return;
+  if (unlikely(!op)) return;
 
   switch (op->state) {
     case OP_submitted:
-      if (cqe->res == -ECANCELED) {
+      if (unlikely(cqe->res == -ECANCELED)) {
         um_op_checkin(machine, op);
+        break;
       }
-      else {
-        op->state = OP_completed;
-        op->cqe_result = cqe->res;
-        op->cqe_flags = cqe->flags;
-        um_runqueue_push(machine, op);
-      }
+      if (!op->is_multishot)
+        um_handle_submitted_op_cqe_single(machine, op, cqe);
+      else
+        um_handle_submitted_op_cqe_multi(machine, op, cqe);
       break;
     case OP_abandonned:
       // op has been abandonned by the I/O method, so we need to cleanup (check
       // the op in to the free list).
       um_op_checkin(machine, op);
+      break;
     default:
       // TODO: invalid state, should raise!
   }
@@ -173,19 +226,26 @@ static inline void um_cancel_op(struct um *machine, struct um_op *op) {
   io_uring_prep_cancel64(sqe, (long long)op, 0);
 }
 
-static inline VALUE um_await_op(struct um *machine, struct um_op *op) {
+static inline VALUE um_await_op(struct um *machine, struct um_op *op, int *result, int *flags) {
   op->fiber = rb_fiber_current();
   VALUE v = um_fiber_switch(machine);
-
   int is_exception = um_value_is_exception_p(v);
 
-  if (is_exception && op->state == OP_submitted) {
+  if (unlikely(is_exception && op->state == OP_submitted)) {
     um_cancel_op(machine, op);
     op->state = OP_abandonned;
   }
-  else
-    um_op_checkin(machine, op);
-  return is_exception ? um_raise_exception(v) : v;
+  else {
+    // We copy over the CQE result and flags, since the op is immediately
+    // checked in.
+    if (result) *result = op->cqe_result;
+    if (flags) *flags = op->cqe_flags;
+    if (!op->is_multishot)
+      um_op_checkin(machine, op);
+  }
+
+  if (unlikely(is_exception)) um_raise_exception(v);
+  return v;
 }
 
 inline VALUE um_await(struct um *machine) {
@@ -216,13 +276,14 @@ inline void um_interrupt(struct um *machine, VALUE fiber, VALUE value) {
   }
 }
 
-struct timeout_ctx {
+struct op_ensure_ctx {
   struct um *machine;
   struct um_op *op;
+  int bgid;
 };
 
 VALUE um_timeout_ensure(VALUE arg) {
-  struct timeout_ctx *ctx = (struct timeout_ctx *)arg;
+  struct op_ensure_ctx *ctx = (struct op_ensure_ctx *)arg;
 
   if (ctx->op->state == OP_submitted) {
     // A CQE has not yet been received, we cancel the timeout and abandon the op
@@ -242,26 +303,155 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
   if (!ID_new) ID_new = rb_intern("new");
 
   struct um_op *op = um_op_checkout(machine);
-  struct __kernel_timespec ts = um_double_to_timespec(NUM2DBL(interval));
+  op->ts = um_double_to_timespec(NUM2DBL(interval));
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-  io_uring_prep_timeout(sqe, &ts, 0, 0);
+  io_uring_prep_timeout(sqe, &op->ts, 0, 0);
   op->state = OP_submitted;
   op->fiber = rb_fiber_current();
   op->resume_value = rb_funcall(class, ID_new, 0);
 
-  struct timeout_ctx ctx = { .machine = machine, .op = op };
+  struct op_ensure_ctx ctx = { .machine = machine, .op = op };
   return rb_ensure(rb_yield, Qnil, um_timeout_ensure, (VALUE)&ctx);
 }
 
 inline VALUE um_sleep(struct um *machine, double duration) {
   struct um_op *op = um_op_checkout(machine);
-  struct __kernel_timespec ts = um_double_to_timespec(duration);
+  op->ts = um_double_to_timespec(duration);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  int result = 0;
+
+  io_uring_prep_timeout(sqe, &op->ts, 0, 0);
+  op->state = OP_submitted;
+
+  return um_await_op(machine, op, &result, NULL);
+}
+
+inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset) {
+  struct um_op *op = um_op_checkout(machine);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  int result = 0;
+  int flags = 0;
+
+  void *ptr = um_prepare_read_buffer(buffer, maxlen, buffer_offset);
+  io_uring_prep_read(sqe, fd, ptr, maxlen, -1);
+  op->state = OP_submitted;
 
+  um_await_op(machine, op, &result, &flags);
+
+  um_raise_on_system_error(result);
+  um_update_read_buffer(machine, buffer, buffer_offset, result, flags);
+  return INT2FIX(result);
+}
+
+VALUE um_multishot_ensure(VALUE arg) {
+  struct op_ensure_ctx *ctx = (struct op_ensure_ctx *)arg;
+  switch (ctx->op->state) {
+    case OP_submitted:
+      um_cancel_op(ctx->machine, ctx->op);
+      break;
+    case OP_completed:
+      um_op_checkin(ctx->machine, ctx->op);
+      break;
+    default:  
+  }
+  return Qnil;
+}
+
+VALUE um_read_each_safe_loop(VALUE arg) {
+  struct op_ensure_ctx *ctx = (struct op_ensure_ctx *)arg;
+  int result = 0;
+  int flags = 0;
+  int total = 0;
+
+  while (1) {
+    um_await_op(ctx->machine, ctx->op, NULL, NULL);
+    if (!ctx->op->results_head) {
+      // TODO: raise, this shouldn't happen
+      printf("no result found!\n");
+    }
+    while (um_op_result_shift(ctx->machine, ctx->op, &result, &flags)) {
+      if (likely(result > 0)) {
+        total += result;
+        VALUE buf = get_string_from_buffer_ring(ctx->machine, ctx->bgid, result, flags);
+        rb_yield(buf);
+      }
+      else
+        return INT2FIX(total);
+    }
+  }
+}
+
+VALUE um_read_each(struct um *machine, int fd, int bgid) {
+  struct um_op *op = um_op_checkout(machine);
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-  io_uring_prep_timeout(sqe, &ts, 0, 0);
+
+  op->is_multishot = 1;
+  io_uring_prep_read_multishot(sqe, fd, 0, -1, bgid);
   op->state = OP_submitted;
 
-  return um_await_op(machine, op);
+  struct op_ensure_ctx ctx = { .machine = machine, .op = op, .bgid = bgid };
+  return rb_ensure(um_read_each_safe_loop, (VALUE)&ctx, um_multishot_ensure, (VALUE)&ctx);
 }
 
+VALUE um_write(struct um *machine, int fd, VALUE buffer, int len) {
+  struct um_op *op = um_op_checkout(machine);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  int result = 0;
+  int flags = 0;
+
+  io_uring_prep_write(sqe, fd, RSTRING_PTR(buffer), len, -1);
+  op->state = OP_submitted;
+
+  um_await_op(machine, op, &result, &flags);
+  um_raise_on_system_error(result);
+  return INT2FIX(result);
+}
+
+VALUE um_accept(struct um *machine, int fd) {
+  struct um_op *op = um_op_checkout(machine);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  struct sockaddr addr;
+  socklen_t len;
+  int result = 0;
+  int flags = 0;
+  io_uring_prep_accept(sqe, fd, &addr, &len, 0);
+  op->state = OP_submitted;
+
+  um_await_op(machine, op, &result, &flags);
+  um_raise_on_system_error(result);
+  return INT2FIX(result);
+}
+
+VALUE um_accept_each_safe_loop(VALUE arg) {
+  struct op_ensure_ctx *ctx = (struct op_ensure_ctx *)arg;
+  int result = 0;
+  int flags = 0;
+
+  while (1) {
+    um_await_op(ctx->machine, ctx->op, NULL, NULL);
+    if (!ctx->op->results_head) {
+      // TODO: raise, this shouldn't happen
+      printf("no result found!\n");
+    }
+    while (um_op_result_shift(ctx->machine, ctx->op, &result, &flags)) {
+      if (likely(result > 0))
+        rb_yield(INT2FIX(result));
+      else
+        return Qnil;
+    }
+  }
+}
+
+VALUE um_accept_each(struct um *machine, int fd) {
+  struct um_op *op = um_op_checkout(machine);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  struct sockaddr addr;
+  socklen_t len;
+  io_uring_prep_multishot_accept(sqe, fd, &addr, &len, 0);
+  op->state = OP_submitted;
+  op->is_multishot = 1;
+
+  struct op_ensure_ctx ctx = { .machine = machine, .op = op };
+  return rb_ensure(um_accept_each_safe_loop, (VALUE)&ctx, um_multishot_ensure, (VALUE)&ctx);
+}

data/ext/um/um.h

@@ -29,13 +29,27 @@ enum op_state {
   OP_schedule,    // the corresponding fiber is scheduled
 };
 
+struct um_result_entry {
+  struct um_result_entry *next;
+
+  int result;
+  int flags;
+};
+
 struct um_op {
   enum op_state state;
   struct um_op *prev;
   struct um_op *next;
+
+  // linked list for multishot results
+  struct um_result_entry *results_head;
+  struct um_result_entry *results_tail;
   
   VALUE fiber;
   VALUE resume_value;
+  int is_multishot;
+  struct __kernel_timespec ts;
+  
   int cqe_result;
   int cqe_flags;
 };
@@ -51,7 +65,9 @@ struct buf_ring_descriptor {
 #define BUFFER_RING_MAX_COUNT 10
 
 struct um {
-  struct um_op *freelist_head;
+  struct um_op *op_freelist;
+  struct um_result_entry *result_freelist;
+
   struct um_op *runqueue_head;
   struct um_op *runqueue_tail;
 
@@ -67,31 +83,43 @@ struct um {
 
 extern VALUE cUM;
 
+void um_setup(struct um *machine);
+void um_teardown(struct um *machine);
+void um_free_op_linked_list(struct um *machine, struct um_op *op);
+void um_free_result_linked_list(struct um *machine, struct um_result_entry *entry);
+
 struct __kernel_timespec um_double_to_timespec(double value);
+int um_value_is_exception_p(VALUE v);
+VALUE um_raise_exception(VALUE v);
+void um_raise_on_system_error(int result);
 
-void um_cleanup(struct um *machine);
+void * um_prepare_read_buffer(VALUE buffer, unsigned len, int ofs);
+void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, int result, int flags);
+VALUE get_string_from_buffer_ring(struct um *machine, int bgid, int result, int flags);
 
-void um_free_linked_list(struct um_op *op);
 VALUE um_fiber_switch(struct um *machine);
 VALUE um_await(struct um *machine);
 
 void um_op_checkin(struct um *machine, struct um_op *op);
 struct um_op* um_op_checkout(struct um *machine);
-
-VALUE um_raise_exception(VALUE v);
+void um_op_result_push(struct um *machine, struct um_op *op, int result, int flags);
+int um_op_result_shift(struct um *machine, struct um_op *op, int *result, int *flags);
 
 struct um_op *um_runqueue_find_by_fiber(struct um *machine, VALUE fiber);
 void um_runqueue_push(struct um *machine, struct um_op *op);
 struct um_op *um_runqueue_shift(struct um *machine);
 void um_runqueue_unshift(struct um *machine, struct um_op *op);
 
-int um_value_is_exception_p(VALUE v);
-
-
 void um_schedule(struct um *machine, VALUE fiber, VALUE value);
 void um_interrupt(struct um *machine, VALUE fiber, VALUE value);
 VALUE um_timeout(struct um *machine, VALUE interval, VALUE class);
 
 VALUE um_sleep(struct um *machine, double duration);
+VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset);
+VALUE um_read_each(struct um *machine, int fd, int bgid);
+VALUE um_write(struct um *machine, int fd, VALUE buffer, int len);
+
+VALUE um_accept(struct um *machine, int fd);
+VALUE um_accept_each(struct um *machine, int fd);
 
 #endif // UM_H

data/ext/um/um_class.c

@@ -1,4 +1,5 @@
 #include "um.h"
+#include <sys/mman.h>
 
 VALUE cUM;
 
@@ -13,7 +14,7 @@ static void UM_compact(void *ptr) {
 }
 
 static void UM_free(void *ptr) {
-  um_cleanup((struct um *)ptr);
+  um_teardown((struct um *)ptr);
   free(ptr);
 }
 
@@ -42,37 +43,58 @@ inline struct um *get_machine(VALUE self) {
 
 VALUE UM_initialize(VALUE self) {
   struct um *machine = RTYPEDDATA_DATA(self);
+  um_setup(machine);
+  return self;
+}
+
+VALUE UM_setup_buffer_ring(VALUE self, VALUE size, VALUE count) {
+  struct um *machine = get_machine(self);
 
-  machine->ring_initialized = 0;
-  machine->unsubmitted_count = 0;
-  machine->buffer_ring_count = 0;
-  machine->pending_count = 0;
-  machine->runqueue_head = NULL;
-  machine->runqueue_tail = NULL;
-  machine->freelist_head = NULL;
-
-  unsigned prepared_limit = 4096;
-  int flags = 0;
-  #ifdef HAVE_IORING_SETUP_SUBMIT_ALL
-  flags |= IORING_SETUP_SUBMIT_ALL;
-  #endif
-  #ifdef HAVE_IORING_SETUP_COOP_TASKRUN
-  flags |= IORING_SETUP_COOP_TASKRUN;
-  #endif
-
-  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));
+  if (machine->buffer_ring_count == BUFFER_RING_MAX_COUNT)
+    rb_raise(rb_eRuntimeError, "Cannot setup more than BUFFER_RING_MAX_COUNT buffer rings");
+
+  struct buf_ring_descriptor *desc = machine->buffer_rings + machine->buffer_ring_count;
+  desc->buf_count = NUM2UINT(count);
+  desc->buf_size = NUM2UINT(size);
+
+  desc->br_size = sizeof(struct io_uring_buf) * desc->buf_count;
+	void *mapped = mmap(
+    NULL, desc->br_size, PROT_READ | PROT_WRITE,
+		MAP_ANONYMOUS | MAP_PRIVATE, 0, 0
+  );
+  if (mapped == MAP_FAILED)
+    rb_raise(rb_eRuntimeError, "Failed to allocate buffer ring");
+
+  desc->br = (struct io_uring_buf_ring *)mapped;
+  io_uring_buf_ring_init(desc->br);
+
+  unsigned bg_id = machine->buffer_ring_count;
+  struct io_uring_buf_reg reg = {
+    .ring_addr = (unsigned long)desc->br,
+		.ring_entries = desc->buf_count,
+		.bgid = bg_id
+  };
+	int ret = io_uring_register_buf_ring(&machine->ring, &reg, 0);
+	if (ret) {
+    munmap(desc->br, desc->br_size);
+    rb_syserr_fail(-ret, strerror(-ret));
+	}
+
+  desc->buf_base = malloc(desc->buf_count * desc->buf_size);
+  if (!desc->buf_base) {
+    io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, bg_id);
+    rb_raise(rb_eRuntimeError, "Failed to allocate buffers");
   }
-  machine->ring_initialized = 1;
 
-  return self;
+  int mask = io_uring_buf_ring_mask(desc->buf_count);
+	for (unsigned i = 0; i < desc->buf_count; i++) {
+		io_uring_buf_ring_add(
+      desc->br, desc->buf_base + i * desc->buf_size, desc->buf_size,
+      i, mask, i);
+	}
+	io_uring_buf_ring_advance(desc->br, desc->buf_count);
+  machine->buffer_ring_count++;
+  return UINT2NUM(bg_id);
 }
 
 VALUE UM_pending_count(VALUE self) {
@@ -114,6 +136,46 @@ VALUE UM_sleep(VALUE self, VALUE duration) {
   return duration;
 }
 
+VALUE UM_read(int argc, VALUE *argv, VALUE self) {
+  struct um *machine = get_machine(self);
+  VALUE fd;
+  VALUE buffer;
+  VALUE maxlen;
+  VALUE buffer_offset;
+  rb_scan_args(argc, argv, "31", &fd, &buffer, &maxlen, &buffer_offset);
+
+  return um_read(
+    machine, NUM2INT(fd), buffer, NUM2INT(maxlen),
+    NIL_P(buffer_offset) ? 0 : NUM2INT(buffer_offset)
+  );
+}
+
+VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
+  struct um *machine = get_machine(self);
+  return um_read_each(machine, NUM2INT(fd), NUM2INT(bgid));
+}
+
+VALUE UM_write(int argc, VALUE *argv, VALUE self) {
+  struct um *machine = get_machine(self);
+  VALUE fd;
+  VALUE buffer;
+  VALUE len;
+  rb_scan_args(argc, argv, "21", &fd, &buffer, &len);
+
+  int bytes = NIL_P(len) ? RSTRING_LEN(buffer) : NUM2INT(len);
+  return um_write(machine, NUM2INT(fd), buffer, bytes);
+}
+
+VALUE UM_accept(VALUE self, VALUE fd) {
+  struct um *machine = get_machine(self);
+  return um_accept(machine, NUM2INT(fd));
+}
+
+VALUE UM_accept_each(VALUE self, VALUE fd) {
+  struct um *machine = get_machine(self);
+  return um_accept_each(machine, NUM2INT(fd));
+}
+
 void Init_UM(void) {
   rb_ext_ractor_safe(true);
 
@@ -121,8 +183,7 @@ void Init_UM(void) {
   rb_define_alloc_func(cUM, UM_allocate);
 
   rb_define_method(cUM, "initialize", UM_initialize, 0);
-  // rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 1);
-
+  rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 2);
   rb_define_method(cUM, "pending_count", UM_pending_count, 0);
 
   rb_define_method(cUM, "snooze", UM_snooze, 0);
@@ -132,6 +193,12 @@ void Init_UM(void) {
   rb_define_method(cUM, "timeout", UM_timeout, 2);
 
   rb_define_method(cUM, "sleep", UM_sleep, 1);
+  rb_define_method(cUM, "read", UM_read, -1);
+  rb_define_method(cUM, "read_each", UM_read_each, 2);
+  rb_define_method(cUM, "write", UM_write, -1);
+
+  rb_define_method(cUM, "accept", UM_accept, 1);
+  rb_define_method(cUM, "accept_each", UM_accept_each, 1);
 
   // rb_define_method(cUM, "emit", UM_emit, 1);
 

data/ext/um/um_ext.c

@@ -1,11 +1,5 @@
-#include "iou.h"
-
-void Init_IOURing();
-void Init_OpCtx();
 void Init_UM();
 
 void Init_um_ext(void) {
-  Init_IOURing();
-  Init_OpCtx();
   Init_UM();
 }