polyphony 0.28 → 0.29

data/test/test_fiber.rb

@@ -25,6 +25,62 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
+  def test_schedule
+    values = []
+    fibers = (0..2).map { |i| spin { suspend; values << i } }
+    snooze
+
+    fibers[0].schedule
+    assert_equal [], values
+
+    snooze
+
+    assert_equal [0], values
+    assert_equal :dead, fibers[0].state
+
+    fibers[1].schedule
+    fibers[2].schedule
+
+    assert_equal [0], values
+    snooze
+    assert_equal [0, 1, 2], values
+  end
+
+  def test_cross_thread_schedule
+    buffer = []
+    worker_fiber = nil
+    async = Gyro::Async.new
+    worker = Thread.new do
+      worker_fiber = Fiber.current
+      async.signal!
+      suspend
+      buffer << :foo
+    end
+
+    async.await
+    assert worker_fiber
+    worker_fiber.schedule
+    worker.join
+    assert_equal [:foo], buffer
+  ensure
+    worker&.kill
+  end
+
+  def test_ev_loop_anti_starve_mechanism
+    async = Gyro::Async.new
+    t = Thread.new do
+      f = spin_loop { snooze }
+      sleep 0.001
+      async.signal!(:foo)
+    end
+
+    result = move_on_after(0.05) { async.await }
+
+    assert_equal :foo, result
+  ensure
+    t.kill if t.alive?
+  end
+
   def test_tag
     assert_equal :main, Fiber.current.tag
     Fiber.current.tag = :foo
@@ -63,7 +119,7 @@ class FiberTest < MiniTest::Test
       2.times { snooze }
       result << 2
     end
-    defer { f.raise }
+    spin { f.raise }
     assert_equal 0, result.size
     begin
       f.await
@@ -88,7 +144,7 @@ class FiberTest < MiniTest::Test
       2.times { snooze }
       result << 2
     end
-    defer { f.raise MyError }
+    spin { f.raise MyError }
     assert_equal 0, result.size
     begin
       f.await
@@ -110,7 +166,7 @@ class FiberTest < MiniTest::Test
       2.times { snooze }
       result << 2
     end
-    defer { f.raise(MyError, 'foo') }
+    spin { f.raise(MyError, 'foo') }
     assert_equal 0, result.size
     begin
       f.await
@@ -133,7 +189,7 @@ class FiberTest < MiniTest::Test
       2.times { snooze }
       result << 2
     end
-    defer { f.raise 'foo' }
+    spin { f.raise 'foo' }
     assert_equal 0, result.size
     begin
       f.await
@@ -156,7 +212,7 @@ class FiberTest < MiniTest::Test
       2.times { snooze }
       result << 2
     end
-    defer { f.raise MyError.new('bar') }
+    spin { f.raise MyError.new('bar') }
     assert_equal 0, result.size
     begin
       f.await
@@ -179,7 +235,7 @@ class FiberTest < MiniTest::Test
       2.times { snooze }
       result << 2
     end
-    defer { f.cancel! }
+    spin { f.cancel! }
     assert_equal 0, result.size
     begin
       f.await
@@ -202,7 +258,7 @@ class FiberTest < MiniTest::Test
       result << 2
       3
     end
-    defer { f.interrupt(42) }
+    spin { f.interrupt(42) }
 
     await_result = f.await
     assert_equal 1, result.size
@@ -220,7 +276,7 @@ class FiberTest < MiniTest::Test
       result << 2
       3
     end
-    defer { f.stop(42) }
+    spin { f.stop(42) }
 
     await_result = f.await
     assert_equal 1, result.size
@@ -253,7 +309,7 @@ class FiberTest < MiniTest::Test
       f2.await
       result && result += 1
     end
-    defer { f2.interrupt }
+    spin { f2.interrupt }
     suspend
     assert_nil result
     assert_equal :dead, f1.state
@@ -337,6 +393,7 @@ class FiberTest < MiniTest::Test
   end
 
   def test_select_from_multiple_fibers
+    sleep 0
     buffer = []
     f1 = spin { sleep 0.01; buffer << :foo; :foo }
     f2 = spin { sleep 0.03; buffer << :bar; :bar }
@@ -388,51 +445,6 @@ class FiberTest < MiniTest::Test
     assert_equal [42], values
     assert !f.running?
   end
