uringmachine 0.4 → 0.5.1

data/test/test_um.rb

@@ -3,13 +3,37 @@
 require_relative 'helper'
 require 'socket'
 
-class SchedulingTest < UMBaseTest
+class UringMachineTest < Minitest::Test
+  def test_kernel_version
+    v = UringMachine.kernel_version
+    assert_kind_of Integer, v
+    assert_in_range 600..700, v
+  end
+end
+
+class FiberTest < UMBaseTest
+  def test_spin
+    x = nil
+    f = machine.spin do
+      x = :foo
+    end
+
+    assert_kind_of Fiber, f
+    assert_nil x
+
+    machine.snooze
+
+    assert_equal :foo, x
+  end
+end
+
+class ScheduleTest < UMBaseTest
   def test_schedule_and_yield
     buf = []
-    cur = Fiber.current
+    main = Fiber.current
     f = Fiber.new do |x|
       buf << [21, x]
-      machine.schedule(cur, 21)
+      machine.schedule(main, 21)
       buf << 22
       x = machine.yield
       buf << [23, x]
@@ -49,12 +73,11 @@ class SchedulingTest < UMBaseTest
     assert_equal [e], buf
   end
 
-  def test_interrupt
-    cur = Fiber.current
+  def test_schedule_exception2
+    main = Fiber.current
     e = CustomError.new
     f = Fiber.new do
-      machine.interrupt(cur, e)
-      assert_equal 2, machine.pending_count
+      machine.schedule(main, e)
       machine.yield
     end
     
@@ -62,17 +85,11 @@ class SchedulingTest < UMBaseTest
     t0 = monotonic_clock
 
     # the call to schedule means an op is checked out
-    assert_equal 1, machine.pending_count
+    assert_equal 0, machine.pending_count
     begin
       machine.sleep(1)
     rescue Exception => e2
     end
-    # the sleep op has been cancelled, but we still need to process the
-    # cancellation. Calling snooze should take care of that.
-    assert_equal 1, machine.pending_count
-    machine.snooze
-
-    # CQE should have been received, and the op checked in
     assert_equal 0, machine.pending_count
     t1 = monotonic_clock
 
@@ -96,13 +113,7 @@ class SchedulingTest < UMBaseTest
       buf << 5
     end
 
-    # at this point, the sleep cancelled CQE should not yet have been received.
-    # So we still have a pending operation. Snooze should have let the CQE be
-    # received.
-    assert_equal 1, machine.pending_count
-    machine.snooze
     assert_equal 0, machine.pending_count
-
     assert_equal [1, 2, 5], buf
     assert_kind_of TOError, e
   end
@@ -117,7 +128,7 @@ class SchedulingTest < UMBaseTest
     end
 
     assert_equal 1, machine.pending_count
-    machine.snooze
+    machine.sleep(0.01) # wait for cancelled CQEs
     assert_equal 0, machine.pending_count
 
     assert_kind_of RuntimeError, e
@@ -130,7 +141,7 @@ class SchedulingTest < UMBaseTest
     assert_equal 42, v
 
     assert_equal 1, machine.pending_count
-    machine.snooze
+    machine.sleep 0.01 # wait for cancelled CQE
     assert_equal 0, machine.pending_count
   end
 
@@ -152,6 +163,10 @@ class SchedulingTest < UMBaseTest
     rescue => e
     end
 
+    assert_equal 2, machine.pending_count
+    machine.sleep(0.01) # wait for cancelled CQEs
+    assert_equal 0, machine.pending_count
+
     assert_kind_of TO2Error, e
     assert_equal [3], buf
   end
@@ -167,6 +182,34 @@ class SleepTest < UMBaseTest
     assert_in_range 0.09..0.13, t1 - t0
     assert_equal 0.1, res
   end
+
+  class C; end
+
+  def test_sleep_interrupted
+    t0 = monotonic_clock
+    ret = machine.timeout(0.03, C) do
+      machine.sleep 1
+    end
+    t1 = monotonic_clock
+    assert_in_range 0.02..0.04, t1 - t0
+    assert_kind_of C, ret
+  end
+
+  class D < RuntimeError; end
+
+  def test_sleep_with_timeout
+    t0 = monotonic_clock
+    ret = begin
+      machine.timeout(0.03, D) do
+        machine.sleep 1
+      end
+    rescue => e
+      e
+    end
+    t1 = monotonic_clock
+    assert_in_range 0.02..0.04, t1 - t0
+    assert_kind_of D, ret
+  end
 end
 
 class ReadTest < UMBaseTest
@@ -199,6 +242,7 @@ class ReadTest < UMBaseTest
     assert_raises(Errno::EBADF) do
       machine.read(w.fileno, +'', 8192)
     end
+    assert_equal 0, machine.pending_count
   end
 
   def test_read_with_buffer_offset
