polyphony 0.45.5 → 0.46.0

data/lib/polyphony/adapters/trace.rb

@@ -118,13 +118,13 @@ module Polyphony
 
         ALL_FIBER_EVENTS = %i[
           fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
-          fiber_ev_loop_enter fiber_ev_loop_leave
+          fiber_event_poll_enter fiber_event_poll_leave
         ].freeze
 
         def event_masks(events)
           events.each_with_object([[], []]) do |e, masks|
             case e
-            when /fiber_/
+            when /^fiber_/
               masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
               masks[0] << :c_return unless masks[0].include?(:c_return)
             else

data/lib/polyphony/core/global_api.rb

@@ -107,10 +107,7 @@ module Polyphony
     end
 
     def sleep_forever
-      Thread.current.backend.ref
-      loop { sleep 60 }
-    ensure
-      Thread.current.backend.unref
+      Thread.current.backend.wait_event(true)
     end
 
     def throttled_loop(rate = nil, **opts, &block)

data/lib/polyphony/extensions/debug.rb

@@ -0,0 +1,13 @@
+module ::Kernel
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.size > 1 && args.first.is_a?(String)
+      format("%s: %p\n", args.shift, args.size == 1 ? args.first : args)
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+end

data/lib/polyphony/extensions/fiber.rb

@@ -175,9 +175,9 @@ module Polyphony
       f = Fiber.new do
         block.call
       rescue Exception => e
-        Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, e)
+        Thread.current.schedule_and_wakeup(Thread.main.main_fiber, e)
       end
-      Thread.current.break_out_of_ev_loop(f, nil)
+      Thread.current.schedule_and_wakeup(f, nil)
     end
   end
 

data/lib/polyphony/extensions/socket.rb

@@ -19,16 +19,21 @@ class ::Socket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    outbuf ||= +''
-    loop do
-      result = recv_nonblock(maxlen, flags, outbuf, **NO_EXCEPTION)
-      case result
-      when nil then raise IOError
-      when :wait_readable then Thread.current.backend.wait_io(self, false)
-      else
-        return result
-      end
-    end
+    Thread.current.backend.recv(self, buf || +'', maxlen)
+    # outbuf ||= +''
+    # loop do
+    #   result = recv_nonblock(maxlen, flags, outbuf, **NO_EXCEPTION)
+    #   case result
+    #   when nil then raise IOError
+    #   when :wait_readable then Thread.current.backend.wait_io(self, false)
+    #   else
+    #     return result
+    #   end
+    # end
+  end
+
+  def recv_loop(&block)
+    Thread.current.backend.recv_loop(self, &block)
   end
 
   def recvfrom(maxlen, flags = 0)
@@ -44,6 +49,19 @@ class ::Socket
     end
   end
 
+  def send(mesg, flags = 0)
+    Thread.current.backend.send(self, mesg)
+  end
+
+  def write(str)
+    Thread.current.backend.send(self, str)
+  end
+  alias_method :<<, :write
+
+  def readpartial(maxlen, str = +'')
+    Thread.current.backend.recv(self, str, maxlen)
+  end
+
   ZERO_LINGER = [0, 0].pack('ii').freeze
 
   def dont_linger
@@ -120,6 +138,37 @@ class ::TCPSocket
     setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, 1)
   end
 
+  def recv(maxlen, flags = 0, outbuf = nil)
+    Thread.current.backend.recv(self, buf || +'', maxlen)
+  end
+
+  def recv_loop(&block)
+    Thread.current.backend.recv_loop(self, &block)
+  end
+
+  def send(mesg, flags = 0)
+    Thread.current.backend.send(self, mesg)
+  end
+
+  def write(str)
+    Thread.current.backend.send(self, str)
+  end
+  alias_method :<<, :write
+
+  def readpartial(maxlen, str = nil)
+    @read_buffer ||= +''
+    result = Thread.current.backend.recv(self, @read_buffer, maxlen)
+    raise EOFError unless result
+
+    if str
+      str << @read_buffer
+    else
+      str = @read_buffer
+    end
+    @read_buffer = +''
+    str
+  end
+
   def read_nonblock(len, str = nil, exception: true)
     @io.read_nonblock(len, str, exception: exception)
   end

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.45.5'
+  VERSION = '0.46.0'
 end

