polyphony 1.4 → 1.6

data/test/test_open3.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+# Adapted from: https://github.com/ruby/open3/blob/master/test/test_open3.rb
+
+require_relative 'open3/envutil'
+
+class TestOpen3 < MiniTest::Test
+  RUBY = EnvUtil.rubybin
+
+  def test_exit_status
+    Open3.popen3(RUBY, '-e', 'exit true') {|i,o,e,t|
+      assert_equal(true, t.value.success?)
+    }
+    Open3.popen3(RUBY, '-e', 'exit false') {|i,o,e,t|
+      assert_equal(false, t.value.success?)
+    }
+  end
+
+  def test_stdin
+    Open3.popen3(RUBY, '-e', 'exit STDIN.gets.chomp == "t"') {|i,o,e,t|
+      i.puts 't'
+      assert_equal(true, t.value.success?)
+    }
+    Open3.popen3(RUBY, '-e', 'exit STDIN.gets.chomp == "t"') {|i,o,e,t|
+      i.puts 'f'
+      assert_equal(false, t.value.success?)
+    }
+  end
+
+  def test_stdout
+    Open3.popen3(RUBY, '-e', 'STDOUT.print "foo"') {|i,o,e,t|
+      assert_equal("foo", o.read)
+    }
+  end
+
+  def test_stderr
+    Open3.popen3(RUBY, '-e', 'STDERR.print "bar"') {|i,o,e,t|
+      assert_equal("bar", e.read)
+    }
+  end
+
+  def test_block
+    r = Open3.popen3(RUBY, '-e', 'STDOUT.print STDIN.read') {|i,o,e,t|
+      i.print "baz"
+      i.close
+      assert_equal("baz", o.read)
+      "qux"
+    }
+    assert_equal("qux", r)
+  end
+
+  def test_noblock
+    i,o,e,t = Open3.popen3(RUBY, '-e', 'STDOUT.print STDIN.read')
+    i.print "baz"
+    i.close
+    assert_equal("baz", o.read)
+  ensure
+    i.close
+    o.close
+    e.close
+    t.join
+  end
+
+  def test_commandline
+    commandline = "echo quux\n"
+    Open3.popen3(commandline) {|i,o,e,t|
+      assert_equal("quux\n", o.read)
+    }
+  end
+
+  def test_pid
+    Open3.popen3(RUBY, '-e', 'print $$') {|i,o,e,t|
+      pid = o.read.to_i
+      # assert_equal(pid, t[:pid])
+      assert_equal(pid, t.pid)
+    }
+  end
+
+  def test_env
+    Open3.popen3({'A' => 'B', 'C' => 'D'}, RUBY, '-e' 'p ENV["A"]') do |i, out, err, thr|
+      output = out.read
+      assert_equal("\"B\"\n", output)
+    end
+  end
+
+  def test_numeric_file_descriptor2
+    with_pipe {|r, w|
+      Open3.popen2(RUBY, '-e', 'STDERR.puts "foo"', 2 => w) {|i,o,t|
+        assert_equal("foo\n", r.gets)
+      }
+    }
+  end
+
+  def test_numeric_file_descriptor3
+    omit "passing FDs bigger than 2 is not supported on Windows" if /mswin|mingw/ =~ RbConfig::CONFIG['host_os']
+    with_pipe {|r, w|
+      Open3.popen3(RUBY, '-e', 'IO.open(3).puts "foo"', 3 => w) {|i,o,e,t|
+        assert_equal("foo\n", r.gets, "[GH-808] [ruby-core:67347] [Bug #10699]")
+      }
+    }
+  end
+
+  def with_pipe
+    r, w = IO.pipe
+    yield r, w
+  ensure
+    r.close
+    w.close
+  end
+
+  def with_reopen(io, arg)
+    old = io.dup
+    io.reopen(arg)
+    yield old
+  ensure
+    io.reopen(old)
+    old.close
+  end
+
+  def test_popen2
+    with_pipe {|r, w|
+      with_reopen(STDERR, w) {|old|
+        w.close
+        Open3.popen2(RUBY, '-e', 's=STDIN.read; STDOUT.print s+"o"; STDERR.print s+"e"') {|i,o,t|
+          assert_kind_of(Fiber, t)
+          i.print "z"
+          i.close
+          STDERR.reopen(old)
+          assert_equal("zo", o.read)
+          assert_equal("ze", r.read)
+        }
+      }
+    }
+  end
+
+  def test_popen2e
+    with_pipe {|r, w|
+      with_reopen(STDERR, w) {|old|
+        w.close
+        Open3.popen2e(RUBY, '-e', 's=STDIN.read; STDOUT.print s+"o"; STDOUT.flush; STDERR.print s+"e"') {|i,o,t|
+          assert_kind_of(Fiber, t)
+          i.print "y"
+          i.close
+          STDERR.reopen(old)
+          assert_equal("yoye", o.read)
+          assert_equal("", r.read)
+        }
+      }
+    }
+  end
+
+  def test_popen2e_noblock
+    i, o, t = Open3.popen2e(RUBY, '-e', 'STDOUT.print STDIN.read')
+    i.print "baz"
+    i.close
+    assert_equal("baz", o.read)
+  ensure
+    i.close
+    o.close
+    t.join
+  end
+
+  def test_capture3
+    o, e, s = Open3.capture3(RUBY, '-e', 'i=STDIN.read; print i+"o"; STDOUT.flush; STDERR.print i+"e"', :stdin_data=>"i")
+    assert_equal("io", o)
+    assert_equal("ie", e)
+    assert(s.success?)
+  end
+
+  def test_capture3_stdin_data_io
+    IO.pipe {|r, w|
+      w.write "i"
+      w.close
+      o, e, s = Open3.capture3(RUBY, '-e', 'i=STDIN.read; print i+"o"; STDOUT.flush; STDERR.print i+"e"', :stdin_data=>r)
+      assert_equal("io", o)
+      assert_equal("ie", e)
+      assert(s.success?)
+    }
+  end
+
+  def test_capture3_flip
+    o, e, s = Open3.capture3(RUBY, '-e', 'STDOUT.sync=true; 1000.times { print "o"*1000; STDERR.print "e"*1000 }')
+    assert_equal("o"*1000000, o)
+    assert_equal("e"*1000000, e)
+    assert(s.success?)
+  end
+
+  def test_capture2
+    o, s = Open3.capture2(RUBY, '-e', 'i=STDIN.read; print i+"o"', :stdin_data=>"i")
+    assert_equal("io", o)
+    assert(s.success?)
+  end
+
+  def test_capture2_stdin_data_io
+    IO.pipe {|r, w|
+      w.write "i"
+      w.close
+      o, s = Open3.capture2(RUBY, '-e', 'i=STDIN.read; print i+"o"', :stdin_data=>r)
+      assert_equal("io", o)
+      assert(s.success?)
+    }
+  end
+
+  def test_capture2e
+    oe, s = Open3.capture2e(RUBY, '-e', 'i=STDIN.read; print i+"o"; STDOUT.flush; STDERR.print i+"e"', :stdin_data=>"i")
+    assert_equal("ioie", oe)
+    assert(s.success?)
+  end
+
+  def test_capture2e_stdin_data_io
+    IO.pipe {|r, w|
+      w.write "i"
+      w.close
+      oe, s = Open3.capture2e(RUBY, '-e', 'i=STDIN.read; print i+"o"; STDOUT.flush; STDERR.print i+"e"', :stdin_data=>r)
+      assert_equal("ioie", oe)
+      assert(s.success?)
+    }
+  end
+
+  def test_capture3_stdin_data
+    o, e, s = Open3.capture3(RUBY, '-e', '', :stdin_data=>"z"*(1024*1024))
+    assert_equal("", o)
+    assert_equal("", e)
+    assert(s.success?)
+  end
+
+  def test_capture2_stdin_data
+    o, s = Open3.capture2(RUBY, '-e', '', :stdin_data=>"z"*(1024*1024))
+    assert_equal("", o)
+    assert(s.success?)
+  end
+
+  def test_capture2e_stdin_data
+    oe, s = Open3.capture2e(RUBY, '-e', '', :stdin_data=>"z"*(1024*1024))
+    assert_equal("", oe)
+    assert(s.success?)
+  end
+
+  def test_pipeline_rw
+    Open3.pipeline_rw([RUBY, '-e', 'print STDIN.read + "1"'],
+                      [RUBY, '-e', 'print STDIN.read + "2"']) {|i,o,ts|
+      assert_kind_of(IO, i)
+      assert_kind_of(IO, o)
+      assert_kind_of(Array, ts)
+      assert_equal(2, ts.length)
+      ts.each {|t| assert_kind_of(Fiber, t) }
+      i.print "0"
+      i.close
+      assert_equal("012", o.read)
+      ts.each {|t|
+        assert(t.value.success?)
+      }
+    }
+  end
+
+  def test_pipeline_r
+    Open3.pipeline_r([RUBY, '-e', 'print "1"'],
+                     [RUBY, '-e', 'print STDIN.read + "2"']) {|o,ts|
+      assert_kind_of(IO, o)
+      assert_kind_of(Array, ts)
+      assert_equal(2, ts.length)
+      ts.each {|t| assert_kind_of(Fiber, t) }
+      assert_equal("12", o.read)
+      ts.each {|t|
+        assert(t.value.success?)
+      }
+    }
+  end
+
+  def test_pipeline_w
+    command = [RUBY, '-e', 's=STDIN.read; print s[1..-1]; exit s[0] == ?t']
+    str = 'ttftff'
+    Open3.pipeline_w(*[command]*str.length) {|i,ts|
+      assert_kind_of(IO, i)
+      assert_kind_of(Array, ts)
+      assert_equal(str.length, ts.length)
+      ts.each {|t| assert_kind_of(Fiber, t) }
+      i.print str
+      i.close
+      ts.each_with_index {|t, ii|
+        assert_equal(str[ii] == ?t, t.value.success?)
+      }
+    }
+  end
+
+  def test_pipeline_start
+    command = [RUBY, '-e', 's=STDIN.read; print s[1..-1]; exit s[0] == ?t']
+    str = 'ttftff'
+    Open3.pipeline_start([RUBY, '-e', 'print ARGV[0]', str],
+                         *([command]*str.length)) {|ts|
+      assert_kind_of(Array, ts)
+      assert_equal(str.length+1, ts.length)
+      ts.each {|t| assert_kind_of(Fiber, t) }
+      ts.each_with_index {|t, i|
+        if i == 0
+          assert(t.value.success?)
+        else
+          assert_equal(str[i-1] == ?t, t.value.success?)
+        end
+      }
+    }
+  end
+
+  def test_pipeline_start_noblock
+    ts = Open3.pipeline_start([RUBY, '-e', ''])
+    assert_kind_of(Array, ts)
+    assert_equal(1, ts.length)
+    ts.each {|t| assert_kind_of(Fiber, t) }
+    t = ts[0]
+    assert(t.value.success?)
+  end
+
+  def test_pipeline
+    command = [RUBY, '-e', 's=STDIN.read; print s[1..-1]; exit s[0] == ?t']
+    str = 'ttftff'
+    ss = Open3.pipeline([RUBY, '-e', 'print ARGV[0]', str],
+                        *([command]*str.length))
+    assert_kind_of(Array, ss)
+    assert_equal(str.length+1, ss.length)
+    ss.each {|s| assert_kind_of(Process::Status, s) }
+    ss.each_with_index {|s, i|
+      if i == 0
+        assert(s.success?)
+      else
+        assert_equal(str[i-1] == ?t, s.success?)
+      end
+    }
+  end
+
+  def test_integer_and_symbol_key
+    command = [RUBY, '-e', 'puts "test_integer_and_symbol_key"']
+    out, status = Open3.capture2(*command, :chdir => '.', 2 => IO::NULL)
+    assert_equal("test_integer_and_symbol_key\n", out)
+    assert_predicate(status, :success?)
+  end
+end

