polyphony 0.44.0 → 0.45.0

data/ext/polyphony/polyphony.c

@@ -22,7 +22,7 @@ ID ID_R;
 ID ID_W;
 ID ID_RW;
 
-agent_interface_t agent_interface;
+backend_interface_t backend_interface;
 
 VALUE Polyphony_snooze(VALUE self) {
   VALUE ret;

data/ext/polyphony/polyphony.h

@@ -4,7 +4,7 @@
 #include "ruby.h"
 #include "ruby/io.h"
 #include "libev.h"
-#include "agent.h"
+#include "backend.h"
 
 // debugging
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
@@ -25,8 +25,8 @@
 }
 
 
-extern agent_interface_t agent_interface;
-#define __AGENT__ (agent_interface)
+extern backend_interface_t backend_interface;
+#define __BACKEND__ (backend_interface)
 
 extern VALUE mPolyphony;
 extern VALUE cQueue;
@@ -39,7 +39,7 @@ extern ID ID_each;
 extern ID ID_fiber_trace;
 extern ID ID_inspect;
 extern ID ID_invoke;
-extern ID ID_ivar_agent;
+extern ID ID_ivar_backend;
 extern ID ID_ivar_running;
 extern ID ID_ivar_thread;
 extern ID ID_new;

data/ext/polyphony/polyphony_ext.c

@@ -2,7 +2,7 @@
 
 void Init_Fiber();
 void Init_Polyphony();
-void Init_LibevAgent();
+void Init_LibevBackend();
 void Init_Queue();
 void Init_Event();
 void Init_Thread();
@@ -12,7 +12,7 @@ void Init_polyphony_ext() {
   ev_set_allocator(xrealloc);
 
   Init_Polyphony();
-  Init_LibevAgent();
+  Init_LibevBackend();
   Init_Queue();
   Init_Event();
 

data/ext/polyphony/queue.c

@@ -80,13 +80,13 @@ VALUE Queue_shift(VALUE self) {
 
   VALUE fiber = rb_fiber_current();
   VALUE thread = rb_thread_current();
-  VALUE agent = rb_ivar_get(thread, ID_ivar_agent);
+  VALUE backend = rb_ivar_get(thread, ID_ivar_backend);
 
   while (1) {
     ring_buffer_push(&queue->shift_queue, fiber);
     if (queue->values.count > 0) Fiber_make_runnable(fiber, Qnil);
     
-    VALUE switchpoint_result = __AGENT__.wait_event(agent, Qnil);
+    VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
     ring_buffer_delete(&queue->shift_queue, fiber);
 
     if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException)))

data/ext/polyphony/thread.c

@@ -1,7 +1,7 @@
 #include "polyphony.h"
 
 ID ID_deactivate_all_watchers_post_fork;
-ID ID_ivar_agent;
+ID ID_ivar_backend;
 ID ID_ivar_join_wait_queue;
 ID ID_ivar_main_fiber;
 ID ID_ivar_result;
@@ -20,20 +20,20 @@ static VALUE Thread_setup_fiber_scheduling(VALUE self) {
 }
 
 int Thread_fiber_ref_count(VALUE self) {
-  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
-  return NUM2INT(__AGENT__.ref_count(agent));
+  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
+  return NUM2INT(__BACKEND__.ref_count(backend));
 }
 
 inline void Thread_fiber_reset_ref_count(VALUE self) {
-  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
-  __AGENT__.reset_ref_count(agent);
+  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
+  __BACKEND__.reset_ref_count(backend);
 }
 
 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 backend = rb_ivar_get(self,ID_ivar_backend);
   VALUE stats = rb_hash_new();
   VALUE queue = rb_ivar_get(self, ID_run_queue);
   long pending_count;
@@ -41,7 +41,7 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   long scheduled_count = RARRAY_LEN(queue);
   rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
 
-  pending_count = __AGENT__.pending_count(agent);
+  pending_count = __BACKEND__.pending_count(backend);
   rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
 
   return stats;
@@ -77,8 +77,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 agent = rb_ivar_get(self,ID_ivar_agent);
-      __AGENT__.wakeup(agent);
+      VALUE backend = rb_ivar_get(self,ID_ivar_backend);
+      __BACKEND__.wakeup(backend);
     }
   }
   return self;
@@ -110,8 +110,8 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
     // 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 agent = rb_ivar_get(self, ID_ivar_agent);
-    __AGENT__.wakeup(agent);
+    VALUE backend = rb_ivar_get(self, ID_ivar_backend);
+    __BACKEND__.wakeup(backend);
   }
   return self;
 }
