uringmachine 0.19.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff89f34d541e086f8016156d4b5290a6a2fdc94292f04e7a3104ef9e7cda256d
-  data.tar.gz: 01dbe57b83effbab744fbd07461dcd803246a88bbf3ce1aeaf1e4eace32fd0ad
+  metadata.gz: 320cde6219f737bd65911d6b860852e1d706a20d807f68e97a103254d27a6c11
+  data.tar.gz: 2a5c40b6121dd4bc25bcfaf0852d56425f398b43660ccb86d883c5f7b2f68dcc
 SHA512:
-  metadata.gz: ca0e44f1121384634b4234b2cd49643f87e8255e77eb250f64fb62be8bcdcb18e6a82480e5da003322c941c9ae2def119a048797d53bc064c4e1f77796b82c4d
-  data.tar.gz: 322090fd12498525d303b63f66ec1c559ed9933e89e74d3b01c9cc5c0f3f1dcee951c767625690c288478d5e460248418bbd693fbd7c31146c7aff76cf545a5d
+  metadata.gz: b6940030d3f45f731c2b2e8a853193c4ef46e815b84848fc6a310605e00bfd10dd633ff952fc324f33dd4748c82d72379ddf7e91c0c0020006cacf1a2a6a83cb
+  data.tar.gz: 60d92ed67095e67e7a36f329e5131a853dff9f4afde843c8022de88ee3613e97e6f032479ee3090870f6a00804d3863e70968e78e92a1753ced3f8baf0a11df2

data/CHANGELOG.md

@@ -1,4 +1,15 @@
-# 0.19.1 2025-01-03
+# 0.20.0 2025-11-26
+
+- Add `UM.pidfd_open`, `UM.pidfd_send_signal` methods
+- Add `#waitid`, `#waitid_status` methods, remove `#waitpid`
+- Set minimal kernel version to 6.7
+- Add `UM::Error` exception class
+- Add support for `IO::Buffer` in all I/O methods
+- Fix and improve mutex and queue implementations
+- Add UM.debug method
+- Implement Fiber scheduler (WIP)
+
+# 0.19.1 2025-11-03
 
 - Add `RB_GC_GUARD` in `process_runqueue_op`
 

data/TODO.md

@@ -37,7 +37,6 @@ Some resources:
 - https://github.com/socketry/async/blob/main/context/getting-started.md
 - https://github.com/socketry/async/blob/main/context/scheduler.md
 - https://github.com/socketry/async/blob/main/lib/async/scheduler.rb#L28
-- 
 
 ## useful concurrency tools
 

data/examples/bm_fileno.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'benchmark'
+  gem 'benchmark-ips'
+end
+
+require 'benchmark/ips'
+
+r, w = IO.pipe
+
+class IO
+  def __fd__
+    @__fd__ ||= fileno
+  end
+end
+
+@map = ObjectSpace::WeakMap.new
+
+def cached_fileno(r)
+  @map[r] ||= r.fileno
+end
+
+Benchmark.ips do |x|
+  x.report('IO#fileno')       { r.fileno }
+  x.report('cached_fileno')   { cached_fileno(r) }
+  x.report('__fd__')          { r.__fd__ }
+
+  x.compare!(order: :baseline)
+end

data/examples/bm_mutex.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark'
+  gem 'benchmark-ips'
+end
+
+require 'benchmark/ips'
+require 'uringmachine'
+require 'thread'
+
+COUNT = 10
+CONCURRENCY = (ENV['CONCURRENCY'] || 4).to_i
+
+p(CONCURRENCY: CONCURRENCY)
+
+STRING = "foo...bar"
+REGEXP = /foo(.+)bar/
+
+def threads_setup
+  @threads_mutex = Mutex.new
+  @threads_start = Queue.new
+  @threads_done = Queue.new
+  @threads = CONCURRENCY.times.map {
+    Thread.new do
+      loop do
+        @threads_start.shift
+        COUNT.times do
+          @threads_mutex.synchronize do
+            COUNT.times do
+              STRING.match(REGEXP)[1]
+            end
+          end
+        end
+        @threads_done << true
+      end
+    end
+  }
+end
+
+def threads_run
+  @threads_start << true
+  @threads_done.shift
+end
+
+def um_setup
+  @um_machine = UM.new
+  @um_mutex = UM::Mutex.new
+  @um_start = UM::Queue.new
+  @um_done = UM::Queue.new
+  @fibers = CONCURRENCY.times.map {
+    @um_machine.spin do
+      loop do
+        @um_machine.shift(@um_start)
+        COUNT.times do
+          @um_machine.synchronize(@um_mutex) do
+            COUNT.times do
+              STRING.match(REGEXP)[1]
+            end
+          end
+        end
+        @um_machine.push(@um_done, true)
+      end
+    end
+  }
+end
+
+def um_run
+  @um_machine.push(@um_start, true)
+  @um_machine.shift(@um_done)
+end
+
+threads_setup
+um_setup
+
+Benchmark.ips do |x|
+  x.report("threads") { @threads_run }
+  x.report("UM")      { @um_run }
+
+  x.compare!(order: :baseline)
+end

