polyphony 0.45.1 → 0.46.1

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.required_ruby_version = '>= 2.6'
 
-  s.add_development_dependency  'rake-compiler',        '1.0.5'
+  s.add_development_dependency  'rake-compiler',        '1.1.1'
   s.add_development_dependency  'minitest',             '5.13.0'
   s.add_development_dependency  'minitest-reporters',   '1.4.2'
   s.add_development_dependency  'simplecov',            '0.17.1'

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

@@ -6,6 +6,7 @@ TEST_CMD = '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
 
@@ -127,4 +125,15 @@ class BackendTest < MiniTest::Test
     snooze
     server&.close
   end
+
+  def test_timer_loop
+    i = 0
+    f = spin do
+      @backend.timer_loop(0.01) { i += 1 }
+    end
+    @backend.sleep(0.05)
+    f.stop
+    f.await # TODO: check why this test sometimes segfaults if we don't a<wait fiber
+    assert_in_range 4..6, i
+  end
 end

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)
@@ -700,16 +704,19 @@ class FiberTest < MiniTest::Test
     buffer = []
     f = Fiber.new { buffer << receive }
     
-    assert_raises(NoMethodError) { f << 'foo' }
+    assert_nil f.thread
     snooze
     f.setup_raw
+
     assert_equal Thread.current, f.thread
     assert_nil f.parent
 
     f.schedule
+    snooze
     f << 'bar'
-    2.times { snooze }
+    snooze
     assert_equal ['bar'], buffer
+    snooze
   end
 end
 
@@ -811,20 +818,20 @@ class MailboxTest < MiniTest::Test
     assert_equal ['foo'] * 100, messages
   end
 
-  def test_receive_pending
-    assert_equal [], receive_pending
+  def test_receive_all_pending
+    assert_equal [], receive_all_pending
 
     (1..5).each { |i| Fiber.current << i }
-    assert_equal (1..5).to_a, receive_pending
-    assert_equal [], receive_pending
+    assert_equal (1..5).to_a, receive_all_pending
+    assert_equal [], receive_all_pending
   end
 
-  def test_receive_pending_on_termination
+  def test_receive_all_pending_on_termination
     buffer = []
     worker = spin do
       loop { buffer << receive }
     rescue Polyphony::Terminate
-      receive_pending.each { |r| buffer << r }
+      receive_all_pending.each { |r| buffer << r }
     end
 
     worker << 1

data/test/test_global_api.rb

@@ -72,28 +72,32 @@ class ExceptionTest < MiniTest::Test
     rescue Exception => e
       frames << 3
       raise e
-    end#.await
-    5.times { snooze }
-  rescue Exception => e
-    error = e
-  ensure
-    assert_kind_of RuntimeError, error
-    assert_equal [2, 3], frames
+    end
+    begin
+      5.times { snooze }
+    rescue Exception => e
+      error = e
+    ensure
+      assert_kind_of RuntimeError, error
+      assert_equal [2, 3], frames
+    end
   end
 
   def test_cross_fiber_backtrace_with_dead_calling_fiber
     error = nil
-    spin do
+    begin
       spin do
         spin do
-          raise 'foo'
+          spin do
+            raise 'foo'
+          end.await
         end.await
       end.await
-    end.await
-  rescue Exception => e
-    error = e
-  ensure
-    assert_kind_of RuntimeError, error
+    rescue Exception => e
+      error = e
+    ensure
+      assert_kind_of RuntimeError, error
+    end
   end
 end
 
@@ -122,6 +126,20 @@ class MoveOnAfterTest < MiniTest::Test
     assert_equal :bar, v
   end
 
+  def test_move_on_after_with_reset
+    t0 = Time.now
+    v = move_on_after(0.01, with_value: :moved_on) do |timeout|
+      sleep 0.007
+      timeout.reset
+      sleep 0.007
+      nil
+    end
+    t1 = Time.now
+
+    assert_nil v
+    assert_in_range 0.014..0.02, t1 - t0
+  end
+
   def test_move_on_after_without_block
     t0 = Time.now
     f = move_on_after(0.01, with_value: 'foo')
@@ -160,6 +178,19 @@ class CancelAfterTest < MiniTest::Test
     assert t1 - t0 < 0.1
   end
 
+  def test_cancel_after_with_reset
+    t0 = Time.now
+    cancel_after(0.01) do |f|
+      assert_kind_of Fiber, f
+      assert_equal Fiber.current, f.parent
+      sleep 0.007
+      f.reset
+      sleep 0.007
+    end
+    t1 = Time.now
+    assert_in_range 0.014..0.02, t1 - t0
+  end
+
   class CustomException < Exception
   end
 
@@ -171,6 +202,19 @@ class CancelAfterTest < MiniTest::Test
       end
     end
 
+    begin
+      err = nil
+      cancel_after(0.01, with_exception: [CustomException, 'custom message']) do
+        sleep 1
+        :foo
+      end
+    rescue Exception => err
+    ensure
+      assert_kind_of CustomException, err
+      assert_equal 'custom message', err.message
+    end
+
+
     begin
       e = nil
       cancel_after(0.01, with_exception: 'foo') do
@@ -226,12 +270,10 @@ class SpinLoopTest < MiniTest::Test
     buffer = []
     counter = 0
     t0 = Time.now
-    f = spin_loop(rate: 10) { buffer << (counter += 1) }
-    sleep 0.2
+    f = spin_loop(rate: 100) { buffer << (counter += 1) }
+    sleep 0.02
     f.stop
-    elapsed = Time.now - t0
-    expected = (elapsed * 10).to_i
-    assert counter >= expected - 1 && counter <= expected + 1
+    assert_in_range 1..3, counter
   end
 end
 
@@ -241,22 +283,22 @@ class ThrottledLoopTest < MiniTest::Test
     counter = 0
     t0 = Time.now
     f = spin do
-      throttled_loop(10) { buffer << (counter += 1) }
+      throttled_loop(100) { buffer << (counter += 1) }
     end
-    sleep 0.3
-    f.stop
-    elapsed = Time.now - t0
-    expected = (elapsed * 10).to_i
-    assert counter >= expected - 1 && counter <= expected + 1
+    sleep 0.03
+    assert_in_range 2..4, counter
   end
 
   def test_throttled_loop_with_count
     buffer = []
     counter = 0
+    t0 = Time.now
     f = spin do
       throttled_loop(50, count: 5) { buffer << (counter += 1) }
     end
     f.await
+    t1 = Time.now
+    assert_in_range 0.075..0.15, t1 - t0
     assert_equal [1, 2, 3, 4, 5], buffer    
   end
 end
@@ -275,13 +317,11 @@ class GlobalAPIEtcTest < MiniTest::Test
     buffer = []
     t0 = Time.now
     f = spin do
-      every(0.1) { buffer << 1 }
+      every(0.01) { buffer << 1 }
     end
-    sleep 0.5
+    sleep 0.05
     f.stop
-    elapsed = Time.now - t0
-    expected = (elapsed / 0.1).to_i
-    assert buffer.size >= expected - 2 && buffer.size <= expected + 2
+    assert_in_range 4..6, buffer.size
   end
 
   def test_sleep
@@ -349,4 +389,4 @@ class GlobalAPIEtcTest < MiniTest::Test
 
     assert_equal [0, 1, 2], values
   end
-end
+end