iou 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81760683a4ded7963311f6d8961dff7d0f13edd164afb4cf3056f151889f612d
-  data.tar.gz: c700916bbe4b519bc95522da3855fa084f40ab56d8c8cebd2f1d04521681add2
+  metadata.gz: f240c18e2449f95a1a41d0af6ddea012c5ade81125c50149930f084499d8721f
+  data.tar.gz: 49c12b7fa7876af3666d93a891d6edac4f7b50ca034c683bc667de3b4bd6410f
 SHA512:
-  metadata.gz: f1aba30375539d2f16083bce2db47a3807abd2a2fa484c270d57a8954bbe3a21d9785408bba667c48e991b47805b38686a4b263602b2b57cf17f30fd32c59187
-  data.tar.gz: e812e047b19ea89c9a0731de4f216dbacf3e1bdc62e363bc5f31fb843b19fc072a3b0e3272152ff215efd90591ec220bc23aff12d7a6dae755153c9fe6892a76
+  metadata.gz: 38194dea0e61f9a2801d74255e5a1db6cdae3739c45667a6dada382a9362698c4eaf46120e04ec2fdb51f6dea995fc30493c3957e3027dc2c3d767d2663b3f36
+  data.tar.gz: e4cfcb063713986a788a344f13492eacc76ae5f0db5111367fe4ef91bc8effdb333e850f3f043fb222fc6516e52533de10ed6bc17c99b20221f57f32134974b2

data/.github/workflows/test.yml

@@ -0,0 +1,35 @@
+name: Tests
+
+on: [push, pull_request]
+
+concurrency:
+  group: tests-${{ format('{0}-{1}', github.head_ref || github.run_number, github.job) }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        # macos-latest uses arm64, macos-13 uses x86
+        os: [ubuntu-latest]
+        ruby: ['3.3', 'head']
+
+    name: ${{matrix.os}}, ${{matrix.ruby}}
+
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name
+
+    runs-on: ${{matrix.os}}
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{matrix.ruby}}
+        bundler-cache: true # 'bundle install' and cache
+    - name: Compile C-extension
+      run: bundle exec rake compile
+    - name: Run tests
+      run:  bundle exec rake test

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# 2024-09-09 Version 0.2
+
+- Add UTF8 encoding option for multishot read.
+- Implement `OpCtx` as wrapper for op specs. This removes the need to call
+  `rb_hash_aref` upon completion (except for pulling the ctx from the
+  `pending_ops` hash), leading to a significant performance improvement.
+
+# 2024-09-08 Version 0.1
+
+- First working version.

data/README.md

@@ -100,7 +100,7 @@ ring.wait_for_completion
 
 Examples for using IOU can be found in the examples directory:
 
-- [v] Echo server
-- [v] HTTP server
-- [v] Event loop (in the style of EventMachine)
-- [ ] Fiber-based concurrency
+- Echo server
+- HTTP server
+- Event loop (in the style of EventMachine)
+- Fiber-based concurrency

data/TODO.md

@@ -1,4 +1,30 @@
-# io_uring ops
+## io_uring ops
 
 - [ ] recv
 - [ ] send
+- [ ] recvmsg
+- [ ] sendmsg
+- [ ] multishot recv
+- [ ] multishot recvmsg
+- [ ] poll
+- [ ] multishot poll
+- [ ] shutdown
+- [ ] connect
+- [ ] socket
+- [ ] openat
+- [ ] splice
+- [ ] wait
+
+- [ ] support for linking requests
+  
+  ```ruby
+  ring.prep_write(fd: fd, buffer: 'foo', link: true)
+  ring.prep_slice(fd: fd, src: src_fd, len: 4096)
+  ```
+
+- [ ] link timeout
+
+  ```ruby
+  # read or timeout in 3 seconds
+  ring.prep_read(fd: fd, buffer: +'', len: 4096, timeout: 3)
+  ```

data/examples/event_loop.rb

@@ -66,4 +66,4 @@ event_loop.run do
   end
 end
 
-puts "Stopped"
+puts "Stopped"

data/examples/fibers.rb

@@ -0,0 +1,105 @@
+require_relative '../lib/iou'
+require 'socket'
+require 'fiber'
+
+class ::Fiber
+  attr_accessor :__op_id
+end
+
+class Scheduler
+  class Cancel < Exception
+  end
+
+  attr_reader :ring
+
+  def initialize
+    @ring = IOU::Ring.new
+    @runqueue = []
+  end
+
+  def switchpoint
+    while true
+      f, v = @runqueue.shift
+      if f
+        return f.transfer(v)
+      end
+
+      @ring.process_completions
+    end
+  end
+
+  def fiber_wait(op_id)
+    Fiber.current.__op_id = op_id
+    v = switchpoint
+    Fiber.current.__op_id = nil
+    raise v if v.is_a?(Exception)
+    
+    v
+  end
+
+  def read(**args)
+    f = Fiber.current
+    id = ring.prep_read(**args) do |c|
+      if c[:result] < 0
+        @runqueue << [f, RuntimeError.new('error')]
+      else
+        @runqueue << [f, c[:buffer]]
+      end
+    end
+    fiber_wait(id)
+  end
+
+  def write(**args)
+    f = Fiber.current
+    id = ring.prep_write(**args) do |c|
+      if c[:result] < 0
+        @runqueue << [f, RuntimeError.new('error')]
+      else
+        @runqueue << [f, c[:result]]
+      end
+    end
+    fiber_wait(id)
+  end
+
+  def sleep(interval)
+    f = Fiber.current
+    id = ring.prep_timeout(interval: interval) do |c|
+      if c[:result] == Errno::ECANCELED::Errno
+        @runqueue << [f, c[:result]]
+      else
+        @runqueue << [f, c[:result]]
+      end
+    end
+    fiber_wait(id)
+  end
+
+  def cancel_fiber_op(f)
+    op_id = f.__op_id
+    if op_id
+      ring.prep_cancel(op_id)
+    end
+  end
+
+  def move_on_after(interval)
+    f = Fiber.current
+    cancel_id = ring.prep_timeout(interval: interval) do |c|
+      if c[:result] != Errno::ECANCELED::Errno
+        cancel_fiber_op(f)
+      end
+    end
+    v = yield
+    ring.prep_cancel(cancel_id)
+    v
+  end
+end
+
+s = Scheduler.new
+
+puts "Going to sleep..."
+s.sleep 3
+puts "Woke up"
+
+s.move_on_after(1) do
+  puts "Going to sleep (move on after 1 second)"
+  s.sleep 3
+end