data/test/test_signal.rb

@@ -4,10 +4,14 @@ require_relative 'helper'
 
 class SignalTrapTest < Minitest::Test
   def test_signal_handler_trace
+    skip # tracing system to be overhauled
+
     if Thread.current.backend.kind != :io_uring
       skip "Skipping signal handler trace because Backend_close on libev behaves differently"
     end
 
+    skip
+
     i1, o1 = IO.pipe
     i2, o2 = IO.pipe
     pid = Process.pid
@@ -86,10 +90,10 @@ class SignalTrapTest < Minitest::Test
   def test_signal_exception_handling
     i, o = IO.pipe
     pid = Polyphony.fork do
-      i.close
       sleep 5
     rescue ::Interrupt => e
       o.puts "3-interrupt"
+      o.flush
     ensure
       o.close
     end

data/test/test_socket.rb

@@ -41,9 +41,12 @@ class TCPSocketTest < MiniTest::Test
     client = TCPSocket.open('ipinfo.io', 80)
     client.write("GET / HTTP/1.0\r\nHost: ipinfo.io\r\n\r\n")
     result = nil
-    move_on_after(3) {
-      result = client.read
-    }
+    3.times do
+      move_on_after(3) {
+        result = client.read
+      }
+      break if result
+    end
     assert result =~ /HTTP\/1.0 200 OK/
   end
 