data/test/helper.rb

@@ -22,29 +22,52 @@ class ::Fiber
   attr_writer :auto_watcher
 end
 
+module ::Kernel
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+end
+
 class MiniTest::Test
   def setup
-    # puts "* setup #{self.name}"
+    # trace "* setup #{self.name}"
     if Fiber.current.children.size > 0
       puts "Children left: #{Fiber.current.children.inspect}"
       exit!
     end
     Fiber.current.setup_main_fiber
     Fiber.current.instance_variable_set(:@auto_watcher, nil)
+    Thread.current.backend.finalize
     Thread.current.backend = Polyphony::Backend.new
-    sleep 0 # apparently this helps with timer accuracy
+    sleep 0
   end
 
   def teardown
-    # puts "* teardown #{self.name.inspect} Fiber.current: #{Fiber.current.inspect}"
+    # trace "* teardown #{self.name}"
     Fiber.current.terminate_all_children
     Fiber.current.await_all_children
-    Fiber.current.auto_watcher = nil
+    Fiber.current.instance_variable_set(:@auto_watcher, nil)
   rescue => e
     puts e
     puts e.backtrace.join("\n")
     exit!
   end
+
+  def fiber_tree(fiber)
+    { fiber: fiber, children: fiber.children.map { |f| fiber_tree(f) } }
+  end
 end
 
 module Kernel
@@ -54,3 +77,12 @@ module Kernel
     e
   end
 end
+
+module Minitest::Assertions
+  def assert_in_range exp_range, act
+    msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
+    assert exp_range.include?(act), msg
+  end
+end
+
+puts "Polyphony backend: #{Thread.current.backend.kind}"

data/test/io_uring_test.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+::Exception.__disable_sanitized_backtrace__ = true
+
+module ::Kernel
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+end
+
+i, o = IO.pipe
+
+buf = []
+f = spin do
+  buf << :ready
+  # loop do
+  #   s = Thread.current.backend.read(i, +'', 6, false)
+  #   trace read_result: s
+  #   break if s.nil?
+  #   buf << s
+  # rescue Exception => e
+  #   trace exception: e
+  #   raise e
+  # end
+  Thread.current.backend.read_loop(i) { |d| buf << d }
+  buf << :done
+end
+
+# writing always causes snoozing
+o << 'foo'
+o << 'bar'
+trace '...closing'
+o.close
+trace '...closed'
+
+f.await
+
+raise "Bad result: #{buf.inspect}" unless buf == [:ready, 'foo', 'bar', :done]
+
+puts '-' * 80
+p buf

data/test/stress.rb

@@ -2,10 +2,11 @@
 
 count = ARGV[0] ? ARGV[0].to_i : 100
 
-TEST_CMD = 'ruby test/run.rb'
+TEST_CMD = 'ruby test/test_backend.rb' #'ruby test/run.rb'
 
 def run_test(count)
   puts "#{count}: running tests..."
+  # sleep 1
   system(TEST_CMD)
   return if $?.exitstatus == 0
 
@@ -15,7 +16,9 @@ end
 
 trap('INT') { exit! }
 t0 = Time.now
