polyphony 0.36 → 0.38

data/ext/gyro/queue.c

@@ -1,19 +1,19 @@
 #include "gyro.h"
 
 struct Gyro_Queue {
-  VALUE queue;
-  VALUE wait_queue;
+  VALUE items;
+  VALUE shift_waiters;
 };
 
 VALUE cGyro_Queue = Qnil;
 
 static void Gyro_Queue_mark(void *ptr) {
   struct Gyro_Queue *queue = ptr;
-  if (queue->queue != Qnil) {
-    rb_gc_mark(queue->queue);
+  if (queue->items != Qnil) {
+    rb_gc_mark(queue->items);
   }
-  if (queue->wait_queue != Qnil) {
-    rb_gc_mark(queue->wait_queue);
+  if (queue->shift_waiters != Qnil) {
+    rb_gc_mark(queue->shift_waiters);
   }
 }
 
@@ -43,22 +43,22 @@ static VALUE Gyro_Queue_initialize(VALUE self) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
-  queue->queue      = rb_ary_new();
-  queue->wait_queue = rb_ary_new();
+  queue->items = rb_ary_new();
+  queue->shift_waiters = rb_ary_new();
   
-  return Qnil;
+  return self;
 }
 
 VALUE Gyro_Queue_push(VALUE self, VALUE value) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
-  if (RARRAY_LEN(queue->wait_queue) > 0) {
-    VALUE async = rb_ary_shift(queue->wait_queue);
+  if (RARRAY_LEN(queue->shift_waiters) > 0) {
+    VALUE async = rb_ary_shift(queue->shift_waiters);
     rb_funcall(async, ID_signal, 1, Qnil);
   }
   
-  rb_ary_push(queue->queue, value);
+  rb_ary_push(queue->items, value);
   return self;
 }
 
@@ -66,33 +66,33 @@ VALUE Gyro_Queue_shift(VALUE self) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
-  if (RARRAY_LEN(queue->queue) == 0) {
+  if (RARRAY_LEN(queue->items) == 0) {
     VALUE async = Fiber_auto_async(rb_fiber_current());
-    rb_ary_push(queue->wait_queue, async);
+    rb_ary_push(queue->shift_waiters, async);
     VALUE ret = Gyro_Async_await_no_raise(async);
     if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-      rb_ary_delete(queue->wait_queue, async);
+      rb_ary_delete(queue->shift_waiters, async);
       return rb_funcall(rb_mKernel, ID_raise, 1, ret);
     }
     RB_GC_GUARD(ret);
   }
 
-  return rb_ary_shift(queue->queue);
+  return rb_ary_shift(queue->items);
 }
 
 VALUE Gyro_Queue_shift_no_wait(VALUE self) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
-  return rb_ary_shift(queue->queue);
+  return rb_ary_shift(queue->items);
 }
 
 VALUE Gyro_Queue_shift_each(VALUE self) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
-  VALUE old_queue = queue->queue;
-  queue->queue = rb_ary_new();
+  VALUE old_queue = queue->items;
+  queue->items = rb_ary_new();
 
   if (rb_block_given_p()) {
     long len = RARRAY_LEN(old_queue);
@@ -112,7 +112,7 @@ VALUE Gyro_Queue_clear(VALUE self) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
-  rb_ary_clear(queue->queue);
+  rb_ary_clear(queue->items);
   return self;
 }
 
@@ -120,7 +120,7 @@ VALUE Gyro_Queue_empty_p(VALUE self) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
-  return (RARRAY_LEN(queue->queue) == 0) ? Qtrue : Qfalse;
+  return (RARRAY_LEN(queue->items) == 0) ? Qtrue : Qfalse;
 }
 
 void Init_Gyro_Queue() {

data/ext/gyro/selector.c

@@ -174,6 +174,26 @@ VALUE Gyro_Selector_break_out_of_ev_loop(VALUE self) {
   return Qnil;
 }
 
+ID ID_deactivate_post_fork;
+
+static int deactivate_watcher(VALUE key, VALUE value, VALUE _) {
+    rb_funcall(key, ID_deactivate_post_fork, 0);
+    return ST_CONTINUE;
+}
+
+VALUE Gyro_Selector_deactivate_all_watchers_post_fork(VALUE self) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  VALUE old_active_watchers = selector->active_watchers;
+  selector->active_watchers = rb_hash_new();
+  
+  rb_hash_foreach(old_active_watchers, deactivate_watcher, Qnil);
+  
+  RB_GC_GUARD(old_active_watchers);
+  return self;
+}
+
 inline static VALUE Gyro_Selector_wait_readable(VALUE self, VALUE io) {
   VALUE watcher = IO_read_watcher(io);
   return Gyro_IO_await(watcher);
@@ -202,4 +222,7 @@ void Init_Gyro_Selector() {
   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);
+  rb_define_method(cGyro_Selector, "deactivate_all_watchers_post_fork", Gyro_Selector_deactivate_all_watchers_post_fork, 0);
+
+  ID_deactivate_post_fork = rb_intern("deactivate_post_fork");
 }