-end
-
-class MailboxTest < MiniTest::Test
-  def test_that_fiber_can_receive_messages
-    msgs = []
-    f = spin { loop { msgs << receive } }
-
-    snooze # allow fiber to start
-
-    3.times do |i|
-      f << i
-      snooze
-    end
-
-    assert_equal [0, 1, 2], msgs
-  ensure
-    f&.stop
-  end
-
-  def test_that_multiple_messages_sent_at_once_arrive_in_order
-    msgs = []
-    f = spin { loop { msgs << receive } }
-
-    snooze # allow coproc to start
-
-    3.times { |i| f << i }
-
-    snooze
-
-    assert_equal [0, 1, 2], msgs
-  ensure
-    f&.stop
-  end
-
-  def test_that_sent_message_are_queued_before_calling_receive
-    buffer = []
-    receiver = spin { suspend; 3.times { buffer << receive } }
-    sender = spin { 3.times { |i| receiver << (i * 10) } }
-
-    sender.await
-    receiver.schedule
-    receiver.await
-
-    assert_equal [0, 10, 20], buffer
-  end
 
   def test_list_and_count
     assert_equal 1, Fiber.count
@@ -510,4 +522,95 @@ class MailboxTest < MiniTest::Test
     assert_nil parent_error
     assert_kind_of Interrupt, main_fiber_error
   end
+
+  def test_signal_exception_in_fiber
+    parent_error = nil
+    main_fiber_error = nil
+    f2 = nil
+    f1 = spin do
+      f2 = spin { raise SignalException.new('HUP') }
+      suspend
+    rescue Exception => parent_error
+    end
+
+    begin
+      suspend
+    rescue Exception => main_fiber_error
+    end
+
+    assert_nil parent_error
+    assert_kind_of SignalException, main_fiber_error
+  end
+end
+
+class MailboxTest < MiniTest::Test
+  def test_that_fiber_can_receive_messages
+    msgs = []
+    f = spin { loop { msgs << receive } }
+
+    snooze # allow fiber to start
+
+    3.times do |i|
+      f << i
+      snooze
+    end
+
+    assert_equal [0, 1, 2], msgs
+  ensure
+    f&.stop
+  end
+
+  def test_that_multiple_messages_sent_at_once_arrive_in_order
+    msgs = []
+    f = spin { loop { msgs << receive } }
+
+    snooze # allow coproc to start
+
+    3.times { |i| f << i }
+
+    snooze
+
+    assert_equal [0, 1, 2], msgs
+  ensure
+    f&.stop
+  end
+
+  def test_that_sent_message_are_queued_before_calling_receive
+    buffer = []
+    receiver = spin { suspend; 3.times { buffer << receive } }
+    sender = spin { 3.times { |i| receiver << (i * 10) } }
+
+    sender.await
+    receiver.schedule
+    receiver.await
+
+    assert_equal [0, 10, 20], buffer
+  end
+
+  def test_cross_thread_send_receive
+    skip "There's currently a race condition in cross-thread send/receive. We're going to rewrite it in C"
+    ping_receive_buffer = []
+    pong_receive_buffer = []
+    pong = Thread.new do
+      loop do
+        peer, data = receive
+        pong_receive_buffer << data
+        peer << 'pong'
+      end
+    end
+
+    ping = Thread.new do
+      3.times do
+        pong << [Fiber.current, 'ping']
+        data = receive
+        ping_receive_buffer << data
+      end
+    end
+
+    ping.join
+    pong.kill
+
+    assert_equal %w{pong pong pong}, ping_receive_buffer
+    assert_equal %w{ping ping ping}, pong_receive_buffer
+  end
 end

data/test/test_global_api.rb

@@ -36,7 +36,7 @@ class SpinTest < MiniTest::Test
       sleep(1)
       42
     end
-    defer { fiber.interrupt }
+    spin { fiber.interrupt }
     suspend
     assert_nil fiber.result
   end
@@ -321,4 +321,54 @@ class MoveOnAfterTest < MiniTest::Test
     f.stop
     assert !f.running?
   end
+
+  def test_snooze
+    values = []
+    3.times.map do |i|
+      spin do
+        3.times do
+          snooze
+          values << i
+        end
+        suspend
+      end
+    end
+    suspend
+
+    assert_equal [0, 1, 2, 0, 1, 2, 0, 1, 2], values
+  end
+
+  def test_defer
+    values = []
+    spin { values << 1 }
+    spin { values << 2 }
+    spin { values << 3 }
+    suspend
+
+    assert_equal [1, 2, 3], values
+  end
+
+  def test_suspend
+    values = []
+    spin do
+      values << :foo
+      suspend
+    end
+    suspend
+
+    assert_equal [:foo], values
+  end
+
+  def test_schedule_and_suspend
+    values = []
+    3.times.map do |i|
+      spin do
+        values << i
+        suspend
+      end
+    end
+    suspend
+
+    assert_equal [0, 1, 2], values
+  end
 end

