uringmachine 0.5.1 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b063db46fac29472c42866eb1864c731b24fc0846fe424eec06213bba8fde0a
-  data.tar.gz: a535fabf5d16107de8d3823766d9ff0d7d22d0702c5401e263eb925eb222dd5d
+  metadata.gz: 602ceb6207baea6b38287928500c73df48258ca2f8cf843f02b45fa65c591e3e
+  data.tar.gz: 78b2bc7a274b03e2ae51510e213be0d23911c4db102ad4ab7eee435f915bb5c0
 SHA512:
-  metadata.gz: 94ad9e942e84e87f0acbd75007962c3df5ea259de77ef4e590ff91dc4ea614dcd22e7db3da1954be05b11951e621f0cf58858391b677e109e97590bb0f8e3dee
-  data.tar.gz: 4c77e826fb33fc879de748b877eec9a6d49f6927b8167377b4191c30b9aa2b638dbd0cc76a77ec0a17daec648d2587ca4357f367501391aad06c7532606e85b2
+  metadata.gz: c0dcbb93493c9778cf4ac12769f88611364d4e190c9e9dfa666543643e3aa3b44fa01cc49cf1ea2a1ba4798c4893b75e8b47e5b1eeac23b48bc5a6d84046e458
+  data.tar.gz: 5b012fcc3e7fd1a6d4e68aae58b9d099f19d5a89670772cdfdd6ef4ac76ed9781f533fd576e2b19b02c7774ba31d3ce6ee06dc590e04ce07a62e3c7fb2394191

data/.github/workflows/test.yml

@@ -13,7 +13,7 @@ jobs:
       matrix:
         # macos-latest uses arm64, macos-13 uses x86
         os: [ubuntu-latest]
-        ruby: ['3.3', 'head']
+        ruby: ['3.3', '3.4', 'head']
 
     name: ${{matrix.os}}, ${{matrix.ruby}}
 

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 2025-04-23 Version 0.6.1
+
+- Improve `#snooze` to prevent op completion starvation
+
+# 2025-04-23 Version 0.6
+
+- Add `#periodically` for multishot timeout
+- Add `UM::Actor` class
 - Add `#prep_timeout` and `AsyncOp`
 
 # 2024-11-14 Version 0.5

data/TODO.md

@@ -1,3 +1,7 @@
+- [ ] multishot timeout
+  - [v] machine.periodically(interval) { ... }
+  - [ ] machine.prep_timeout_multishot(interval)
+
 - splice / - tee
 - sendto
 - recvfrom