data/examples/http_server_multishot.rb

@@ -22,9 +22,7 @@ def setup_connection(fd)
 
   parser = Http::Parser.new
   parser.on_message_complete = -> {
-    http_send_response(fd, "Hello, world!\n") do
-      @ring.prep_close(fd: fd)
-    end
+    http_send_response(fd, "Hello, world!\n")
   }
 
   http_prep_read(fd, parser)

data/examples/http_server_simpler.rb

@@ -0,0 +1,34 @@
+require_relative '../lib/iou'
+require 'socket'
+require 'http/parser'
+
+socket = TCPServer.open('127.0.0.1', 1234)
+puts 'Listening on port 1234... (multishot read)'
+
+@ring = IOU::Ring.new
+@buffer_group = @ring.setup_buffer_ring(count: 1024, size: 4096)
+
+@ring.prep_accept(fd: socket.fileno, multishot: true) do |c|
+  http_handle_connection(c[:result]) if c[:result] > 0
+end
+
+def http_handle_connection(fd)
+  parser = Http::Parser.new
+  parser.on_message_complete = -> { http_send_response(fd, "Hello, world!\n") }
+
+  @ring.prep_read(fd: fd, multishot: true, buffer_group: @buffer_group) do |c|
+    if c[:result] > 0
+      parser << c[:buffer]
+    else
+      puts "Connection closed on fd #{fd}"
+    end
+  end
+end
+
+def http_send_response(fd, body)
+  msg = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nConnection: keep-alive\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}"
+  @ring.prep_write(fd: fd, buffer: msg)
+end
+
+trap('SIGINT') { exit! }
+@ring.process_completions_loop

data/ext/iou/iou.h

@@ -48,19 +48,54 @@ struct sa_data {
   socklen_t len;
 };
 
-typedef struct OpSpecData_t {
+struct read_data {
+  VALUE buffer;
+  int buffer_offset;
+  unsigned bg_id;
+  int utf8_encoding;
+};
+
+enum op_type {
+  OP_accept,
+  OP_cancel,
+  OP_close,
+  OP_emit,
+  OP_nop,
+  OP_read,
+  OP_timeout,
+  OP_write
+};
+
+typedef struct OpCtx_t {
+  enum op_type type;
+  VALUE spec;
+  VALUE proc;
   union {
     struct __kernel_timespec ts;
     struct sa_data sa;
+    struct read_data rd;
   } data;
-} OpSpecData_t;
+  int stop_signal;
+} OpCtx_t;
 
 extern VALUE mIOU;
-extern VALUE cOpSpecData;
+extern VALUE cOpCtx;
+
+enum op_type OpCtx_type_get(VALUE self);
+void OpCtx_type_set(VALUE self, enum op_type type);
+
+VALUE OpCtx_spec_get(VALUE self);
+VALUE OpCtx_proc_get(VALUE self);
+
+struct __kernel_timespec *OpCtx_ts_get(VALUE self);
+void OpCtx_ts_set(VALUE self, VALUE value);
+
+struct sa_data *OpCtx_sa_get(VALUE self);
 
-struct __kernel_timespec *OpSpecData_ts_get(VALUE self);
-void OpSpecData_ts_set(VALUE self, VALUE value);
+struct read_data *OpCtx_rd_get(VALUE self);
+void OpCtx_rd_set(VALUE self, VALUE buffer, int buffer_offset, unsigned bg_id, int utf8_encoding);
 
-struct sa_data *OpSpecData_sa_get(VALUE self);
+int OpCtx_stop_signal_p(VALUE self);
+void OpCtx_stop_signal_set(VALUE self);
 
 #endif // IOU_H

data/ext/iou/iou_ext.c

@@ -1,9 +1,9 @@
 #include "iou.h"
 
 void Init_IOU();
-void Init_OpSpecData();
+void Init_OpCtx();
 
 void Init_iou_ext(void) {
   Init_IOU();
-  Init_OpSpecData();
+  Init_OpCtx();
 }

data/ext/iou/op_ctx.c

