polyphony 0.26 → 0.27

data/ext/gyro/timer.c

@@ -2,35 +2,40 @@
 
 struct Gyro_Timer {
   struct  ev_timer ev_timer;
+  struct  ev_loop *ev_loop;
   int     active;
   double  after;
   double  repeat;
+  int     should_free;
   VALUE   self;
   VALUE   fiber;
+  VALUE   selector;
 };
 
-static VALUE cGyro_Timer = Qnil;
+VALUE cGyro_Timer = Qnil;
 
-/* Allocator/deallocator */
-static VALUE Gyro_Timer_allocate(VALUE klass);
-static void Gyro_Timer_mark(void *ptr);
-static void Gyro_Timer_free(void *ptr);
-static size_t Gyro_Timer_size(const void *ptr);
-
-/* Methods */
-static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat);
-
-static VALUE Gyro_Timer_await(VALUE self);
-
-void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
+static void Gyro_Timer_mark(void *ptr) {
+  struct Gyro_Timer *timer = ptr;
+  if (timer->fiber != Qnil) {
+    rb_gc_mark(timer->fiber);
+  }
+  if (timer->selector != Qnil) {
+    rb_gc_mark(timer->selector);
+  }
+}
 
-/* Timer encapsulates an timer watcher */
-void Init_Gyro_Timer() {
-  cGyro_Timer = rb_define_class_under(mGyro, "Timer", rb_cData);
-  rb_define_alloc_func(cGyro_Timer, Gyro_Timer_allocate);
+static void Gyro_Timer_free(void *ptr) {
+  struct Gyro_Timer *timer = ptr;
+  if (timer->active) {
+    printf("Timer watcher garbage collected while still active (%g, %g)!\n", timer->after, timer->repeat);
+    timer->should_free = 1;
+  } else {
+    xfree(timer);
+  }
+}
 
-  rb_define_method(cGyro_Timer, "initialize", Gyro_Timer_initialize, 2);
-  rb_define_method(cGyro_Timer, "await", Gyro_Timer_await, 0);
+static size_t Gyro_Timer_size(const void *ptr) {
+  return sizeof(struct Gyro_Timer);
 }
 
 static const rb_data_type_t Gyro_Timer_type = {
@@ -44,29 +49,28 @@ static VALUE Gyro_Timer_allocate(VALUE klass) {
   struct Gyro_Timer *timer = (struct Gyro_Timer *)xmalloc(sizeof(struct Gyro_Timer));
   return TypedData_Wrap_Struct(klass, &Gyro_Timer_type, timer);
 }
+#define GetGyro_Timer(obj, timer) \
+  TypedData_Get_Struct((obj), struct Gyro_Timer, &Gyro_Timer_type, (timer))
 
-static void Gyro_Timer_mark(void *ptr) {
-  struct Gyro_Timer *timer = ptr;
-  if (timer->fiber != Qnil) {
-    rb_gc_mark(timer->fiber);
+void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int revents) {
+  struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
+
+  if (timer->should_free) {
+    ev_timer_stop(timer->ev_loop, ev_timer);
+    xfree(timer);
+    return;
   }
-}
 
-static void Gyro_Timer_free(void *ptr) {
-  struct Gyro_Timer *timer = ptr;
-  if (timer->active) {
-    ev_timer_stop(EV_DEFAULT, &timer->ev_timer);
+  if (!timer->repeat) {
+    timer->active = 0;
+    timer->selector = Qnil;
   }
-  xfree(timer);
-}
 
-static size_t Gyro_Timer_size(const void *ptr) {
-  return sizeof(struct Gyro_Timer);
+  if (timer->fiber != Qnil) {
+    Gyro_schedule_fiber(timer->fiber, DBL2NUM(timer->after));
+  }
 }
 
-#define GetGyro_Timer(obj, timer) \
-  TypedData_Get_Struct((obj), struct Gyro_Timer, &Gyro_Timer_type, (timer))
-
 static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
   struct Gyro_Timer *timer;
 
@@ -77,47 +81,72 @@ static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
   timer->after    = NUM2DBL(after);
   timer->repeat   = NUM2DBL(repeat);
   timer->active   = 0;
-  
+
+  timer->should_free    = 0;
+
   ev_timer_init(&timer->ev_timer, Gyro_Timer_callback, timer->after, timer->repeat);
+  timer->ev_loop = 0;
+  timer->selector = Qnil;
 
   return Qnil;
 }
 
-void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int revents) {
-  struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
+VALUE Gyro_Timer_stop(VALUE self) {
+  struct Gyro_Timer *timer;
+  GetGyro_Timer(self, timer);
 
-  if (!timer->repeat) {
+  if (timer->active) {
     timer->active = 0;
-  }
-
-  if (timer->fiber != Qnil) {
-    VALUE fiber = timer->fiber;
-    VALUE resume_value = DBL2NUM(timer->after);
-
     timer->fiber = Qnil;
-    Gyro_schedule_fiber(fiber, resume_value);
+    timer->selector = Qnil;
+    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
+    timer->ev_loop = 0;
   }
+
+  return self;
 }
 
-static VALUE Gyro_Timer_await(VALUE self) {
+VALUE Gyro_Timer_await(VALUE self) {
   struct Gyro_Timer *timer;
   VALUE ret;
   
   GetGyro_Timer(self, timer);
 
   timer->fiber = rb_fiber_current();
+  timer->selector = Thread_current_event_selector();
+  timer->ev_loop = Gyro_Selector_ev_loop(timer->selector);
+
   if (timer->active != 1) {
     timer->active = 1;
-    ev_timer_start(EV_DEFAULT, &timer->ev_timer);
+    ev_timer_start(timer->ev_loop, &timer->ev_timer);
   }
 
-  ret = Gyro_await();
+  ret = Fiber_await();
+  RB_GC_GUARD(ret);
+
+  if (timer->active && (timer->repeat == .0)) {
+    timer->active = 0;
+    timer->fiber = Qnil;
+    timer->selector = Qnil;
+    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
+  }
+  RB_GC_GUARD(self);
 
   // fiber is resumed, check if resumed value is an exception
   timer->fiber = Qnil;
+  timer->selector = Qnil;
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
     return rb_funcall(rb_mKernel, ID_raise, 1, ret);
   }
   else
     return ret;
-}
+}
+
+void Init_Gyro_Timer() {
+  cGyro_Timer = rb_define_class_under(mGyro, "Timer", rb_cData);
+  rb_define_alloc_func(cGyro_Timer, Gyro_Timer_allocate);
+
+  rb_define_method(cGyro_Timer, "initialize", Gyro_Timer_initialize, 2);
+  rb_define_method(cGyro_Timer, "stop", Gyro_Timer_stop, 0);
+  rb_define_method(cGyro_Timer, "await", Gyro_Timer_await, 0);
+}

data/ext/libev/ev.c

@@ -3809,7 +3809,10 @@ rb_thread_unsafe_dangerous_crazy_blocking_region_end(...);
 
         poll_args.loop = loop;
         poll_args.waittime = waittime;
+
         rb_thread_call_without_gvl(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
+
+        // backend_poll (EV_A_ waittime);
 /*
 ############################# END PATCHERY ############################
 */

data/lib/polyphony.rb

@@ -7,7 +7,11 @@ export_default :Polyphony
 require 'fiber'
 require_relative './gyro_ext'
 
+Thread.event_selector = Gyro::Selector
+Thread.current.setup_fiber_scheduling
+
 import './polyphony/extensions/core'
+import './polyphony/extensions/thread'
 import './polyphony/extensions/fiber'
 import './polyphony/extensions/io'
 
@@ -29,8 +33,8 @@ module Polyphony
     ResourcePool: './polyphony/core/resource_pool',
     Supervisor:   './polyphony/core/supervisor',
     Sync:         './polyphony/core/sync',
-    Thread:       './polyphony/core/thread',
     ThreadPool:   './polyphony/core/thread_pool',
+    Throttler:    './polyphony/core/throttler',
     Websocket:    './polyphony/websocket'
   )
 
@@ -55,24 +59,15 @@ module Polyphony
     end
 
     def fork(&block)
-      Gyro.break!
       pid = Kernel.fork do
-        setup_forked_process
+        Gyro.post_fork
         block.()
       end
-      Gyro.reset!
       pid
     end
 
     def reset!
-      Gyro.reset!
-      Fiber.reset!
-    end
-
-    private
-
-    def setup_forked_process
-      Gyro.post_fork
+      Thread.current.reset_fiber_scheduling
       Fiber.reset!
     end
   end

data/lib/polyphony/core/global_api.rb

@@ -44,6 +44,8 @@ module API
       timer.await
       yield
     end
+  ensure
+    timer.stop
   end
 
   def move_on_after(interval, with_value: nil, &block)
@@ -74,12 +76,14 @@ module API
     Supervisor.new.await(&block)
   end
 
-  def throttled_loop(rate, count: nil, &block)
+  def throttled_loop(rarote, count: nil, &block)
     throttler = Throttler.new(rate)
     if count
       count.times { throttler.(&block) }
     else
       loop { throttler.(&block) }
     end
+  ensure
+    throttler.stop
   end
 end

data/lib/polyphony/core/throttler.rb

@@ -7,25 +7,20 @@ class Throttler
   def initialize(rate)
     @rate = rate_from_argument(rate)
     @min_dt = 1.0 / @rate
-    @last_iteration_clock = clock - @min_dt
-  end
-
-  def clock
-    ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
   end
 
   def call(&block)
-    now = clock
-    dt = now - @last_iteration_clock
-
-    sleep(@min_dt - dt) if dt < @min_dt
-
-    @last_iteration_clock = dt > @min_dt ? now : @last_iteration_clock + @min_dt
+    @timer ||= Gyro::Timer.new(0, @min_dt)
+    @timer.await
     block.call(self)
   end
 
   alias_method :process, :call
 
+  def stop
+    @timer&.stop
+  end
+
   private
 
   def rate_from_argument(arg)

data/lib/polyphony/extensions/core.rb

@@ -102,6 +102,8 @@ module ::Kernel
       end
     end
     true
+  rescue SystemCallError
+    nil
   end
 end
 

data/lib/polyphony/extensions/fiber.rb

@@ -35,7 +35,7 @@ module FiberControl
 
   def raise(*args)
     error = error_from_raise_args(args)
-    schedule error
+    schedule(error)
     snooze
   end
 
@@ -83,17 +83,11 @@ end
 
 # Fiber extensions
 class ::Fiber
-  include FiberControl
+  prepend FiberControl
   include FiberMessaging
 
-  # map of currently running fibers
-  def self.root
-    @root_fiber
-  end
-
   def self.reset!
-    @root_fiber = current
-    @running_fibers_map = { @root_fiber => true }
+    @running_fibers_map = { Thread.current.main_fiber => true }
   end
 
   reset!
@@ -132,6 +126,8 @@ class ::Fiber
     finish_execution(result)
   rescue Exceptions::MoveOn => e
     finish_execution(e.value)
+  rescue ::Interrupt, ::SystemExit => e
+    Thread.current.main_fiber.transfer e.class.new
   rescue Exception => e
     finish_execution(e, true)
   end
@@ -142,13 +138,15 @@ class ::Fiber
     self.class.map.delete(self)
     @when_done&.(result)
     @waiting_fiber&.schedule(result)
-
     return unless uncaught_exception && !@waiting_fiber
 
-    parent_fiber = @calling_fiber.running? ? @calling_fiber : Fiber.root
-    parent_fiber.schedule(result)
+    exception_receiving_fiber.schedule(result)
   ensure
-    Gyro.run
+    Thread.current.switch_fiber
+  end
+
+  def exception_receiving_fiber
+    @calling_fiber.running? ? @calling_fiber : Thread.current.main_fiber
   end
 
   attr_reader :result

data/lib/polyphony/extensions/thread.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+Exceptions = import '../core/exceptions'
+
+# Thread extensions
+class ::Thread
+  attr_reader :main_fiber
+
+  alias_method :orig_initialize, :initialize
+  def initialize(*args, &block)
+    @join_wait_queue = Gyro::Queue.new
+    @block = block
+    orig_initialize do
+      setup_fiber_scheduling
+      block.(*args)
+      signal_waiters
+    ensure
+      stop_event_selector
+    end
+  end
+
+  def signal_waiters
+    @join_wait_queue.shift_each { |w| w.signal!(self) }
+  end
+
+  alias_method :orig_join, :join
+  def join(timeout = nil)
+    return unless alive?
+
+    async = Gyro::Async.new
+    @join_wait_queue << async
+
+    if timeout
+      move_on_after(timeout) { async.await }
+    else
+      async.await
+    end
+  end
+
+  alias_method :orig_inspect, :inspect
+  def inspect
+    return orig_inspect if self == Thread.main
+
+    state = status || 'dead'
+    "#<Thread:#{object_id} #{location} (#{state})>"
+  end
+  alias_method :to_s, :inspect
+
+  def location
+    @block.source_location.join(':')
+  end
+end

data/lib/polyphony/version.rb

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

data/test/helper.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
+require 'polyphony'
 
 require 'fileutils'
 require_relative './eg'
@@ -10,8 +11,6 @@ require_relative './coverage' if ENV['COVERAGE']
 require 'minitest/autorun'
 require 'minitest/reporters'
 
-require 'polyphony'
-
 ::Exception.__disable_sanitized_backtrace__ = true
 
 Minitest::Reporters.use! [
@@ -19,9 +18,15 @@ 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
+  end
+
   def teardown
     # wait for any remaining scheduled work
-    Gyro.run
+    Thread.current.switch_fiber
     Polyphony.reset!
   end
 end