@@ -390,98 +393,3 @@ class SSLSocketTest < MiniTest::Test
     assert_kind_of OpenSSL::SSL::SSLError, errors.first
   end
 end
-
-class MultishotAcceptTest < MiniTest::Test
-  def setup
-    skip if !TCPServer.instance_methods(false).include?(:multishot_accept)
-  end
-
-  def start_tcp_server_on_random_port(host = '127.0.0.1')
-    port = rand(1100..60000)
-    server = TCPServer.new(host, port)
-    [port, server]
-  rescue Errno::EADDRINUSE
-    retry
-  end
-
-  def test_multishot_accept_while_loop
-    port, server = start_tcp_server_on_random_port
-    server_fiber = spin do
-      server.multishot_accept do
-        while (socket = server.accept)
-          spin do
-            while (data = socket.gets(8192))
-              socket << data
-            end
-          end
-        end
-      end
-    end
-
-    snooze
-    client = TCPSocket.new('127.0.0.1', port)
-    client.write("1234\n")
-    assert_equal "1234\n", client.recv(8192)
-    client.close
-
-    client = TCPSocket.new('127.0.0.1', port)
-    client.write("5678\n")
-    assert_equal "5678\n", client.recv(8192)
-    client.close
-
-  ensure
-    server_fiber&.stop
-    server_fiber&.await
-    server&.close
-  end
-
-  def spin_client(socket)
-    spin do
-      while (data = socket.gets(8192))
-        socket << data
-      end
-    end
-  end
-
-  def test_multishot_accept_loop
-    port, server = start_tcp_server_on_random_port
-    server_fiber = spin do
-      server.multishot_accept do
-        server.accept_loop { |s| spin_client(s) }
-      end
-    end
-
-    snooze
-    client = TCPSocket.new('127.0.0.1', port)
-    client.write("1234\n")
-    assert_equal "1234\n", client.recv(8192)
-    client.close
-
-    client = TCPSocket.new('127.0.0.1', port)
-    client.write("5678\n")
-    assert_equal "5678\n", client.recv(8192)
-    client.close
-
-  ensure
-    server_fiber&.stop
-    server_fiber&.await
-    server&.close
-  end
-
-  def test_multishot_accept_error
-    port, server = start_tcp_server_on_random_port
-    error = nil
-    server_fiber = spin do
-      server.multishot_accept do
-        server.accept_loop { |s| spin_client(s) }
-      rescue SystemCallError => e
-        error = e
-      end
-    end
-    snooze
-    server.close
-    snooze
-    server_fiber.await
-    assert_kind_of Errno::EBADF, error
-  end
-end

