uringmachine 0.20.0 → 0.21.0

data/test/test_um.rb

@@ -11,6 +11,80 @@ class UringMachineTest < Minitest::Test
   end
 end
 
+class EntriesTest < Minitest::Test
+  def test_default_entries
+    m = UM.new
+    assert_equal 4096, m.entries
+  end
+
+  def test_custom_entries_value
+    m = UM.new(13)
+    assert_equal 13, m.entries
+  end
+end
+
+class SQPOLLTest < Minitest::Test
+  def test_sqpoll_timeout
+    m = UM.new(10, 0.05)
+
+    r, w = UM.pipe
+
+    buf = nil
+    t = Thread.new { buf = IO.new(r).readpartial(3) }
+
+    # let SQPOLL worker thread timeout
+    sleep(0.06)
+
+    # SQE is prepared but not submitted
+    m.write_async(w, 'foo')
+
+    # thread should timeout
+    ret = t.join(0.03)
+    assert_nil buf
+  ensure
+    t.kill rescue nil
+  end
+
+  def test_sqpoll_timeout_with_submit
+    m = UM.new(10, 0.05)
+
+    r, w = UM.pipe
+
+    buf = nil
+    t = Thread.new { buf = IO.new(r).readpartial(3) }
+
+    # let SQPOLL worker thread timeout
+    sleep(0.06)
+
+    # SQE is prepared but not submitted
+    m.write_async(w, 'foo')
+    ret = m.submit
+    assert_equal 1, ret
+
+    # thread should timeout
+    ret = t.join(0.1)
+    assert_equal 'foo', buf
+  ensure
+    t.kill rescue nil
+  end
+end
+
+class SubmitTest < UMBaseTest
+  def test_submit
+    _r, w = UM.pipe
+
+    machine.write_async(w, 'foo')
+    machine.write_async(w, 'bar')
+    machine.write_async(w, 'baz')
+
+    assert_equal 3, machine.pending_count
+    assert_equal 3, machine.submit
+    assert_equal 0, machine.submit
+    machine.snooze
+    assert_equal 0, machine.pending_count
+  end
+end
+
 class SpinTest < UMBaseTest
   def test_spin
     x = nil
@@ -327,16 +401,36 @@ class PeriodicallyTest < UMBaseTest
     rescue Cancel
       cancel = 1
     end
-    20.times { machine.snooze }
-    assert_equal 0, machine.pending_count
+    assert_equal 1, cancel
     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 StatsTest < UMBaseTest
+  def test_op_counts
+    _r, w = IO.pipe
+
+    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.total_op_count
+    machine.write_async(w.fileno, 'foo')
+    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.total_op_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal 1, machine.total_op_count
+
+    machine.write_async(w.fileno, 'foo')
+    assert_equal 1, machine.pending_count
+    assert_equal 2, machine.total_op_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal 2, machine.total_op_count
+  end
+end
+
 class ReadTest < UMBaseTest
   def test_read
     r, w = IO.pipe
@@ -464,6 +558,19 @@ class ReadTest < UMBaseTest
       machine.read(r, [])
     }
   end
+
+  def test_read_with_file_offset
+    fn = "/tmp/#{SecureRandom.hex}"
+    IO.write(fn, 'foobar')
+
+    fd = machine.open(fn, UM::O_RDONLY)
+    buffer = +''
+    result = machine.read(fd, buffer, 100, 0, 2)
+    assert_equal 4, result
+    assert_equal 'obar', buffer
+  ensure
+    machine.close(fd)
+  end
 end
 
 class ReadEachTest < UMBaseTest
@@ -614,11 +721,13 @@ class WriteTest < UMBaseTest
     r, w = IO.pipe
 
     assert_equal 0, machine.pending_count
-    machine.write(w.fileno, 'foo')
+    res = machine.write(w.fileno, 'foo')
+    assert_equal 3, res
     assert_equal 0, machine.pending_count
     assert_equal 'foo', r.readpartial(3)
 
-    machine.write(w.fileno, 'bar', 2)
+    res = machine.write(w.fileno, 'bar', 2)
+    assert_equal 2, res
     assert_equal 'ba', r.readpartial(3)
   end
 
@@ -632,6 +741,24 @@ class WriteTest < UMBaseTest
     assert_equal 0, machine.pending_count
   end
 
+  def test_write_zero_length
+    r, w = IO.pipe
+
+    res = machine.write(w.fileno, '')
+    assert_equal 0, res
+
+    res = machine.write(w.fileno, 'bar', 0)
+    assert_equal 0, res
+
+    buf = IO::Buffer.new(3)
+    buf.set_string('baz')
+    res = machine.write(w.fileno, buf, 0, 0)
+    assert_equal 0, res
+
+    w.close
+    assert_equal '', r.read
+  end
+
   def test_write_io_buffer
     r, w = UM.pipe
 
@@ -679,6 +806,19 @@ class WriteTest < UMBaseTest
       machine.write(w, [])
     }
   end