data/examples/bm_http_parse.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark-ips'
+  gem 'http_parser.rb'
+end
+
+require 'benchmark/ips'
+require 'uringmachine'
+require 'http/parser'
+
+$machine = UM.new
+
+HTTP_MSG = "GET /foo/bar HTTP/1.1\r\nServer: foobar.com\r\nFoo: bar\r\n\r\n"
+
+$count = 0
+
+def parse_http_parser
+  current_fiber = Fiber.current
+  $count += 1
+  r, w = IO.pipe
+  parser = Http::Parser.new
+  $machine.spin do
+    buffer = +''
+    loop do
+      res = $machine.read(r.fileno, buffer, 512)
+      break if res == 0
+      parser << buffer
+    end
+  rescue Exception => e
+    $machine.schedule(current_fiber, e)
+    # puts e.backtrace.join("\n")
+    # exit!
+  end
+  parser.on_message_complete = -> do
+    headers = parser.headers
+    headers['method'] = parser.http_method.downcase
+    headers['path'] = parser.request_url
+    headers['protocol'] = parser.http_version
+    $machine.schedule(current_fiber, headers)
+  end
+  
+  $machine.write(w.fileno, HTTP_MSG)
+  $machine.yield
+ensure
+  $machine.close(r.fileno)
+  $machine.close(w.fileno)
+end
+
+require 'stringio'
+
+RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
+RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
+
+def get_line(fd, sio, buffer)
+  while true
+    line = sio.gets(chomp: true)
+    return line if line
+
+    res = $machine.read(fd, buffer, 1024, -1)
+    return nil if res == 0
+  end
+end
+
+def get_request_line(fd, sio, buffer)
+  line = get_line(fd, sio, buffer)
+
+  m = line.match(RE_REQUEST_LINE)
+  return nil if !m
+
+  {
+    'method'   => m[1].downcase,
+    'path'     => m[2],
+    'protocol' => m[3].downcase
+  }
+end
+
+def parse_headers(fd)
+  buffer = String.new('', capacity: 4096)
+  sio = StringIO.new(buffer)
+
+  headers = get_request_line(fd, sio, buffer)
+  return nil if !headers
+
+  while true
+    line = get_line(fd, sio, buffer)
+    break if line.empty?
+    
+    m = line.match(RE_HEADER_LINE)
+    raise "Invalid header" if !m
+
+    headers[m[1]] = m[2]
+  end
+
+  headers
+end
+
+def parse_http_stringio
+  current_fiber = Fiber.current
+  r, w = IO.pipe
+
+  $machine.spin do
+    headers = parse_headers(r.fileno)
+    $machine.schedule(current_fiber, headers)
+  rescue Exception => e
+    p e
+    puts e.backtrace.join("\n")
+    exit!
+  end
+  
+  $machine.write(w.fileno, HTTP_MSG)
+  $machine.yield
+ensure
+  $machine.close(r.fileno)
+  $machine.close(w.fileno)
+end
+
+# p parse_http_parser
+# p parse_http_stringio
+# exit
+
+GC.disable
+
+def alloc_count
+  count0 = ObjectSpace.count_objects[:TOTAL]
+  yield
+  count1 = ObjectSpace.count_objects[:TOTAL]
+  count1 - count0
+end
+
+X = 100
+p(
+  alloc_http_parser: alloc_count { X.times { parse_http_parser } },
+  alloc_stringio: alloc_count { X.times { parse_http_stringio } }
+)
+exit
+
+Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 3)
+
+  x.report("http_parser") { parse_http_parser }
+  x.report("homegrown") { parse_http_stringio }
+
+  x.compare!
+end

data/examples/bm_queue.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark-ips'
+end
+
+require 'benchmark/ips'
+require 'uringmachine'
+
+COUNT = 1000
+NUM_PRODUCERS = 2
+NUM_CONSUMERS = 10
+
+def run_threads
+  queue = Queue.new
+  done = Queue.new
+  
+  NUM_PRODUCERS.times do
+    Thread.new do
+      COUNT.times { queue << rand(1000) }
+      done << true
+    end
+  end
+  
+  total = 0
+  NUM_CONSUMERS.times do
+    Thread.new do
+      loop do
+        item = queue.shift
+        break if item.nil?
+
+        total += item
+      end
+      done << true
+    end
+  end
+
+  # wait for producers
+  NUM_PRODUCERS.times { done.shift }
+
+  # stop and wait for consumers
+  NUM_CONSUMERS.times do
+    queue << nil
+    done.shift
+  end
+
+  total
+end
+
+def run_um
+  machine = UM.new
+  queue = UM::Queue.new
+  done = UM::Queue.new
+
+  NUM_PRODUCERS.times do
+    machine.spin do
+      COUNT.times { machine.push(queue, rand(1000)) }
+      machine.push(done, true)
+    end
+  end
+
+  total = 0
+  NUM_CONSUMERS.times do
+    machine.spin do
+      loop do
+        item = machine.shift(queue)
+        break if item.nil?
+
+        total += item
+      end
+      machine.push(done, true)
+    end
+  end
+
+  # wait for producers
+  NUM_PRODUCERS.times { machine.shift(done) }
+
+  # stop and wait for consumers
+  NUM_CONSUMERS.times do
+    machine.push(queue, nil)
+    machine.shift(done)
+  end
+
+  total
+end
+
+
+# puts "running"
+# res = run_threads
+# p threads: res
+
+# 100.times {
+#   res = run_um
+#   p fibers: res
+# }
+
+
+# __END__
+
+Benchmark.ips do |x|
+  x.config(:time => 5, :warmup => 2)
+
+  x.report("threads") { run_threads }
+  x.report("UM")      { run_um }
+
+  x.compare!
+end

data/ext/um/extconf.rb

@@ -90,7 +90,7 @@ def get_config
   }
 end
 
