uringmachine 0.1

data/ext/um/um.c

@@ -0,0 +1,267 @@
+#include "um.h"
+#include "ruby/thread.h"
+#include <sys/mman.h>
+
+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);
+  if (likely(sqe)) goto done;
+
+  rb_raise(rb_eRuntimeError, "Failed to get SQE");
+
+  // TODO: retry getting SQE?
+
+  // if (likely(backend->pending_sqes))
+  //   io_uring_um_immediate_submit(backend);
+  // else {
+  //   VALUE resume_value = um_snooze(&backend->base);
+  //   RAISE_IF_EXCEPTION(resume_value);
+  // }
+done:
+  sqe->user_data = (long long)op;
+  sqe->flags = 0;
+  machine->unsubmitted_count++;
+  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;
+  int result;
+};
+
+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;
+    ctx->result = io_uring_submit_and_wait_timeout(&ctx->machine->ring, &ctx->cqe, 1, NULL, NULL);
+  }
+  else
+    ctx->result = io_uring_wait_cqe(&ctx->machine->ring, &ctx->cqe);
+  return NULL;
+}
+
+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;
+
+  switch (op->state) {
+    case OP_submitted:
+      if (cqe->res == -ECANCELED) {
+        um_op_checkin(machine, op);
+      }
+      else {
+        op->state = OP_completed;
+        op->cqe_result = cqe->res;
+        op->cqe_flags = cqe->flags;
+        um_runqueue_push(machine, op);
+      }
+      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);
+    default:
+      // TODO: invalid state, should raise!
+  }
+}
+
+static inline void um_wait_for_and_process_cqe(struct um *machine) {
+  struct wait_for_cqe_ctx ctx = {
+    .machine = machine,
+    .cqe = NULL
+  };
+
+  rb_thread_call_without_gvl(um_wait_for_cqe_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  if (unlikely(ctx.result < 0)) {
+    rb_syserr_fail(-ctx.result, strerror(-ctx.result));
+  }
+  io_uring_cqe_seen(&machine->ring, ctx.cqe);
+  um_process_cqe(machine, ctx.cqe);
+}
+
+// copied from liburing/queue.c
+static inline bool cq_ring_needs_flush(struct io_uring *ring) {
+  return IO_URING_READ_ONCE(*ring->sq.kflags) & IORING_SQ_CQ_OVERFLOW;
+}
+
+static inline int um_process_ready_cqes(struct um *machine) {
+  unsigned total_count = 0;
+iterate:
+  bool overflow_checked = false;
+  struct io_uring_cqe *cqe;
+  unsigned head;
+  unsigned count = 0;
+  io_uring_for_each_cqe(&machine->ring, head, cqe) {
+    ++count;
+    um_process_cqe(machine, cqe);
+  }
+  io_uring_cq_advance(&machine->ring, count);
+  total_count += count;
+
+  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);
+    overflow_checked = true;
+    goto iterate;
+  }
+
+done:
+  return total_count;
+}
+
+static inline void um_wait_for_and_process_ready_cqes(struct um *machine) {
+  um_wait_for_and_process_cqe(machine);
+  um_process_ready_cqes(machine);
+}
+
+inline VALUE um_fiber_switch(struct um *machine) {
+  struct um_op *op = 0;
+  unsigned int first_iteration = 1;
+loop:
+  // in the case where:
+  // - first time through loop
+  // - there are SQEs waiting to be submitted
+  // - the runqueue head references the current fiber
+  // we need to submit events and check completions without blocking
+  if (
+    unlikely(
+      first_iteration && machine->unsubmitted_count && 
+      machine->runqueue_head &&
+      machine->runqueue_head->fiber == rb_fiber_current()
+    )
+  ) {
+    io_uring_submit(&machine->ring);
+    um_process_ready_cqes(machine);
+  }
+  first_iteration = 0;
+
+  op = um_runqueue_shift(machine);
+  if (op) {
+    VALUE resume_value = op->resume_value;
+    if (op->state == OP_schedule) {
+      um_op_checkin(machine, op);
+    }
+    // the resume value is disregarded, we pass the fiber itself
+    VALUE v = rb_fiber_transfer(op->fiber, 1, &resume_value);
+    return v;
+  }
+
+  um_wait_for_and_process_ready_cqes(machine);
+  goto loop;
+}
+
+static inline 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);
+}
+
+static inline VALUE um_await_op(struct um *machine, struct um_op *op) {
+  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) {
+    um_cancel_op(machine, op);
+    op->state = OP_abandonned;
+  }
+  else
+    um_op_checkin(machine, op);
+  return is_exception ? um_raise_exception(v) : v;
+}
+
+inline VALUE um_await(struct um *machine) {
+  VALUE v = um_fiber_switch(machine);
+  return um_value_is_exception_p(v) ? um_raise_exception(v) : v;
+}
+
+inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
+  struct um_op *op = um_op_checkout(machine);
+  op->state = OP_schedule;
+  op->fiber = fiber;
+  op->resume_value = value;
+  um_runqueue_push(machine, op);
+}
+
+inline void um_interrupt(struct um *machine, VALUE fiber, VALUE value) {
+  struct um_op *op = um_runqueue_find_by_fiber(machine, fiber);
+  if (op) {
+    op->state = OP_cancelled;
+    op->resume_value = value;
+  }
+  else {
+    op = um_op_checkout(machine);
+    op->state = OP_schedule;
+    op->fiber = fiber;
+    op->resume_value = value;
+    um_runqueue_unshift(machine, op);
+  }
+}
+
+struct timeout_ctx {
+  struct um *machine;
+  struct um_op *op;
+};
+
+VALUE um_timeout_ensure(VALUE arg) {
+  struct timeout_ctx *ctx = (struct timeout_ctx *)arg;
+
+  if (ctx->op->state == OP_submitted) {
+    // A CQE has not yet been received, we cancel the timeout and abandon the op
+    // (it will be checked in upon receiving the -ECANCELED CQE)
+    um_cancel_op(ctx->machine, ctx->op);
+    ctx->op->state == OP_abandonned;
+  }
+  else {
+    // completed, so can be checked in
+    um_op_checkin(ctx->machine, ctx->op);
+  }
+  return Qnil;
+}
+
+VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
+  static ID ID_new = 0;
+  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));
+
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_timeout(sqe, &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 };
+  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);
+
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_timeout(sqe, &ts, 0, 0);
+  op->state = OP_submitted;
+
+  return um_await_op(machine, op);
+}
+