@@ -0,0 +1,125 @@
+#include "iou.h"
+
+VALUE cOpCtx;
+
+static void OpCtx_mark(void *ptr) {
+  OpCtx_t *ctx = ptr;
+  rb_gc_mark_movable(ctx->spec);
+  rb_gc_mark_movable(ctx->proc);
+}
+
+static void OpCtx_compact(void *ptr) {
+  OpCtx_t *ctx = ptr;
+  ctx->spec = rb_gc_location(ctx->spec);
+  ctx->proc = rb_gc_location(ctx->proc);
+}
+
+static size_t OpCtx_size(const void *ptr) {
+  return sizeof(OpCtx_t);
+}
+
+static const rb_data_type_t OpCtx_type = {
+    "OpCtx",
+    {OpCtx_mark, 0, OpCtx_size, OpCtx_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE OpCtx_allocate(VALUE klass) {
+  OpCtx_t *osd = ALLOC(OpCtx_t);
+
+  return TypedData_Wrap_Struct(klass, &OpCtx_type, osd);
+}
+
+VALUE OpCtx_initialize(VALUE self, VALUE spec, VALUE proc) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  RB_OBJ_WRITE(self, &osd->spec, spec);
+  RB_OBJ_WRITE(self, &osd->proc, proc);
+  memset(&osd->data, 0, sizeof(osd->data));
+  osd->stop_signal = 0;
+  return self;
+}
+
+VALUE OpCtx_spec(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  return osd->spec;
+}
+
+inline enum op_type OpCtx_type_get(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  return osd->type;
+}
+
+inline void OpCtx_type_set(VALUE self, enum op_type type) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  osd->type = type;
+}
+
+inline VALUE OpCtx_spec_get(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  return osd->spec;
+}
+
+inline VALUE OpCtx_proc_get(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  return osd->proc;
+}
+
+struct __kernel_timespec *OpCtx_ts_get(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  return &osd->data.ts;
+}
+
+inline struct __kernel_timespec 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;
+}
+
+inline struct __kernel_timespec value_to_timespec(VALUE value) {
+  return double_to_timespec(NUM2DBL(value));
+}
+
+inline void OpCtx_ts_set(VALUE self, VALUE value) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  osd->data.ts = value_to_timespec(value);
+}
+
+inline struct sa_data *OpCtx_sa_get(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  return &osd->data.sa;
+}
+
+inline struct read_data *OpCtx_rd_get(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  return &osd->data.rd;
+}
+
+inline void OpCtx_rd_set(VALUE self, VALUE buffer, int buffer_offset, unsigned bg_id, int utf8_encoding) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  osd->data.rd.buffer = buffer;
+  osd->data.rd.buffer_offset = buffer_offset;
+  osd->data.rd.bg_id = bg_id;
+  osd->data.rd.utf8_encoding = utf8_encoding;
+}
+
+inline int OpCtx_stop_signal_p(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  return osd->stop_signal;
+}
+
+inline void OpCtx_stop_signal_set(VALUE self) {
+  OpCtx_t *osd = RTYPEDDATA_DATA(self);
+  osd->stop_signal = 1;
+}
+
+void Init_OpCtx(void) {
+  mIOU = rb_define_module("IOU");
+  cOpCtx = rb_define_class_under(mIOU, "OpCtx", rb_cObject);
+  rb_define_alloc_func(cOpCtx, OpCtx_allocate);
+
+  rb_define_method(cOpCtx, "initialize", OpCtx_initialize, 2);
+  rb_define_method(cOpCtx, "spec", OpCtx_spec, 0);
+}

data/ext/iou/{iou.c → ring.c}

@@ -220,22 +220,28 @@ VALUE IOU_setup_buffer_ring(VALUE self, VALUE opts) {
   return UINT2NUM(bg_id);
 }
 
