uringmachine 0.1 → 0.3

data/ext/um/um_op.c

@@ -1,5 +1,58 @@
 #include "um.h"
 
+inline struct um_result_entry *um_result_checkout(struct um *machine) {
+  if (machine->result_freelist) {
+    struct um_result_entry *entry = machine->result_freelist;
+    machine->result_freelist = entry->next;
+    return entry;
+  }
+
+  struct um_result_entry *entry = malloc(sizeof(struct um_result_entry));
+  return entry;
+}
+
+inline void um_result_checkin(struct um *machine, struct um_result_entry *entry) {
+  entry->next = machine->result_freelist;
+  machine->result_freelist = entry;  
+}
+
+inline void um_op_result_cleanup(struct um *machine, struct um_op *op) {  
+  struct um_result_entry *entry = op->results_head;
+  while (entry) {
+    struct um_result_entry *next = entry->next;
+    um_result_checkin(machine, entry);
+    entry = next;
+  }
+  op->results_head = op->results_tail = NULL;
+}
+
+inline void um_op_result_push(struct um *machine, struct um_op *op, int result, int flags) {
+  struct um_result_entry *entry = um_result_checkout(machine);
+  entry->next = 0;
+  entry->result = result;
+  entry->flags = flags;
+  if (op->results_tail) {
+    op->results_tail->next = entry;
+    op->results_tail = entry;
+  }
+  else {
+    op->results_head = op->results_tail = entry;
+  }
+}
+
+inline int um_op_result_shift(struct um *machine, struct um_op *op, int *result, int *flags) {
+  if (!op->results_head) return 0;
+
+  struct um_result_entry *entry = op->results_head;
+  *result = entry->result;
+  *flags = entry->flags;
+  op->results_head = entry->next;
+  if (!op->results_head)
+    op->results_tail = NULL;
+  um_result_checkin(machine, entry);
+  return 1;
+}
+
 inline void um_op_clear(struct um_op *op) {
   memset(op, 0, sizeof(struct um_op));
   op->fiber = op->resume_value = Qnil;
@@ -8,9 +61,9 @@ inline void um_op_clear(struct um_op *op) {
 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;
+  if (machine->op_freelist) {
+    struct um_op *op = machine->op_freelist;
+    machine->op_freelist = op->next;
     um_op_clear(op);
     return op;
   }
@@ -21,10 +74,12 @@ inline struct um_op *um_op_checkout(struct um *machine) {
 }
 
 inline void um_op_checkin(struct um *machine, struct um_op *op) {
+  um_op_result_cleanup(machine, op);
+
   machine->pending_count--;
 
-  op->next = machine->freelist_head;
-  machine->freelist_head = op;
+  op->next = machine->op_freelist;
+  machine->op_freelist = op;
 }
 
 inline struct um_op *um_runqueue_find_by_fiber(struct um *machine, VALUE fiber) {
@@ -78,10 +133,19 @@ inline struct um_op *um_runqueue_shift(struct um *machine) {
   return op;
 }
 
-inline void um_free_linked_list(struct um_op *op) {
+inline void um_free_op_linked_list(struct um *machine, struct um_op *op) {
   while (op) {
     struct um_op *next = op->next;
+    um_op_result_cleanup(machine, op);
     free(op);
     op = next;
   }
 }
+
+inline void um_free_result_linked_list(struct um *machine, struct um_result_entry *entry) {
+  while (entry) {
+    struct um_result_entry *next = entry->next;
+    free(entry);
+    entry = next;
+  }
+}

data/ext/um/um_utils.c

@@ -15,9 +15,59 @@ 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) {
+inline 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);
 }
+
+inline void um_raise_on_system_error(int result) {
+  if (unlikely(result < 0)) rb_syserr_fail(-result, strerror(-result));
+}
+
+inline void * um_prepare_read_buffer(VALUE buffer, unsigned len, int ofs) {
+  unsigned current_len = RSTRING_LEN(buffer);
+  if (ofs < 0) ofs = current_len + ofs + 1;
+  unsigned new_len = len + (unsigned)ofs;
+
+  if (current_len < new_len)
+    rb_str_modify_expand(buffer, new_len);
+  else
+    rb_str_modify(buffer);
+  return RSTRING_PTR(buffer) + ofs;
+}
+
+static inline void adjust_read_buffer_len(VALUE buffer, int result, int ofs) {
+  rb_str_modify(buffer);
+  unsigned len = result > 0 ? (unsigned)result : 0;
+  unsigned current_len = RSTRING_LEN(buffer);
+  if (ofs < 0) ofs = current_len + ofs + 1;
+  rb_str_set_len(buffer, len + (unsigned)ofs);
+}
+
+inline void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, int result, int flags) {
+  if (!result) return;
+
+  adjust_read_buffer_len(buffer, result, buffer_offset);
+}
+
+inline VALUE get_string_from_buffer_ring(struct um *machine, int bgid, int result, int flags) {
+  if (!result) return Qnil;
+
+  unsigned buf_idx = flags >> IORING_CQE_BUFFER_SHIFT;
+  struct buf_ring_descriptor *desc = machine->buffer_rings + bgid;
+  char *src = desc->buf_base + desc->buf_size * buf_idx;
+  // TODO: add support for UTF8
+  // buf = rd->utf8_encoding ? rb_utf8_str_new(src, cqe->res) : rb_str_new(src, cqe->res);
+  VALUE buf = rb_str_new(src, result);
+
+  // 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);
+
+  RB_GC_GUARD(buf);
+  return buf;
+}

data/lib/uringmachine/version.rb

@@ -1,3 +1,5 @@
 # frozen_string_literal: true
 
-UM_VERSION = '0.1'
+class UringMachine
+  VERSION = '0.3'
+end

data/lib/uringmachine.rb

@@ -3,6 +3,3 @@
 require_relative './um_ext'
 
 UM = UringMachine
-
-class UringMachine
-end

data/test/helper.rb

@@ -3,8 +3,12 @@
 require 'bundler/setup'
 require_relative './coverage' if ENV['COVERAGE']
 require 'uringmachine'
+require 'socket'
 require 'minitest/autorun'
 
+STDOUT.sync = true
+STDERR.sync = true
+
 module ::Kernel
   def debug(**h)
     k, v = h.first
@@ -46,18 +50,6 @@ module Minitest::Assertions
   end
 end
 
-class IOURingBaseTest < Minitest::Test
-  attr_accessor :ring
-  
-  def setup
-    @ring = IOU::Ring.new
-  end
-
-  def teardown
-    ring.close
-  end
-end
-
 class UMBaseTest < Minitest::Test
   attr_accessor :machine
   
@@ -66,5 +58,6 @@ class UMBaseTest < Minitest::Test
   end
 
   def teardown
+    # @machine&.cleanup
   end
 end

data/test/test_um.rb

@@ -3,16 +3,6 @@
 require_relative 'helper'
 require 'socket'
 
-class SleepTest < UMBaseTest
-  def test_sleep
-    t0 = monotonic_clock
-    res = machine.sleep(0.1)
-    t1 = monotonic_clock
-    assert_in_range 0.09..0.13, t1 - t0
-    assert_equal 0.1, res
-  end
-end
-
 class SchedulingTest < UMBaseTest
   def test_schedule_and_yield
     buf = []
@@ -119,8 +109,8 @@ class SchedulingTest < UMBaseTest
 
   def test_timeout_with_raising_block
     e = nil
-    v = begin
-      machine.timeout(0.01, TOError) do
+    begin
+      machine.timeout(0.1, TOError) do
         raise 'hi'
       end
     rescue => e
@@ -135,7 +125,7 @@ class SchedulingTest < UMBaseTest
   end
 
   def test_timeout_with_nothing_blocking
-    v = machine.timeout(0.01, TOError) { 42 }
+    v = machine.timeout(0.1, TOError) { 42 }
 
     assert_equal 42, v
 
@@ -166,3 +156,259 @@ class SchedulingTest < UMBaseTest
     assert_equal [3], buf
   end
 end
+
+class SleepTest < UMBaseTest
+  def test_sleep
+    t0 = monotonic_clock
+    res = machine.sleep(0.1)
+    t1 = monotonic_clock
+    assert_in_range 0.09..0.13, t1 - t0
+    assert_equal 0.1, res
+  end
+end
+
+class ReadTest < UMBaseTest
+  def test_read
+    r, w = IO.pipe
+    w << 'foobar'
+
+    buf = +''
+    res = machine.read(r.fileno, buf, 3)
+    assert_equal 3, res
+    assert_equal 'foo', buf
+
+    buf = +''
+    res = machine.read(r.fileno, buf, 128)
+    assert_equal 3, res
+    assert_equal 'bar', buf
+
+    w.close
+    buf = +''
+    res = machine.read(r.fileno, buf, 128)
+    assert_equal 0, res
+    assert_equal '', buf
+  end
+
+  def test_read_bad_fd
+    _r, w = IO.pipe
+
+    assert_raises(Errno::EBADF) do
+      machine.read(w.fileno, +'', 8192)
+    end
+  end
+
+  def test_read_with_buffer_offset
+    buffer = +'foo'
+    r, w = IO.pipe
+    w << 'bar'
+
+    result = machine.read(r.fileno, buffer, 100, buffer.bytesize)
+    assert_equal 3, result
+    assert_equal 'foobar', buffer
+  end
+
+  def test_read_with_negative_buffer_offset
+    buffer = +'foo'
+
+    r, w = IO.pipe
+    w << 'bar'
+
+    result = machine.read(r.fileno, buffer, 100, -1)
+    assert_equal 3, result
+    assert_equal 'foobar', buffer
+
+    buffer = +'foogrr'
+
+    r, w = IO.pipe
+    w << 'bar'
+
+    result = machine.read(r.fileno, buffer, 100, -4)
+    assert_equal 3, result
+    assert_equal 'foobar', buffer
+  end
+end
+
+class ReadEachTest < UMBaseTest
+  def test_read_each
+    r, w = IO.pipe
+    bufs = []
+
+    bgid = machine.setup_buffer_ring(4096, 1024)
+    assert_equal 0, bgid
+
+    f = Fiber.new do
+      w << 'foo'
+      machine.snooze
+      w << 'bar'
+      machine.snooze
+      w << 'baz'
+      machine.snooze
+      w.close
+      machine.yield
+    end
+    machine.schedule(f, nil)
+
+    machine.read_each(r.fileno, bgid) do |buf|
+      bufs << buf
+    end
+
+    assert_equal ['foo', 'bar', 'baz'], bufs
+    assert_equal 0, machine.pending_count
+  end
+
+  # send once and close write fd
+  def test_read_each_raising_1
+    r, w = IO.pipe
+
+    bgid = machine.setup_buffer_ring(4096, 1024)
+    assert_equal 0, bgid
+
+    w << 'foo'
+    w.close
+
+    e = nil
+    begin
+      machine.read_each(r.fileno, bgid) do |buf|
+        raise 'hi'
+      end
+    rescue => e
+    end
+
+    assert_kind_of RuntimeError, e
+    assert_equal 'hi', e.message
+    assert_equal 0, machine.pending_count
+  end
+
+  # send once and leave write fd open
+  def test_read_each_raising_2
+    r, w = IO.pipe
+
+    bgid = machine.setup_buffer_ring(4096, 1024)
+    assert_equal 0, bgid
+
+    w << 'foo'
+
+    e = nil
+    begin
+      machine.read_each(r.fileno, bgid) do |buf|
+        raise 'hi'
+      end
+    rescue => e
+    end
+
+    assert_kind_of RuntimeError, e
+    assert_equal 'hi', e.message
+
+    # since the write fd is still open, the read_each impl is supposed to cancel
+    # the op, which is done asynchronously.
+    assert_equal 1, machine.pending_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+  end
+
+  # send twice
+  def test_read_each_raising_3
+    r, w = IO.pipe
+
+    bgid = machine.setup_buffer_ring(4096, 1024)
+    assert_equal 0, bgid
+
+    w << 'foo'
+    w << 'bar'
+
+    e = nil
+    begin
+      machine.read_each(r.fileno, bgid) do |buf|
+        raise 'hi'
+      end
+    rescue => e
+    end
+
+    assert_kind_of RuntimeError, e
+    assert_equal 'hi', e.message
+
+    # since the write fd is still open, the read_each impl is supposed to cancel
+    # the op, which is done asynchronously.
+    assert_equal 1, machine.pending_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+  end
+end
+
+class WriteTest < UMBaseTest
+  def test_write
+    r, w = IO.pipe
+
+    machine.write(w.fileno, 'foo')
+    assert_equal 'foo', r.readpartial(3)
+
+    machine.write(w.fileno, 'bar', 2)
+    assert_equal 'ba', r.readpartial(3)
+  end
+
+  def test_write_bad_fd
+    r, _w = IO.pipe
+
+    assert_raises(Errno::EBADF) do
+      machine.write(r.fileno, 'foo')
+    end
+  end
+end
+
+class AcceptTest < UMBaseTest
+  def setup
+    super
+    @port = 9000 + rand(1000)
+    @server = TCPServer.open('127.0.0.1', @port)
+  end
+
+  def teardown
+    @server&.close
+    super
+  end
+
+  def test_accept
+    conn = TCPSocket.new('127.0.0.1', @port)
+    
+    fd = machine.accept(@server.fileno)
+    assert_kind_of Integer, fd
+    assert fd > 0
+
+    machine.write(fd, 'foo')
+    buf = conn.readpartial(3)
+
+    assert_equal 'foo', buf
+  end
+end
+
+class AcceptEachTest < UMBaseTest
+  def setup
+    super
+    @port = 9000 + rand(1000)
+    @server = TCPServer.open('127.0.0.1', @port)
+  end
+
+  def teardown
+    @server&.close
+    super
+  end
+
+  def test_accept_each
+    conns = 3.times.map { TCPSocket.new('127.0.0.1', @port) }
+
+    count = 0
+    machine.accept_each(@server.fileno) do |fd|
+      machine.write(fd, (count += 1).to_s)
+      break if count == 3
+    end
+
+    assert_equal 3, count
+    assert_equal 1, machine.pending_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+
+    assert_equal '1', conns[0].readpartial(3)
+    assert_equal '2', conns[1].readpartial(3)
+    assert_equal '3', conns[2].readpartial(3)
+  end
+end

data/uringmachine.gemspec

@@ -2,7 +2,7 @@ require_relative './lib/uringmachine/version'
 
 Gem::Specification.new do |s|
   s.name        = 'uringmachine'
-  s.version     = UM_VERSION
+  s.version     = UringMachine::VERSION
   s.licenses    = ['MIT']
   s.summary     = 'A lean, mean io_uring machine'
   s.author      = 'Sharon Rosner'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.3'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-03 00:00:00.000000000 Z
+date: 2024-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -91,9 +91,6 @@ files:
 - examples/http_server_multishot.rb
 - examples/http_server_simpler.rb
 - ext/um/extconf.rb
-- ext/um/iou.h
-- ext/um/op_ctx.c
-- ext/um/ring.c
 - ext/um/um.c
 - ext/um/um.h
 - ext/um/um_class.c
@@ -103,7 +100,6 @@ files:
 - lib/uringmachine.rb
 - lib/uringmachine/version.rb
 - test/helper.rb
-- test/test_iou.rb
 - test/test_um.rb
 - uringmachine.gemspec
 - vendor/liburing/.github/actions/codespell/stopwords

data/ext/um/iou.h

@@ -1,101 +0,0 @@
-#ifndef IOU_H
-#define IOU_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
-
-struct buf_ring_descriptor {
-  struct io_uring_buf_ring *br;
-  size_t br_size;
-  // struct io_uring_buf_ring *buf_ring;
-  unsigned buf_count;
-  unsigned buf_size;
-	char *buf_base;
-  // size_t buf_ring_size;
-};
-
-#define BUFFER_RING_MAX_COUNT 10
-
-typedef struct IOURing_t {
-  struct io_uring ring;
-  unsigned int    ring_initialized;
-  unsigned int    op_counter;
-  unsigned int    unsubmitted_sqes;
-  VALUE           pending_ops;
-
-  struct buf_ring_descriptor brs[BUFFER_RING_MAX_COUNT];
-  unsigned int br_counter;
-} IOURing_t;
-
-struct sa_data {
-  struct sockaddr addr;
-  socklen_t len;
-};
-
-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;
-  int stop_signal;
-} OpCtx_t;
-
-extern VALUE mIOU;
-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 read_data *OpCtx_rd_get(VALUE self);
-void OpCtx_rd_set(VALUE self, VALUE buffer, int buffer_offset, unsigned bg_id, int utf8_encoding);
-
-int OpCtx_stop_signal_p(VALUE self);
-void OpCtx_stop_signal_set(VALUE self);
-
-#endif // IOU_H