data/ext/um/um.h

@@ -0,0 +1,97 @@
+#ifndef UM_H
+#define UM_H
+
+#include "ruby.h"
+#include <liburing.h>
+
+// debugging
+#define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
+#define INSPECT(str, obj) { printf(str); VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf(": %s\n", StringValueCStr(s)); }
+#define CALLER() rb_funcall(rb_mKernel, rb_intern("caller"), 0)
+#define TRACE_CALLER() INSPECT("caller: ", CALLER())
+#define TRACE_FREE(ptr) //printf("Free %p %s:%d\n", ptr, __FILE__, __LINE__)
+
+// branching
+#ifndef unlikely
+#define unlikely(cond)	__builtin_expect(!!(cond), 0)
+#endif
+
+#ifndef likely
+#define likely(cond)	__builtin_expect(!!(cond), 1)
+#endif
+
+enum op_state {
+  OP_initial,     // initial state
+  OP_submitted,   // op has been submitted (SQE prepared)
+  OP_completed,   // op has been completed (CQE processed)
+  OP_cancelled,   // op is cancelled (after CQE is processed)
+  OP_abandonned,  // op is abandonned by fiber (before CQE is processed)
+  OP_schedule,    // the corresponding fiber is scheduled
+};
+
+struct um_op {
+  enum op_state state;
+  struct um_op *prev;
+  struct um_op *next;
+  
+  VALUE fiber;
+  VALUE resume_value;
+  int cqe_result;
+  int cqe_flags;
+};
+
+struct buf_ring_descriptor {
+  struct io_uring_buf_ring *br;
+  size_t br_size;
+  unsigned buf_count;
+  unsigned buf_size;
+	char *buf_base;
+};
+
+#define BUFFER_RING_MAX_COUNT 10
+
+struct um {
+  struct um_op *freelist_head;
+  struct um_op *runqueue_head;
+  struct um_op *runqueue_tail;
+
+  struct io_uring ring;
+
+  unsigned int    ring_initialized;
+  unsigned int    unsubmitted_count;
+  unsigned int    pending_count;
+
+  struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
+  unsigned int buffer_ring_count;
+};
+
+extern VALUE cUM;
+
+struct __kernel_timespec um_double_to_timespec(double value);
+
+void um_cleanup(struct um *machine);
+
+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);
+
+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);
+
+#endif // UM_H

data/ext/um/um_class.c