+
+  def test_write_with_file_offset
+    fn = "/tmp/#{SecureRandom.hex}"
+    IO.write(fn, 'foobar')
+
+    fd = machine.open(fn, UM::O_WRONLY)
+    result = machine.write(fd, 'baz', -1, 2)
+    assert_equal 3, result
+    assert_equal 'fobazr', IO.read(fn)
+  ensure
+    machine.close(fd)
+  end
+
 end
 
 class WriteAsyncTest < UMBaseTest
@@ -689,7 +829,7 @@ class WriteAsyncTest < UMBaseTest
     machine.write_async(w.fileno, 'foo')
     assert_equal 1, machine.pending_count
 
-    machine.snooze
+    machine.snooze while machine.pending_count > 0
     assert_equal 0, machine.pending_count
     assert_equal 'foo', r.readpartial(3)
   end
@@ -705,7 +845,7 @@ class WriteAsyncTest < UMBaseTest
     GC.start
     assert_equal 1, machine.pending_count
 
-    machine.snooze
+    machine.snooze while machine.pending_count > 0
     assert_equal 0, machine.pending_count
     assert_equal "foo#{123}#{'bar' * 48}", r.readpartial(len)
   end
@@ -728,7 +868,7 @@ class WriteAsyncTest < UMBaseTest
     write_buffer.set_string(msg)
 
     machine.write_async(w, write_buffer)
-    3.times { machine.snooze }
+    machine.snooze while machine.pending_count > 0
     machine.close(w)
 
     str = +''
@@ -741,6 +881,32 @@ class WriteAsyncTest < UMBaseTest
 
     assert_raises(UM::Error) { machine.write_async(w, []) }
   end
+
+  def test_write_async_with_len
+    r, w = IO.pipe
+
+    assert_equal 0, machine.pending_count
+    machine.write_async(w.fileno, 'foobar', 4)
+
+    assert_equal 1, machine.pending_count
+    machine.snooze while machine.pending_count > 0
+    assert_equal 0, machine.pending_count
+    assert_equal 'foob', r.readpartial(6)
+  end
+
+  def test_write_async_with_file_offset
+    fn = "/tmp/#{SecureRandom.hex}"
+    IO.write(fn, 'foobar')
+
+    fd = machine.open(fn, UM::O_WRONLY)
+    machine.write_async(fd, 'baz', -1, 2)
+
+    assert_equal 1, machine.pending_count
+    machine.snooze while machine.pending_count > 0
+    assert_equal 'fobazr', IO.read(fn)
+  ensure
+    machine.close(fd)
+  end
 end
 
 class CloseTest < UMBaseTest
@@ -1276,8 +1442,6 @@ end
 
 class SynchronizeTest < UMBaseTest
   def test_synchronize_single
-    skip if !machine.respond_to?(:synchronize)
-
     m = UM::Mutex.new
 
     buf = []
@@ -1293,7 +1457,6 @@ class SynchronizeTest < UMBaseTest
   end
 
   def test_synchronize_pair
-    skip if !machine.respond_to?(:synchronize)
     m = UM::Mutex.new
 
     buf = []
@@ -1348,8 +1511,6 @@ 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)
@@ -1363,8 +1524,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_2
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1395,8 +1554,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_3
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1423,8 +1580,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_4
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1452,8 +1607,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_shift_1
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
 
     machine.push(q, :foo)
@@ -1466,8 +1619,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_shift_shift_1
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
 
     machine.unshift(q, :foo)
@@ -1479,6 +1630,15 @@ class QueueTest < UMBaseTest
     assert_equal :foo, machine.shift(q)
   end
 
+  def test_shift_exception_value
+    q = UM::Queue.new
+    machine.unshift(q, Exception.new("foo"))
+
+    e = machine.shift(q)
+    assert_kind_of Exception, e
+    assert_equal "foo", e.message
+  end
+
   def test_cross_thread_push_shift
     q = UM::Queue.new
 
@@ -1502,6 +1662,42 @@ class QueueTest < UMBaseTest
 
     assert_equal [0, 1, 2], items
   end
+
+  def test_cross_thread_cross_queue_comms
+    worker_queue = UM::Queue.new
+
+    buf = []
+    t1 = Thread.new {
+      m = UM.new
+      (1..10).each {
+        q = UM::Queue.new
+        m.push(worker_queue, [q, it])
+        res = m.shift(q)
+        buf << res
+      }
+    }
+
+    t2 = Thread.new {
+      m = UM.new
+      loop do
+        q, v = m.shift(worker_queue)
+        break if q == :STOP
+
+        res = v * 10
+        m.push(q, res)
+      end
+    }
+
+    t1.join
+    q = UM::Queue.new
+    machine.push(worker_queue, :STOP)
+    t2.join
+
+    assert_equal (1..10).map { it * 10 }, buf
+  ensure
+    t1.kill rescue nil
+    t2.kill rescue nil
+  end
 end
 
 class OpenTest < UMBaseTest