@@ -234,22 +278,24 @@ end
 
 class ReadEachTest < UMBaseTest
   def test_read_each
+    skip if UringMachine.kernel_version < 607
+
     r, w = IO.pipe
     bufs = []
-
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
 
     f = Fiber.new do
       w << 'foo'
-      machine.snooze
+      machine.sleep 0.02
       w << 'bar'
-      machine.snooze
+      machine.sleep 0.02
       w << 'baz'
-      machine.snooze
+      machine.sleep 0.02
       w.close
       machine.yield
     end
+    
     machine.schedule(f, nil)
 
     machine.read_each(r.fileno, bgid) do |buf|
@@ -262,8 +308,9 @@ class ReadEachTest < UMBaseTest
 
   # send once and close write fd
   def test_read_each_raising_1
-    r, w = IO.pipe
+    skip if UringMachine.kernel_version < 607
 
+    r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
 
@@ -285,8 +332,9 @@ class ReadEachTest < UMBaseTest
 
   # send once and leave write fd open
   def test_read_each_raising_2
-    r, w = IO.pipe
+    skip if UringMachine.kernel_version < 607
 
+    r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
 
@@ -303,17 +351,15 @@ class ReadEachTest < UMBaseTest
     assert_kind_of RuntimeError, e
     assert_equal 'hi', e.message
 
-    # since the write fd is still open, the read_each impl is supposed to cancel
-    # the op, which is done asynchronously.
-    assert_equal 1, machine.pending_count
-    machine.snooze
+    machine.snooze # in case the final CQE has not yet arrived
     assert_equal 0, machine.pending_count
   end
 
   # send twice
   def test_read_each_raising_3
-    r, w = IO.pipe
+    skip if UringMachine.kernel_version < 607
 
+    r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
 
@@ -331,12 +377,46 @@ class ReadEachTest < UMBaseTest
     assert_kind_of RuntimeError, e
     assert_equal 'hi', e.message
 
-    # since the write fd is still open, the read_each impl is supposed to cancel
-    # the op, which is done asynchronously.
-    assert_equal 1, machine.pending_count
-    machine.snooze
+    machine.snooze # in case the final CQE has not yet arrived
     assert_equal 0, machine.pending_count
   end
+
+  def test_read_each_break
+    skip if UringMachine.kernel_version < 607
+
+    r, w = IO.pipe
+    bgid = machine.setup_buffer_ring(4096, 1024)
+
+    t = Thread.new do
+      sleep 0.1
+      w << 'foo'
+      sleep 0.1
+      w.close
+    end
+    
+    bufs = []
+    machine.read_each(r.fileno, bgid) do |b|
+      bufs << b
+      break
+    end
+
+    assert_equal ['foo'], bufs
+    machine.snooze # in case the final CQE has not yet arrived
+    assert_equal 0, machine.pending_count
+  ensure
+    t&.kill
+  end
+
+  def test_read_each_bad_file
+    skip if UringMachine.kernel_version < 607
+
+    _r, w = IO.pipe
+    bgid = machine.setup_buffer_ring(4096, 1024)
+
+    assert_raises(Errno::EBADF) do
+      machine.read_each(w.fileno, bgid)
+    end
+  end
 end
 
 class WriteTest < UMBaseTest
@@ -421,7 +501,7 @@ class AcceptEachTest < UMBaseTest
   def test_accept_each
     conns = []
     t = Thread.new do
-      sleep 0.1
+      sleep 0.05
       3.times { conns << TCPSocket.new('127.0.0.1', @port) }
     end
 
@@ -432,8 +512,6 @@ class AcceptEachTest < UMBaseTest
     end
 
     assert_equal 3, count
-    assert_equal 1, machine.pending_count
-    machine.snooze
     assert_equal 0, machine.pending_count
   ensure
     t&.kill
@@ -471,7 +549,7 @@ class ConnectTest < UMBaseTest
       sleep
     end
 
-    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0);
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
     assert_equal 0, machine.pending_count
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, machine.pending_count
@@ -513,7 +591,7 @@ class SendTest < UMBaseTest
       sleep
     end
 
-    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0);
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, res
 
@@ -548,7 +626,7 @@ class RecvTest < UMBaseTest
       sleep
     end
 
-    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0);
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, res
 
@@ -561,6 +639,52 @@ class RecvTest < UMBaseTest
   end
 end
 
