uringmachine 0.22.1 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbf0486feb49686a85ad162dd569ce125b4f168904e6f364e7c4358be234ca78
-  data.tar.gz: 27d0e3533c7d41f87b95376258992e37ebfa0d42c32ac0b46e7595939b3f1afa
+  metadata.gz: b185b9cafdee3930061ed7101a12ccb500a8f131a9715a6a1268b22507ec2d85
+  data.tar.gz: c2d0fe4aced8f2340b2cdd29cf9540b7075198be56a0e695f58b9fbab5fae65c
 SHA512:
-  metadata.gz: c4bf87080fe32e145e334944cc1871d109f5b11c5c3cb413c9de3f44cf09b9554ac3fabeb54650c18f67ed96d6381a0290ae8e461ff37b9fef3d27351675ff68
-  data.tar.gz: a53addafe3007de3ad77f3e42e4ca3b3f90ae372af24b00beff1b5b486fa4c1f5d6c84de22788192b05328c14c7eeec4e602a77623a00c5c2f8de5bdbd8dca7d
+  metadata.gz: 75b0fe0a71242d728cbe1901457e41a11255c1922eca6501e3fa4286a7bd89a01ad7e5625baa24721ad63efc16da24a4b4d8ffeb85114be8fbe910066a0b033e
+  data.tar.gz: 64afeb65cc42c5b5c3af30dc361f2917a6341fd38e645114c48972bb6aa6617f496be6de040dfec6eefa102ae1d933cd726549890a9d57369f465be3b6df613f

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+
+# 0.23.0 2025-12-16
+
+- Add `UM#accept_into_queue`, fix `#accept_each` to throw on error
+- Use Set instead of Hash for holding pending fibers
+- Add `UM#writev`, `UM#sendv` methods
+- Allocate um_op and um_op_result in batches of 256
+- Remove `SIGCLD` const
+
 # 0.22.1 2025-12-11
 
 - Comment out SIGCLD constant
@@ -12,6 +21,7 @@
 - More tests and benchmarks
 - Add `UM#await_fibers` for awaiting fibers
 - Add `UM.socketpair` for creating a socket pair
+- Fix segfault caused by waiting fibers not being marked
 - Fiber scheduler:
   - Use fiber's mailbox for processing blocking operations
   - Add `#io_close`, `#yield` hooks, remove `#process_fork` hook
@@ -26,8 +36,8 @@
 - Add debug logging for key io_uring interactions
 - Add UM#mark and DEBUG_MARK for debugging specific UM instances
 - Short-circuit zero-length writes
-- Add optional file_offset argument to #read, #write. Add optional len and file_off
-set arguments to #write_async
+- Add optional file_offset argument to #read, #write. Add optional len and
+  file_offset arguments to #write_async
 - Add support for specifying SQPOLL mode and SQ idle timeout in `UM#initialize`
 - Add support for specifying number of SQ entries in `UM#initialize`
 - Implement global worker pool for blocking operations in fiber scheduler

data/TODO.md

@@ -1,148 +1,28 @@
 ## immediate
 
-## Measuring CPU time for fibers
-
-- use CPU time (CLOCK_THREAD_CPUTIME_ID)
-- measure:
-  - time each fiber is waiting
-  - time each fiber is running
-  - time machine is waiting (for CQEs)
-  - time machine is running fibers from the runqueue
-- can be turned on/off at any time
-- no performance impact when off
-
-How can this be implemented:
-
-- `um_get_time_cpu()` function for reading CPU time (CLOCK_THREAD_CPUTIME_ID) as
-  double.
-- add to `struct um`:
-
-  ```c
-  struct um {
-    ...
-    int profiling_mode;
-    double total_time_run;
-    double total_time_wait;
-    double last_cpu_time;
-  }
-  ```
+## buffer rings - automatic management
 
-- `UM#profile=` to turn it on/off.
-- On `machine.profile = true`, reset `total_time_xxx` and `last_cpu_time`
+```ruby
+# completely hands off
+machine.read_each(fd) { |str| ... }
 
-  ```c
-  machine->total_time_run = 0;
-  machine->total_time_wait = 0;
-  machine->last_cpu_time = um_get_time_cpu();
-  ```
+# what if we want to get IO::Buffer?
+machine.read_each(fd, io_buffer: true) { |iobuff, len| ... }
+```
 