@@ -0,0 +1,175 @@
+#include "um.h"
+
+VALUE cUM;
+
+static void UM_mark(void *ptr) {
+  // struct um *machine = ptr;
+  // um_runqueue_mark(machine);
+}
+
+static void UM_compact(void *ptr) {
+  // struct um *machine = ptr;
+  // um_runqueue_compact(machine);
+}
+
+static void UM_free(void *ptr) {
+  um_cleanup((struct um *)ptr);
+  free(ptr);
+}
+
+static size_t UM_size(const void *ptr) {
+  return sizeof(struct um);
+}
+
+static const rb_data_type_t UM_type = {
+    "UringMachine",
+    {UM_mark, UM_free, UM_size, UM_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE UM_allocate(VALUE klass) {
+  struct um *machine = ALLOC(struct um);
+
+  return TypedData_Wrap_Struct(klass, &UM_type, machine);
+}
+
+inline struct um *get_machine(VALUE self) {
+  struct um *machine = RTYPEDDATA_DATA(self);
+  if (!machine->ring_initialized)
+    rb_raise(rb_eRuntimeError, "Machine not initialized");
+  return machine;
+}
+
+VALUE UM_initialize(VALUE self) {
+  struct um *machine = RTYPEDDATA_DATA(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));
+  }
+  machine->ring_initialized = 1;
+
+  return self;
+}
+
+VALUE UM_pending_count(VALUE self) {
+  struct um *machine = get_machine(self);
+  return INT2FIX(machine->pending_count);
+}
+
+VALUE UM_snooze(VALUE self) {
+  struct um *machine = get_machine(self);
+  um_schedule(machine, rb_fiber_current(), Qnil);
+  return um_await(machine);
+}
+
+VALUE UM_yield(VALUE self) {
+  struct um *machine = get_machine(self);
+  return um_await(machine);
+}
+
+VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
+  struct um *machine = get_machine(self);
+  um_schedule(machine, fiber, value);
+  return self;
+}
+
+VALUE UM_interrupt(VALUE self, VALUE fiber, VALUE value) {
+  struct um *machine = get_machine(self);
+  um_interrupt(machine, fiber, value);
+  return self;
+}
+
+VALUE UM_timeout(VALUE self, VALUE interval, VALUE class) {
+  struct um *machine = get_machine(self);
+  return um_timeout(machine, interval, class);
+}
+
+VALUE UM_sleep(VALUE self, VALUE duration) {
+  struct um *machine = get_machine(self);
+  um_sleep(machine, NUM2DBL(duration));
+  return duration;
+}
+
+void Init_UM(void) {
+  rb_ext_ractor_safe(true);
+
+  cUM = rb_define_class("UringMachine", rb_cObject);
+  rb_define_alloc_func(cUM, UM_allocate);
+
+  rb_define_method(cUM, "initialize", UM_initialize, 0);
+  // rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 1);
+
+  rb_define_method(cUM, "pending_count", UM_pending_count, 0);
+
+  rb_define_method(cUM, "snooze", UM_snooze, 0);
+  rb_define_method(cUM, "yield", UM_yield, 0);
+  rb_define_method(cUM, "schedule", UM_schedule, 2);
+  rb_define_method(cUM, "interrupt", UM_interrupt, 2);
+  rb_define_method(cUM, "timeout", UM_timeout, 2);
+
+  rb_define_method(cUM, "sleep", UM_sleep, 1);
+
+  // rb_define_method(cUM, "emit", UM_emit, 1);
+
+  // rb_define_method(cUM, "prep_accept", UM_prep_accept, 1);
+  // rb_define_method(cUM, "prep_cancel", UM_prep_cancel, 1);
+  // rb_define_method(cUM, "prep_close", UM_prep_close, 1);
+  // rb_define_method(cUM, "prep_nop", UM_prep_nop, 0);
+  // rb_define_method(cUM, "prep_read", UM_prep_read, 1);
+  // rb_define_method(cUM, "prep_timeout", UM_prep_timeout, 1);
+  // rb_define_method(cUM, "prep_write", UM_prep_write, 1);
+
+  // rb_define_method(cUM, "submit", UM_submit, 0);
+  // rb_define_method(cUM, "wait_for_completion", UM_wait_for_completion, 0);
+  // rb_define_method(cUM, "process_completions", UM_process_completions, -1);
+  // rb_define_method(cUM, "process_completions_loop", UM_process_completions_loop, 0);
+
+  // SYM_accept        = MAKE_SYM("accept");
+  // SYM_block         = MAKE_SYM("block");
+  // SYM_buffer        = MAKE_SYM("buffer");
+  // SYM_buffer_group  = MAKE_SYM("buffer_group");
+  // SYM_buffer_offset = MAKE_SYM("buffer_offset");
+  // SYM_close         = MAKE_SYM("close");
+  // SYM_count         = MAKE_SYM("count");
+  // SYM_emit          = MAKE_SYM("emit");
+  // SYM_fd            = MAKE_SYM("fd");
+  // SYM_id            = MAKE_SYM("id");
+  // SYM_interval      = MAKE_SYM("interval");
+  // SYM_len           = MAKE_SYM("len");
+  // SYM_link          = MAKE_SYM("link");
+  // SYM_multishot     = MAKE_SYM("multishot");
+  // SYM_op            = MAKE_SYM("op");
+  // SYM_read          = MAKE_SYM("read");
+  // SYM_result        = MAKE_SYM("result");
+  // SYM_signal        = MAKE_SYM("signal");
+  // SYM_size          = MAKE_SYM("size");
+  // SYM_spec_data     = MAKE_SYM("spec_data");
+  // SYM_stop          = MAKE_SYM("stop");
+  // SYM_timeout       = MAKE_SYM("timeout");
+  // SYM_utf8          = MAKE_SYM("utf8");
+  // SYM_write         = MAKE_SYM("write");
+}

