uringmachine 0.2 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52ccd2dc6b2caf48fd03405d4536cb9a0a9640470fb14a5f105da84029857471
-  data.tar.gz: cf1c06469be27a93089a805cfd7552978f8f84d1a6f6d225289954d908ec981e
+  metadata.gz: 7129b3c8605d5734f7152bddb4fa1b6f034fd1de26262eabfbfc2190846967bd
+  data.tar.gz: 902e6663bac65d56e45d67383e2cd3eb0601534ed2b451f4f76b2812ce6125b1
 SHA512:
-  metadata.gz: e79d481864b8be758efc1f67924b491118c4d00a038fc24ee2a6078cc34edbfab9602166836e155fb74dcd423f5bcee2da47dd89d24fb23c68b3412481704f98
-  data.tar.gz: 00f2867826b20a9ed0198dc683f5f26d81d59a94bacfa2320b991c89c0dcb0cb327cb821b33d6c501fb2f67d73c2ff0784841cb01d973d58584081d621ff4563
+  metadata.gz: 683db63642ddb5d98c9eb137f8121a8cb8cb0fe44456928fca78cf8e322cebc01078efa71379abcceae1a1889140bf5b39f6ac16348db0b77d9c8a5bb9cf5cd0
+  data.tar.gz: 850dce780030b6102371861805f831299d3ea113f8c02141515afe167b0e49f43a51812a6159a91b6335085b41fcb226713eeb963ae69d208818cb1f3cb303b3

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 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.

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, machine->freelist_head);
-  um_free_linked_list(machine, machine->runqueue_head);
-}
-
 struct wait_for_cqe_ctx {
   struct um *machine;
   struct io_uring_cqe *cqe;
@@ -97,6 +129,7 @@ inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe) {
       // 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!
   }
@@ -270,10 +303,10 @@ 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);
@@ -284,11 +317,11 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
 
 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, &ts, 0, 0);
+  io_uring_prep_timeout(sqe, &op->ts, 0, 0);
   op->state = OP_submitted;
 
   return um_await_op(machine, op, &result, NULL);
@@ -311,7 +344,7 @@ inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int b
   return INT2FIX(result);
 }
 
-VALUE um_read_each_ensure(VALUE arg) {
+VALUE um_multishot_ensure(VALUE arg) {
   struct op_ensure_ctx *ctx = (struct op_ensure_ctx *)arg;
   switch (ctx->op->state) {
     case OP_submitted:
@@ -358,5 +391,67 @@ VALUE um_read_each(struct um *machine, int fd, int bgid) {
   op->state = OP_submitted;
 
   struct op_ensure_ctx ctx = { .machine = machine, .op = op, .bgid = bgid };
-  return rb_ensure(um_read_each_safe_loop, (VALUE)&ctx, um_read_each_ensure, (VALUE)&ctx);
+  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

@@ -48,6 +48,8 @@ struct um_op {
   VALUE fiber;
   VALUE resume_value;
   int is_multishot;
+  struct __kernel_timespec ts;
+  
   int cqe_result;
   int cqe_flags;
 };
@@ -63,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;
 
@@ -79,6 +83,11 @@ 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);
@@ -88,9 +97,6 @@ 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_cleanup(struct um *machine);
-
-void um_free_linked_list(struct um *machine, struct um_op *op);
 VALUE um_fiber_switch(struct um *machine);
 VALUE um_await(struct um *machine);
 
@@ -111,5 +117,9 @@ 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

@@ -14,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);
 }
 
@@ -43,36 +43,7 @@ inline struct um *get_machine(VALUE self) {
 
 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;
-
+  um_setup(machine);
   return self;
 }
 
@@ -126,7 +97,6 @@ VALUE UM_setup_buffer_ring(VALUE self, VALUE size, VALUE count) {
   return UINT2NUM(bg_id);
 }
 
-
 VALUE UM_pending_count(VALUE self) {
   struct um *machine = get_machine(self);
   return INT2FIX(machine->pending_count);
@@ -185,6 +155,27 @@ VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
   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);
 
@@ -204,6 +195,10 @@ void Init_UM(void) {
   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_op.c

@@ -1,17 +1,33 @@
 #include "um.h"
 
-inline void um_op_result_cleanup(struct um *machine, struct um_op *op) {
+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;
-    free(entry);
+    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 = malloc(sizeof(struct um_result_entry));
+  struct um_result_entry *entry = um_result_checkout(machine);
   entry->next = 0;
   entry->result = result;
   entry->flags = flags;
@@ -33,7 +49,7 @@ inline int um_op_result_shift(struct um *machine, struct um_op *op, int *result,
   op->results_head = entry->next;
   if (!op->results_head)
     op->results_tail = NULL;
-  free(entry);
+  um_result_checkin(machine, entry);
   return 1;
 }
 
@@ -45,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;
   }
@@ -62,8 +78,8 @@ inline void um_op_checkin(struct um *machine, struct um_op *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) {
@@ -117,7 +133,7 @@ inline struct um_op *um_runqueue_shift(struct um *machine) {
   return op;
 }
 
-inline void um_free_linked_list(struct um *machine, 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);
@@ -125,3 +141,11 @@ inline void um_free_linked_list(struct um *machine, struct um_op *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/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.2'
+  VERSION = '0.3'
 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

@@ -110,7 +110,7 @@ class SchedulingTest < UMBaseTest
   def test_timeout_with_raising_block
     e = nil
     begin
-      machine.timeout(0.01, TOError) do
+      machine.timeout(0.1, TOError) do
         raise 'hi'
       end
     rescue => e
@@ -125,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
 
@@ -189,7 +189,7 @@ class ReadTest < UMBaseTest
     assert_equal '', buf
   end
 
-  def test_prep_read_bad_fd
+  def test_read_bad_fd
     _r, w = IO.pipe
 
     assert_raises(Errno::EBADF) do
@@ -334,3 +334,81 @@ class ReadEachTest < UMBaseTest
     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  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