data/ext/gyro/signal.c

@@ -24,11 +24,15 @@ static void Gyro_Signal_mark(void *ptr) {
 
 static void Gyro_Signal_free(void *ptr) {
   struct Gyro_Signal *signal = ptr;
-  if (signal->active) {
-    ev_clear_pending(signal->ev_loop, &signal->ev_signal);
-    ev_signal_stop(signal->ev_loop, &signal->ev_signal);
+  switch (signal->active) {
+    case GYRO_WATCHER_POST_FORK:
+      return;
+    case 1:
+      ev_clear_pending(signal->ev_loop, &signal->ev_signal);
+      ev_signal_stop(signal->ev_loop, &signal->ev_signal);
+    default:
+      xfree(signal);
   }
-  xfree(signal);
 }
 
 static size_t Gyro_Signal_size(const void *ptr) {
@@ -46,7 +50,7 @@ static VALUE Gyro_Signal_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Gyro_Signal_type, signal);
 }
 
-inline void Gyro_Signal_activate(struct Gyro_Signal *signal) {
+inline void signal_activate(struct Gyro_Signal *signal) {
   if (signal->active) return;
 
   signal->active = 1;
@@ -57,7 +61,7 @@ inline void Gyro_Signal_activate(struct Gyro_Signal *signal) {
   ev_signal_start(signal->ev_loop, &signal->ev_signal);
 }
 
-inline void Gyro_Signal_deactivate(struct Gyro_Signal *signal) {
+inline void signal_deactivate(struct Gyro_Signal *signal) {
   if (!signal->active) return;
 
   ev_signal_stop(signal->ev_loop, &signal->ev_signal);
@@ -72,7 +76,7 @@ void Gyro_Signal_callback(struct ev_loop *ev_loop, struct ev_signal *ev_signal,
   struct Gyro_Signal *signal = (struct Gyro_Signal*)ev_signal;
 
   Fiber_make_runnable(signal->fiber, INT2NUM(signal->signum));
-  Gyro_Signal_deactivate(signal);
+  signal_deactivate(signal);
 }
 
 #define GetGyro_Signal(obj, signal) \
@@ -100,19 +104,30 @@ static VALUE Gyro_Signal_await(VALUE self) {
   struct Gyro_Signal *signal;
   GetGyro_Signal(self, signal);
 
-  Gyro_Signal_activate(signal);
+  signal_activate(signal);
   VALUE ret = Gyro_switchpoint();
-  Gyro_Signal_deactivate(signal);
+  signal_deactivate(signal);
 
   TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
+VALUE Gyro_Signal_deactivate_post_fork(VALUE self) {
+  struct Gyro_Signal *signal;
+  GetGyro_Signal(self, signal);
+
+  if (signal->active)
+    signal->active = GYRO_WATCHER_POST_FORK;
+
+  return self;
+}
+
 void Init_Gyro_Signal() {
   cGyro_Signal = rb_define_class_under(mGyro, "Signal", rb_cData);
   rb_define_alloc_func(cGyro_Signal, Gyro_Signal_allocate);
 
   rb_define_method(cGyro_Signal, "initialize", Gyro_Signal_initialize, 1);
   rb_define_method(cGyro_Signal, "await", Gyro_Signal_await, 0);
+  rb_define_method(cGyro_Signal, "deactivate_post_fork", Gyro_Signal_deactivate_post_fork, 0);
 }

data/ext/gyro/thread.c

@@ -3,6 +3,7 @@
 static VALUE cQueue;
 
 static ID ID_create_event_selector;
+static ID ID_deactivate_all_watchers_post_fork;
 static ID ID_empty;
 static ID ID_fiber_ref_count;
 static ID ID_ivar_event_selector_proc;
@@ -14,8 +15,6 @@ static ID ID_ivar_terminated;
 static ID ID_pop;
 static ID ID_push;
 static ID ID_run_queue;
-// static ID ID_run_queue_head;
-// static ID ID_run_queue_tail;
 static ID ID_runnable_next;
 static ID ID_stop;
 
@@ -63,6 +62,15 @@ static VALUE Thread_stop_event_selector(VALUE self) {
   return self;
 }
 
+static VALUE Thread_deactivate_all_watchers_post_fork(VALUE self) {
+  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+  if (selector != Qnil) {
+    rb_funcall(selector, ID_deactivate_all_watchers_post_fork, 0);
+  }
+
+  return self;
+}
+
 VALUE Thread_ref(VALUE self) {
   VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
   int new_count = NUM2INT(count) + 1;
@@ -267,6 +275,7 @@ void Init_Thread() {
 
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "stop_event_selector", Thread_stop_event_selector, 0);
+  rb_define_method(rb_cThread, "deactivate_all_watchers_post_fork", Thread_deactivate_all_watchers_post_fork, 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, 2);
@@ -277,6 +286,7 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
 
   ID_create_event_selector    = rb_intern("create_event_selector");
+  ID_deactivate_all_watchers_post_fork = rb_intern("deactivate_all_watchers_post_fork");
   ID_empty                    = rb_intern("empty?");
   ID_fiber_ref_count          = rb_intern("fiber_ref_count");
   ID_ivar_event_selector      = rb_intern("@event_selector");

data/ext/gyro/timer.c

@@ -25,11 +25,15 @@ static void Gyro_Timer_mark(void *ptr) {
 
 static void Gyro_Timer_free(void *ptr) {
   struct Gyro_Timer *timer = ptr;
-  if (timer->active) {
-    ev_clear_pending(timer->ev_loop, &timer->ev_timer);
-    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
+  switch (timer->active) {
+    case GYRO_WATCHER_POST_FORK:
+      return;
+    case 1:
+      ev_clear_pending(timer->ev_loop, &timer->ev_timer);
+      ev_timer_stop(timer->ev_loop, &timer->ev_timer);
+    default:
+      xfree(timer);
   }
-  xfree(timer);
 }
 
 static size_t Gyro_Timer_size(const void *ptr) {
@@ -50,7 +54,7 @@ static VALUE Gyro_Timer_allocate(VALUE klass) {
 #define GetGyro_Timer(obj, timer) \
   TypedData_Get_Struct((obj), struct Gyro_Timer, &Gyro_Timer_type, (timer))
 
-inline void Gyro_Timer_activate(struct Gyro_Timer *timer) {
+inline void timer_activate(struct Gyro_Timer *timer) {
   timer->fiber = rb_fiber_current();
   timer->selector = Thread_current_event_selector();
   timer->ev_loop = Gyro_Selector_ev_loop(timer->selector);
@@ -62,7 +66,7 @@ inline void Gyro_Timer_activate(struct Gyro_Timer *timer) {
   ev_timer_start(timer->ev_loop, &timer->ev_timer);
 }
 
-inline void Gyro_Timer_deactivate(struct Gyro_Timer *timer, int non_recurring_only) {
+inline void timer_deactivate(struct Gyro_Timer *timer, int non_recurring_only) {
   if (!timer->active) return;
 
   if (!timer->repeat || !non_recurring_only) {
@@ -82,7 +86,7 @@ void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int
   struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
 
   Fiber_make_runnable(timer->fiber, DBL2NUM(timer->after));
-  Gyro_Timer_deactivate(timer, 1);
+  timer_deactivate(timer, 1);
 }
 
 static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
@@ -90,13 +94,13 @@ static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
 
   GetGyro_Timer(self, timer);
 
-  timer->self     = self;
-  timer->fiber    = Qnil;
-  timer->selector = Qnil;
-  timer->after    = NUM2DBL(after);
-  timer->repeat   = NUM2DBL(repeat);
-  timer->active   = 0;
-  timer->ev_loop  = 0;
+  timer->self       = self;
+  timer->fiber      = Qnil;
+  timer->selector   = Qnil;
+  timer->after      = NUM2DBL(after);
+  timer->repeat     = NUM2DBL(repeat);
+  timer->active     = 0;
+  timer->ev_loop    = 0;
 
   ev_timer_init(&timer->ev_timer, Gyro_Timer_callback, timer->after, timer->repeat);
 
@@ -107,7 +111,7 @@ VALUE Gyro_Timer_stop(VALUE self) {
   struct Gyro_Timer *timer;
   GetGyro_Timer(self, timer);
 
-  Gyro_Timer_deactivate(timer, 0);
+  timer_deactivate(timer, 0);
   return self;
 }
 
@@ -115,20 +119,31 @@ VALUE Gyro_Timer_await(VALUE self) {
   struct Gyro_Timer *timer;
   GetGyro_Timer(self, timer);
 
-  Gyro_Timer_activate(timer);
+  timer_activate(timer);
   VALUE ret = Gyro_switchpoint();
-  Gyro_Timer_deactivate(timer, 1);
+  timer_deactivate(timer, 1);
 
   TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
+VALUE Gyro_Timer_deactivate_post_fork(VALUE self) {
+  struct Gyro_Timer *timer;
+  GetGyro_Timer(self, timer);
+
+  if (timer->active)
+    timer->active = GYRO_WATCHER_POST_FORK;
+
+  return self;
+}
+
 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);
+  rb_define_method(cGyro_Timer, "deactivate_post_fork", Gyro_Timer_deactivate_post_fork, 0);
+  rb_define_method(cGyro_Timer, "stop", Gyro_Timer_stop, 0);
 }

data/lib/polyphony.rb

@@ -1,44 +1,24 @@
 # frozen_string_literal: true
 
-require 'modulation/gem'
-
-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'
+require_relative './polyphony/extensions/core'
+require_relative './polyphony/extensions/thread'
+require_relative './polyphony/extensions/fiber'
+require_relative './polyphony/extensions/io'
+
+require_relative './polyphony/core/global_api'
+require_relative './polyphony/core/resource_pool'
+require_relative './polyphony/net'
+
+require_relative './polyphony/adapters/process'
 
 # Main Polyphony API
 module Polyphony
-  GlobalAPI = import './polyphony/core/global_api'
-  ::Object.include GlobalAPI
-
-  exceptions = import './polyphony/core/exceptions'
-  Cancel    = exceptions::Cancel
-  MoveOn    = exceptions::MoveOn
-  Restart   = exceptions::Restart
-  Terminate = exceptions::Terminate
-
-  Net = import './polyphony/net'
-
-  auto_import(
-    Channel:      './polyphony/core/channel',
-    FS:           './polyphony/adapters/fs',
-    Process:      './polyphony/adapters/process',
-    ResourcePool: './polyphony/core/resource_pool',
-    Sync:         './polyphony/core/sync',
-    ThreadPool:   './polyphony/core/thread_pool',
-    Throttler:    './polyphony/core/throttler',
-    Trace:        './polyphony/adapters/trace'
-  )
-
   class << self
     def wait_for_signal(sig)
       fiber = Fiber.current
@@ -52,7 +32,10 @@ module Polyphony
     end
 
     def fork(&block)
+      old_threads = Thread.list - [Thread.current]
       Kernel.fork do
+        old_threads.each(&:deactivate_all_watchers_post_fork)
+
         # Since the fiber doing the fork will become the main fiber of the
         # forked process, we leave it behind by transferring to a new fiber
         # created in the context of the forked process, which rescues *all*
@@ -64,12 +47,13 @@ module Polyphony
     def spin_forked_block(&block)
       Fiber.new do
         run_forked_block(&block)
-        exit_forked_process
-      rescue ::SystemExit
-        exit_forked_process
+      rescue SystemExit
+        # fall through to ensure
       rescue Exception => e
         e.full_message
         exit!
+      ensure
+        exit_forked_process
       end
     end
 
@@ -91,14 +75,13 @@ module Polyphony
     end
 
     def exit_forked_process
+      terminate_threads
       Fiber.current.shutdown_all_children
+
       # Since fork could be called from any fiber, we explicitly call exit here.
       # Otherwise, the fiber might want to pass execution to another fiber that
       # previously transferred execution to the forking fiber, but doesn't exist
       # anymore...
-      #
-      # The call to exit will invoke the at_exit handler we use to terminate the
-      # (forked) main fiber's child fibers.
       exit
     end
 
@@ -118,6 +101,14 @@ module Polyphony
       install_terminating_signal_handler('SIGTERM', ::SystemExit)
       install_terminating_signal_handler('SIGINT', ::Interrupt)
     end
+
+    def terminate_threads
+      threads = Thread.list - [Thread.current]
+      return if threads.empty?
+
+      threads.each(&:kill)
+      threads.each(&:join)
+    end
   end
 end