+class RecvEachTest < UMBaseTest
+  def setup
+    super
+    @port = assign_port
+    @server = TCPServer.open('127.0.0.1', @port)
+  end
+
+  def teardown
+    @server&.close
+    super
+  end
+
+  def test_recv_each
+    t = Thread.new do
+      conn = @server.accept
+      conn.write('abc')
+      sleep 0.01
+      conn.write('def')
+      sleep 0.01
+      conn.write('ghi')
+      sleep 0.01
+      conn.close
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    bgid = machine.setup_buffer_ring(4096, 1024)
+    assert_equal 0, bgid
+
+    bgid2 = machine.setup_buffer_ring(4096, 1024)
+    assert_equal 1, bgid2
+
+    bufs = []
+
+    machine.recv_each(fd, bgid, 0) do |buf|
+      bufs << buf
+    end
+    assert_equal ['abc', 'def', 'ghi'], bufs
+  ensure
+    t&.kill
+  end
+end
+
 class BindTest < UMBaseTest
   def setup
     super
@@ -569,7 +693,7 @@ class BindTest < UMBaseTest
 
   def test_bind
     assert_equal 0, machine.pending_count
-    fd = machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0);
+    fd = machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0)
     res = machine.bind(fd, '127.0.0.1', @port)
     assert_equal 0, res
     assert_equal 0, machine.pending_count
@@ -587,7 +711,7 @@ class BindTest < UMBaseTest
   def test_bind_invalid_args
     assert_equal 0, machine.pending_count
 
-    fd = machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0);
+    fd = machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0)
     assert_raises(Errno::EACCES) { machine.bind(fd, 'foo.bar.baz', 3) }
     assert_raises(Errno::EBADF) { machine.bind(-3, '127.0.01', 1234) }
 
@@ -602,7 +726,7 @@ class ListenTest < UMBaseTest
   end
 
   def test_listen
-    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0);
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
     machine.bind(fd, '127.0.0.1', @port)
     res = machine.listen(fd, 5)
     assert_equal 0, res
@@ -631,4 +755,297 @@ class ConstTest < UMBaseTest
   def test_constants
     assert_equal UM::SOCK_STREAM, UM::SOCK_STREAM
   end