-config_ssl
+# config_ssl
 
 config = get_config
 puts "Building UringMachine (\n#{config.map { |(k, v)| "  #{k}: #{v}\n"}.join})"

data/ext/um/um.c

@@ -88,8 +88,9 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
     op->result.flags  = cqe->flags;
   }
 
-  if (!(op->flags & OP_F_ASYNC))
-    um_runqueue_push(machine, op);
+  if (op->flags & OP_F_ASYNC) return;
+  
+  um_runqueue_push(machine, op);
 }
 
 // copied from liburing/queue.c
@@ -174,8 +175,28 @@ inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
 inline VALUE um_fiber_switch(struct um *machine) {
   while (true) {
     struct um_op *op = um_runqueue_shift(machine);
-    if (op)
+    if (op) {
+      // in case of a snooze, we need to prevent a situation where completions
+      // are not processed because the runqueue is never empty. Theoretically,
+      // we can still have a situation where multiple fibers are all doing a
+      // snooze repeatedly, which can prevent completions from being processed.
+
+      // is the op a snooze op and is this the same fiber as the current one?
+      if (unlikely(op->kind == OP_SCHEDULE && op->fiber == rb_fiber_current())) {
+        //  are there any pending ops (i.e. waiting for completion)?
+        if (machine->pending_count > 0) {
+          // if yes, process completions, get runqueue head, put original op
+          // back on runqueue.
+          um_wait_for_and_process_ready_cqes(machine);
+          struct um_op *op2 = um_runqueue_shift(machine);
+          if (likely(op2 && op2 != op)) {
+            um_runqueue_push(machine, op);
+            op = op2; 
+          }
+        }
+      }
       return process_runqueue_op(machine, op);
+    }
 
     um_wait_for_and_process_ready_cqes(machine);
   }
@@ -216,6 +237,8 @@ inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind)
     case OP_ACCEPT_MULTISHOT:
     case OP_READ_MULTISHOT:
     case OP_RECV_MULTISHOT:
+    case OP_TIMEOUT_MULTISHOT:
+    case OP_SLEEP_MULTISHOT:
       op->flags |= OP_F_MULTISHOT;
     default:
   }
@@ -297,6 +320,33 @@ VALUE um_sleep(struct um *machine, double duration) {
   return raise_if_exception(ret);
 }
 
+// VALUE um_periodically(struct um *machine, double interval) {
+//   struct um_op op;
+//   VALUE ret = Qnil;
+//   um_prep_op(machine, &op, OP_SLEEP_MULTISHOT);
+//   op.ts = um_double_to_timespec(interval);
+//   op.flags |= OP_F_MULTISHOT;
+//   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+//   io_uring_prep_timeout(sqe, &op.ts, 0, IORING_TIMEOUT_MULTISHOT);
+
+//   while (true) {
+//     ret = um_fiber_switch(machine);
+
+//     if (!um_op_completed_p(&op)) {
+//       um_cancel_and_wait(machine, &op);
+//       break;
+//     }
+//     else {
+//       if (op.result.res != -ETIME) um_raise_on_error_result(op.result.res);
+//       ret = DBL2NUM(interval);
+//     }
+//   }
+
+//   RB_GC_GUARD(ret);
+//   return raise_if_exception(ret);
+
+// }
+
 inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset) {
   struct um_op op;
   um_prep_op(machine, &op, OP_READ);
@@ -701,3 +751,44 @@ VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags) {
   struct op_ctx ctx = { .machine = machine, .op = &op, .fd = fd, .bgid = bgid, .read_buf = NULL, .flags = flags };
   return rb_ensure(read_recv_each_begin, (VALUE)&ctx, multishot_ensure, (VALUE)&ctx);
 }