-count.times { |i| run_test(i + 1) }
+count.times do |i|
+  run_test(i + 1)
+end
 elapsed = Time.now - t0
 puts format(
   "Successfully ran %d tests in %f seconds (%f per test)",

data/test/test_backend.rb

@@ -85,7 +85,7 @@ class BackendTest < MiniTest::Test
     i, o = IO.pipe
 
     buf = []
-    spin do
+    f = spin do
       buf << :ready
       @backend.read_loop(i) { |d| buf << d }
       buf << :done
@@ -96,9 +96,7 @@ class BackendTest < MiniTest::Test
     o << 'bar'
     o.close
 
-    # read_loop will snooze after every read
-    6.times { snooze }
-
+    f.await
     assert_equal [:ready, 'foo', 'bar', :done], buf
   end
 
@@ -111,12 +109,12 @@ class BackendTest < MiniTest::Test
     end
 
     c1 = TCPSocket.new('127.0.0.1', 1234)
-    10.times { snooze }
+    sleep 0.01
 
     assert_equal 1, clients.size
 
     c2 = TCPSocket.new('127.0.0.1', 1234)
-    10.times { snooze }
+    sleep 0.01
 
     assert_equal 2, clients.size
 

data/test/test_ext.rb

@@ -183,8 +183,7 @@ class TimeoutTest < MiniTest::Test
   end
 
   def test_that_timeout_method_accepts_custom_error_class_and_message
-    buffer = []
-    spin { 3.times { |i| buffer << i; snooze } }
+    e = nil
     begin
       Timeout.timeout(0.05, MyTimeout, 'foo') { sleep 1 }
     rescue Exception => e

data/test/test_fiber.rb

@@ -62,7 +62,7 @@ class FiberTest < MiniTest::Test
     assert_equal 0, Fiber.current.children.size
   end
 
-  def test_await_from_multiple_fibers_with_interruption
+  def test_await_from_multiple_fibers_with_interruption=
     buffer = []
     f1 = spin {
       sleep 0.02
@@ -128,15 +128,16 @@ class FiberTest < MiniTest::Test
     worker&.join
   end
 
-  def test_ev_loop_anti_starve_mechanism
-    async = Polyphony::Event.new
+  def test_backend_wakeup_mechanism
+    event = Polyphony::Event.new
+
     t = Thread.new do
       f = spin_loop { snooze }
       sleep 0.001
-      async.signal(:foo)
+      event.signal(:foo)
     end
 
-    result = move_on_after(1) { async.await }
+    result = move_on_after(1) { event.await }
 
     assert_equal :foo, result
   ensure
@@ -469,12 +470,14 @@ class FiberTest < MiniTest::Test
       end
       snooze # allow nested fiber to run before finishing
     end
-    suspend
-  rescue Exception => e
-    raised_error = e
-  ensure
-    assert raised_error
-    assert_equal 'foo', raised_error.message
+    begin
+      suspend
+    rescue Exception => e
+      raised_error = e
+    ensure
+      assert raised_error
+      assert_equal 'foo', raised_error.message
+    end
   end
 
   def test_await_multiple_fibers
@@ -631,11 +634,12 @@ class FiberTest < MiniTest::Test
   def test_signal_handling_int
     i, o = IO.pipe
     pid = Polyphony.fork do
-      f = spin { sleep 100 }
+      f = spin { sleep 3 }
       begin
         i.close
         f.await
       rescue Exception => e
+        trace e
         o << e.class.name
         o.close
       end
@@ -653,7 +657,7 @@ class FiberTest < MiniTest::Test
   def test_signal_handling_term
     i, o = IO.pipe
     pid = Polyphony.fork do
-      f = spin { sleep 100 }
+      f = spin { sleep 3 }
       begin
         i.close
         f.await
@@ -662,7 +666,7 @@ class FiberTest < MiniTest::Test
         o.close
       end
     end
-    sleep 0.2
+    sleep 0.1
     f = spin { Thread.current.backend.waitpid(pid) }
     o.close
     Process.kill('TERM', pid)
@@ -677,7 +681,7 @@ class FiberTest < MiniTest::Test
     pid = Polyphony.fork do
       i.close
       spin do
-        sleep 100
+        sleep 3
       rescue Exception => e
         o << e.class.to_s
         o.close
@@ -687,7 +691,7 @@ class FiberTest < MiniTest::Test
     end
     o.close
     spin do
-      sleep 0.2
+      sleep 0.1
       Process.kill('TERM', pid)
     end
     Thread.current.backend.waitpid(pid)
@@ -703,6 +707,7 @@ class FiberTest < MiniTest::Test
     assert_nil f.thread
     snooze
     f.setup_raw
+
     assert_equal Thread.current, f.thread
     assert_nil f.parent
 
@@ -711,6 +716,7 @@ class FiberTest < MiniTest::Test
     f << 'bar'
     snooze
     assert_equal ['bar'], buffer
+    snooze
   end
 end