data/examples/bm_mutex_single.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'uringmachine', path: '..'
+  gem 'benchmark'
+  gem 'benchmark-ips'
+end
+
+require 'benchmark/ips'
+require 'uringmachine'
+require 'thread'
+
+def threads_setup
+  @threads_mutex = Mutex.new
+end
+
+def um_setup
+  @um_machine = UM.new
+  @um_mutex = UM::Mutex.new
+end
+
+threads_setup
+um_setup
+
+Benchmark.ips do |x|
+  x.report("threads") { @threads_mutex.synchronize { } }
+  x.report("UM")      { @um_machine.synchronize(@um_mutex) {} }
+
+  x.compare!(order: :baseline)
+end

data/examples/bm_queue.rb

@@ -12,17 +12,18 @@ require 'benchmark/ips'
 require 'uringmachine'
 
 COUNT = 1000
-NUM_PRODUCERS = 2
-NUM_CONSUMERS = 10
+NUM_PRODUCERS = 8
+NUM_CONSUMERS = 8
+
+@queue = Queue.new
+@done = Queue.new
 
 def run_threads
-  queue = Queue.new
-  done = Queue.new
 
   NUM_PRODUCERS.times do
     Thread.new do
-      COUNT.times { queue << rand(1000) }
-      done << true
+      COUNT.times { @queue << rand(1000) }
+      @done << true
     end
   end
 
@@ -30,65 +31,64 @@ def run_threads
   NUM_CONSUMERS.times do
     Thread.new do
       loop do
-        item = queue.shift
+        item = @queue.shift
         break if item.nil?
 
         total += item
       end
-      done << true
+      @done << true
     end
   end
 
   # wait for producers
-  NUM_PRODUCERS.times { done.shift }
+  NUM_PRODUCERS.times { @done.shift }
 
   # stop and wait for consumers
   NUM_CONSUMERS.times do
-    queue << nil
-    done.shift
+    @queue << nil
+    @done.shift
   end
 
   total
 end
 
-def run_um
-  machine = UM.new
-  queue = UM::Queue.new
-  done = UM::Queue.new
+@machine = UM.new
+@um_queue = UM::Queue.new
+@um_done = UM::Queue.new
 
+def run_um
   NUM_PRODUCERS.times do
-    machine.spin do
-      COUNT.times { machine.push(queue, rand(1000)) }
-      machine.push(done, true)
+    @machine.spin do
+      COUNT.times { @machine.push(@um_queue, rand(1000)) }
+      @machine.push(@um_done, true)
     end
   end
 
   total = 0
   NUM_CONSUMERS.times do
-    machine.spin do
+    @machine.spin do
       loop do
-        item = machine.shift(queue)
+        item = @machine.shift(@um_queue)
         break if item.nil?
 
         total += item
       end
-      machine.push(done, true)
+      @machine.push(@um_done, true)
     end
   end
 
   # wait for producers
-  NUM_PRODUCERS.times { machine.shift(done) }
+  NUM_PRODUCERS.times { @machine.shift(@um_done) }
 
   # stop and wait for consumers
   NUM_CONSUMERS.times do
-    machine.push(queue, nil)
-    machine.shift(done)
+    @machine.push(@um_queue, nil)
+    @machine.shift(@um_done)
   end
 
   total
 end
 
-
 # puts "running"
 # res = run_threads
 # p threads: res
@@ -98,14 +98,13 @@ end
 #   p fibers: res
 # }
 
-
 # __END__
 
 Benchmark.ips do |x|
-  x.config(:time => 5, :warmup => 2)
+  x.config(:time => 10, :warmup => 3)
 
   x.report("threads") { run_threads }
   x.report("UM")      { run_um }
 
-  x.compare!
+  x.compare!(order: :baseline)
 end

data/examples/bm_send.rb

@@ -71,10 +71,6 @@ def um_send_bundle
   @machine.send_bundle(@server_fd, @bgid, @parts)
 end
 
-# um_send_bundle
-# 10.times { @machine.snooze }
-# exit
-
 p(STR_COUNT:, STR_SIZE:)
 
 Benchmark.ips do |x|
@@ -82,5 +78,6 @@ Benchmark.ips do |x|
   x.report('UM#write')       { um_write }
   x.report('UM#send')        { um_send }
   x.report('UM#send_bundle') { um_send_bundle }
-  x.compare!
+
+  x.compare!(order: :baseline)
 end