data/test/test_gyro.rb

@@ -3,175 +3,23 @@
 require_relative 'helper'
 
 class GyroTest < MiniTest::Test
-  def test_fiber_state
-    assert_equal :running, Fiber.current.state
-
-    f = Fiber.new {}
-
-    assert_equal :waiting, f.state
-    f.resume
-    assert_equal :dead, f.state
-
-    f = Fiber.new { }
-    f.schedule
-    assert_equal :runnable, f.state
-    snooze
-    assert_equal :dead, f.state
-  end
-
-  def test_schedule
-    values = []
-    fibers = 3.times.map { |i| Fiber.new { values << i } }
-    fibers[0].schedule
-
-    assert_equal [], values
-    snooze
-    assert_equal [0], values
-    
-    fibers[1].schedule
-    fibers[2].schedule
-
-    assert_equal [0], values
-    snooze
-    assert_equal [0, 1, 2], values
-  end
-
-  def test_that_run_loop_returns_immediately_if_no_watchers
-    t0 = Time.now
-    suspend
-    t1 = Time.now
-    assert((t1 - t0) < 0.01)
-  end
-
-  def test_defer
-    values = []
-    defer { values << 1 }
-    defer { values << 2 }
-    defer { values << 3 }
-    suspend
-
-    assert_equal [1, 2, 3], values
-  end
-
-  def test_schedule
-    values = []
-    f = Fiber.new do
-      values << :foo
-      # We *have* to suspend the fiber in order to yield to the reactor,
-      # otherwise control will transfer back to root fiber.
-      suspend
-    end
-    assert_equal [], values
-    f.schedule
-    suspend
-
-    assert_equal [:foo], values
-  end
-
-  def test_suspend
-    values = []
-    Fiber.new do
-      values << :foo
-      suspend
-    end.schedule
-    suspend
-
-    assert_equal [:foo], values
-  end
-
-  def test_schedule_and_suspend
-    values = []
-    3.times.map do |i|
-      Fiber.new do
-        values << i
-        suspend
-      end.schedule
-    end
-    suspend
-
-    assert_equal [0, 1, 2], values
-  end
-
-  def test_snooze
-    values = []
-    3.times.map do |i|
-      Fiber.new do
-        3.times do
-          snooze
-          values << i
-        end
-        suspend
-      end.schedule
-    end
-    suspend
-
-    assert_equal [0, 1, 2, 0, 1, 2, 0, 1, 2], values
-  end
-
   def test_break
     skip "break is still not implemented for new scheduler"
     values = []
-    Fiber.new do
+    Fiber.spin do
       values << :foo
       snooze
       # here will never be reached
       values << :bar
       suspend
-    end.schedule
+    end
 
-    Fiber.new do
+    Fiber.spin do
       Gyro.break!
-    end.schedule
+    end
 
     suspend
 
     assert_equal [:foo], values
   end
-
-  def test_reset
-    values = []
-    f1 = Fiber.new do
-      values << :foo
-      snooze
-      values << :bar
-      suspend
-    end.schedule
-
-    f2 = Fiber.new do
-      Thread.current.reset_fiber_scheduling
-      values << :restarted
-      snooze
-      values << :baz
-    end.schedule
-
-    suspend
-
-    f1.schedule
-    suspend
-    assert_equal %i[foo restarted baz], values
-  end
-
-  def test_restart
-    values = []
-    Fiber.new do
-      values << :foo
-      snooze
-      # this part will not be reached, as Gyro state is reset
-      values << :bar
-      suspend
-    end.schedule
-
-    Fiber.new do
-      Thread.current.reset_fiber_scheduling
-
-      # control is transfer to the fiber that called Gyro.restart
-      values << :restarted
-      snooze
-      values << :baz
-    end.schedule
-
-    suspend
-
-    assert_equal %i[foo restarted baz], values
-  end
 end

data/test/test_io.rb

@@ -16,7 +16,7 @@ class GyroIOTest < MiniTest::Test
     }
     snooze
     sequence << 3
-    defer do
+    spin do
       o << 'hello'
       sequence << 4
     end

data/test/test_supervisor.rb

@@ -106,7 +106,7 @@ class SupervisorTest < MiniTest::Test
     buffer = []
     supervisor = nil
     supervisor = Polyphony::Supervisor.new