-inline void store_spec(IOU_t *iou, VALUE spec, VALUE id, VALUE op) {
+static inline VALUE setup_op_ctx(IOU_t *iou, enum op_type type, VALUE op, VALUE id, VALUE spec) {
   rb_hash_aset(spec, SYM_id, id);
   rb_hash_aset(spec, SYM_op, op);
-  if (rb_block_given_p())
-    rb_hash_aset(spec, SYM_block, rb_block_proc());
-  rb_hash_aset(iou->pending_ops, id, spec);
+  VALUE block_proc = rb_block_given_p() ? rb_block_proc() : Qnil;
+  if (block_proc != Qnil)
+    rb_hash_aset(spec, SYM_block, block_proc);
+  VALUE ctx = rb_funcall(cOpCtx, rb_intern("new"), 2, spec, block_proc);
+  OpCtx_type_set(ctx, type);
+  rb_hash_aset(iou->pending_ops, id, ctx);
+  return ctx;
 }
 
-VALUE IOU_emit(VALUE self, VALUE obj) {
+VALUE IOU_emit(VALUE self, VALUE spec) {
   IOU_t *iou = get_iou(self);
   unsigned id_i = ++iou->op_counter;
   VALUE id = UINT2NUM(id_i);
 
   struct io_uring_sqe *sqe = get_sqe(iou);
   sqe->user_data = id_i;
-  store_spec(iou, obj, id, SYM_emit);
+  VALUE ctx = setup_op_ctx(iou, OP_emit, SYM_emit, id, spec);
+  if (rb_hash_aref(spec, SYM_signal) == SYM_stop)
+    OpCtx_stop_signal_set(ctx);
 
   io_uring_prep_nop(sqe);
 
@@ -256,13 +262,11 @@ VALUE IOU_prep_accept(VALUE self, VALUE spec) {
   VALUE fd = values[0];
   VALUE multishot = rb_hash_aref(spec, SYM_multishot);
 
-  VALUE spec_data = rb_funcall(cOpSpecData, rb_intern("new"), 0);
   struct io_uring_sqe *sqe = get_sqe(iou);
   sqe->user_data = id_i;
-  rb_hash_aset(spec, SYM_spec_data, spec_data);
-  store_spec(iou, spec, id, SYM_accept);
 
-  struct sa_data *sa = OpSpecData_sa_get(spec_data);
+  VALUE ctx = setup_op_ctx(iou, OP_accept, SYM_accept, id, spec);
+  struct sa_data *sa = OpCtx_sa_get(ctx);
   if (RTEST(multishot))
     io_uring_prep_multishot_accept(sqe, NUM2INT(fd), &sa->addr, &sa->len, 0);
   else
@@ -310,7 +314,8 @@ VALUE IOU_prep_close(VALUE self, VALUE spec) {
 
   struct io_uring_sqe *sqe = get_sqe(iou);
   sqe->user_data = id_i;
-  store_spec(iou, spec, id, SYM_close);
+
+  setup_op_ctx(iou, OP_close, SYM_close, id, spec);
 
   io_uring_prep_close(sqe, NUM2INT(fd));
   iou->unsubmitted_sqes++;
@@ -358,10 +363,13 @@ VALUE prep_read_multishot(IOU_t *iou, VALUE spec) {
   get_required_kwargs(spec, values, 2, SYM_fd, SYM_buffer_group);
   int fd = NUM2INT(values[0]);
   unsigned bg_id = NUM2UINT(values[1]);
+  int utf8 = RTEST(rb_hash_aref(spec, SYM_utf8));
 
   struct io_uring_sqe *sqe = get_sqe(iou);
   sqe->user_data = id_i;
-  store_spec(iou, spec, id, SYM_read);
+
+  VALUE ctx = setup_op_ctx(iou, OP_read, SYM_read, id, spec);
+  OpCtx_rd_set(ctx, Qnil, 0, bg_id, utf8);
 
   io_uring_prep_read_multishot(sqe, fd, 0, -1, bg_id);
   iou->unsubmitted_sqes++;
@@ -387,10 +395,13 @@ VALUE IOU_prep_read(VALUE self, VALUE spec) {
 
   VALUE buffer_offset = rb_hash_aref(spec, SYM_buffer_offset);
   int buffer_offset_i = NIL_P(buffer_offset) ? 0 : NUM2INT(buffer_offset);
+  int utf8 = RTEST(rb_hash_aref(spec, SYM_utf8));
 
   struct io_uring_sqe *sqe = get_sqe(iou);
   sqe->user_data = id_i;
-  store_spec(iou, spec, id, SYM_read);
+
+  VALUE ctx = setup_op_ctx(iou, OP_read, SYM_read, id, spec);
+  OpCtx_rd_set(ctx, buffer, buffer_offset_i, 0, utf8);
 
   void *ptr = prepare_read_buffer(buffer, len_i, buffer_offset_i);
   io_uring_prep_read(sqe, NUM2INT(fd), ptr, len_i, -1);
@@ -409,15 +420,13 @@ VALUE IOU_prep_timeout(VALUE self, VALUE spec) {
   VALUE multishot = rb_hash_aref(spec, SYM_multishot);
   unsigned flags = RTEST(multishot) ? IORING_TIMEOUT_MULTISHOT : 0;
 
-  VALUE spec_data = rb_funcall(cOpSpecData, rb_intern("new"), 0);
-  OpSpecData_ts_set(spec_data, interval);
-
   struct io_uring_sqe *sqe = get_sqe(iou);
   sqe->user_data = id_i;
-  rb_hash_aset(spec, SYM_spec_data, spec_data);
-  store_spec(iou, spec, id, SYM_timeout);
 
-  io_uring_prep_timeout(sqe, OpSpecData_ts_get(spec_data), 0, flags);
+  VALUE ctx = setup_op_ctx(iou, OP_timeout, SYM_timeout, id, spec);
+  OpCtx_ts_set(ctx, interval);
+
+  io_uring_prep_timeout(sqe, OpCtx_ts_get(ctx), 0, flags);
   iou->unsubmitted_sqes++;
   return id;
 }
@@ -436,7 +445,8 @@ VALUE IOU_prep_write(VALUE self, VALUE spec) {
 
   struct io_uring_sqe *sqe = get_sqe(iou);
   sqe->user_data = id_i;
-  store_spec(iou, spec, id, SYM_write);
+
+  setup_op_ctx(iou, OP_write, SYM_write, id, spec);
 
   io_uring_prep_write(sqe, NUM2INT(fd), RSTRING_PTR(buffer), nbytes, -1);
   iou->unsubmitted_sqes++;
@@ -476,106 +486,112 @@ void *wait_for_completion_without_gvl(void *ptr) {
   return NULL;
 }
 
-static inline void update_read_buffer_from_buffer_ring(IOU_t *iou, VALUE spec, struct io_uring_cqe *cqe) {
+static inline void update_read_buffer_from_buffer_ring(IOU_t *iou, VALUE ctx, struct io_uring_cqe *cqe) {
   VALUE buf = Qnil;
   if (cqe->res == 0) {
     buf = rb_str_new_literal("");
     goto done;
   }
   
-  unsigned bg_id = NUM2UINT(rb_hash_aref(spec, SYM_buffer_group));
+  struct read_data *rd = OpCtx_rd_get(ctx);
   unsigned buf_idx = cqe->flags >> IORING_CQE_BUFFER_SHIFT;
 
-  struct buf_ring_descriptor *desc = iou->brs + bg_id;
+  struct buf_ring_descriptor *desc = iou->brs + rd->bg_id;
   char *src = desc->buf_base + desc->buf_size * buf_idx;
-  buf = rb_str_new(src, cqe->res);
+  buf = rd->utf8_encoding ? rb_utf8_str_new(src, cqe->res) : rb_str_new(src, cqe->res);
   
-  // release buffer back to io_uring
+  // add buffer back to buffer ring
   io_uring_buf_ring_add(
     desc->br, src, desc->buf_size, buf_idx,
 		io_uring_buf_ring_mask(desc->buf_count), 0
   );
   io_uring_buf_ring_advance(desc->br, 1);
 done:
-  rb_hash_aset(spec, SYM_buffer, buf);
+  rb_hash_aset(OpCtx_spec_get(ctx), SYM_buffer, buf);
   RB_GC_GUARD(buf);
   return;
 }
 
-static inline void update_read_buffer(IOU_t *iou, VALUE spec, struct io_uring_cqe *cqe) {
+static inline void update_read_buffer(IOU_t *iou, VALUE ctx, struct io_uring_cqe *cqe) {
   if (cqe->res < 0) return;
 
   if (cqe->flags & IORING_CQE_F_BUFFER) {
-    update_read_buffer_from_buffer_ring(iou, spec, cqe);
+    update_read_buffer_from_buffer_ring(iou, ctx, cqe);
     return;
   }
 
   if (cqe->res == 0) return;
 
-  VALUE buffer = rb_hash_aref(spec, SYM_buffer);
-  VALUE buffer_offset = rb_hash_aref(spec, SYM_buffer_offset);
-  int buffer_offset_i = NIL_P(buffer_offset) ? 0 : NUM2INT(buffer_offset);
-  adjust_read_buffer_len(buffer, cqe->res, buffer_offset_i);
-}
-
-inline int is_stop_signal(VALUE op, VALUE spec) {
-  return (op == SYM_emit) && (rb_hash_aref(spec, SYM_signal) == SYM_stop);
+  struct read_data *rd = OpCtx_rd_get(ctx);
+  adjust_read_buffer_len(rd->buffer, cqe->res, rd->buffer_offset);
 }
 
-static inline VALUE get_cqe_op_spec(IOU_t *iou, struct io_uring_cqe *cqe, int *stop_flag) {
+static inline VALUE get_cqe_ctx(IOU_t *iou, struct io_uring_cqe *cqe, int *stop_flag, VALUE *spec) {
   VALUE id = UINT2NUM(cqe->user_data);
-  VALUE spec = rb_hash_aref(iou->pending_ops, id);
+  VALUE ctx = rb_hash_aref(iou->pending_ops, id);
   VALUE result = INT2NUM(cqe->res);
-  if (NIL_P(spec))
-    return make_empty_op_with_result(id, result);
+  if (NIL_P(ctx)) {
+    *spec = make_empty_op_with_result(id, result);
+    return Qnil;
+  }
 
   // post completion work
-  VALUE op = rb_hash_aref(spec, SYM_op);
-  if (op == SYM_read)
-    update_read_buffer(iou, spec, cqe);
-  else if (stop_flag && is_stop_signal(op, spec))
-    *stop_flag = 1;
+  switch (OpCtx_type_get(ctx)) {
+    case OP_read:
+      update_read_buffer(iou, ctx, cqe);
+      break;
+    case OP_emit:
+      if (stop_flag && OpCtx_stop_signal_p(ctx))
+        *stop_flag = 1;
+      break;
+    default:
+  }
   
   // for multishot ops, the IORING_CQE_F_MORE flag indicates more completions
   // will be coming, so we need to keep the spec. Otherwise, we remove it.
   if (!(cqe->flags & IORING_CQE_F_MORE))
     rb_hash_delete(iou->pending_ops, id);
 
-  rb_hash_aset(spec, SYM_result, result);
-  RB_GC_GUARD(spec);
-  return spec;
+  *spec = OpCtx_spec_get(ctx);
+  rb_hash_aset(*spec, SYM_result, result);
+  RB_GC_GUARD(ctx);
+  return ctx;
 }
 
 VALUE IOU_wait_for_completion(VALUE self) {
   IOU_t *iou = get_iou(self);
 
-  wait_for_completion_ctx_t ctx = {
+  wait_for_completion_ctx_t cqe_ctx = {
     .iou = iou
   };
 
-  rb_thread_call_without_gvl(wait_for_completion_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  rb_thread_call_without_gvl(wait_for_completion_without_gvl, (void *)&cqe_ctx, RUBY_UBF_IO, 0);
 
-  if (unlikely(ctx.ret < 0)) {
-    rb_syserr_fail(-ctx.ret, strerror(-ctx.ret));
+  if (unlikely(cqe_ctx.ret < 0)) {
+    rb_syserr_fail(-cqe_ctx.ret, strerror(-cqe_ctx.ret));
   }
-  io_uring_cqe_seen(&iou->ring, ctx.cqe);
-  return get_cqe_op_spec(iou, ctx.cqe, 0);
+  io_uring_cqe_seen(&iou->ring, cqe_ctx.cqe);
+
+  VALUE spec = Qnil;
+  get_cqe_ctx(iou, cqe_ctx.cqe, 0, &spec);
+  return spec;
 }
 
-static inline void process_cqe(IOU_t *iou, struct io_uring_cqe *cqe, int *stop_flag) {
+static inline void process_cqe(IOU_t *iou, struct io_uring_cqe *cqe, int block_given, int *stop_flag) {
   if (stop_flag) *stop_flag = 0;
-  VALUE spec = get_cqe_op_spec(iou, cqe, stop_flag);
+  VALUE spec;
+  VALUE ctx = get_cqe_ctx(iou, cqe, stop_flag, &spec);
   if (stop_flag && *stop_flag) return;
 
-  if (rb_block_given_p())
+  if (block_given)
     rb_yield(spec);
-  else {
-    VALUE block = rb_hash_aref(spec, SYM_block);
-    if (RTEST(block))
-      rb_proc_call_with_block_kw(block, 1, &spec, Qnil, Qnil);
+  else if (ctx != Qnil) {
+    VALUE proc = OpCtx_proc_get(ctx);
+    if (RTEST(proc))
+      rb_proc_call_with_block_kw(proc, 1, &spec, Qnil, Qnil);
   }
 
-  RB_GC_GUARD(spec);
+  RB_GC_GUARD(ctx);
 }
 
 // copied from liburing/queue.c
@@ -585,7 +601,7 @@ static inline bool cq_ring_needs_flush(struct io_uring *ring) {
 
 // adapted from io_uring_peek_batch_cqe in liburing/queue.c
 // this peeks at cqes and handles each available cqe
-static inline int process_ready_cqes(IOU_t *iou, int *stop_flag) {
+static inline int process_ready_cqes(IOU_t *iou, int block_given, int *stop_flag) {
   unsigned total_count = 0;
 
 iterate:
@@ -596,7 +612,7 @@ iterate:
   io_uring_for_each_cqe(&iou->ring, head, cqe) {
     ++count;
     if (stop_flag) *stop_flag = 0;
-    process_cqe(iou, cqe, stop_flag);
+    process_cqe(iou, cqe, block_given, stop_flag);
     if (stop_flag && *stop_flag)
       break;
   }
@@ -618,6 +634,7 @@ done:
 
 VALUE IOU_process_completions(int argc, VALUE *argv, VALUE self) {
   IOU_t *iou = get_iou(self);
+  int block_given = rb_block_given_p();
   VALUE wait;
 
   rb_scan_args(argc, argv, "01", &wait);
@@ -639,15 +656,16 @@ VALUE IOU_process_completions(int argc, VALUE *argv, VALUE self) {
     }
     ++count;
     io_uring_cqe_seen(&iou->ring, ctx.cqe);
-    process_cqe(iou, ctx.cqe, 0);
+    process_cqe(iou, ctx.cqe, block_given, 0);
   }
 
-  count += process_ready_cqes(iou, 0);
+  count += process_ready_cqes(iou, block_given, 0);
   return UINT2NUM(count);
 }
 
 VALUE IOU_process_completions_loop(VALUE self) {
   IOU_t *iou = get_iou(self);
+  int block_given = rb_block_given_p();
   int stop_flag = 0;
   wait_for_completion_ctx_t ctx = { .iou = iou };
 
@@ -663,14 +681,14 @@ VALUE IOU_process_completions_loop(VALUE self) {
       rb_syserr_fail(-ctx.ret, strerror(-ctx.ret));
     }
     io_uring_cqe_seen(&iou->ring, ctx.cqe);
-    process_cqe(iou, ctx.cqe, &stop_flag);
+    process_cqe(iou, ctx.cqe, block_given, &stop_flag);
     if (stop_flag) goto done;
 
-    process_ready_cqes(iou, &stop_flag);
+    process_ready_cqes(iou, block_given, &stop_flag);
     if (stop_flag) goto done;
   }
 done:
-  return self;  
+  return self;
 }
 
 #define MAKE_SYM(sym) ID2SYM(rb_intern(sym))

data/lib/iou/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IOU
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/test/test_iou.rb

@@ -16,7 +16,7 @@ class IOURingTest < IOURingBaseTest
     assert_equal({}, ring.pending_ops)
 
     id = ring.prep_timeout(interval: 1)
-    spec = ring.pending_ops[id]
+    spec = ring.pending_ops[id].spec
     assert_equal id, spec[:id]
     assert_equal :timeout, spec[:op]
     assert_equal 1, spec[:interval]
@@ -46,7 +46,7 @@ class PrepTimeoutTest < IOURingBaseTest
     assert_equal id, c[:id]
     assert_equal :timeout, c[:op]
     assert_equal interval, c[:interval]
-    assert_equal -Errno::ETIME::Errno, c[:result]
+    assert_equal (-Errno::ETIME::Errno), c[:result]
   end
 
   def test_prep_timeout_invalid_args
@@ -74,7 +74,7 @@ class PrepCancelTest < IOURingBaseTest
     assert_equal timeout_id, c[:id]
     assert_equal :timeout, c[:op]
     assert_equal interval, c[:interval]
-    assert_equal -Errno::ECANCELED::Errno, c[:result]
+    assert_equal (-Errno::ECANCELED::Errno), c[:result]
   end
 
   def test_prep_cancel_kw
@@ -94,7 +94,7 @@ class PrepCancelTest < IOURingBaseTest
     assert_equal timeout_id, c[:id]
     assert_equal :timeout, c[:op]
     assert_equal interval, c[:interval]
-    assert_equal -Errno::ECANCELED::Errno, c[:result]
+    assert_equal (-Errno::ECANCELED::Errno), c[:result]
   end
 
   def test_prep_cancel_invalid_args
@@ -111,7 +111,7 @@ class PrepCancelTest < IOURingBaseTest
     ring.submit
     c = ring.wait_for_completion
     assert_equal cancel_id, c[:id]
-    assert_equal -Errno::ENOENT::Errno, c[:result]
+    assert_equal (-Errno::ENOENT::Errno), c[:result]
   end
 end
 
@@ -124,9 +124,9 @@ class PrepTimeoutMultishotTest < IOURingBaseTest
     t0 = monotonic_clock
     id = ring.prep_timeout(interval: interval, multishot: true) do |c|
       case c[:result]
-      when -Errno::ETIME::Errno
+      when (-Errno::ETIME::Errno)
         count += 1
-      when -Errno::ECANCELED::Errno
+      when (-Errno::ECANCELED::Errno)
         cancelled = true
       end
     end
@@ -151,7 +151,7 @@ class PrepTimeoutMultishotTest < IOURingBaseTest
 
     ring.prep_cancel(id)
     ring.submit
-    c = ring.process_completions(true)
+    ring.process_completions(true)
     assert_equal true, cancelled
     assert_equal 3, count
     assert_nil ring.pending_ops[id]
@@ -207,7 +207,7 @@ class PrepWriteTest < IOURingBaseTest
   end
 
   def test_prep_write_invalid_fd
-    r, w = IO.pipe
+    r, _w = IO.pipe
     s = 'foobar'
 
     id = ring.prep_write(fd: r.fileno, buffer: s)
@@ -220,7 +220,7 @@ class PrepWriteTest < IOURingBaseTest
     assert_equal id, c[:id]
     assert_equal :write, c[:op]
     assert_equal r.fileno, c[:fd]
-    assert_equal -Errno::EBADF::Errno, c[:result]
+    assert_equal (-Errno::EBADF::Errno), c[:result]
   end
 end
 
@@ -266,7 +266,8 @@ class PrepNopTest < IOURingBaseTest
     assert_nil c[:op]
     assert_equal 0, c[:result]    
   ensure
-    signaller.kill rescue nil
+    signaller&.kill rescue nil
+    waiter&.kill rescue nil
   end
 end
 
@@ -301,9 +302,9 @@ class ProcessCompletionsTest < IOURingBaseTest
   def test_process_completions_with_block
     r, w = IO.pipe
 
-    id1 = ring.prep_write(fd: w.fileno, buffer: 'foo')
-    id2 = ring.prep_write(fd: w.fileno, buffer: 'bar')
-    id3 = ring.prep_write(fd: w.fileno, buffer: 'baz')
+    ring.prep_write(fd: w.fileno, buffer: 'foo')
+    ring.prep_write(fd: w.fileno, buffer: 'bar')
+    ring.prep_write(fd: w.fileno, buffer: 'baz')
     ring.submit
     sleep 0.01
 
@@ -326,8 +327,8 @@ class ProcessCompletionsTest < IOURingBaseTest
   def test_process_completions_op_with_block
     cc = []
 
-    id1 = ring.prep_timeout(interval: 0.01) { cc << 1 }
-    id2 = ring.prep_timeout(interval: 0.02) { cc << 2 }
+    ring.prep_timeout(interval: 0.01) { cc << 1 }
+    ring.prep_timeout(interval: 0.02) { cc << 2 }
     ring.submit
 
     ret = ring.process_completions
@@ -344,8 +345,8 @@ class ProcessCompletionsTest < IOURingBaseTest
   def test_process_completions_op_with_block_no_submit
     cc = []
 
-    id1 = ring.prep_timeout(interval: 0.01) { cc << 1 }
-    id2 = ring.prep_timeout(interval: 0.02) { cc << 2 }
+    ring.prep_timeout(interval: 0.01) { cc << 1 }
+    ring.prep_timeout(interval: 0.02) { cc << 2 }
 
     ret = ring.process_completions
     assert_equal 0, ret
@@ -406,7 +407,7 @@ class PrepReadTest < IOURingBaseTest
   end
 
   def test_prep_read_bad_fd
-    r, w = IO.pipe
+    _r, w = IO.pipe
 
     id = ring.prep_read(fd: w.fileno, buffer: +'', len: 8192)
     assert_equal 1, id
@@ -418,7 +419,7 @@ class PrepReadTest < IOURingBaseTest
     assert_equal id, c[:id]
     assert_equal :read, c[:op]
     assert_equal w.fileno, c[:fd]
-    assert_equal -Errno::EBADF::Errno, c[:result]
+    assert_equal (-Errno::EBADF::Errno), c[:result]
   end
 
   def test_prep_read_with_block
@@ -513,7 +514,7 @@ end
 
 class PrepCloseTest < IOURingBaseTest
   def test_prep_close
-    r, w = IO.pipe
+    _r, w = IO.pipe
     fd = w.fileno
 
     id = ring.prep_close(fd: fd)
@@ -538,7 +539,7 @@ class PrepCloseTest < IOURingBaseTest
     assert_equal id, c[:id]
     assert_equal :close, c[:op]
     assert_equal fd, c[:fd]
-    assert_equal -Errno::EBADF::Errno, c[:result]
+    assert_equal (-Errno::EBADF::Errno), c[:result]
 
   end
 
@@ -560,7 +561,7 @@ class PrepCloseTest < IOURingBaseTest
     assert_equal id, c[:id]
     assert_equal :close, c[:op]
     assert_equal 9999, c[:fd]
-    assert_equal -Errno::EBADF::Errno, c[:result]
+    assert_equal (-Errno::EBADF::Errno), c[:result]
   end
 end
 
@@ -581,7 +582,7 @@ class PrepAcceptTest < IOURingBaseTest
     ring.submit
 
     t = Thread.new do
-      client = TCPSocket.new('127.0.0.1', @port)
+      TCPSocket.new('127.0.0.1', @port)
     end
 
     c = ring.wait_for_completion
@@ -611,7 +612,7 @@ class PrepAcceptTest < IOURingBaseTest
     assert_equal id, c[:id]
     assert_equal :accept, c[:op]
     assert_equal STDIN.fileno, c[:fd]
-    assert_equal -Errno::ENOTSOCK::Errno, c[:result]
+    assert_equal (-Errno::ENOTSOCK::Errno), c[:result]
   end
 
   def test_prep_accept_multishot
@@ -622,7 +623,7 @@ class PrepAcceptTest < IOURingBaseTest
 
     connect = -> {
       tt << Thread.new do
-        client = TCPSocket.new('127.0.0.1', @port)
+        TCPSocket.new('127.0.0.1', @port)
       end
     }
 
@@ -707,7 +708,6 @@ class PrepReadMultishotTest < IOURingBaseTest
   def test_prep_read_multishot
     r, w = IO.pipe
 
-    bb = []
     bgid = ring.setup_buffer_ring(size: 4096, count: 1024)
     assert_equal 0, bgid
 
@@ -717,6 +717,10 @@ class PrepReadMultishotTest < IOURingBaseTest
 
     w << 'foo'
     c = ring.wait_for_completion
+
+    # make sure the OS supports this op (the liburing docs are not clear)
+    skip if c[:result] == (-Errno::EINVAL::Errno)
+
     assert_kind_of Hash, c
     assert_equal id, c[:id]
     assert_equal :read, c[:op]
@@ -747,13 +751,8 @@ class PrepReadMultishotTest < IOURingBaseTest
   end
 
   def test_prep_read_multishot_utf8
-    # checking for UTF-8 incurs a serious performance degradation. We'll leave
-    # it for later...
-    skip
-
     r, w = IO.pipe
 
-    bb = []
     bgid = ring.setup_buffer_ring(size: 4096, count: 1024)
     assert_equal 0, bgid
 
@@ -763,6 +762,10 @@ class PrepReadMultishotTest < IOURingBaseTest
 
     w << 'foo'
     c = ring.wait_for_completion
+
+    # make sure the OS supports this op (the liburing docs are not clear)
+    skip if c[:result] == (-Errno::EINVAL::Errno)
+
     assert_kind_of Hash, c
     assert_equal id, c[:id]
     assert_equal :read, c[:op]
@@ -792,3 +795,36 @@ class PrepReadMultishotTest < IOURingBaseTest
     assert_nil ring.pending_ops[id]
   end
 end
+
+class OpCtxTest < IOURingBaseTest
+  def test_ctx_spec
+    id = ring.emit(foo: :bar)
+    assert_equal({ foo: :bar, id: 1, op: :emit }, ring.pending_ops[id].spec)
+  end
+
+  def test_ctx_type
+    id = ring.emit(v: 1)
+    assert_equal 1, id
+    assert_equal :emit, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_timeout(interval: 1)
+    assert_equal 2, id
+    assert_equal :timeout, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_read(fd: STDIN.fileno, buffer: +'', len: 42)
+    assert_equal 3, id
+    assert_equal :read, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_write(fd: STDOUT.fileno, buffer: '')
+    assert_equal 4, id
+    assert_equal :write, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_accept(fd: STDIN.fileno)
+    assert_equal 5, id
+    assert_equal :accept, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_close(fd: STDIN.fileno)
+    assert_equal 6, id
+    assert_equal :close, ring.pending_ops[id].spec[:op]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iou
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-07 00:00:00.000000000 Z
+date: 2024-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -75,8 +75,10 @@ extra_rdoc_files:
 - README.md
 files:
 - ".github/dependabot.yml"
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".gitmodules"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -84,13 +86,15 @@ files:
 - TODO.md
 - examples/echo_server.rb
 - examples/event_loop.rb
+- examples/fibers.rb
 - examples/http_server.rb
 - examples/http_server_multishot.rb
+- examples/http_server_simpler.rb
 - ext/iou/extconf.rb
-- ext/iou/iou.c
 - ext/iou/iou.h
 - ext/iou/iou_ext.c
-- ext/iou/op_spec_data.c
+- ext/iou/op_ctx.c
+- ext/iou/ring.c
 - iou.gemspec
 - lib/iou.rb
 - lib/iou/version.rb

data/ext/iou/op_spec_data.c

@@ -1,61 +0,0 @@
-#include "iou.h"
-
-VALUE cOpSpecData;
-
-static size_t OpSpecData_size(const void *ptr) {
-  return sizeof(OpSpecData_t);
-}
-
-static const rb_data_type_t OpSpecData_type = {
-    "OpSpecData",
-    {0, 0, OpSpecData_size, 0},
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
-};
-
-static VALUE OpSpecData_allocate(VALUE klass) {
-  OpSpecData_t *osd = ALLOC(OpSpecData_t);
-
-  return TypedData_Wrap_Struct(klass, &OpSpecData_type, osd);
-}
-
-VALUE OpSpecData_initialize(VALUE self) {
-  OpSpecData_t *osd = RTYPEDDATA_DATA(self);
-  memset(&osd->data, 0, sizeof(osd->data));
-  return self;
-}
-
-struct __kernel_timespec *OpSpecData_ts_get(VALUE self) {
-  OpSpecData_t *osd = RTYPEDDATA_DATA(self);
-  return &osd->data.ts;
-}
-
-inline struct __kernel_timespec 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;
-}
-
-inline struct __kernel_timespec value_to_timespec(VALUE value) {
-  return double_to_timespec(NUM2DBL(value));
-}
-
-void OpSpecData_ts_set(VALUE self, VALUE value) {
-  OpSpecData_t *osd = RTYPEDDATA_DATA(self);
-  osd->data.ts = value_to_timespec(value);
-}
-
-struct sa_data *OpSpecData_sa_get(VALUE self) {
-  OpSpecData_t *osd = RTYPEDDATA_DATA(self);
-  return &osd->data.sa;
-}
-
-void Init_OpSpecData(void) {
-  mIOU = rb_define_module("IOU");
-  cOpSpecData = rb_define_class_under(mIOU, "OpSpecData", rb_cObject);
-  rb_define_alloc_func(cOpSpecData, OpSpecData_allocate);
-
-  rb_define_method(cOpSpecData, "initialize", OpSpecData_initialize, 0);
-}