-- when profiling is active:
-  - before processing CQEs:
-
-    ```c
-    // before
-    double cpu_time0;
-    VALUE fiber;
-    int profiling_mode = machine->profiling_mode;
-    if (profiling_mode) {
-      fiber = rb_fiber_current();
-      cpu_time0 = um_get_time_cpu();
-      double elapsed = cpu_time0 - machine->last_cpu_time;
-      um_update_fiber_time_run(fiber, cpu_time0, elapsed);
-      machine->total_time_run += elapsed;
-    }
-    process_cqes(...)
-    // after
-    if (profiling_mode) {
-      double cpu_time1 = um_get_time_cpu();
-      double elapsed = cpu_time1 - cpu_time0;
-      um_update_fiber_last_time(fiber, cpu_time1);
-      machine->total_time_wait += elapsed;
-      machine->last_cpu_time = cpu_time1;
-    }
-    ```
-
-  - when doing switching, in `um_process_runqueue_op`:
-
-    ```c
-    // before
-    double cpu_time;
-    VALUE cur_fiber;
-    VALUE next_fiber = get_next_fiber(...);
-    int profiling_mode = machine->profiling_mode;
-    if (profiling_mode) {
-      cur_fiber = rb_fiber_current();
-      cpu_time = um_get_time_cpu();
-      double elapsed = cpu_time - machine->last_cpu_time;
-      um_update_fiber_time_run(cur_fiber, cpu_time, elapsed);
-      machine->total_time_run += elapsed;
-      um_update_fiber_time_wait(next_fiber, cpu_time);
-      machine->last_cpu_time = cpu_time;
-    }
-    do_fiber_transfer(...)
-    ```
-
-  - updating fiber time instance vars:
-
-    ```c
-    inline void um_update_fiber_time_run(VALUE fiber, double stamp, double elapsed) {
-      // VALUE fiber_stamp = rb_ivar_get(fiber, ID_time_last_cpu);
-      VALUE fiber_total_run = rb_ivar_get(fiber, ID_time_total_run);
-      double total = NIL_P(fiber_total_run) ?
-        elapsed : NUM2DBL(fiber_total_run) + elapsed;
-      rb_ivar_set(fiber, ID_time_total_run, DBL2NUM(total));
-      rb_ivar_set(fiber, ID_time_last_cpu, DBL2NUM(stamp));
-    }
-
-    inline void um_update_fiber_time_wait(VALUE fiber, double stamp) {
-      VALUE fiber_last_stamp = rb_ivar_get(fiber, ID_time_last_cpu);
-      if (likely(!NIL_P(fiber_last_stamp))) {
-        double last_stamp = NUM2DBL(fiber_last_stamp);
-        double elapsed = stamp - last_stamp;
-        VALUE fiber_total_wait = rb_ivar_get(fiber, ID_time_total_wait);
-        double total = NIL_P(fiber_total_wait) ?
-          elapsed : NUM2DBL(fiber_total_wait) + elapsed;
-        rb_ivar_set(fiber, ID_time_total_wait, DBL2NUM(total));
-      }
-      else
-        rb_ivar_set(fiber, ID_time_total_wait, DBL2NUM(0.0));
-      rb_ivar_set(fiber, ID_time_last_cpu, DBL2NUM(stamp));
-    }
-    ```
-
-## Metrics API
-
-- machine metrics: `UM#metrics` - returns a hash containing metrics:
+## write/send multiple buffers at once
 
-  ```ruby
-  {
-    size:,          # SQ size (entries)
-    total_ops:, # total ops submitted
-    total_fiber_switches:, # total fiber switches
-    total_cqe_waits:, # total number of CQE waits
-    ops_pending:, # number of pending ops
-    ops_unsubmitted:, # number of unsubmitted
-    ops_runqueue:, # number of ops in runqueue
-    ops_free:, # number of ops in freelist
-    ops_transient:, # number of ops in transient list
-    hwm_pending:, # high water mark - pending ops
-    hwm_unsubmitted:, # high water mark - unsubmitted ops
-    hwm_runqueue:, # high water mark - runqueue depth
-    hwm_free:, # high water mark - ops in free list
-    hwm_transient:, # high water mark - ops in transient list
-    # when profiling is active
-    time_total_run:, # total CPU time running
-    time_total_wait:, # total CPU time waiting for CQEs
-  }
-  ```
+This is done as vectored IO:
 