@@ -121,28 +121,28 @@ VALUE Thread_switch_fiber(VALUE self) {
   VALUE queue = rb_ivar_get(self, ID_run_queue);
   VALUE next_fiber;
   VALUE value;
-  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   int ref_count;
-  int agent_was_polled = 0;
+  int backend_was_polled = 0;
 
   if (__tracing_enabled__ && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
     TRACE(2, SYM_fiber_switchpoint, current_fiber);
 
-  ref_count = __AGENT__.ref_count(agent);
+  ref_count = __BACKEND__.ref_count(backend);
   while (1) {
     next_fiber = Queue_shift_no_wait(queue);
     if (next_fiber != Qnil) {
-      if (agent_was_polled == 0 && ref_count > 0) {
+      if (backend_was_polled == 0 && ref_count > 0) {
         // this mechanism prevents event starvation in case the run queue never
         // empties
-        __AGENT__.poll(agent, Qtrue, current_fiber, queue);
+        __BACKEND__.poll(backend, Qtrue, current_fiber, queue);
       }
       break;
     }
     if (ref_count == 0) break;
 
-    __AGENT__.poll(agent, Qnil, current_fiber, queue);
-    agent_was_polled = 1;
+    __BACKEND__.poll(backend, Qnil, current_fiber, queue);
+    backend_was_polled = 1;
   }
 
   if (next_fiber == Qnil) return Qnil;
@@ -172,12 +172,12 @@ VALUE Thread_reset_fiber_scheduling(VALUE self) {
 }
 
 VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE fiber, VALUE resume_obj) {
-  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   if (fiber != Qnil) {
     Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
   }
 
-  if (__AGENT__.wakeup(agent) == Qnil) {
+  if (__BACKEND__.wakeup(backend) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
@@ -205,7 +205,7 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "debug!", Thread_debug, 0);
 
   ID_deactivate_all_watchers_post_fork = rb_intern("deactivate_all_watchers_post_fork");
-  ID_ivar_agent               = rb_intern("@agent");
+  ID_ivar_backend               = rb_intern("@backend");
   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/lib/polyphony.rb

@@ -3,28 +3,21 @@
 require 'fiber'
 require_relative './polyphony_ext'
 
-module Polyphony
-  # replace core Queue class with our own
-  verbose = $VERBOSE
-  $VERBOSE = nil
-  Object.const_set(:Queue, Polyphony::Queue)
-  $VERBOSE = verbose
-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::Agent.new
+Thread.current.backend = Polyphony::Backend.new
 
 require_relative './polyphony/core/global_api'
 require_relative './polyphony/core/resource_pool'
+require_relative './polyphony/core/sync'
 require_relative './polyphony/net'
 require_relative './polyphony/adapters/process'
 
-# Main Polyphony API
+# Polyphony API
 module Polyphony
   class << self
     def fork(&block)
@@ -60,7 +53,7 @@ module Polyphony
     def run_forked_block(&block)
       Thread.current.setup
       Fiber.current.setup_main_fiber
-      Thread.current.agent.post_fork
+      Thread.current.backend.post_fork
 
       install_terminating_signal_handlers
 
@@ -109,12 +102,20 @@ module Polyphony
       # processes (see Polyphony.fork).
       at_exit do
         next unless @original_pid == ::Process.pid
-      
+
         Polyphony.terminate_threads
         Fiber.current.shutdown_all_children
       end
     end
   end
+
+  # replace core Queue class with our own
+  verbose = $VERBOSE
+  $VERBOSE = nil
+  Object.const_set(:Queue, Polyphony::Queue)
+  Object.const_set(:Mutex, Polyphony::Mutex)
+  Object.const_set(:ConditionVariable, Polyphony::ConditionVariable)
+  $VERBOSE = verbose
 end
 
 Polyphony.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|
-        Thread.current.agent.wait_io(io, false)
+        Thread.current.backend.wait_io(io, false)
         return [io]
       end
     rescue Polyphony::Cancel
@@ -26,22 +26,7 @@ if Object.constants.include?(:Reline)
     end
   end
 else
-  # readline blocks the current thread, so we offload it to the blocking-ops
-  # thread pool. That way, the reactor loop can keep running while waiting for
-  # readline to return
-  module ::Readline
-    alias_method :orig_readline, :readline
-
-    Workers = Polyphony::ThreadPool.new
-
-    def readline(*args)
-      p :readline
-      # caller.each do |l|
-      #   STDOUT.orig_puts l
-      # end
-      Workers.process { orig_readline(*args) }
-    end
-  end
+  require_relative './readline'
 
   # RubyLex patches
   class ::RubyLex

data/lib/polyphony/adapters/mysql2.rb

@@ -13,7 +13,7 @@ Mysql2::Client.prepend(Module.new do
 
   def query(sql, **options)
     super
-    Thread.current.agent.wait_io(@io, false)
+    Thread.current.backend.wait_io(@io, false)
     async_result
   end
 end)

data/lib/polyphony/adapters/postgres.rb

@@ -15,8 +15,8 @@ module ::PG
       res = conn.connect_poll
       case res
       when PGRES_POLLING_FAILED   then raise Error, conn.error_message
-      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_READING  then Thread.current.backend.wait_io(socket_io, false)
+      when PGRES_POLLING_WRITING  then Thread.current.backend.wait_io(socket_io, true)
       when PGRES_POLLING_OK       then return conn.setnonblocking(true)
       end
     end
@@ -42,7 +42,7 @@ class ::PG::Connection
 
   def get_result(&block)
     while is_busy
-      Thread.current.agent.wait_io(socket_io, false)
+      Thread.current.backend.wait_io(socket_io, false)
       consume_input
     end
     orig_get_result(&block)
@@ -59,7 +59,7 @@ class ::PG::Connection
 
   def block(_timeout = 0)
     while is_busy
-      Thread.current.agent.wait_io(socket_io, false)
+      Thread.current.backend.wait_io(socket_io, false)
       consume_input
     end
   end
@@ -97,7 +97,7 @@ class ::PG::Connection
     return move_on_after(timeout) { wait_for_notify(&block) } if timeout
 
     loop do
-      Thread.current.agent.wait_io(socket_io, false)
+      Thread.current.backend.wait_io(socket_io, false)
       consume_input
       notice = notifies
       next unless notice

data/lib/polyphony/adapters/process.rb

@@ -7,7 +7,7 @@ module Polyphony
       def watch(cmd = nil, &block)
         terminated = nil
         pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
-        Thread.current.agent.waitpid(pid)
+        Thread.current.backend.waitpid(pid)
         terminated = true
       ensure
         kill_process(pid) unless terminated || pid.nil?
@@ -23,7 +23,7 @@ module Polyphony
 
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
-        Thread.current.agent.waitpid(pid)
+        Thread.current.backend.waitpid(pid)
       rescue SystemCallError
         # ignore
         puts 'SystemCallError in kill_and_await'

data/lib/polyphony/adapters/readline.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'polyphony'
+require 'readline'
+
+# readline blocks the current thread, so we offload it to the blocking-ops
+# thread pool. That way, the reactor loop can keep running while waiting for
+# readline to return
+module ::Readline
+  alias_method :orig_readline, :readline
+
+  Worker = Polyphony::ThreadPool.new(1)
+
+  def readline(*args)
+    Worker.process { orig_readline(*args) }
+  end
+end

data/lib/polyphony/adapters/sequel.rb

@@ -39,7 +39,7 @@ module Polyphony
   # Override Sequel::Database to use FiberConnectionPool by default.
   Sequel::Database.prepend(Module.new do
     def connection_pool_default_options
-      {pool_class: FiberConnectionPool}
+      { pool_class: FiberConnectionPool }
     end
   end)
 end

data/lib/polyphony/core/global_api.rb

@@ -19,13 +19,18 @@ module Polyphony
       fiber = ::Fiber.current
       canceller = spin do
         sleep interval
-        exception = with_exception.is_a?(Class) ?
-          with_exception.new : RuntimeError.new(with_exception)
+        exception = cancel_exception(with_exception)
         fiber.schedule exception
       end
       block ? cancel_after_wrap_block(canceller, &block) : canceller
     end
 
+    def cancel_exception(exception)
+      return exception.new if exception.is_a?(Class)
+
+      RuntimeError.new(exception)
+    end
+
     def cancel_after_wrap_block(canceller, &block)
       block.call
     ensure
@@ -50,7 +55,7 @@ module Polyphony
       next_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + interval
       loop do
         now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        Thread.current.agent.sleep(next_time - now)
+        Thread.current.backend.sleep(next_time - now)
         yield
         loop do
           next_time += interval
@@ -98,14 +103,14 @@ module Polyphony
     def sleep(duration = nil)
       return sleep_forever unless duration
 
-      Thread.current.agent.sleep duration
+      Thread.current.backend.sleep duration
     end
 
     def sleep_forever
-      Thread.current.agent.ref
+      Thread.current.backend.ref
       loop { sleep 60 }
     ensure
-      Thread.current.agent.unref
+      Thread.current.backend.unref
     end
 
     def throttled_loop(rate, count: nil, &block)

data/lib/polyphony/core/resource_pool.rb

@@ -28,7 +28,7 @@ module Polyphony
     end
 
     def acquire_from_stock(fiber)
-      add_to_stock if (@stock.empty? || @stock.pending?) && @size < @limit 
+      add_to_stock if (@stock.empty? || @stock.pending?) && @size < @limit
       resource = @stock.shift
       @acquired_resources[fiber] = resource
       yield resource
@@ -38,7 +38,7 @@ module Polyphony
         @stock.push resource
       end
     end
-        
+
     def method_missing(sym, *args, &block)
       acquire { |r| r.send(sym, *args, &block) }
     end