-end
+end
+
+class GetSetSockOptTest < UMBaseTest
+  def test_getsockopt_setsockopt
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    reuseaddr = machine.getsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR)
+    assert_equal 0, reuseaddr
+
+    res = machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    assert_equal 0, res
+
+    reuseaddr = machine.getsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR)
+    assert_equal 1, reuseaddr
+  end
+end
+
+class SynchronizeTest < UMBaseTest
+  def test_synchronize_single
+    skip if !machine.respond_to?(:synchronize)
+
+    m = UM::Mutex.new
+
+    buf = []
+    machine.synchronize(m) do
+      buf << 1
+    end
+    machine.synchronize(m) do
+      buf << 2
+    end
+
+    assert_equal [1, 2], buf
+    assert_equal 0, machine.pending_count
+  end
+
+  def test_synchronize_pair
+    skip if !machine.respond_to?(:synchronize)
+    m = UM::Mutex.new
+
+    buf = []
+
+    f1 = Fiber.new do
+      machine.synchronize(m) do
+        buf << 11
+        machine.sleep(0.01)
+        buf << 12
+      end
+      buf << 13
+      machine.yield
+    end
+
+    f2 = Fiber.new do
+      machine.synchronize(m) do
+        buf << 21
+        machine.sleep(0.01)
+        buf << 22
+      end
+      buf << 23
+      machine.yield
+    end
+
+    machine.schedule(f1, nil)
+    machine.schedule(f2, nil)
+
+    machine.sleep(0.03)
+    assert_equal [11, 12, 13, 21, 22, 23], buf
+    assert_equal 0, machine.pending_count
+  end
+end
+
+class QueueTest < UMBaseTest
+  def test_push_pop_1
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+    assert_equal 0, q.count
+    machine.push(q, :foo)
+    machine.push(q, :bar)
+    assert_equal 2, q.count
+
+    assert_equal :bar, machine.pop(q)
+    assert_equal 1, q.count
+    assert_equal :foo, machine.pop(q)
+    assert_equal 0, q.count
+  end
+
+  def test_push_pop_2
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+    buf = []
+
+    f1 = Fiber.new do
+      buf << [1, machine.pop(q)]
+      machine.yield
+    end
+
+    machine.schedule(f1, nil)
+
+    f2 = Fiber.new do
+      buf << [2, machine.pop(q)]
+      machine.yield
+    end
+
+    machine.schedule(f2, nil)
+
+    machine.snooze
+    assert_equal [], buf
+
+    machine.push(q, :foo)
+    assert_equal 1, q.count
+    machine.sleep(0.02)
+    assert_equal [[1, :foo]], buf
+
+    machine.push(q, :bar)
+    assert_equal 1, q.count
+
+    machine.sleep(0.02)
+    assert_equal [[1, :foo], [2, :bar]], buf
+    assert_equal 0, q.count
+  end
+
+  def test_push_pop_3
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+    buf = []
+
+    machine.push(q, :foo)
+    machine.push(q, :bar)
+    assert_equal 2, q.count
+
+    f1 = Fiber.new do
+      buf << [1, machine.pop(q)]
+      machine.yield
+    end
+    machine.schedule(f1, nil)
+
+    f2 = Fiber.new do
+      buf << [2, machine.pop(q)]
+      machine.yield
+    end
+    machine.schedule(f2, nil)
+
+    3.times { machine.snooze }
+
+    assert_equal [[1, :bar], [2, :foo]], buf.sort
+    assert_equal 0, q.count
+  end
+
+  def test_push_pop_4
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+    buf = []
+
+    machine.push(q, :foo)
+    assert_equal 1, q.count
+
+    f1 = Fiber.new do
+      buf << [1, machine.pop(q)]
+      machine.yield
+    end
+    machine.schedule(f1, nil)
+
+    f2 = Fiber.new do
+      buf << [2, machine.pop(q)]
+      machine.yield
+    end
+    machine.schedule(f2, nil)
+
+    machine.sleep 0.01
+
+    assert_equal [[1, :foo]], buf
+    machine.push(q, :bar)
+
+    machine.sleep 0.01
+    assert_equal [[1, :foo], [2, :bar]], buf
+  end
+
+  def test_push_shift_1
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+
+    machine.push(q, :foo)
+    machine.push(q, :bar)
+    machine.push(q, :baz)
+
+    assert_equal :foo, machine.shift(q)
+    assert_equal :bar, machine.shift(q)
+    assert_equal :baz, machine.shift(q)
+  end
+
+  def test_shift_shift_1
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+
+    machine.unshift(q, :foo)
+    machine.unshift(q, :bar)
+    machine.unshift(q, :baz)
+
+    assert_equal :baz, machine.shift(q)
+    assert_equal :bar, machine.shift(q)
+    assert_equal :foo, machine.shift(q)
+  end
+end
+
+class OpenTest < UMBaseTest
+  PATH = '/tmp/um_open_test'
+
+  def setup
+    super
+    FileUtils.rm(PATH, force: true)
+  end
+
+  def test_open
+    fd = machine.open(PATH, UM::O_CREAT | UM::O_WRONLY)
+    assert_kind_of Integer, fd
+    assert File.file?(PATH)
+
+    machine.write(fd, 'foo')
+    machine.close(fd)
+
+    assert_equal 'foo', IO.read(PATH)
+  end
+
+  def test_open_with_block
+    res = machine.open(PATH, UM::O_CREAT | UM::O_WRONLY) do |fd|
+      machine.write(fd, 'bar')
+      fd
+    end
+
+    assert_kind_of Integer, res
+    assert_raises(Errno::EBADF) { machine.close(res) }
+    assert_equal 'bar', IO.read(PATH)
+  end
+
+  def test_open_bad_arg
+    assert_raises(Errno::ENOENT) { machine.open(PATH, UM::O_RDONLY) }
+    assert_raises(Errno::ENOENT) { machine.open(PATH, UM::O_RDONLY) {} }
+  end
+end
+
+class PipeTest < UMBaseTest
+  def test_pipe
+    rfd, wfd = UM.pipe
+    ret = machine.write(wfd, 'foo')
+    assert_equal 3, ret
+    
+    ret = machine.close(wfd)
+    assert_equal wfd, ret
+
+    buf = +''
+    ret = machine.read(rfd, buf, 8192)
+
+    assert_equal 3, ret
+    assert_equal 'foo', buf
+
+    ret = machine.close(rfd)
+    assert_equal rfd, ret
+  end
+end
+
+class WaitTest < UMBaseTest
+  def test_waitpid
+    skip if UM.kernel_version < 607
+
+    msg = 'hello from child'
+
+    rfd, wfd = UM.pipe
+    pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
+
+    ret = machine.waitpid(pid, UM::WEXITED)
+    assert_kind_of Array, ret
+    assert_equal [pid, 42], ret
+
+    buf = +''
+    ret = machine.read(rfd, buf, 8192)
+    assert_equal msg.bytesize, ret
+    assert_equal msg, buf
+  end
+
+  def test_waitpid_bad_pid
+    skip if UM.kernel_version < 607
+
+    assert_raises(Errno::ECHILD) { machine.waitpid(1, UM::WEXITED) }    
+  end
+end

data/uringmachine.gemspec

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

data/vendor/liburing/.gitignore

@@ -27,11 +27,16 @@
 /examples/send-zerocopy
 /examples/rsrc-update-bench
 /examples/kdigest
+/examples/reg-wait
 
 /test/*.t
 /test/*.dmesg
 /test/output/
 
+# Clang's compilation database file and directory.
+/.cache
+/compile_commands.json
+
 config-host.h
 config-host.mak
 config.log