polyphony 0.44.0 → 0.45.5

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
 
@@ -83,10 +76,10 @@ module Polyphony
     end
 
     def install_terminating_signal_handlers
-      trap('SIGTERM', SystemExit)
+      trap('SIGTERM') { raise SystemExit }
       orig_trap('SIGINT') do
         orig_trap('SIGINT') { exit! }
-        Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, Interrupt.new)
+        Fiber.schedule_priority_oob_fiber { raise Interrupt }
       end
     end
 
@@ -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/fs.rb

@@ -2,7 +2,7 @@
 
 require 'fileutils'
 
-require_relative './core/thread_pool'
+require_relative '../core/thread_pool'
 
 ::File.singleton_class.instance_eval do
   alias_method :orig_stat, :stat

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,10 +23,7 @@ module Polyphony
 
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
-        Thread.current.agent.waitpid(pid)
-      rescue SystemCallError
-        # ignore
-        puts 'SystemCallError in kill_and_await'
+        Thread.current.backend.waitpid(pid)
       end
     end
   end

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/redis.rb

@@ -56,7 +56,7 @@ class Polyphony::RedisDriver
     reply = @reader.gets
     return reply if reply
 
-    while (data = @connection.readpartial(8192))
+    @connection.read_loop do |data|
       @reader.feed(data)
       reply = @reader.gets
       return reply unless reply == false

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,15 +19,20 @@ 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
+      block.call(canceller)
     ensure
       canceller.stop
     end
@@ -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
@@ -76,7 +81,7 @@ module Polyphony
         sleep interval
         fiber.schedule Polyphony::MoveOn.new(with_value)
       end
-      block.call
+      block.call(canceller)
     rescue Polyphony::MoveOn => e
       e.value
     ensure
@@ -87,8 +92,8 @@ module Polyphony
       Fiber.current.receive
     end
 
-    def receive_pending
-      Fiber.current.receive_pending
+    def receive_all_pending
+      Fiber.current.receive_all_pending
     end
 
     def supervise(*args, &block)
@@ -98,20 +103,20 @@ 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)
-      throttler = Polyphony::Throttler.new(rate)
-      if count
-        count.times { |_i| throttler.(&block) }
+    def throttled_loop(rate = nil, **opts, &block)
+      throttler = Polyphony::Throttler.new(rate || opts)
+      if opts[:count]
+        opts[:count].times { |_i| throttler.(&block) }
       else
         loop { throttler.(&block) }
       end

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

data/lib/polyphony/core/sync.rb

@@ -8,16 +8,56 @@ module Polyphony
       @store << :token
     end
 
-    def synchronize
+    def synchronize(&block)
       return yield if @holding_fiber == Fiber.current
 
+      synchronize_not_holding(&block)
+    end
+
+    def synchronize_not_holding
+      @token = @store.shift
       begin
-        token = @store.shift
         @holding_fiber = Fiber.current
         yield
       ensure
         @holding_fiber = nil
-        @store << token if token
+        @store << @token if @token
+      end
+    end
+
+    def conditional_release
+      @store << @token
+      @token = nil
+      @holding_fiber = nil
+    end
+
+    def conditional_reacquire
+      @token = @store.shift
+      @holding_fiber = Fiber.current
+    end
+  end
+
+  # Implements a fiber-aware ConditionVariable
+  class ConditionVariable
+    def initialize
+      @queue = Polyphony::Queue.new
+    end
+
+    def wait(mutex, _timeout = nil)
+      mutex.conditional_release
+      @queue << Fiber.current
+      Thread.current.backend.wait_event(true)
+      mutex.conditional_reacquire
+    end
+
+    def signal
+      fiber = @queue.shift
+      fiber.schedule
+    end
+
+    def broadcast
+      while (fiber = @queue.shift)
+        fiber.schedule
       end
     end
   end

data/lib/polyphony/core/throttler.rb

@@ -12,7 +12,7 @@ module Polyphony
     def call
       now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       delta = @next_time - now
-      Thread.current.agent.sleep(delta) if delta > 0
+      Thread.current.backend.sleep(delta) if delta > 0
       yield self
 
       loop do

data/lib/polyphony/extensions/core.rb

@@ -57,7 +57,7 @@ module ::Process
   class << self
     alias_method :orig_detach, :detach
     def detach(pid)
-      fiber = spin { Thread.current.agent.waitpid(pid) }
+      fiber = spin { Thread.current.backend.waitpid(pid) }
       fiber.define_singleton_method(:pid) { pid }
       fiber
     end
@@ -116,55 +116,48 @@ module ::Kernel
     strs = args.inject([]) do |m, a|
       m << a.inspect << "\n"
     end
-    STDOUT.write *strs
+    STDOUT.write(*strs)
     args.size == 1 ? args.first : args
   end
 
   alias_method :orig_system, :system
   def system(*args)
-    Open3.popen2(*args) do |i, o, _t|
-      i.close
-      pipe_to_eof(o, $stdout)
+    Kernel.system(*args)
+  end
+
+  class << self
+    alias_method :orig_system, :system
+    def system(*args)
+      waiter = nil
+      Open3.popen2(*args) do |i, o, t|
+        waiter = t
+        i.close
+        pipe_to_eof(o, $stdout)
+      end
+      waiter.await.last == 0
+    rescue SystemCallError
+      nil
     end
-    true
-  rescue SystemCallError
-    nil
   end
 
   def pipe_to_eof(src, dest)
-    loop do
-      data = src.readpartial(8192)
-      dest << data
-    rescue EOFError
-      break
-    end
+    src.read_loop { |data| dest << data }
   end
 
   alias_method :orig_trap, :trap
   def trap(sig, command = nil, &block)
     return orig_trap(sig, command) if command.is_a? String
-      
-    block = command if !block && command.respond_to?(:call)
-    if block
-      exception = Polyphony::Interjection.new(block)
-    else
-      exception = command.is_a?(Class) && command.new
-    end
 
-    unless exception
-      raise ArgumentError, "Must supply block or exception or callable object"
-    end
+    block = command if !block && command.respond_to?(:call)
 
     # The signal trap can be invoked at any time, including while the system
-    # agent is blocking while polling for events. In order to deal with this
-    # correctly, we spin a fiber that will run the signal handler code, then
-    # call break_out_of_ev_loop, which will put the fiber at the front of the
-    # run queue, then wake up the system agent.
-    #
-    # If the command argument is an exception class however, it will be raised
-    # directly in the context of the main fiber.
+    # backend is blocking while polling for events. In order to deal with this
+    # correctly, we run the signal handler code in an out-of-band, priority
+    # scheduled fiber, that will pass any uncaught exception (including
+    # SystemExit and Interrupt) to the main thread's main fiber. See also
+    # `Fiber#schedule_priority_oob_fiber`.
     orig_trap(sig) do
-      Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, exception)
+      Fiber.schedule_priority_oob_fiber(&block)
     end
   end
 end