+
+VALUE periodically_begin(VALUE arg) {
+  struct op_ctx *ctx = (struct op_ctx *)arg;
+  struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
+  io_uring_prep_timeout(sqe, &ctx->ts, 0, IORING_TIMEOUT_MULTISHOT);
+
+  while (true) {
+    VALUE ret = um_fiber_switch(ctx->machine);
+    if (!um_op_completed_p(ctx->op))
+      return raise_if_exception(ret);
+
+    int more = false;
+    struct um_op_result *result = &ctx->op->result;
+    while (result) {
+      more = (result->flags & IORING_CQE_F_MORE);
+      if (result->res < 0 && result->res != -ETIME) {
+        um_op_multishot_results_clear(ctx->machine, ctx->op);
+        return Qnil;
+      }
+      rb_yield(Qnil);
+      result = result->next;
+    }
+    um_op_multishot_results_clear(ctx->machine, ctx->op);
+    if (more)
+      ctx->op->flags &= ~OP_F_COMPLETED;
+    else
+      break;
+  }
+
+  return Qnil;
+}
+
+VALUE um_periodically(struct um *machine, double interval) {
+  struct um_op op;
+  um_prep_op(machine, &op, OP_SLEEP_MULTISHOT);
+  op.ts = um_double_to_timespec(interval);
+  
+  struct op_ctx ctx = { .machine = machine, .op = &op, .ts = op.ts, .read_buf = NULL };
+  return rb_ensure(periodically_begin, (VALUE)&ctx, multishot_ensure, (VALUE)&ctx);
+}
+

data/ext/um/um.h

@@ -43,14 +43,16 @@ enum op_kind {
 
   OP_ACCEPT_MULTISHOT,
   OP_READ_MULTISHOT,
-  OP_RECV_MULTISHOT
+  OP_RECV_MULTISHOT,
+  OP_TIMEOUT_MULTISHOT,
+  OP_SLEEP_MULTISHOT
 };
 