@@ -1646,6 +1842,85 @@ class PollTest < UMBaseTest
   end
 end
 
+class SelectTest < UMBaseTest
+  def test_select
+    rfd1, wfd1 = UM.pipe
+    rfd2, wfd2 = UM.pipe
+
+    events = []
+    machine.spin do
+      events << 1
+      events << machine.select([rfd1, rfd2], [], [])
+      events << 2
+      events << machine.select([rfd1, rfd2], [], [])
+      events << 3
+      machine.snooze
+      events << machine.select([], [wfd1, wfd2], [])
+      events << 4
+    end
+
+    machine.snooze
+    assert_equal [1], events
+
+    machine.write(wfd1, 'foo')
+    machine.snooze
+    assert_equal [1, [[rfd1], [], []], 2], events
+
+    machine.write(wfd2, 'foo')
+
+    machine.snooze
+    assert_equal [1, [[rfd1], [], []], 2, [[rfd1, rfd2], [], []], 3], events
+
+    machine.snooze
+
+    assert_equal [
+      1, [[rfd1], [], []],
+      2, [[rfd1, rfd2], [], []],
+      3, [[], [wfd1, wfd2], []],
+      4
+    ], events
+
+    machine.close(rfd1)
+    machine.close(rfd2)
+  end
+
+  def test_select_single
+    rfd1, wfd1 = UM.pipe
+
+    events = []
+    machine.spin do
+      events << 1
+      events << machine.select([rfd1], [], [])
+      events << 2
+      machine.snooze
+      events << machine.select([], [wfd1], [])
+      events << 3
+    end
+
+    machine.snooze
+    assert_equal [1], events
+
+    machine.write(wfd1, 'foo')
+    machine.snooze
+    assert_equal [1, [[rfd1], [], []], 2], events
+
+    3.times { machine.snooze }
+    assert_equal [1, [[rfd1], [], []], 2, [[], [wfd1], []], 3], events
+
+    machine.close(rfd1)
+    machine.close(wfd1)
+  end
+
+  def test_select_empty
+    ret = machine.select([], [], [])
+    assert_equal [[], [], []], ret
+  end
+
+  def test_select_bad_fd
+    assert_raises(Errno::EBADF) { machine.select([9876, 9877], [], []) }
+  end
+end
+
 class WaitidTest < UMBaseTest
   def test_waitid
     msg = 'hello from child'

data/uringmachine.gemspec

@@ -18,10 +18,10 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.md"]
   s.extensions = ["ext/um/extconf.rb"]
   s.require_paths = ["lib"]
-  s.required_ruby_version = '>= 3.4'
+  s.required_ruby_version = '>= 3.5'
 
-  s.add_development_dependency  'rake-compiler',        '1.2.9'
-  s.add_development_dependency  'minitest',             '5.25.4'
-  s.add_development_dependency  'benchmark-ips',        '2.14.0'
-  s.add_development_dependency  'http_parser.rb',       '0.8.0'
+  s.add_development_dependency  'rake-compiler',        '~>1.3.0'
+  s.add_development_dependency  'minitest',             '~>5.26.2'
+  s.add_development_dependency  'benchmark-ips',        '~>2.14.0'
+  s.add_development_dependency  'http_parser.rb',       '~>0.8.0'
 end

data/vendor/liburing/src/include/liburing/io_uring.h

@@ -966,6 +966,7 @@ enum io_uring_socket_op {
 	SOCKET_URING_OP_GETSOCKOPT,
 	SOCKET_URING_OP_SETSOCKOPT,
 	SOCKET_URING_OP_TX_TIMESTAMP,
+	SOCKET_URING_OP_GETSOCKNAME,
 };
 
 /*

data/vendor/liburing/src/include/liburing.h

@@ -1572,6 +1572,19 @@ IOURINGINLINE void io_uring_prep_cmd_sock(struct io_uring_sqe *sqe,
 	sqe->level = level;
 }
 
+IOURINGINLINE void io_uring_prep_cmd_getsockname(struct io_uring_sqe *sqe,
+						 int fd, struct sockaddr *sockaddr,
+						 socklen_t *sockaddr_len,
+						 int peer)
+	LIBURING_NOEXCEPT
+{
+	io_uring_prep_uring_cmd(sqe, SOCKET_URING_OP_GETSOCKNAME, fd);
+
+	sqe->addr = (uintptr_t) sockaddr;
+	sqe->addr3 = (unsigned long) (uintptr_t) sockaddr_len;
+	sqe->optlen = peer;
+}
+
 IOURINGINLINE void io_uring_prep_waitid(struct io_uring_sqe *sqe,
 					idtype_t idtype,
 					id_t id,

data/vendor/liburing/src/liburing-ffi.map

@@ -258,4 +258,5 @@ LIBURING_2.13 {
 		io_uring_prep_uring_cmd;
 		io_uring_prep_uring_cmd128;
 		io_uring_get_sqe128;
+		io_uring_prep_cmd_getsockname;
 } LIBURING_2.12;