-- For this we need to add tracking for:
-  - runqueue list size
-  - transient list size
-  - free list size
-- Those will be done in um_op.c (in linked list management code)
+```ruby
+machine.writev(fd, buf1, buf2, buf3)
 
-- All metrics info in kept in
+# with optional file offset:
+machine.writev(fd, buf1, buf2, buf3, 0)
+
+# for the moment it won't take flags
+machine.sendv(fd, buf1, buf2, buf3)
+```
 
 ## useful concurrency tools
 
@@ -152,13 +32,19 @@ How can this be implemented:
   debouncer = UM.debounce { }
   ```
 
+
+
+## polyvalent select
+
+- select on multiple queues (ala Go)
+- select on mixture of queues and fds
+
 ## ops
 
 - [ ] multishot timeout
   - [v] machine.periodically(interval) { ... }
   - [ ] machine.prep_timeout_multishot(interval)
 
-- writev
 - splice / - tee
 - sendto
 - recvfrom

data/benchmark/README.md

@@ -21,7 +21,7 @@ implementations:
 
 - `UM`: fiber-based concurrency using the UringMachine low-level API.
 
-<img src="./chart.png">
+<img src="./chart_all.png">
 
 ## Observations
 

data/benchmark/bm_io_pipe.rb

@@ -38,6 +38,20 @@ class UMBenchmark
     end
   end
 
+  def do_baseline
+    GROUPS.times do
+      r, w = IO.pipe
+      r.sync = true
+      w.sync = true
+      ITERATIONS.times {
+        w.write(DATA)
+        r.read(SIZE)
+      }
+      r.close
+      w.close
+    end
+  end
+
   def do_scheduler(scheduler, ios)
     GROUPS.times do
       r, w = IO.pipe

data/benchmark/common.rb

@@ -54,6 +54,7 @@ class UMBenchmark
   end
 
   @@benchmarks = {
+    baseline:     [:baseline,     "No Concurrency"],
     threads:      [:threads,      "Threads"],
     thread_pool:  [:thread_pool,  "ThreadPool"],
     async_uring:  [:scheduler,    "Async uring"],
@@ -69,6 +70,10 @@ class UMBenchmark
     end
   end
 
+  def run_baseline
+    do_baseline
+  end
+
   def run_threads
     threads = []
     ios = []

data/benchmark/read_each.rb

@@ -0,0 +1,83 @@
+# 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'
+
+@machine = UM.new
+
+make_socket_pair = -> do
+  port = 10000 + rand(30000)
+  server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+  @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+  @machine.bind(server_fd, '127.0.0.1', port)
+  @machine.listen(server_fd, UM::SOMAXCONN)
+
+  client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+  @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+  server_conn_fd = @machine.accept(server_fd)
+
+  @machine.close(server_fd)
+  [client_conn_fd, server_conn_fd]
+end
+
+@client_fd, @server_fd = make_socket_pair.()
+
+@read_buf = +''
+@read_fiber = @machine.spin do
+  while true
+    @machine.read(@client_fd, @read_buf, 65536, 0)
+  end
+end
+
+STR_COUNT = ARGV[0]&.to_i || 3
+STR_SIZE = ARGV[1]&.to_i || 100
+
+@parts = ['*' * STR_SIZE] * STR_COUNT
+
+@server_io = IO.new(@server_fd)
+@server_io.sync = true
+def io_write
+  @server_io.write(*@parts)
+  @machine.snooze
+end
+
+def um_write
+  str = @parts.join
+  len = str.bytesize
+
+  while len > 0
+    ret = @machine.write(@server_fd, str, len)
+    len -= ret
+    str = str[ret..-1] if len > 0
+  end
+end
+
+def um_send
+  str = @parts.join
+  @machine.send(@server_fd, str, str.bytesize, UM::MSG_WAITALL)
+end
+
+@bgid = @machine.setup_buffer_ring(0, 8)
+def um_send_bundle
+  @machine.send_bundle(@server_fd, @bgid, @parts)
+end
+
+p(STR_COUNT:, STR_SIZE:)
+
+Benchmark.ips do |x|
+  x.report('IO#write')       { io_write }
+  x.report('UM#write')       { um_write }
+  x.report('UM#send')        { um_send }
+  x.report('UM#send_bundle') { um_send_bundle }
+
+  x.compare!(order: :baseline)
+end

data/benchmark/send.rb

@@ -5,49 +5,21 @@ require 'bundler/inline'
 gemfile do
   source 'https://rubygems.org'
   gem 'uringmachine', path: '..'
+  gem 'benchmark'
   gem 'benchmark-ips'
 end
 
 require 'benchmark/ips'
 require 'uringmachine'
+require 'securerandom'
 
 @machine = UM.new
 
-make_socket_pair = -> do
-  port = 10000 + rand(30000)
-  server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-  @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
-  @machine.bind(server_fd, '127.0.0.1', port)
-  @machine.listen(server_fd, UM::SOMAXCONN)
+@parts = ['1' * 256, '2' * (1 << 14), '3' * 256]
+@total_len = @parts.map(&:bytesize).reduce(:+)
 
-  client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-  @machine.connect(client_conn_fd, '127.0.0.1', port)
-
-  server_conn_fd = @machine.accept(server_fd)
-
-  @machine.close(server_fd)
-  [client_conn_fd, server_conn_fd]
-end
-
-@client_fd, @server_fd = make_socket_pair.()
-
-@read_buf = +''
-@read_fiber = @machine.spin do
-  while true
-    @machine.read(@client_fd, @read_buf, 65536, 0)
-  end
-end
-
-STR_COUNT = ARGV[0]&.to_i || 3
-STR_SIZE = ARGV[1]&.to_i || 100
-
-@parts = ['*' * STR_SIZE] * STR_COUNT
-
-@server_io = IO.new(@server_fd)
-@server_io.sync = true
 def io_write
   @server_io.write(*@parts)
-  @machine.snooze
 end
 
 def um_write
@@ -55,28 +27,51 @@ def um_write
   len = str.bytesize
 
   while len > 0
-    ret = @machine.write(@server_fd, str, len)
+    ret = @machine.write(@s2, str, len)
     len -= ret
     str = str[ret..-1] if len > 0
   end
 end
 
+def um_writev
+  @machine.writev(@s2, *@parts)
+end
+
 def um_send
   str = @parts.join
-  @machine.send(@server_fd, str, str.bytesize, UM::MSG_WAITALL)
+  @machine.send(@s2, str, str.bytesize, UM::MSG_WAITALL)
+end
+
+def um_sendv
+  @machine.sendv(@s2, *@parts)
 end
 
 @bgid = @machine.setup_buffer_ring(0, 8)
 def um_send_bundle
-  @machine.send_bundle(@server_fd, @bgid, @parts)
+  @machine.send_bundle(@s2, @bgid, @parts)
 end
 
-p(STR_COUNT:, STR_SIZE:)
+PORT = SecureRandom.rand(10001..60001)
+
+pid = fork { `nc -l localhost #{PORT} > /dev/null` }
+at_exit {
+  Process.kill(:SIGKILL, pid)
+  Process.wait(pid)
+}
+
+sleep 0.5
+@s2 = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+@machine.connect(@s2, '127.0.0.1', PORT)
+@server_io = IO.for_fd(@s2)
+@server_io.sync = true
+
 
 Benchmark.ips do |x|
   x.report('IO#write')       { io_write }
   x.report('UM#write')       { um_write }
