polyphony 0.40 → 0.41

data/ext/{gyro → polyphony}/thread.c

@@ -1,75 +1,26 @@
-#include "gyro.h"
-
-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;
-static ID ID_ivar_event_selector;
-static ID ID_ivar_join_wait_queue;
-static ID ID_ivar_main_fiber;
-static ID ID_ivar_result;
-static ID ID_ivar_terminated;
-static ID ID_pop;
-static ID ID_push;
-static ID ID_run_queue;
-static ID ID_runnable_next;
-static ID ID_stop;
-
-VALUE event_selector_factory_proc(RB_BLOCK_CALL_FUNC_ARGLIST(args, klass)) {
-  return rb_funcall(klass, ID_new, 1, rb_ary_entry(args, 0));
-}
-
-static VALUE Thread_event_selector_set_proc(VALUE self, VALUE proc) {
-  if (!rb_obj_is_proc(proc)) {
-    proc = rb_proc_new(event_selector_factory_proc, proc);
-  }
-  rb_ivar_set(self, ID_ivar_event_selector_proc, proc);
-  return self;
-}
-
-static VALUE Thread_create_event_selector(VALUE self, VALUE thread) {
-  VALUE selector_proc = rb_ivar_get(self, ID_ivar_event_selector_proc);
-  if (selector_proc == Qnil) {
-    rb_raise(rb_eRuntimeError, "No event_selector_proc defined");
-  }
-
-  return rb_funcall(selector_proc, ID_call, 1, thread);
-}
+#include "polyphony.h"
+
+ID ID_deactivate_all_watchers_post_fork;
+ID ID_empty;
+ID ID_fiber_ref_count;
+ID ID_ivar_agent;
+ID ID_ivar_join_wait_queue;
+ID ID_ivar_main_fiber;
+ID ID_ivar_result;
+ID ID_ivar_terminated;
+ID ID_pop;
+ID ID_push;
+ID ID_run_queue;
+ID ID_runnable_next;
+ID ID_stop;
 
 static VALUE Thread_setup_fiber_scheduling(VALUE self) {
   VALUE queue;
-  VALUE selector;
   
   rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
   rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
   queue = rb_ary_new();
   rb_ivar_set(self, ID_run_queue, queue);
-  selector = rb_funcall(rb_cThread, ID_create_event_selector, 1, self);
-  rb_ivar_set(self, ID_ivar_event_selector, selector);
-
-  return self;
-}
-
-static VALUE Thread_stop_event_selector(VALUE self) {
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  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;
-}
-
-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;
 }
@@ -101,15 +52,15 @@ static VALUE SYM_scheduled_fibers;
 static VALUE SYM_pending_watchers;
 
 static VALUE Thread_fiber_scheduling_stats(VALUE self) {
+  VALUE agent = rb_ivar_get(self,ID_ivar_agent);
   VALUE stats = rb_hash_new();
   VALUE queue = rb_ivar_get(self, ID_run_queue);
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
   long pending_count;
 
   long scheduled_count = RARRAY_LEN(queue);
   rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
 
-  pending_count = Gyro_Selector_pending_count(selector);
+  pending_count = LibevAgent_pending_count(agent);
   rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
 
   return stats;
@@ -137,10 +88,8 @@ VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
     // 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);
-    }
+    VALUE agent = rb_ivar_get(self,ID_ivar_agent);
+    LibevAgent_break(agent);
   }
   return self;
 }
@@ -168,13 +117,11 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
   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
+    // event loop. 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);
-    }
+    VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+    LibevAgent_break(agent);
   }
   return self;
 }