data/test/test_sync.rb

@@ -155,3 +155,49 @@ class MutexTest < MiniTest::Test
     assert_equal true, r
   end
 end
+
+class MonitorTest < MiniTest::Test
+  def test_monitor
+    m = Monitor.new
+
+    assert_kind_of Polyphony::Monitor, m
+  end
+
+  def safe_check_owner(m)
+    m.mon_check_owner
+    true
+  rescue ThreadError
+    false
+  end
+
+  def test_monitor_mon_check_owner
+    m = Monitor.new
+
+    assert_equal false, safe_check_owner(m)
+    
+    m.enter
+    assert_equal true, safe_check_owner(m)
+
+    spin do
+      assert_equal false, safe_check_owner(m)
+    end.join
+  end
+
+  def test_monitor_reentrancy
+    m = Monitor.new
+
+    assert_equal false, safe_check_owner(m)
+
+    m.enter
+    assert_equal true, safe_check_owner(m)
+
+    m.enter
+    assert_equal true, safe_check_owner(m)
+
+    m.exit
+    assert_equal true, safe_check_owner(m)
+
+    m.exit
+    assert_equal false, safe_check_owner(m)
+  end
+end

data/test/test_thread.rb

@@ -60,7 +60,7 @@ class ThreadTest < MiniTest::Test
   def test_thread_await_alias_method
     buffer = []
     spin { (1..3).each { |i| snooze; buffer << i } }
-    t = Thread.new { sleep 0.01; buffer << 4; :foo }
+    t = Thread.new { sleep 0.1; buffer << 4; :foo }
     r = t.await
     t = nil
 
@@ -241,4 +241,13 @@ class ThreadTest < MiniTest::Test
     t.join
     assert_equal [1, 2, 3], buf
   end
+
+  def test_value
+    t = Thread.new { sleep 0.01; :foo }
+    assert_equal :foo, t.value
+
+    t = Thread.new { sleep 0.01; raise 'foo' }
+    assert_raises { t.value }
+    assert !t.alive?
+  end
 end