data/examples/bm_snooze.rb

@@ -15,37 +15,19 @@ ITERATIONS = 1000
 
 $machine = UringMachine.new
 
-def run_snooze
+def run_snooze_um
   count = 0
-  main = Fiber.current
 
-  f1 = Fiber.new do
-    loop do
-      count += 1
-      if count == ITERATIONS
-        $machine.schedule(main, nil)
-        break
-      else
-        $machine.snooze
-      end
-    end
-  end
+  f1 = $machine.spin {
+    ITERATIONS.times { count += 1; $machine.snooze }
+  }
+  f2 = $machine.spin {
+    ITERATIONS.times { count += 1; $machine.snooze }
+  }
 
-  f2 = Fiber.new do
-    loop do
-      count += 1
-      if count == ITERATIONS
-        $machine.schedule(main, nil)
-        break
-      else
-        $machine.snooze
-      end
-    end
-  end
+  $machine.join(f1, f2)
 
-  $machine.schedule(f1, nil)
-  $machine.schedule(f2, nil)
-  $machine.yield
+  count
 end
 
 def run_raw_transfer
@@ -53,36 +35,32 @@ def run_raw_transfer
   main = Fiber.current
   f2 = nil
   f1 = Fiber.new do
-    loop do
+    ITERATIONS.times do
       count += 1
-      if count == ITERATIONS
-        main.transfer(nil)
-        break
-      else
-        f2.transfer(nil)
-      end
+      f2.transfer(nil)
     end
   end
 
   f2 = Fiber.new do
-    loop do
+    ITERATIONS.times do
       count += 1
-      if count == ITERATIONS
-        main.transfer(nil)
-        break
-      else
-        f1.transfer(nil)
-      end
+      f1.transfer(nil)
     end
+    main.transfer(nil)
   end
 
   f1.transfer(nil)
+
+  count
 end
 
+p run_snooze_um:    run_snooze_um
+p run_raw_transfer: run_raw_transfer
+
 bm = Benchmark.ips do |x|
   x.config(:time => 5, :warmup => 2)
 
-  x.report("snooze")        { run_snooze }
+  x.report("snooze_um")     { run_snooze_um }
   x.report("raw transfer")  { run_raw_transfer }
 
   x.compare!

data/examples/fiber_scheduler_demo.rb

@@ -1,71 +1,35 @@
 # frozen_string_literal: true
 
-require_relative '../lib/uringmachine'
-require_relative '../lib/uringmachine/fiber_scheduler'
+require 'bundler/setup'
+
+require 'uringmachine'
+require 'uringmachine/fiber_scheduler'
 require 'net/http'
 
-machine = UringMachine.new
-scheduler = UM::FiberScheduler.new(machine)
+$machine = UringMachine.new
+scheduler = UM::FiberScheduler.new($machine)
 Fiber.set_scheduler scheduler
 
 i, o = IO.pipe
 
 f1 = Fiber.schedule do
-  # sleep 0.4
-  # o.write 'Hello, world!'
-  # o.close
+  puts "Hello from fiber 1!!!"
 end
 
 f2 = Fiber.schedule do
-  # puts "hi"
-  # 10.times do
-  #   sleep 0.1
-  #   puts "."
-  # end
+  puts "Hello from fiber 2!!!"
 end
 
-# Fiber.schedule do
-#   scheduler.block(:wait)
-# end
-
 f3 = Fiber.schedule do
-#   message = i.read
-#   puts message
-# rescue => e
-#   scheduler.p e
-#   scheduler.p e.backtrace
+  o.write 'hello'
+  puts "wrote it!"
+  o.close
 end
 
 f4 = Fiber.schedule do
-  puts '*' * 40
-  # tcp = TCPSocket.new('noteflakes.com', 80)
-  # tcp.timeout = 10
-  # scheduler.p tcp
-  # tcp << "GET / HTTP/1.1\r\nHost: noteflakes.com\r\n\r\n"
-  # s = tcp.read
-  # scheduler.p s: s
-  ret = Net::HTTP.get('noteflakes.com', '/ping')
-  scheduler.p ret: ret
-rescue => e
-  scheduler.p e
-  scheduler.p e.backtrace
+  str = i.read
+  puts "got: #{str}"
 end
 
-scheduler.join(f1, f2, f3, f4)
-
-__END__
-
-stdout_fd = STDOUT.fileno
-stdin_fd = STDIN.fileno
-machine.write(stdout_fd, "Hello, world!\n")
-
-loop do
-  machine.write(stdout_fd, "Say something: ")
-  buf = +''
-  res = machine.read(stdin_fd, buf, 8192)
-  if res > 0
-    machine.write(stdout_fd, "You said: #{buf}")
-  else
-    break
-  end
-end
+# scheduler.join
+# Fiber.set_scheduler(nil)