+  x.report('UM#writev')      { um_writev }
   x.report('UM#send')        { um_send }
+  x.report('UM#sendv')       { um_sendv }
   x.report('UM#send_bundle') { um_send_bundle }
 
   x.compare!(order: :baseline)

data/ext/um/extconf.rb

@@ -24,7 +24,8 @@ def get_config
   {
     kernel_version:       combined_version,
     prep_bind:            combined_version >= 611,
-    prep_listen:          combined_version >= 611
+    prep_listen:          combined_version >= 611,
+    send_vectoized:       combined_version >= 617
   }
 end
 
@@ -45,6 +46,10 @@ if !find_header 'liburing.h', File.join(liburing_path, 'src/include')
   raise "Couldn't find liburing.h"
 end
 
+if !find_header 'liburing/io_uring.h', File.join(liburing_path, 'src/include')
+  raise "Couldn't find liburing/io_uring.h"
+end
+
 if !find_library('uring', nil, File.join(liburing_path, 'src'))
   raise "Couldn't find liburing.a"
 end
@@ -54,6 +59,7 @@ have_func("&rb_process_status_new")
 $defs << "-DUM_KERNEL_VERSION=#{config[:kernel_version]}"
 $defs << '-DHAVE_IO_URING_PREP_BIND'            if config[:prep_bind]
 $defs << '-DHAVE_IO_URING_PREP_LISTEN'          if config[:prep_listen]
+$defs << '-DHAVE_IO_URING_SEND_VECTORIZED'      if config[:send_vectoized]
 
 $CFLAGS << ' -Wno-pointer-arith'