data/test/test_thread_pool.rb

@@ -8,6 +8,11 @@ class ThreadPoolTest < MiniTest::Test
     @pool = Polyphony::ThreadPool.new
   end
 
+  def teardown
+    @pool.stop
+    super
+  end
+
   def test_process
     current_thread = Thread.current
 

data/test/test_throttler.rb

@@ -30,7 +30,7 @@ class ThrottlerTest < MiniTest::Test
     f = spin { loop { t.process { buffer << 1 } } }
     sleep 0.02
     f.stop
-    assert_in_range 2..4, buffer.size if IS_LINUX
+    assert_in_range 1..4, buffer.size if IS_LINUX
   end
 
   def test_throttler_with_invalid_argument

data/test/test_timer.rb

@@ -4,11 +4,13 @@ require_relative 'helper'
 
 class TimerMoveOnAfterTest < MiniTest::Test
   def setup
+    super
     @timer = Polyphony::Timer.new(resolution: 0.01)
   end
 
   def teardown
     @timer.stop
+    super
   end
 
   def test_timer_move_on_after
@@ -56,11 +58,13 @@ end
 
 class TimerCancelAfterTest < MiniTest::Test
   def setup
+    super
     @timer = Polyphony::Timer.new(resolution: 0.01)
   end
 
   def teardown
     @timer.stop
+    super
   end
 
   def test_timer_cancel_after
@@ -134,21 +138,23 @@ end
 
 class TimerMiscTest < MiniTest::Test
   def setup
+    super
     @timer = Polyphony::Timer.new(resolution: 0.001)
     sleep 0
   end
 
   def teardown
     @timer.stop
+    super
   end
 
   def test_timer_after
     buffer = []
-    f = @timer.after(0.01) { buffer << 2 }
+    f = @timer.after(0.1) { buffer << 2 }
     assert_kind_of Fiber, f
     snooze
     assert_equal [], buffer
-    sleep 0.1
+    sleep 0.2
     assert_equal [2], buffer
   end
 

data/test/test_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+__END__
+
 require_relative 'helper'
 require 'polyphony/core/debug'
 

data/vendor/liburing/.github/workflows/build.yml

@@ -85,6 +85,13 @@ jobs:
             cc: mips-linux-gnu-gcc
             cxx: mips-linux-gnu-g++
 
+          # hppa
+          - arch: hppa
+            cc_pkg: gcc-hppa-linux-gnu
+            cxx_pkg: g++-hppa-linux-gnu
+            cc: hppa-linux-gnu-gcc
+            cxx: hppa-linux-gnu-g++
+
     env:
       FLAGS: -g -O3 -Wall -Wextra -Werror -Wno-sign-compare ${{matrix.extra_flags}}
 
@@ -99,6 +106,7 @@ jobs:
       run: |
         if [[ "${{matrix.cc_pkg}}" == "clang" ]]; then \
             wget https://apt.llvm.org/llvm.sh -O /tmp/llvm.sh; \
+            sudo apt-get purge --auto-remove llvm python3-lldb-14 llvm-14 -y; \
             sudo bash /tmp/llvm.sh 17; \
             sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-17 400; \
             sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-17 400; \

data/vendor/liburing/.gitignore

@@ -22,6 +22,7 @@
 /examples/ucontext-cp
 /examples/poll-bench
 /examples/send-zerocopy
+/examples/rsrc-update-bench
 
 /test/*.t
 /test/*.dmesg

data/vendor/liburing/CHANGELOG

@@ -8,6 +8,14 @@ liburing-2.4 release
 - CONFIG_NOLIBC is always enabled on x86-64, x86, and aarch64.
 - Add support for IORING_REGISTER_USE_REGISTERED_RING and use if available.
 - Add io_uring_close_ring_fd() function.
+- Add io_uring_prep_msg_ring_fd_alloc function.
+- Add io_uring_free_buf_ring() and io_uring_setup_buf_ring() functions.
+- Ensure that io_uring_prep_accept_direct(), io_uring_prep_openat_direct(),
+  io_uring_prep_openat2_direct(), io_uring_prep_msg_ring_fd(), and
+  io_uring_prep_socket_direct() factor in being called with
+  IORING_FILE_INDEX_ALLOC for allocating a direct descriptor.
+- Add io_uring_prep_sendto() function.
+- Add io_uring_prep_cmd_sock() function.
 
 liburing-2.3 release