uringmachine 0.27.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1211434f5b2f4aad1e47d1bd166204cce6792a80e3ef845ae4dee097d8e1ea45
-  data.tar.gz: eff370b4564c88c3daf57cbed3d8b165113ddee697ee1b16aa63ad3452a38c02
+  metadata.gz: c42e434298bf496752efc6fe6a4cc81d04857f28f1151cfc3165ac3c288ec6a2
+  data.tar.gz: ec176b165f129aa7d1b6d0bdbc5f4b7e55d5e553569061d89956d0b1aee68503
 SHA512:
-  metadata.gz: cdb26cf58a41a9f7ad2d025ccc473b0088f4c3e622a65058b1ee6e0aeb95c0eb3775f980cccb60e81b2213ed8fb49263c6500b2c05fbbb71abb156be00dca636
-  data.tar.gz: 06f509928387d2812578c143dfb96ed031be10994c7b43908babfef02d72d149b8f2a3932dee7a4d3577150b5512addb8b7c44d5b7ea2e63dddb7f2b427df604
+  metadata.gz: 1760b892d6ae21c7007fd0a109a78d631da4ae9a79667ad85bc4740ac0e339802ca9cb0bc34114570bf7e6113e4dab704a1c9f40513a196e840b759a494a35b9
+  data.tar.gz: 7dfe1426f96ecd1e99af4224c34d3b3173858b5d6c156b949314a0e80c34b836ae738e930ed26662319bc6700401cd0b369028e172ed1b70982cee64fb13f7a1

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 0.28.0 2026-02-19
+
+- Add `#terminate`
+- Make `#sendv` available also for older kernels (using `#writev`)
+- Implement `Stream#skip`
+- Inherit exceptions from `StandardError` instead of `RuntimeError`
+
 # 0.27.0 2026-02-15
 
 - Add `.pr_set_child_subreaper` method

data/TODO.md

@@ -1,9 +1,11 @@
 ## immediate
 
-- Fix all futex value (Queue, Mutex) to be properly aligned
+- Add tests for support for Set in `machine#await_fibers`
+- Add tests for support for Set, Array in `machine#join`
 
-## Buffer rings - automatic management
+- (?) Fix all futex value (Queue, Mutex) to be properly aligned
 
+## Buffer rings - automatic management
 - Take the buffer_pool branch, rewrite it
 - Allow multiple stream modes:
   - :buffer_pool - uses buffer rings

data/ext/um/um.c

@@ -977,7 +977,7 @@ VALUE um_shutdown_async(struct um *machine, int fd, int how) {
   return INT2NUM(fd);
 }
 