-#define OP_F_COMPLETED        (1U << 0)
-#define OP_F_TRANSIENT        (1U << 1)
-#define OP_F_ASYNC            (1U << 2)
-#define OP_F_IGNORE_CANCELED  (1U << 3)
-#define OP_F_MULTISHOT        (1U << 4)
+#define OP_F_COMPLETED        (1U << 0) // op is completed (set on each CQE for multishot ops)
+#define OP_F_TRANSIENT        (1U << 1) // op is heap allocated
+#define OP_F_ASYNC            (1U << 2) // op belongs to an AsyncOp
+#define OP_F_IGNORE_CANCELED  (1U << 3) // CQE with -ECANCEL should be ignored
+#define OP_F_MULTISHOT        (1U << 4) // op is multishot
 
 struct um_op_result {
   __s32 res;
@@ -199,6 +201,7 @@ void um_schedule(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_periodically(struct um *machine, double interval);
 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 str, int len);

data/ext/um/um_class.c

@@ -91,6 +91,11 @@ VALUE UM_sleep(VALUE self, VALUE duration) {
   return um_sleep(machine, NUM2DBL(duration));
 }
 
+VALUE UM_periodically(VALUE self, VALUE interval) {
+  struct um *machine = um_get_machine(self);
+  return um_periodically(machine, NUM2DBL(interval));
+}
+
 VALUE UM_read(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
   VALUE fd;
@@ -329,6 +334,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "read", UM_read, -1);
   rb_define_method(cUM, "read_each", UM_read_each, 2);
   rb_define_method(cUM, "sleep", UM_sleep, 1);
+  rb_define_method(cUM, "periodically", UM_periodically, 1);
   rb_define_method(cUM, "write", UM_write, -1);
 
   rb_define_method(cUM, "waitpid", UM_waitpid, 2);

data/lib/uringmachine/actor.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class UringMachine
+  def spin_actor(mod, *a, **k)
+    target = Object.new.extend(mod)
+    mailbox = UM::Queue.new
+    actor = spin(nil, Actor) { actor.run(self, target, mailbox) }
+    target.setup(*a, **k)
+    snooze
+    actor
+  end
+
+  class Actor < Fiber
+    def run(machine, target, mailbox)
+      @machine = machine
+      @target = target      
+      @mailbox = mailbox
+      while (msg = machine.shift(mailbox))
+        process_message(msg)
+      end
+    ensure
+      @target.teardown if @target.respond_to?(:teardown)
+    end
+
+    def cast(sym, *a, **k)
+      self << [:cast, nil, sym, a, k]
+      self
+    end
+
+    def call(sym, *a, **k)
+      self << [:call, Fiber.current, sym, a, k]
+      @machine.yield
+    end
+
+    private
+
+    def process_message(msg)
+      type, fiber, sym, args, kwargs = msg
+      case type
+      when :cast
+        @target.send(sym, *args, **kwargs)
+      when :call
+        res = @target.send(sym, *args, **kwargs)
+        @machine.schedule(fiber, res)
+      end
+    end
+
+    def <<(msg)
+      @machine.push(@mailbox, msg)
+    end
+  end
+end

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.5.1'
+  VERSION = '0.6.1'
 end

data/lib/uringmachine.rb

@@ -12,8 +12,8 @@ class UringMachine
     @@fiber_map
   end
 
-  def spin(value = nil, &block)
-    f = Fiber.new do |resume_value|
+  def spin(value = nil, fiber_class = Fiber, &block)
+    f = fiber_class.new do |resume_value|
       block.(resume_value)
     rescue Exception => e
       STDERR.puts "Unhandled fiber exception: #{e.inspect}"

data/test/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{__dir__}/test_*.rb").each do |path|
+  require(path)
+end

data/test/test_actor.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'socket'
+require 'uringmachine/actor'
+
+class ActorTest < UMBaseTest
+  module Counter
+    def setup
+      @count = 0      
+    end
+
+    def incr
+      @count += 1
+    end
+
+    def get
+      @count
+    end
+
+    def reset
+      @count = 0
+    end
+  end
+
+  def test_basic_actor_functionality
+    actor = @machine.spin_actor(Counter)
+    
+    assert_kind_of Fiber, actor
+
+    assert_equal 0, actor.call(:get)
+    assert_equal 1, actor.call(:incr)
+    assert_equal actor, actor.cast(:incr)
+    assert_equal 2, actor.call(:get)
+    assert_equal actor, actor.cast(:reset)
+    assert_equal 0, actor.call(:get)
+  end
+
+  module Counter2
+    def setup(count)
+      @count = count
+    end
+
+    def incr
+      @count += 1
+    end
+
+    def get
+      @count
+    end
+
+    def reset
+      @count = 0
+    end
+  end
+
+
+  def test_actor_with_args
+    actor = @machine.spin_actor(Counter2, 43)
+    
+    assert_equal 43, actor.call(:get)
+  end
+end

data/test/test_um.rb

@@ -212,6 +212,57 @@ class SleepTest < UMBaseTest
   end
 end
 
+class PeriodicallyTest < UMBaseTest
+  class Cancel < StandardError; end
+
+  def test_periodically
+    count = 0
+    cancel = 0
+
+    t0 = monotonic_clock
+    assert_equal 0, machine.pending_count
+    begin
+      machine.periodically(0.01) do
+        count += 1
+        raise Cancel if count >= 5
+      end
+    rescue Cancel
+      cancel = 1
+    end
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    t1 = monotonic_clock
+    assert_in_range 0.05..0.09, t1 - t0
+    assert_equal 5, count
+    assert_equal 1, cancel 
+  end
+
+  def test_periodically_with_timeout
+    count = 0
+    cancel = 0
+
+    t0 = monotonic_clock
+    assert_equal 0, machine.pending_count
+    begin
+      machine.timeout(0.05, Cancel) do
+        machine.periodically(0.01) do
+          count += 1
+          raise Cancel if count >= 5
+        end
+      end
+    rescue Cancel
+      cancel = 1
+    end
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    t1 = monotonic_clock
+    assert_in_range 0.05..0.08, t1 - t0
+    assert_in_range 4..6, count
+    assert_equal 1, cancel 
+
+  end
+end
+
 class ReadTest < UMBaseTest
   def test_read
     r, w = IO.pipe
@@ -274,6 +325,26 @@ class ReadTest < UMBaseTest
     assert_equal 3, result
     assert_equal 'foobar', buffer
   end
+
+  def test_read_with_string_io
+    require 'stringio'
+
+    buffer = +'foo'
+    sio = StringIO.new(buffer)
+    
+    r, w = IO.pipe
+    w << 'bar'
+
+    result = machine.read(r.fileno, buffer, 100, -1)
+    assert_equal 3, result
+    assert_equal 'foobar', sio.read
+
+    w << 'baz'
+
+    result = machine.read(r.fileno, buffer, 100, -1)
+    assert_equal 3, result
+    assert_equal 'baz', sio.read
+  end
 end
 
 class ReadEachTest < UMBaseTest
@@ -846,32 +917,28 @@ class QueueTest < UMBaseTest
     q = UM::Queue.new
     buf = []
 
-    f1 = Fiber.new do
+    machine.spin do
       buf << [1, machine.pop(q)]
-      machine.yield
     end
 
-    machine.schedule(f1, nil)
-
-    f2 = Fiber.new do
+    machine.spin do
       buf << [2, machine.pop(q)]
-      machine.yield
     end
 
-    machine.schedule(f2, nil)
-
     machine.snooze
     assert_equal [], buf
+    assert_equal 2, machine.pending_count
 
     machine.push(q, :foo)
     assert_equal 1, q.count
-    machine.sleep(0.02)
+    machine.snooze
+    assert_equal 1, machine.pending_count
     assert_equal [[1, :foo]], buf
 
     machine.push(q, :bar)
     assert_equal 1, q.count
 
-    machine.sleep(0.02)
+    machine.snooze
     assert_equal [[1, :foo], [2, :bar]], buf
     assert_equal 0, q.count
   end
@@ -898,7 +965,7 @@ class QueueTest < UMBaseTest
     end
     machine.schedule(f2, nil)
 
-    3.times { machine.snooze }
+    machine.snooze
 
     assert_equal [[1, :bar], [2, :foo]], buf.sort
     assert_equal 0, q.count
@@ -925,12 +992,12 @@ class QueueTest < UMBaseTest
     end
     machine.schedule(f2, nil)
 
-    machine.sleep 0.01
+    machine.snooze
 
     assert_equal [[1, :foo]], buf
     machine.push(q, :bar)
 
-    machine.sleep 0.01
+    machine.snooze
     assert_equal [[1, :foo], [2, :bar]], buf
   end
 

data/uringmachine.gemspec

@@ -20,8 +20,8 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.required_ruby_version = '>= 3.3'
 
-  s.add_development_dependency  'rake-compiler',        '1.2.8'
-  s.add_development_dependency  'minitest',             '5.25.1'
+  s.add_development_dependency  'rake-compiler',        '1.2.9'
+  s.add_development_dependency  'minitest',             '5.25.4'
   s.add_development_dependency  'http_parser.rb',       '0.8.0'
   s.add_development_dependency  'benchmark-ips',        '2.14.0'
   s.add_development_dependency  'localhost',            '1.3.1'

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.1
 platform: ruby
 authors:
 - Sharon Rosner
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-11 00:00:00.000000000 Z
+date: 2025-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -16,28 +15,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.8
+        version: 1.2.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.8
+        version: 1.2.9
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.25.1
+        version: 5.25.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.25.1
+        version: 5.25.4
 - !ruby/object:Gem::Dependency
   name: http_parser.rb
   requirement: !ruby/object:Gem::Requirement
@@ -80,7 +79,6 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.3.1
-description:
 email: sharon@noteflakes.com
 executables: []
 extensions:
@@ -98,6 +96,8 @@ files:
 - README.md
 - Rakefile
 - TODO.md
+- examples/bm_http_parse.rb
+- examples/bm_queue.rb
 - examples/bm_snooze.rb
 - examples/bm_sqlite.rb
 - examples/bm_write.rb
@@ -129,12 +129,15 @@ files:
 - ext/um/um_sync.c
 - ext/um/um_utils.c
 - lib/uringmachine.rb
+- lib/uringmachine/actor.rb
 - lib/uringmachine/dns_resolver.rb
 - lib/uringmachine/ssl.rb
 - lib/uringmachine/ssl/context_builder.rb
 - lib/uringmachine/version.rb
 - supressions/ruby.supp
 - test/helper.rb
+- test/run.rb
+- test/test_actor.rb
 - test/test_async_op.rb
 - test/test_ssl.rb
 - test/test_um.rb
@@ -439,7 +442,6 @@ metadata:
   source_code_uri: https://github.com/digital-fabric/uringmachine
   documentation_uri: https://www.rubydoc.info/gems/uringmachine
   changelog_uri: https://github.com/digital-fabric/uringmachine/blob/master/CHANGELOG.md
-post_install_message:
 rdoc_options:
 - "--title"
 - UringMachine
@@ -458,8 +460,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A lean, mean io_uring machine
 test_files: []