@@ -182,9 +129,9 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
 VALUE Thread_switch_fiber(VALUE self) {
   VALUE current_fiber = rb_fiber_current();
   VALUE queue = rb_ivar_get(self, ID_run_queue);
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
   VALUE next_fiber;
   VALUE value;
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
   int ref_count;
 
   if (__tracing_enabled__) {
@@ -193,31 +140,23 @@ VALUE Thread_switch_fiber(VALUE self) {
     }
   }
 
-
   while (1) {
-    next_fiber = rb_ary_shift(queue);
-    // if (break_flag != 0) {
-    //   return Qnil;
-    // }
     ref_count = Thread_fiber_ref_count(self);
+    next_fiber = rb_ary_shift(queue);
     if (next_fiber != Qnil) {
       if (ref_count > 0) {
         // this mechanism prevents event starvation in case the run queue never
         // empties
-        Gyro_Selector_run_no_wait(selector, current_fiber, RARRAY_LEN(queue));
+        LibevAgent_poll(agent, Qtrue, current_fiber, queue);
       }
       break;
     }
-    if (ref_count == 0) {
-      break;
-    }
+    if (ref_count == 0) break;
 
-    Gyro_Selector_run(selector, current_fiber);
+    LibevAgent_poll(agent, Qnil, current_fiber, queue);
   }
 
-  if (next_fiber == Qnil) {
-    return Qnil;
-  }
+  if (next_fiber == Qnil) return Qnil;
 
   // run next fiber
   value = rb_ivar_get(next_fiber, ID_runnable_value);
@@ -236,14 +175,7 @@ VALUE Thread_reset_fiber_scheduling(VALUE self) {
   return self;
 }
 
-VALUE Thread_post_fork(VALUE self) {
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  Gyro_Selector_post_fork(selector);
-
-  return self;
-}
-
-VALUE Gyro_switchpoint() {
+VALUE Polyphony_switchpoint() {
   VALUE ret;
   VALUE thread = rb_thread_current();
   Thread_ref(thread);
@@ -253,17 +185,13 @@ VALUE Gyro_switchpoint() {
   return ret;
 }
 
-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 fiber, VALUE resume_obj) {
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
   if (fiber != Qnil) {
     Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
   }
 
-  if (Gyro_Selector_break_out_of_ev_loop(selector) == Qnil) {
+  if (LibevAgent_break(agent) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
@@ -272,19 +200,10 @@ VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE fiber, VALUE resume_ob
 }
 
 void Init_Thread() {
-  cQueue = rb_const_get(rb_cObject, rb_intern("Queue"));
-
-  rb_define_singleton_method(rb_cThread, "event_selector=", Thread_event_selector_set_proc, 1);
-  rb_define_singleton_method(rb_cThread, "create_event_selector", Thread_create_event_selector, 1);
-
   rb_define_method(rb_cThread, "fiber_ref", Thread_ref, 0);
   rb_define_method(rb_cThread, "fiber_unref", Thread_unref, 0);
 
-  rb_define_method(rb_cThread, "post_fork", Thread_post_fork, 0);
-
   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);
@@ -294,12 +213,10 @@ void Init_Thread() {
     Thread_schedule_fiber_with_priority, 2);
   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");
-  ID_ivar_event_selector_proc = rb_intern("@event_selector_proc");
+  ID_ivar_agent               = rb_intern("@agent");
   ID_ivar_join_wait_queue     = rb_intern("@join_wait_queue");
   ID_ivar_main_fiber          = rb_intern("@main_fiber");
   ID_ivar_result              = rb_intern("@result");

data/ext/{gyro → polyphony}/tracing.c

@@ -1,4 +1,4 @@
-#include "gyro.h"
+#include "polyphony.h"
 
 int __tracing_enabled__ = 0;
 

data/lib/polyphony.rb

@@ -1,29 +1,35 @@
 # frozen_string_literal: true
 
 require 'fiber'
-require_relative './gyro_ext'
+require_relative './polyphony_ext'
 
-Thread.event_selector = Gyro::Selector
-Thread.current.setup_fiber_scheduling
+module Polyphony
+  # Map Queue to Libev queue implementation
+  Queue = LibevQueue
+end
 
 require_relative './polyphony/extensions/core'
 require_relative './polyphony/extensions/thread'
 require_relative './polyphony/extensions/fiber'
 require_relative './polyphony/extensions/io'
 
+Thread.current.setup_fiber_scheduling
+Thread.current.agent = Polyphony::LibevAgent.new
+
 require_relative './polyphony/core/global_api'
 require_relative './polyphony/core/resource_pool'
 require_relative './polyphony/net'
 require_relative './polyphony/adapters/process'
+require_relative './polyphony/event'
 
 # Main Polyphony API
 module Polyphony
   class << self
     def wait_for_signal(sig)
       fiber = Fiber.current
-      Gyro.ref
+      Polyphony.ref
       old_trap = trap(sig) do
-        Gyro.unref
+        Polyphony.unref
         fiber.schedule(sig)
         trap(sig, old_trap)
       end
@@ -32,12 +38,10 @@ module Polyphony
 
     def fork(&block)
       Kernel.fork do
-        Gyro.incr_generation
-
-        # 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*
-        # exceptions, including Interrupt and SystemExit.
+        # # 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*
+        # # exceptions, including Interrupt and SystemExit.
         spin_forked_block(&block).transfer
       end
     end
@@ -63,9 +67,9 @@ module Polyphony
       trap('SIGTERM', 'DEFAULT')
       trap('SIGINT', 'DEFAULT')
 
-      Thread.current.post_fork
       Thread.current.setup
       Fiber.current.setup_main_fiber
+      Thread.current.agent.post_fork
 
       install_terminating_signal_handlers
 

data/lib/polyphony/adapters/irb.rb

@@ -16,7 +16,7 @@ if Object.constants.include?(:Reline)
         fiber.cancel
       end
       read_ios.each do |io|
-        io.read_watcher.await
+        Thread.current.agent.wait_io(io, false)
         return [io]
       end
     rescue Polyphony::Cancel

data/lib/polyphony/adapters/postgres.rb

@@ -10,12 +10,13 @@ module ::PG
   end
 
   def self.connect_async(conn)
+    socket_io = conn.socket_io
     loop do
       res = conn.connect_poll
       case res
       when PGRES_POLLING_FAILED   then raise Error, conn.error_message
-      when PGRES_POLLING_READING  then conn.socket_io.read_watcher.await
-      when PGRES_POLLING_WRITING  then conn.socket_io.write_watcher.await
+      when PGRES_POLLING_READING  then Thread.current.agent.wait_io(socket_io, false)
+      when PGRES_POLLING_WRITING  then Thread.current.agent.wait_io(socket_io, true)
       when PGRES_POLLING_OK       then return conn.setnonblocking(true)
       end
     end
@@ -41,7 +42,7 @@ class ::PG::Connection
 
   def get_result(&block)
     while is_busy
-      socket_io.read_watcher.await
+      Thread.current.agent.wait_io(socket_io, false)
       consume_input
     end
     orig_get_result(&block)
@@ -58,7 +59,7 @@ class ::PG::Connection
 
   def block(_timeout = 0)
     while is_busy
-      socket_io.read_watcher.await
+      Thread.current.agent.wait_io(socket_io, false)
       consume_input
     end
   end
@@ -96,7 +97,7 @@ class ::PG::Connection
     return move_on_after(timeout) { wait_for_notify(&block) } if timeout
 
     loop do
-      socket_io.read_watcher.await
+      Thread.current.agent.wait_io(socket_io, false)
       consume_input
       notice = notifies
       next unless notice

data/lib/polyphony/adapters/process.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 module Polyphony
+  # Process patches
   module Process
     class << self
       def watch(cmd = nil, &block)
         terminated = nil
         pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
-        watcher = Gyro::Child.new(pid)
-        watcher.await
+        Thread.current.agent.waitpid(pid)
         terminated = true
       ensure
         kill_process(pid) unless terminated || pid.nil?
       end
-      
+
       def kill_process(pid)
         cancel_after(5) do
           kill_and_await('TERM', pid)
@@ -20,10 +20,10 @@ module Polyphony
       rescue Polyphony::Cancel
         kill_and_await(-9, pid)
       end
-      
+
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
-        Gyro::Child.new(pid).await
+        Thread.current.agent.waitpid(pid)
       rescue SystemCallError
         # ignore
         puts 'SystemCallError in kill_and_await'

data/lib/polyphony/adapters/trace.rb

@@ -5,6 +5,7 @@ require_relative '../../polyphony'
 STOCK_EVENTS = %i[line call return c_call c_return b_call b_return].freeze
 
 module Polyphony
+  # Tracing functionality for Polyphony
   module Trace
     class << self
       def new(*events)
@@ -12,10 +13,10 @@ module Polyphony
         events = STOCK_EVENTS if events.empty?
         ::TracePoint.new(*events) { |tp| yield trace_record(tp, start_stamp) }
       end
-      
+
       def trace_record(trp, start_stamp)
         stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_stamp
-      
+
         { stamp: stamp, event: trp.event, location: "#{trp.path}:#{trp.lineno}",
           self: trp.self, binding: trp.binding, fiber: tp_fiber(trp),
           lineno: trp.lineno, method_id: trp.method_id,
@@ -23,103 +24,103 @@ module Polyphony
           return_value: tp_return_value(trp), schedule_value: tp_schedule_value(trp),
           exception: tp_raised_exception(trp) }
       end
-      
+
       def tp_fiber(trp)
         trp.is_a?(FiberTracePoint) ? trp.fiber : Fiber.current
       end
-      
+
       PARAMS_EVENTS = %i[call c_call b_call].freeze
-      
+
       def tp_params(trp)
         PARAMS_EVENTS.include?(trp.event) ? trp.parameters : nil
       end
-      
+
       RETURN_VALUE_EVENTS = %i[return c_return b_return].freeze
-      
+
       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
-      
+
       def analyze(records)
         by_fiber = Hash.new { |h, f| h[f] = [] }
         records.each_with_object(by_fiber) { |r, h| h[r[:fiber]] << r }
         { by_fiber: by_fiber }
       end
-      
+
       # Implements fake TracePoint instances for fiber-related events
       class FiberTracePoint
         attr_reader :event, :fiber, :value
-      
+
         def initialize(tpoint)
           @tp = tpoint
           @event = tpoint.return_value[0]
           @fiber = tpoint.return_value[1]
           @value = tpoint.return_value[2]
         end
-      
+
         def lineno
           @tp.lineno
         end
-      
+
         def method_id
           @tp.method_id
         end
-      
+
         def path
           @tp.path
         end
-      
+
         def self
           @tp.self
         end
-      
+
         def binding
           @tp.binding
         end
       end
-      
+
       class << ::TracePoint
         POLYPHONY_FILE_REGEXP = /^#{::Exception::POLYPHONY_DIR}/.freeze
-      
+
         alias_method :orig_new, :new
         def new(*args, &block)
           events_mask, fiber_events_mask = event_masks(args)
-      
+
           orig_new(*events_mask) do |tp|
             handle_tp_event(tp, fiber_events_mask, &block)
           end
         end
-      
+
         def handle_tp_event(tpoint, fiber_events_mask)
           # next unless !$watched_fiber || Fiber.current == $watched_fiber
-      
+
           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
@@ -135,4 +136,3 @@ module Polyphony
     end
   end
 end
-