-struct send_recv_fd_data {
+struct send_recv_fd_ctx {
   struct msghdr msgh;
   char iobuf[1];
   struct iovec iov;
@@ -987,41 +987,34 @@ struct send_recv_fd_data {
   } u;
 };
 
-inline void recv_fd_prepare(struct send_recv_fd_data *data) {
-  memset(&data->msgh, 0, sizeof(data->msgh));
-  data->iov.iov_base = data->iobuf;
-  data->iov.iov_len = sizeof(data->iobuf);
-  data->msgh.msg_iov = &data->iov;
-  data->msgh.msg_iovlen = 1;
-  data->msgh.msg_control = data->u.buf;
-  data->msgh.msg_controllen = sizeof(data->u.buf);
-}
-
-inline void send_fd_prepare(struct send_recv_fd_data *data, int fd) {
-  memset(&data->msgh, 0, sizeof(data->msgh));
-  data->iov.iov_base = data->iobuf;
-  data->iov.iov_len = sizeof(data->iobuf);
-  data->msgh.msg_iov = &data->iov;
-  data->msgh.msg_iovlen = 1;
-  data->msgh.msg_control = data->u.buf;
-  data->msgh.msg_controllen = sizeof(data->u.buf);
-
-  struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&data->msgh);
-  cmsgp->cmsg_level = SOL_SOCKET;
-  cmsgp->cmsg_type = SCM_RIGHTS;
-  cmsgp->cmsg_len = CMSG_LEN(sizeof(fd));
-  memcpy(CMSG_DATA(cmsgp), &fd, sizeof(fd));
+inline void send_recv_fd_setup_ctx(struct send_recv_fd_ctx *ctx, int fd) {
+  ctx->iov.iov_base = ctx->iobuf;
+  ctx->iov.iov_len = sizeof(ctx->iobuf);
+
+  memset(&ctx->msgh, 0, sizeof(ctx->msgh));
+  ctx->msgh.msg_iov = &ctx->iov;
+  ctx->msgh.msg_iovlen = 1;
+  ctx->msgh.msg_control = ctx->u.buf;
+  ctx->msgh.msg_controllen = sizeof(ctx->u.buf);
+
+  if (fd > 0) {
+    struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&ctx->msgh);
+    cmsgp->cmsg_level = SOL_SOCKET;
+    cmsgp->cmsg_type = SCM_RIGHTS;
+    cmsgp->cmsg_len = CMSG_LEN(sizeof(fd));
+    memcpy(CMSG_DATA(cmsgp), &fd, sizeof(fd));
+  }
 }
 
 VALUE um_send_fd(struct um *machine, int sock_fd, int fd) {
-  struct send_recv_fd_data data;
-  send_fd_prepare(&data, fd);
+  struct send_recv_fd_ctx ctx;
+  send_recv_fd_setup_ctx(&ctx, fd);
 
   VALUE ret = Qnil;
   struct um_op *op = um_op_acquire(machine);
   um_prep_op(machine, op, OP_SENDMSG, 2, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-  io_uring_prep_sendmsg(sqe, sock_fd, &data.msgh, 0);
+  io_uring_prep_sendmsg(sqe, sock_fd, &ctx.msgh, 0);
 
   ret = um_yield(machine);
 
@@ -1033,9 +1026,9 @@ VALUE um_send_fd(struct um *machine, int sock_fd, int fd) {
   return ret;
 }
 
-inline int recv_fd_get_fd(struct send_recv_fd_data *data) {
+inline int recv_fd_get_fd(struct send_recv_fd_ctx *ctx) {
   int fd;
-  struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&data->msgh);
+  struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&ctx->msgh);
 
   if (cmsgp == NULL || cmsgp->cmsg_len != CMSG_LEN(sizeof(int)) ||
       cmsgp->cmsg_level != SOL_SOCKET || cmsgp->cmsg_type != SCM_RIGHTS
@@ -1046,17 +1039,17 @@ inline int recv_fd_get_fd(struct send_recv_fd_data *data) {
 }
 
 VALUE um_recv_fd(struct um *machine, int sock_fd) {
-  struct send_recv_fd_data data;
-  recv_fd_prepare(&data);
+  struct send_recv_fd_ctx ctx;
+  send_recv_fd_setup_ctx(&ctx, -1);
 
   struct um_op *op = um_op_acquire(machine);
   um_prep_op(machine, op, OP_RECVMSG, 2, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-  io_uring_prep_recvmsg(sqe, sock_fd, &data.msgh, 0);
+  io_uring_prep_recvmsg(sqe, sock_fd, &ctx.msgh, 0);
 
   VALUE ret = um_yield(machine);
 
-  if (likely(um_verify_op_completion(machine, op, true))) ret = INT2NUM(recv_fd_get_fd(&data));
+  if (likely(um_verify_op_completion(machine, op, true))) ret = INT2NUM(recv_fd_get_fd(&ctx));
   um_op_release(machine, op);
 
   RAISE_IF_EXCEPTION(ret);

data/ext/um/um.h

@@ -377,6 +377,7 @@ VALUE um_queue_shift(struct um *machine, struct um_queue *queue);
 
 VALUE stream_get_line(struct um_stream *stream, VALUE buf, ssize_t maxlen);
 VALUE stream_get_string(struct um_stream *stream, VALUE buf, ssize_t len);
+VALUE stream_skip(struct um_stream *stream, size_t len);
 VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
 void resp_encode(struct um_write_buffer *buf, VALUE obj);
 void resp_encode_cmd(struct um_write_buffer *buf, int argc, VALUE *argv);

data/ext/um/um_class.c

@@ -747,8 +747,6 @@ VALUE UM_send(VALUE self, VALUE fd, VALUE buffer, VALUE len, VALUE flags) {
   return um_send(machine, NUM2INT(fd), buffer, NUM2INT(len), NUM2INT(flags));
 }
 
-#ifdef HAVE_IO_URING_SEND_VECTORIZED
-
 /* call-seq:
  *   machine.sendv(fd, *buffers) -> bytes_sent
  *
@@ -770,10 +768,13 @@ VALUE UM_sendv(int argc, VALUE *argv, VALUE self) {
   int fd = NUM2INT(argv[0]);
   if (argc < 2) return INT2NUM(0);
 
+#ifdef HAVE_IO_URING_SEND_VECTORIZED
   return um_sendv(machine, fd, argc - 1, argv + 1);
+#else
+  return um_writev(machine, fd, argc - 1, argv + 1);
+#endif
 }
 
-#endif
 
 /* call-seq:
  *   machine.send_bundle(fd, bgid, *buffers) -> bytes_sent
@@ -1492,10 +1493,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "recv", UM_recv, 4);
   rb_define_method(cUM, "recv_each", UM_recv_each, 3);
   rb_define_method(cUM, "send", UM_send, 4);
-
-  #ifdef HAVE_IO_URING_SEND_VECTORIZED
   rb_define_method(cUM, "sendv", UM_sendv, -1);
-  #endif
 
   rb_define_method(cUM, "send_bundle", UM_send_bundle, -1);
   rb_define_method(cUM, "setsockopt", UM_setsockopt, 4);

data/ext/um/um_stream.c

@@ -19,6 +19,7 @@ static inline void stream_check_truncate_buffer(struct um_stream *stream) {
   }
 }
 
+// returns true if eof
 int stream_read_more(struct um_stream *stream) {
   stream_check_truncate_buffer(stream);
 
@@ -104,6 +105,16 @@ VALUE stream_get_string(struct um_stream *stream, VALUE buf, ssize_t len) {
   return buf;
 }
 
+VALUE stream_skip(struct um_stream *stream, size_t len) {
+  while (stream->len - stream->pos < len)
+    if (!stream_read_more(stream)) {
+      return Qnil;
+    }
+
+  stream->pos += len;
+  return NUM2INT(len);
+}
+
 VALUE resp_get_line(struct um_stream *stream, VALUE out_buffer) {
   char *start = RSTRING_PTR(stream->buffer) + stream->pos;
   while (true) {

data/ext/um/um_stream_class.c

@@ -65,6 +65,14 @@ VALUE Stream_get_string(VALUE self, VALUE buf, VALUE len) {
   return stream_get_string(stream, buf, NUM2LONG(len));
 }
 
+// skips `len` bytes in the stream. This function returns nil if eof is
+// encountered.
+VALUE Stream_skip(VALUE self, VALUE len) {
+  struct um_stream *stream = Stream_data(self);
+
+  return stream_skip(stream, NUM2LONG(len));
+}
+
 VALUE Stream_resp_decode(VALUE self) {
   struct um_stream *stream = Stream_data(self);
   if (unlikely(stream->eof)) return Qnil;
@@ -104,6 +112,7 @@ void Init_Stream(void) {
 
   rb_define_method(cStream, "get_line", Stream_get_line, 2);
   rb_define_method(cStream, "get_string", Stream_get_string, 2);
+  rb_define_method(cStream, "skip", Stream_skip, 1);
 
   rb_define_method(cStream, "resp_decode", Stream_resp_decode, 0);
 

data/grant-2025/tasks.md

@@ -147,22 +147,9 @@
   - [ ] docs (similar to papercraft docs)
 
 - [ ] Uma - web server
-  - [ ] child process workers
-  - [ ] reforking (following https://github.com/Shopify/pitchfork)
-        see also: https://byroot.github.io/ruby/performance/2025/03/04/the-pitchfork-story.html
-        - Monitor worker memory usage - how much is shared
-        - Choose worker with most served request count as "mold" for next generation
-        - Perform GC out of band, preferably when there are no active requests
-          https://railsatscale.com/2024-10-23-next-generation-oob-gc/
-        - When a worker is promoted to "mold", it:
-          - Stops `accept`ing requests
-          - When finally idle, calls `Process.warmup`
-          - Starts replacing sibling workers with forked workers
-        see also: https://www.youtube.com/watch?v=kAW5O2dkSU8
-  - [ ] Each worker is single-threaded (except for worker threads)
   - [ ] Rack 3.0-compatible
         see: https://github.com/socketry/protocol-rack
   - [ ] Rails integration (Railtie)
         see: https://github.com/socketry/falcon
   - [ ] Benchmarks
-  - [ ] Add to the TechEmpower bencchmarks
+  - [ ] Add to the TechEmpower benchmarks

data/lib/uringmachine/version.rb

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

data/lib/uringmachine.rb

@@ -36,6 +36,11 @@ class UringMachine
     fiber
   end
 
+  def terminate(*fibers)
+    exception = UM::Terminate.new
+    fibers.each { schedule(it, exception) }
+  end
+
   # Runs the given block in the given fiber. This method is used to run fibers
   # indirectly.
   #

data/test/test_async_op.rb

@@ -60,7 +60,7 @@ class AsyncOpTest < UMBaseTest
     assert_equal true, @op.cancelled?
   end
 
-  class TOError < RuntimeError; end
+  class TOError < StandardError; end
 
   def test_async_op_await_with_timeout
     e = nil

data/test/test_stream.rb

@@ -98,6 +98,23 @@ class StreamTest < StreamBaseTest
     ret = @stream.get_string(nil, -4)
     assert_nil ret
   end
+
+  def test_skip
+    machine.write(@wfd, "foobar")
+    machine.close(@wfd)
+
+    ret = @stream.get_string(nil, 2)
+    assert_equal 'fo', ret
+
+    ret = @stream.skip(2)
+    assert_equal 2, ret
+
+    ret = @stream.get_string(nil, 2)
+    assert_equal 'ar', ret
+
+    ret = @stream.skip(2)
+    assert_nil ret
+  end
 end
 
 class StreamRespTest < StreamBaseTest

data/test/test_um.rb

@@ -238,7 +238,38 @@ class ScheduleTest < UMBaseTest
     assert_in_range 0..0.1, t1 - t0
   end
 
-  class TOError < RuntimeError; end
+  def test_terminate
+    e = nil
+    f = machine.spin do
+      machine.sleep(1)
+    rescue UM::Terminate => e
+    end
+
+    machine.snooze
+    machine.terminate(f)
+    machine.snooze
+    assert_kind_of UM::Terminate, e
+    assert_equal true, f.done?
+  end
+
+  def test_terminate_multi
+    f1 = machine.spin { machine.sleep(1) }
+    f2 = machine.spin { machine.sleep(1) }
+    f3 = machine.spin { machine.sleep(1) }
+
+    machine.snooze
+    machine.terminate(f1, f2)
+    machine.snooze
+    assert_equal true, f1.done?
+    assert_equal true, f2.done?
+    assert_nil f3.done?
+
+    machine.terminate(f3)
+    machine.snooze
+    assert_equal true, f3.done?
+  end
+
+  class TOError < StandardError; end
 
   def test_timeout
     buf = []
@@ -299,8 +330,8 @@ class ScheduleTest < UMBaseTest
     assert_equal 0, machine.metrics[:ops_pending]
   end
 
-  class TO2Error < RuntimeError; end
-  class TO3Error < RuntimeError; end
+  class TO2Error < StandardError; end
+  class TO3Error < StandardError; end
 
   def test_timeout_nested
     e = nil
@@ -351,7 +382,7 @@ class SleepTest < UMBaseTest
     assert_kind_of C, ret
   end
 
-  class D < RuntimeError; end
+  class D < StandardError; end
 
   def test_sleep_with_timeout
     t0 = monotonic_clock
@@ -955,7 +986,7 @@ class WritevTest < UMBaseTest
     machine.join(f)
   end
 
-  class TOError < RuntimeError; end
+  class TOError < StandardError; end
 
   def test_writev_timeout
     r, w = UM.pipe
@@ -1639,8 +1670,6 @@ class SendvTest < UMBaseTest
   end
 
   def test_sendv
-    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
-
     ret = machine.sendv(@s1, 'foo', 'bar', 'baz')
     assert_equal 9, ret
 
@@ -1653,8 +1682,6 @@ class SendvTest < UMBaseTest
   end
 
   def test_sendv_io_buffer
-    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
-
     buf1 = IO::Buffer.new(6)
     buf1.set_string('foobar')
 
@@ -1673,8 +1700,6 @@ class SendvTest < UMBaseTest
   end
 
   def test_sendv_invalid_buffer
-    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
-
     assert_raises(UM::Error) { machine.sendv(@s1, [], 'abc') }
     assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 0, machine.metrics[:ops_free]
@@ -1914,6 +1939,98 @@ class SendRecvFdTest < UMBaseTest
     assert_equal 'foobar', buf
   end
 
+  def test_send_recv_fd_multi
+    r_fd, w_fd = UM.pipe
+
+    res = machine.send_fd(@s1_fd, w_fd)
+    assert_equal w_fd, res
+
+    w_fd2 = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, w_fd2
+    refute_equal w_fd, w_fd2
+
+    res = machine.send_fd(@s1_fd, r_fd)
+    assert_equal r_fd, res
+
+    r_fd2 = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, r_fd2
+    refute_equal r_fd, r_fd2
+
+    machine.close(w_fd)
+    machine.write(w_fd2, 'foobar')
+    machine.close(w_fd2)
+
+    buf = +''
+    res = machine.read(r_fd, buf, 12)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  ensure
+    machine.close(r_fd) if r_fd rescue nil
+    machine.close(w_fd) if w_fd rescue nil
+    machine.close(r_fd2) if r_fd2 rescue nil
+    machine.close(w_fd2) if w_fd2 rescue nil
+
+  end
+
+  def test_send_recv_fd_mixed_multi
+    r_fd, w_fd = UM.pipe
+
+    machine.send(@s1_fd, 'hi', 2, 0)
+    buf = +''
+    ret = machine.recv(@s2_fd, buf, 2, 0)
+    assert_equal 2, ret
+    assert_equal 'hi', buf
+
+    res = machine.send_fd(@s1_fd, w_fd)
+    assert_equal w_fd, res
+
+    w_fd2 = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, w_fd2
+    refute_equal w_fd, w_fd2
+
+    res = machine.send_fd(@s1_fd, r_fd)
+    assert_equal r_fd, res
+
+    r_fd2 = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, r_fd2
+    refute_equal r_fd, r_fd2
+
+    machine.close(w_fd)
+    machine.write(w_fd2, 'foobar')
+    machine.close(w_fd2)
+
+    buf = +''
+    res = machine.read(r_fd, buf, 12)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  ensure
+    machine.close(r_fd) if r_fd rescue nil
+    machine.close(w_fd) if w_fd rescue nil
+    machine.close(r_fd2) if r_fd2 rescue nil
+    machine.close(w_fd2) if w_fd2 rescue nil
+
+  end
+
+  def test_send_recv_fd_inverse
+    r_fd, w_fd = UM.pipe
+
+    res = machine.send_fd(@s2_fd, w_fd)
+    assert_equal w_fd, res
+
+    fd = machine.recv_fd(@s1_fd)
+    assert_kind_of Integer, fd
+    refute_equal w_fd, fd
+
+    machine.close(w_fd)
+    machine.write(fd, 'foobar')
+    machine.close(fd)
+
+    buf = +''
+    res = machine.read(r_fd, buf, 12)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  end
+
   def test_send_recv_fd_fork
     pid = fork do
       m = UM.new
@@ -1944,6 +2061,68 @@ class SendRecvFdTest < UMBaseTest
     machine.close(w_fd) rescue nil
   end
 
+  def test_send_recv_fd_fork_mixed_msgs
+    skip
+
+    pid = fork do
+      m = UM.new
+      buf = +''
+      ret = m.recv(@s2_fd, buf, 128, 0)
+      p forked_recv: buf, ret: ret
+      ret = m.send(@s2_fd, buf, buf.bytesize, 0)
+      p forked_send: buf, ret: ret
+      fd = m.recv_fd(@s2_fd)
+      p forked_recv_fd: fd
+      ret = m.send(@s2_fd, buf, buf.bytesize, 0)
+      p forked_send: buf, ret: ret
+
+      m.write(fd, 'foo')
+    ensure
+      m.close(fd) if fd rescue nil
+    end
+
+    buf = +''
+    
+    machine.send(@s1_fd, 'coocoo', 6, 0)
+    machine.recv(@s1_fd, buf, 128, 0)
+    assert_equal 'coocoo', buf
+
+    r_fd, w_fd = UM.pipe
+    machine.send_fd(@s1_fd, w_fd)
+    machine.recv(@s1_fd, buf, 128, 0)
+    assert_equal 'coocoo', buf
+
+    machine.read(r_fd, buf, 128)
+    assert_equal 'foo', buf
+  ensure
+    if pid
+      Process.kill('KILL', pid) rescue nil
+      Process.wait(pid) rescue nil
+    end
+    machine.close(r_fd) rescue nil
+    machine.close(w_fd) rescue nil
+  end
+
+  def test_send_recv_fd_fork_inverse
+    pid = fork do
+      m = UM.new
+      r, w = UM.pipe
+      m.send_fd(@s2_fd, r)
+
+      buf = +''
+      m.read(r, buf, 128)
+      m.send(@s2_fd, buf)
+    end
+
+    assert_raises(Errno::EINVAL) { machine.recv_fd(@s1_fd) }
+  ensure
+    if pid
+      Process.kill('KILL', pid) rescue nil
+      Process.wait(pid) rescue nil
+    end
+    machine.close(w) rescue nil
+  end
+
   def test_send_fd_bad_sock_fd
     _r_fd, w_fd = UM.pipe
     assert_raises(Errno::ENOTSOCK) { machine.send_fd(0, w_fd) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 0.27.0
+  version: 0.28.0
 platform: ruby
 authors:
 - Sharon Rosner