data/examples/fiber_scheduler_fork.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'uringmachine'
+require 'uringmachine/fiber_scheduler'
+require 'net/http'
+
+$machine = UringMachine.new
+scheduler = UM::FiberScheduler.new($machine)
+Fiber.set_scheduler scheduler
+
+p parent: Fiber.scheduler
+p Fiber.current
+
+pid = fork do
+  Fiber.scheduler.post_fork
+  Fiber.set_scheduler nil
+  p child: Fiber.scheduler
+  # Fiber.scheduler.post_fork
+end
+
+Process.wait(pid)
+p :done

data/examples/nc_ssl.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../lib/uringmachine'
+require 'openssl'
+
+HOST = ARGV[0]
+PORT = ARGV[1].to_i
+
+machine = UringMachine.new
+
+conn_fd = machine.socket(Socket::AF_INET, Socket::SOCK_STREAM, 0, 0);
+machine.connect(conn_fd, HOST, PORT)
+
+class FakeIO < File
+  def initialize(machine, fd)
+    @machine = machine
+    @fd = fd
+  end
+
+  def nonblock=(x)
+    p 'nonblock=': x
+  end
+
+  def sync
+    p sync: true
+    true
+  end
+
+  def write(buf)
+    p write: buf
+    @machine.write(fd, buf)
+  end
+
+  def read(maxlen = 4096, buf = nil)
+    p read: [maxlen, buf]
+    buf ||= +''
+    _res = @machine.read(@fd, buf, maxlen)
+    buf
+  end
+end
+
+conn_io = FakeIO.new(machine, conn_fd)
+
+ssl_io = OpenSSL::SSL::SSLSocket.new(conn_io)
+
+stdin_fd = STDIN.fileno
+stdout_fd = STDOUT.fileno
+
+f_writer = Fiber.new do
+  bgidw = machine.setup_buffer_ring(4096, 1024)
+  machine.read_each(stdin_fd, bgidw) do |buf|
+    ssl_io.write(buf)
+  end
+end
+machine.schedule(f_writer, nil)
+
+f_reader = Fiber.new do
+  buffer = +''
+  loop do
+    ssl_io.read(4096, buffer)
+    break if buffer.empty?
+
+    machine.write(stdout_fd, buf)
+  end
+end
+machine.schedule(f_reader, nil)
+
+trap('SIGINT') { exit! }
+loop do
+  machine.sleep(60)
+end

data/ext/um/extconf.rb

@@ -19,19 +19,12 @@ def get_config
   version, major_revision, distribution = m[1].to_i, m[2].to_i, m[4]
 
   combined_version = version.to_i * 100 + major_revision.to_i
-  raise "UringMachine requires kernel version 6.4 or newer!" if combined_version < 604
+  raise "UringMachine requires kernel version 6.7 or newer!" if combined_version < 607
 
   {
     kernel_version:       combined_version,
-    submit_all_flag:      combined_version >= 518,
-    coop_taskrun_flag:    combined_version >= 519,
-    single_issuer_flag:   combined_version >= 600,
     prep_bind:            combined_version >= 611,
-    prep_listen:          combined_version >= 611,
-    prep_cmd_sock:        combined_version >= 607,
-    prep_futex:           combined_version >= 607,
-    prep_waitid:          combined_version >= 607,
-    prep_read_multishot:  combined_version >= 607
+    prep_listen:          combined_version >= 611
   }
 end
 
@@ -56,15 +49,12 @@ if !find_library('uring', nil, File.join(liburing_path, 'src'))
   raise "Couldn't find liburing.a"
 end
 
+have_func("rb_process_status_new")
+
 $defs << "-DUM_KERNEL_VERSION=#{config[:kernel_version]}"
-$defs << '-DHAVE_IORING_SETUP_SUBMIT_ALL'       if config[:submit_all_flag]
-$defs << '-DHAVE_IORING_SETUP_COOP_TASKRUN'     if config[:coop_taskrun_flag]
 $defs << '-DHAVE_IO_URING_PREP_BIND'            if config[:prep_bind]
 $defs << '-DHAVE_IO_URING_PREP_LISTEN'          if config[:prep_listen]
-$defs << '-DHAVE_IO_URING_PREP_CMD_SOCK'        if config[:prep_cmd_sock]
-$defs << '-DHAVE_IO_URING_PREP_FUTEX'           if config[:prep_futex]
-$defs << '-DHAVE_IO_URING_PREP_WAITID'          if config[:prep_waitid]
-$defs << '-DHAVE_IO_URING_PREP_READ_MULTISHOT'  if config[:prep_read_multishot]
+
 $CFLAGS << ' -Wno-pointer-arith'
 
 CONFIG['optflags'] << ' -fno-strict-aliasing'