-    defer { supervisor.interrupt(42) }
+    spin { supervisor.interrupt(42) }
     buffer << supervisor.await { |s|
       (1..3).each { |i|
         s.spin {
@@ -125,7 +125,7 @@ class SupervisorTest < MiniTest::Test
     buffer = []
     supervisor = nil
     supervisor = Polyphony::Supervisor.new
-    defer { supervisor.interrupt(42) }
+    spin { supervisor.interrupt(42) }
     buffer << supervisor.select { |s|
       (1..3).each { |i|
         s.spin {

data/test/test_thread.rb

@@ -5,25 +5,35 @@ require_relative 'helper'
 class ThreadTest < MiniTest::Test
   def test_thread_spin
     buffer = []
-    spin { (1..3).each { |i| snooze; buffer << i } }
+    f = spin { (1..3).each { |i| snooze; buffer << i } }
     t = Thread.new do
       s1 = spin { (11..13).each { |i| snooze; buffer << i } }
       s2 = spin { (21..23).each { |i| snooze; buffer << i } }
       Fiber.join(s1, s2)
     end
+    f.join
     t.join
 
     assert_equal [1, 2, 3, 11, 12, 13, 21, 22, 23], buffer.sort
   end
 
   def test_thread_join
+    tr = nil
+    # tr = Polyphony::Trace.new(:fiber_all) { |r| p r[:event] }
+    # Gyro.trace(true)
+    # tr.enable
+
     buffer = []
     spin { (1..3).each { |i| snooze; buffer << i } }
     t = Thread.new { sleep 0.01; buffer << 4 }
+
     r = t.join
 
     assert_equal [1, 2, 3, 4], buffer
     assert_equal t, r
+  ensure
+    tr&.disable
+    Gyro.trace(nil)
   end
 
   def test_thread_join_with_timeout
@@ -53,4 +63,65 @@ class ThreadTest < MiniTest::Test
     )
     assert_equal str, t.inspect
   end
+
+  def test_that_suspend_returns_immediately_if_no_watchers
+    records = []
+    t = Polyphony::Trace.new(:fiber_all) { |r| records << r if r[:event] =~ /^fiber_/ }
+    t.enable
+    Gyro.trace(true)
+
+    suspend
+    t.disable
+    assert_equal [:fiber_switchpoint], records.map { |r| r[:event] }
+  ensure
+    t&.disable
+    Gyro.trace(false)
+  end
+
+  def test_reset
+    values = []
+    f1 = spin do
+      values << :foo
+      snooze
+      values << :bar
+      suspend
+    end
+
+    f2 = spin do
+      Thread.current.reset_fiber_scheduling
+      values << :restarted
+      snooze
+      values << :baz
+    end
+
+    suspend
+
+    f1.schedule
+    suspend
+    assert_equal %i[foo restarted baz], values
+  end
+
+  def test_restart
+    values = []
+    spin do
+      values << :foo
+      snooze
+      # this part will not be reached, as Gyro state is reset
+      values << :bar
+      suspend
+    end
+
+    spin do
+      Thread.current.reset_fiber_scheduling
+
+      # control is transfer to the fiber that called Gyro.restart
+      values << :restarted
+      snooze
+      values << :baz
+    end
+
+    suspend
+
+    assert_equal %i[foo restarted baz], values
+  end
 end

data/test/test_thread_pool.rb

@@ -5,10 +5,11 @@ require_relative 'helper'
 class ThreadPoolTest < MiniTest::Test
   def setup
     super
-    @pool = Polyphony::ThreadPool.new
+    # @pool = Polyphony::ThreadPool.new
   end
 
   def test_process
+    skip
     current_thread = Thread.current
 
     processing_thread = nil
@@ -21,6 +22,7 @@ class ThreadPoolTest < MiniTest::Test
   end
 
   def test_multi_process
+    skip
     current_thread = Thread.current
     threads = []
     results = []
@@ -42,6 +44,7 @@ class ThreadPoolTest < MiniTest::Test
   end
 
   def test_process_with_exception
+    skip
     result = nil
     begin
       result = @pool.process { raise 'foo' }
@@ -53,6 +56,7 @@ class ThreadPoolTest < MiniTest::Test
   end
 
   def test_cast
+    skip
     t0 = Time.now
     threads = []
     buffer = []
@@ -68,7 +72,7 @@ class ThreadPoolTest < MiniTest::Test
     assert elapsed < 0.005
     assert buffer.size < 2
     
-    sleep 0.04
+    sleep 0.05
     assert_equal @pool.size, threads.uniq.size
     assert_equal (0..9).to_a, buffer.sort
   end