data/ext/um/um_ext.c

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

data/ext/um/um_op.c

@@ -0,0 +1,87 @@
+#include "um.h"
+
+inline void um_op_clear(struct um_op *op) {
+  memset(op, 0, sizeof(struct um_op));
+  op->fiber = op->resume_value = Qnil;
+}
+
+inline struct um_op *um_op_checkout(struct um *machine) {
+  machine->pending_count++;
+
+  if (machine->freelist_head) {
+    struct um_op *op = machine->freelist_head;
+    machine->freelist_head = op->next;
+    um_op_clear(op);
+    return op;
+  }
+
+  struct um_op *op = malloc(sizeof(struct um_op));
+  um_op_clear(op);
+  return op;
+}
+
+inline void um_op_checkin(struct um *machine, struct um_op *op) {
+  machine->pending_count--;
+
+  op->next = machine->freelist_head;
+  machine->freelist_head = op;
+}
+
+inline struct um_op *um_runqueue_find_by_fiber(struct um *machine, VALUE fiber) {
+  struct um_op *op = machine->runqueue_head;
+  while (op) {
+    if (op->fiber == fiber) return op;
+
+    op = op->next;
+  }
+  return NULL;
+}
+
+inline void um_runqueue_push(struct um *machine, struct um_op *op) {
+  if (machine->runqueue_tail) {
+    op->prev = machine->runqueue_tail;
+    machine->runqueue_tail->next = op;
+    machine->runqueue_tail = op;
+  }
+  else {
+    op->prev = NULL;
+    machine->runqueue_head = machine->runqueue_tail = op;
+  }
+  op->next = NULL;
+}
+
+inline void um_runqueue_unshift(struct um *machine, struct um_op *op) {
+  if (machine->runqueue_head) {
+    op->next = machine->runqueue_head;
+    machine->runqueue_head->prev = op;
+    machine->runqueue_head = op;
+  }
+  else {
+    op->next = NULL;
+    machine->runqueue_head = machine->runqueue_tail = op;
+  }
+  op->prev = NULL;
+}
+
+inline struct um_op *um_runqueue_shift(struct um *machine) {
+  struct um_op *op = machine->runqueue_head;
+  if (!op) return NULL;
+
+  op->prev = NULL;
+  if (!op->next) {
+    machine->runqueue_head = machine->runqueue_tail = NULL;    
+  }
+  else {
+    machine->runqueue_head = op->next;
+    op->next = NULL;
+  }
+  return op;
+}
+
+inline void um_free_linked_list(struct um_op *op) {
+  while (op) {
+    struct um_op *next = op->next;
+    free(op);
+    op = next;
+  }
+}

data/ext/um/um_utils.c

@@ -0,0 +1,23 @@
+#include "um.h"
+
+inline struct __kernel_timespec um_double_to_timespec(double value) {
+  double integral;
+  double fraction = modf(value, &integral);
+  struct __kernel_timespec ts;
+  ts.tv_sec = integral;
+  ts.tv_nsec = floor(fraction * 1000000000);
+  return ts;
+}
+
+#define RAISE_EXCEPTION(e) rb_funcall(e, ID_invoke, 0);
+
+inline int um_value_is_exception_p(VALUE v) {
+  return rb_obj_is_kind_of(v, rb_eException) == Qtrue;
+}
+
+VALUE um_raise_exception(VALUE e) {
+  static ID ID_raise = 0;
+  if (!ID_raise) ID_raise = rb_intern("raise");
+
+  return rb_funcall(rb_mKernel, ID_raise, 1, e);
+}

data/lib/uringmachine/version.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+UM_VERSION = '0.1'

data/lib/uringmachine.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative './um_ext'
+
+UM = UringMachine
+
+class UringMachine
+end