polyphony 0.28 → 0.29

data/ext/gyro/selector.c

@@ -2,6 +2,7 @@
 
 struct Gyro_Selector {
   struct  ev_loop *ev_loop;
+  long run_no_wait_count;
 };
 
 VALUE cGyro_Selector = Qnil;
@@ -52,6 +53,13 @@ inline struct ev_loop *Gyro_Selector_current_thread_ev_loop() {
   return selector->ev_loop;
 }
 
+inline ev_tstamp Gyro_Selector_now(VALUE self) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  return ev_now(selector->ev_loop);
+}
+
 long Gyro_Selector_pending_count(VALUE self) {
   struct Gyro_Selector *selector;
   GetGyro_Selector(self, selector);
@@ -65,19 +73,40 @@ static VALUE Gyro_Selector_initialize(VALUE self, VALUE thread) {
 
   int use_default_loop = (rb_thread_current() == rb_thread_main());
   selector->ev_loop = use_default_loop ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
+  selector->run_no_wait_count = 0;
+
+  ev_run(selector->ev_loop, EVRUN_NOWAIT);
 
   return Qnil;
 }
 
-inline VALUE Gyro_Selector_run(VALUE self) {
+inline VALUE Gyro_Selector_run(VALUE self, VALUE current_fiber) {
   struct Gyro_Selector *selector;
   GetGyro_Selector(self, selector);
   if (selector->ev_loop) {
+    selector->run_no_wait_count = 0;
+    FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
     ev_run(selector->ev_loop, EVRUN_ONCE);
+    FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
   }
   return Qnil;
 }
 
+inline void Gyro_Selector_run_no_wait(VALUE self, VALUE current_fiber, long runnable_count) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  selector->run_no_wait_count++;
+  if (selector->run_no_wait_count < runnable_count || selector->run_no_wait_count < 10) {
+    return;
+  }
+
+  selector->run_no_wait_count = 0;
+  FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
+  ev_run(selector->ev_loop, EVRUN_NOWAIT);
+  FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
+}
+
 VALUE Gyro_Selector_stop(VALUE self) {
   struct Gyro_Selector *selector;
   GetGyro_Selector(self, selector);
@@ -109,7 +138,7 @@ void Init_Gyro_Selector() {
   rb_define_alloc_func(cGyro_Selector, Gyro_Selector_allocate);
 
   rb_define_method(cGyro_Selector, "initialize", Gyro_Selector_initialize, 1);
-  rb_define_method(cGyro_Selector, "run", Gyro_Selector_run, 0);
+  rb_define_method(cGyro_Selector, "run", Gyro_Selector_run, 1);
   rb_define_method(cGyro_Selector, "stop", Gyro_Selector_stop, 0);
   rb_define_method(cGyro_Selector, "wait_readable", Gyro_Selector_wait_readable, 1);
   rb_define_method(cGyro_Selector, "wait_writable", Gyro_Selector_wait_writable, 1);

data/ext/gyro/thread.c

@@ -98,13 +98,16 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
 }
 
 inline VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
+  FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
   // if fiber is already scheduled, just set the scheduled value, then return
   rb_ivar_set(fiber, ID_runnable_value, value);
-  if (rb_ivar_get(fiber, ID_runnable) == Qnil) {
-    VALUE queue = rb_ivar_get(self, ID_run_queue);
-    rb_ary_push(queue, fiber);
-    rb_ivar_set(fiber, ID_runnable, Qtrue);
+  if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
+    return self;
   }
+
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  rb_ary_push(queue, fiber);
+  rb_ivar_set(fiber, ID_runnable, Qtrue);
   return self;
 }
 
@@ -118,6 +121,7 @@ VALUE Thread_switch_fiber(VALUE self) {
   }
   VALUE queue = rb_ivar_get(self, ID_run_queue);
   VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+
   VALUE next_fiber;
 
   while (1) {
@@ -125,17 +129,18 @@ VALUE Thread_switch_fiber(VALUE self) {
     // if (break_flag != 0) {
     //   return Qnil;
     // }
-    if ((next_fiber != Qnil) || (Thread_fiber_ref_count(self) == 0)) {
+    int ref_count = Thread_fiber_ref_count(self);
+    if (next_fiber != Qnil) {
+      if (ref_count > 0) {
+        Gyro_Selector_run_no_wait(selector, current_fiber, RARRAY_LEN(queue));
+      }
       break;
     }
-
-    if (__tracing_enabled__) {
-      rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_ev_loop_enter, current_fiber);
-    }
-    Gyro_Selector_run(selector);
-    if (__tracing_enabled__) {
-      rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_ev_loop_leave, current_fiber);
+    if (ref_count == 0) {
+      break;
     }
+
+    Gyro_Selector_run(selector, current_fiber);
   }
 
   if (next_fiber == Qnil) {
@@ -144,10 +149,7 @@ VALUE Thread_switch_fiber(VALUE self) {
 
   // run next fiber
   VALUE value = rb_ivar_get(next_fiber, ID_runnable_value);
-
-  if (__tracing_enabled__) {
-    rb_funcall(rb_cObject, ID_fiber_trace, 3, SYM_fiber_run, next_fiber, value);
-  }
+  FIBER_TRACE(3, SYM_fiber_run, next_fiber, value);
 
   rb_ivar_set(next_fiber, ID_runnable, Qnil);
   RB_GC_GUARD(next_fiber);

data/lib/polyphony/core/global_api.rb

@@ -32,7 +32,6 @@ module API
   def spin(tag = nil, &block)
     Fiber.spin(tag, caller, &block)
   end
-  alias_method :defer, :spin
 
   def spin_loop(&block)
     spin { loop(&block) }

data/lib/polyphony/core/thread_pool.rb

@@ -8,6 +8,11 @@ require 'etc'
 class ThreadPool
   attr_reader :size
 
+  def self.process(&block)
+    @default_pool ||= new
+    @default_pool.process(&block)
+  end
+
   def initialize(size = Etc.nprocessors)
     @size = size
     @task_queue = ::Queue.new

data/lib/polyphony/core/throttler.rb

@@ -14,7 +14,6 @@ class Throttler
     @timer.await
     block.call(self)
   end
-
   alias_method :process, :call
 
   def stop

data/lib/polyphony/extensions/fiber.rb

@@ -55,11 +55,12 @@ module FiberMessaging
     if @receive_waiting && @running
       schedule value
     else
-      @queued_messages ||= []
+      @queued_messages ||= Gyro::Queue.new
       @queued_messages << value
     end
     snooze
   end
+  alias_method :send, :<<
 
   def receive
     if !@queued_messages || @queued_messages&.empty?
@@ -110,11 +111,11 @@ class ::Fiber
     f
   end
 
-  attr_accessor :tag
-  Fiber.current.tag = :main
+  attr_accessor :tag, :thread
 
   def setup(tag, block, caller)
     __fiber_trace__(:fiber_create, self)
+    @thread = Thread.current
     @tag = tag
     @calling_fiber = Fiber.current
     @caller = caller
@@ -122,12 +123,20 @@ class ::Fiber
     schedule
   end
 
+  def setup_main_fiber
+    @tag = :main
+    @thread = Thread.current
+    @running = true
+  end
+
   def run(first_value)
     Kernel.raise first_value if first_value.is_a?(Exception)
 
     start_execution(first_value)
   rescue ::Interrupt, ::SystemExit => e
     Thread.current.main_fiber.transfer e.class.new
+  rescue ::SignalException => e
+    Thread.current.main_fiber.transfer e
   rescue Exceptions::MoveOn => e
     finish_execution(e.value)
   rescue Exception => e
@@ -187,3 +196,5 @@ class ::Fiber
     end
   end
 end
+
+Fiber.current.setup_main_fiber

data/lib/polyphony/extensions/thread.rb

@@ -4,6 +4,10 @@ Exceptions = import '../core/exceptions'
 
 # Thread extensions
 class ::Thread
+  def self.join_queue_mutex
+    @join_queue_mutex ||= Mutex.new
+  end
+
   attr_reader :main_fiber
 
   alias_method :orig_initialize, :initialize
@@ -11,10 +15,11 @@ class ::Thread
     @join_wait_queue = Gyro::Queue.new
     @block = block
     orig_initialize do
+      Fiber.current.setup_main_fiber
       setup_fiber_scheduling
       block.(*args)
-      signal_waiters
     ensure
+      signal_waiters
       stop_event_selector
     end
   end
@@ -25,10 +30,12 @@ class ::Thread
 
   alias_method :orig_join, :join
   def join(timeout = nil)
-    return unless alive?
-
     async = Gyro::Async.new
-    @join_wait_queue << async
+    Thread.join_queue_mutex.synchronize do
+      return unless alive?
+
+      @join_wait_queue << async
+    end
 
     if timeout
       move_on_after(timeout) { async.await }
@@ -49,4 +56,9 @@ class ::Thread
   def location
     @block.source_location.join(':')
   end
+
+  def <<(value)
+    main_fiber << value
+  end
+  alias_method :send, :<<
 end

data/lib/polyphony/irb.rb

@@ -7,7 +7,13 @@ require 'polyphony'
 # readline to return
 module ::Readline
   alias_method :orig_readline, :readline
+
   def readline(*args)
-    Polyphony::ThreadPool.process { orig_readline(*args) }
+    async = Gyro::Async.new
+    Thread.new do
+      result = orig_readline(*args)
+      async.signal!(result)
+    end
+    async.await
   end
 end

data/lib/polyphony/trace.rb

@@ -6,9 +6,10 @@ require 'polyphony'
 
 STOCK_EVENTS = %i[line call return c_call c_return b_call b_return].freeze
 
-def new
+def new(*events)
   start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-  ::TracePoint.new(*STOCK_EVENTS) { |tp| yield trace_record(tp, start_stamp) }
+  events = STOCK_EVENTS if events.empty?
+  ::TracePoint.new(*events) { |tp| yield trace_record(tp, start_stamp) }
 end
 
 def trace_record(trp, start_stamp)
@@ -16,7 +17,7 @@ def trace_record(trp, start_stamp)
   { stamp: stamp, self: trp.self, binding: trp.binding, event: trp.event,
     fiber: tp_fiber(trp), lineno: trp.lineno, method_id: trp.method_id,
     file: trp.path, parameters: tp_params(trp),
-    return_value: tp_return_value(trp),
+    return_value: tp_return_value(trp), schedule_value: tp_schedule_value(trp),
     exception: tp_raised_exception(trp) }
 end
 
@@ -36,6 +37,12 @@ def tp_return_value(trp)
   RETURN_VALUE_EVENTS.include?(trp.event) ? trp.return_value : nil
 end
 
+SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
+
+def tp_schedule_value(trp)
+  SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
+end
+
 def tp_raised_exception(trp)
   trp.event == :raise && trp.raised_exception
 end
@@ -79,19 +86,45 @@ class FiberTracePoint
 end
 
 class << ::TracePoint
+  POLYPHONY_FILE_REGEXP = /^#{::Exception::POLYPHONY_DIR}/.freeze
+
   alias_method :orig_new, :new
   def new(*args, &block)
-    polyphony_file_regexp = /^#{::Exception::POLYPHONY_DIR}/
+    events_mask, fiber_events_mask = event_masks(args)
 
-    orig_new(*args) do |tp|
-      # next unless !$watched_fiber || Fiber.current == $watched_fiber
+    orig_new(*events_mask) do |tp|
+      handle_tp_event(tp, fiber_events_mask, &block)
+    end
+  end
 
-      if tp.method_id == :__fiber_trace__
-        block.(FiberTracePoint.new(tp)) if tp.event == :c_return
-      else
-        next if tp.path =~ polyphony_file_regexp
+  def handle_tp_event(tpoint, fiber_events_mask)
+    # next unless !$watched_fiber || Fiber.current == $watched_fiber
 
-        block.(tp)
+    if tpoint.method_id == :__fiber_trace__
+      return if tpoint.event != :c_return
+      return unless fiber_events_mask.include?(tpoint.return_value[0])
+
+      tpoint = FiberTracePoint.new(tpoint)
+    elsif tpoint.path =~ POLYPHONY_FILE_REGEXP
+      return
+    end
+
+    yield tpoint
+  end
+
+  ALL_FIBER_EVENTS = %i[
+    fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
+    fiber_ev_loop_enter fiber_ev_loop_leave
+  ].freeze
+
+  def event_masks(events)
+    events.each_with_object([[], []]) do |e, masks|
+      case e
+      when /fiber_/
+        masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
+        masks[0] << :c_return unless masks[0].include?(:c_return)
+      else
+        masks[0] << e
       end
     end
   end

data/lib/polyphony/version.rb

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

data/lib/polyphony.rb

@@ -62,6 +62,7 @@ module Polyphony
     def fork(&block)
       pid = Kernel.fork do
         Gyro.post_fork
+        Fiber.current.setup_main_fiber
         block.()
       end
       pid

data/test/helper.rb

@@ -20,9 +20,7 @@ Minitest::Reporters.use! [
 
 class MiniTest::Test
   def setup
-    # for some reason, the first call to sleep in the context of tests returns
-    # too early
-    sleep 0
+    Fiber.current.setup_main_fiber
   end
 
   def teardown

data/test/test_async.rb

@@ -26,7 +26,7 @@ class AsyncTest < MiniTest::Test
       loop {
         a.await
         count += 1
-        defer { coproc.stop }
+        spin { coproc.stop }
       }
     }
     snooze

data/test/test_cancel_scope.rb

@@ -6,7 +6,7 @@ class CancelScopeTest < MiniTest::Test
   def test_that_cancel_scope_can_cancel_provided_block
     buffer = []
     Polyphony::CancelScope.new { |scope|
-      defer { scope.cancel! }
+      spin { scope.cancel! }
       buffer << 1
       snooze
       buffer << 2
@@ -77,7 +77,7 @@ class CancelScopeTest < MiniTest::Test
     scope.call {
       sleep 0.005
       scope.reset_timeout
-      sleep 0.008
+      sleep 0.005
     }
 
     assert !scope.cancelled?
@@ -86,7 +86,7 @@ class CancelScopeTest < MiniTest::Test
   def test_on_cancel
     buffer = []
     Polyphony::CancelScope.new { |scope|
-      defer { scope.cancel! }
+      spin { scope.cancel! }
       scope.on_cancel { buffer << :cancelled }
       buffer << 1
       snooze