polyphony 0.29 → 0.30

data/ext/gyro/gyro.c

@@ -47,11 +47,11 @@ VALUE SYM_fiber_switchpoint;
 VALUE SYM_fiber_terminate;
 
 
-// static VALUE Gyro_break_set(VALUE self) {
-//   break_flag = 1;
-//   ev_break(EV_DEFAULT, EVBREAK_ALL);
-//   return Qnil;
-// }
+static VALUE Gyro_break_set(VALUE self) {
+  // break_flag = 1;
+  ev_break(Gyro_Selector_current_thread_ev_loop(), EVBREAK_ALL);
+  return Qnil;
+}
 
 // static VALUE Gyro_break_get(VALUE self) {
 //   return (break_flag == 0) ? Qfalse : Qtrue;
@@ -82,7 +82,6 @@ static VALUE Gyro_unref(VALUE self) {
 }
 
 static VALUE Gyro_suspend(VALUE self) {
-  rb_ivar_set(self, ID_runnable_value, Qnil);
   VALUE ret = Thread_switch_fiber(rb_thread_current());
   
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
@@ -117,7 +116,7 @@ static VALUE Fiber_state(VALUE self) {
   return SYM_waiting;
 }
 
-inline void Gyro_schedule_fiber(VALUE fiber, VALUE value) {
+void Gyro_schedule_fiber(VALUE fiber, VALUE value) {
   VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
   if (thread != Qnil) {
     Thread_schedule_fiber(thread, fiber, value);
@@ -140,7 +139,7 @@ void Init_Gyro() {
   rb_define_singleton_method(mGyro, "unref", Gyro_unref, 0);
   rb_define_singleton_method(mGyro, "trace", Gyro_trace, 1);
 
-  // rb_define_singleton_method(mGyro, "break!", Gyro_break_set, 0);
+  rb_define_singleton_method(mGyro, "break!", Gyro_break_set, 0);
   // rb_define_singleton_method(mGyro, "break?", Gyro_break_get, 0);
 
   rb_define_global_function("snooze", Gyro_snooze, 0);

data/ext/gyro/gyro.h

@@ -48,7 +48,9 @@ VALUE Thread_switch_fiber(VALUE thread);
 VALUE Fiber_await();
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_post_fork(VALUE thread);
+VALUE Gyro_Selector_break_out_of_ev_loop(VALUE self);
 
+VALUE Gyro_Queue_push(VALUE self, VALUE value);
 
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
 #define INSPECT(...) (rb_funcall(rb_cObject, rb_intern("p"), __VA_ARGS__))

data/ext/gyro/queue.c

@@ -75,7 +75,9 @@ VALUE Gyro_Queue_shift(VALUE self) {
   
   VALUE async = rb_funcall(cGyro_Async, ID_new, 0);
   rb_ary_push(queue->wait_queue, async);
-  return Gyro_Async_await(async);
+  VALUE ret = Gyro_Async_await(async);
+  RB_GC_GUARD(async);
+  return ret;
 }
 
 VALUE Gyro_Queue_shift_no_wait(VALUE self) {
@@ -85,7 +87,7 @@ VALUE Gyro_Queue_shift_no_wait(VALUE self) {
   return rb_ary_shift(queue->queue);
 }
 
-VALUE Gyro_Queue_shift_all(VALUE self) {
+VALUE Gyro_Queue_shift_each(VALUE self) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
@@ -97,9 +99,7 @@ VALUE Gyro_Queue_shift_all(VALUE self) {
     for (long i = 0; i < len; i++) {
       rb_yield(RARRAY_AREF(old_queue, i));
     }
-    // while (RARRAY_LEN(old_queue) > 0) {
-    //   rb_yield(rb_ary_shift(old_queue));
-    // }
+    RB_GC_GUARD(old_queue);
     return self;
   }
   else {
@@ -135,7 +135,7 @@ void Init_Gyro_Queue() {
   
   rb_define_method(cGyro_Queue, "shift_no_wait", Gyro_Queue_shift_no_wait, 0);
 
-  rb_define_method(cGyro_Queue, "shift_each", Gyro_Queue_shift_all, 0);
+  rb_define_method(cGyro_Queue, "shift_each", Gyro_Queue_shift_each, 0);
   rb_define_method(cGyro_Queue, "clear", Gyro_Queue_clear, 0);
   rb_define_method(cGyro_Queue, "empty?", Gyro_Queue_empty_p, 0);
 }

data/ext/gyro/selector.c

@@ -2,7 +2,9 @@
 
 struct Gyro_Selector {
   struct  ev_loop *ev_loop;
-  long run_no_wait_count;
+  long    run_no_wait_count;
+  int     ev_loop_running;
+  struct  ev_async async;
 };
 
 VALUE cGyro_Selector = Qnil;
@@ -13,6 +15,7 @@ static void Gyro_Selector_mark(void *ptr) {
 
 static void Gyro_Selector_free(void *ptr) {
   struct Gyro_Selector *selector = ptr;
+  ev_async_stop(selector->ev_loop, &selector->async);
   if (selector->ev_loop && !ev_is_default_loop(selector->ev_loop)) {
     // printf("Selector garbage collected before being stopped!\n");
     ev_loop_destroy(selector->ev_loop);
@@ -67,6 +70,11 @@ long Gyro_Selector_pending_count(VALUE self) {
   return ev_pending_count(selector->ev_loop);
 }
 
+void dummy_async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+  // This callback does nothing, the selector's async is used solely for waking
+  // up the event loop.
+}
+
 static VALUE Gyro_Selector_initialize(VALUE self, VALUE thread) {
   struct Gyro_Selector *selector;
   GetGyro_Selector(self, selector);
@@ -75,6 +83,9 @@ static VALUE Gyro_Selector_initialize(VALUE self, VALUE thread) {
   selector->ev_loop = use_default_loop ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
   selector->run_no_wait_count = 0;
 
+  ev_async_init(&selector->async, dummy_async_callback);
+  ev_async_start(selector->ev_loop, &selector->async);
+
   ev_run(selector->ev_loop, EVRUN_NOWAIT);
 
   return Qnil;
@@ -86,7 +97,9 @@ inline VALUE Gyro_Selector_run(VALUE self, VALUE current_fiber) {
   if (selector->ev_loop) {
     selector->run_no_wait_count = 0;
     FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
+    selector->ev_loop_running = 1;
     ev_run(selector->ev_loop, EVRUN_ONCE);
+    selector->ev_loop_running = 0;
     FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
   }
   return Qnil;
@@ -118,6 +131,23 @@ VALUE Gyro_Selector_stop(VALUE self) {
   return Qnil;
 }
 
+VALUE Gyro_Selector_break_out_of_ev_loop(VALUE self) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  if (selector->ev_loop_running) {
+    // Since the loop will run until at least one event has occurred, we signal
+    // the associated async watcher, which will cause the ev loop to return. In
+    // contrast to using `ev_break` to break out of the loop, which should be
+    // called from the same thread (from within the ev_loop), using an
+    // `ev_async` allows us to interrupt the event loop across threads.
+    ev_async_send(selector->ev_loop, &selector->async);
+    return Qtrue;
+  }
+
+  return Qnil;
+}
+
 inline static VALUE Gyro_Selector_wait_readable(VALUE self, VALUE io) {
   VALUE watcher = IO_read_watcher(io);
   return Gyro_IO_await(watcher);
@@ -143,4 +173,5 @@ void Init_Gyro_Selector() {
   rb_define_method(cGyro_Selector, "wait_readable", Gyro_Selector_wait_readable, 1);
   rb_define_method(cGyro_Selector, "wait_writable", Gyro_Selector_wait_writable, 1);
   rb_define_method(cGyro_Selector, "wait_timeout", Gyro_Selector_wait_timeout, 1);
+  rb_define_method(cGyro_Selector, "break_out_of_ev_loop", Gyro_Selector_break_out_of_ev_loop, 0);
 }

data/ext/gyro/thread.c

@@ -53,30 +53,33 @@ static VALUE Thread_stop_event_selector(VALUE self) {
   if (selector != Qnil) {
     rb_funcall(selector, ID_stop, 0);
   }
+  // Nullify the selector in order to prevent running the
+  // selector after the thread is done running.
+  rb_ivar_set(self, ID_ivar_event_selector, Qnil);
 
   return self;
 }
 
-inline VALUE Thread_ref(VALUE self) {
+VALUE Thread_ref(VALUE self) {
   VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
   int new_count = NUM2INT(count) + 1;
   rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(new_count));
   return self;
 }
 
-inline VALUE Thread_unref(VALUE self) {
+VALUE Thread_unref(VALUE self) {
   VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
   int new_count = NUM2INT(count) - 1;
   rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(new_count));
   return self;
 }
 
-inline int Thread_fiber_ref_count(VALUE self) {
+int Thread_fiber_ref_count(VALUE self) {
   VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
   return NUM2INT(count);
 }
 
-inline void Thread_fiber_reset_ref_count(VALUE self) {
+void Thread_fiber_reset_ref_count(VALUE self) {
   rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
 }
 
@@ -97,7 +100,10 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   return stats;
 }
 
-inline VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
+VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
+  if (rb_fiber_alive_p(fiber) != Qtrue) {
+    return self;
+  }
   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);
@@ -108,13 +114,24 @@ inline VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
   VALUE queue = rb_ivar_get(self, ID_run_queue);
   rb_ary_push(queue, fiber);
   rb_ivar_set(fiber, ID_runnable, Qtrue);
+
+  if (rb_thread_current() != self) {
+    // if the fiber scheduling is done across threads, we need to make sure the
+    // target thread is woken up in case it is in the middle of running its
+    // event selector. Otherwise it's gonna be stuck waiting for an event to
+    // happen, not knowing that it there's already a fiber ready to run in its
+    // run queue.
+    VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+    if (selector != Qnil) {
+      Gyro_Selector_break_out_of_ev_loop(selector);
+    }
+  }
   return self;
 }
 
 VALUE Thread_switch_fiber(VALUE self) {
-  VALUE current_fiber;
+  VALUE current_fiber = rb_fiber_current();
   if (__tracing_enabled__) {
-    current_fiber = rb_fiber_current();
     if (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse) {
       rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_switchpoint, current_fiber);
     }
@@ -170,7 +187,7 @@ VALUE Thread_post_fork(VALUE self) {
   return self;
 }
 
-inline VALUE Fiber_await() {
+VALUE Fiber_await() {
   VALUE thread = rb_thread_current();
   Thread_ref(thread);
   VALUE ret = Thread_switch_fiber(thread);
@@ -179,10 +196,37 @@ inline VALUE Fiber_await() {
   return ret;
 }
 
-inline VALUE Thread_current_event_selector() {
+VALUE Thread_current_event_selector() {
   return rb_ivar_get(rb_thread_current(), ID_ivar_event_selector);
 }
 
+VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE resume_obj) {
+  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+  Thread_schedule_fiber(self, rb_fiber_current(), resume_obj);
+
+  if (Gyro_Selector_break_out_of_ev_loop(selector) == Qnil) {
+    // we're not inside the ev_loop, so we just do a switchpoint
+    Thread_switch_fiber(self);
+  }
+
+  return self;
+}
+
+VALUE Thread_join_perform(VALUE self) {
+  if (!RTEST(rb_funcall(self, rb_intern("alive?"), 0))) {
+    return self;
+  }
+
+  VALUE async = rb_funcall(cGyro_Async, ID_new, 0);
+  VALUE wait_queue = rb_ivar_get(self, rb_intern("@join_wait_queue"));
+
+  Gyro_Queue_push(wait_queue, async);
+
+  VALUE ret = Gyro_Async_await(async);
+  RB_GC_GUARD(async);
+  return ret;
+}
+
 void Init_Thread() {
   cQueue = rb_const_get(rb_cObject, rb_intern("Queue"));
 
@@ -196,10 +240,12 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "stop_event_selector", Thread_stop_event_selector, 0);
   rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
+  rb_define_method(rb_cThread, "break_out_of_ev_loop", Thread_fiber_break_out_of_ev_loop, 1);
 
   rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 2);
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
 
+  rb_define_method(rb_cThread, "join_perform", Thread_join_perform, 0);
 
   ID_create_event_selector    = rb_intern("create_event_selector");
   ID_empty                    = rb_intern("empty?");

data/ext/gyro/timer.c

@@ -129,6 +129,7 @@ VALUE Gyro_Timer_await(VALUE self) {
     timer->fiber = Qnil;
     timer->selector = Qnil;
     ev_timer_stop(timer->ev_loop, &timer->ev_timer);
+    timer->ev_loop = 0;
   }
   RB_GC_GUARD(self);
 

data/lib/polyphony/core/exceptions.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-export :Interrupt, :MoveOn, :Cancel
+export :Interrupt, :MoveOn, :Cancel, :Terminate
 
 # Common exception class for interrupting fibers. These exceptions allow
 # control of fibers. Interrupt exceptions can encapsulate a value and thus
@@ -24,3 +24,6 @@ class MoveOn < Interrupt; end
 # Cancel is used to interrupt a long-running blocking operation, bubbling the
 # exception up through cancel scopes and supervisors.
 class Cancel < Interrupt; end
+
+# Terminate is used to interrupt a fiber once its parent fiber has terminated.
+class Terminate < Interrupt; end

data/lib/polyphony/core/global_api.rb

@@ -6,7 +6,6 @@ import '../extensions/core'
 import '../extensions/fiber'
 
 Exceptions  = import '../core/exceptions'
-Supervisor  = import '../core/supervisor'
 Throttler   = import '../core/throttler'
 
 # Global API methods to be included in ::Object
@@ -30,7 +29,7 @@ module API
   end
 
   def spin(tag = nil, &block)
-    Fiber.spin(tag, caller, &block)
+    Fiber.current.spin(tag, caller, &block)
   end
 
   def spin_loop(&block)
@@ -78,10 +77,6 @@ module API
     Thread.current.fiber_unref
   end
 
-  def supervise(&block)
-    Supervisor.new.await(&block)
-  end
-
   def throttled_loop(rate, count: nil, &block)
     throttler = Throttler.new(rate)
     if count

data/lib/polyphony/core/thread_pool.rb

@@ -22,9 +22,9 @@ class ThreadPool
   def process(&block)
     setup unless @task_queue
 
-    watcher = Gyro::Async.new
-    @task_queue << [block, watcher]
-    watcher.await
+    async = Gyro::Async.new
+    @task_queue << [block, async]
+    async.await
   end
 
   def cast(&block)

data/lib/polyphony/extensions/core.rb

@@ -14,6 +14,8 @@ class ::Exception
 
   alias_method :orig_initialize, :initialize
 
+  EXIT_EXCEPTION_CLASSES = [::Interrupt, ::SystemExit].freeze
+
   def initialize(*args)
     @__raising_fiber__ = Fiber.current
     orig_initialize(*args)
@@ -21,11 +23,15 @@ class ::Exception
 
   alias_method_once :orig_backtrace, :backtrace
   def backtrace
-    unless @first_backtrace_call
+    unless @first_backtrace_call || EXIT_EXCEPTION_CLASSES.include?(self.class)
       @first_backtrace_call = true
       return orig_backtrace
     end
 
+    sanitized_backtrace
+  end
+
+  def sanitized_backtrace
     if @__raising_fiber__
       backtrace = orig_backtrace || []
       sanitize(backtrace + @__raising_fiber__.caller)