polyphony 0.36 → 0.42

data/lib/polyphony/core/resource_pool.rb

@@ -1,107 +1,107 @@
 # frozen_string_literal: true
 
-export_default :ResourcePool
-
-# Implements a limited resource pool
-class ResourcePool
-  attr_reader :limit, :size
-
-  # Initializes a new resource pool
-  # @param opts [Hash] options
-  # @param &block [Proc] allocator block
-  def initialize(opts, &block)
-    @allocator = block
+module Polyphony
+  # Implements a limited resource pool
+  class ResourcePool
+    attr_reader :limit, :size
+
+    # Initializes a new resource pool
+    # @param opts [Hash] options
+    # @param &block [Proc] allocator block
+    def initialize(opts, &block)
+      @allocator = block
+
+      @stock = []
+      @queue = []
+
+      @limit = opts[:limit] || 4
+      @size = 0
+    end
 
-    @stock = []
-    @queue = []
+    def available
+      @stock.size
+    end
 
-    @limit = opts[:limit] || 4
-    @size = 0
-  end
+    def acquire
+      Thread.current.agent.ref
+      resource = wait_for_resource
+      return unless resource
 
-  def available
-    @stock.size
-  end
+      yield resource
+    ensure
+      Thread.current.agent.unref
+      release(resource) if resource
+    end
 
-  def acquire
-    Gyro.ref
-    resource = wait_for_resource
-    return unless resource
+    def wait_for_resource
+      fiber = Fiber.current
+      @queue << fiber
+      ready_resource = from_stock
+      return ready_resource if ready_resource
 
-    yield resource
-  ensure
-    Gyro.unref
-    release(resource) if resource
-  end
+      suspend
+    ensure
+      @queue.delete(fiber)
+    end
 
-  def wait_for_resource
-    fiber = Fiber.current
-    @queue << fiber
-    ready_resource = from_stock
-    return ready_resource if ready_resource
+    def release(resource)
+      if resource.__discarded__
+        @size -= 1
+      elsif resource
+        return_to_stock(resource)
+        dequeue
+      end
+    end
 
-    suspend
-  ensure
-    @queue.delete(fiber)
-  end
+    def dequeue
+      return if @queue.empty? || @stock.empty?
 
-  def release(resource)
-    if resource.__discarded__
-      @size -= 1
-    elsif resource
-      return_to_stock(resource)
-      dequeue
+      @queue.shift.schedule(@stock.shift)
     end
-  end
-
-  def dequeue
-    return if @queue.empty? || @stock.empty?
 
-    @queue.shift.schedule(@stock.shift)
-  end
+    def return_to_stock(resource)
+      @stock << resource
+    end
 
-  def return_to_stock(resource)
-    @stock << resource
-  end
+    def from_stock
+      @stock.shift || (@size < @limit && allocate)
+    end
 
-  def from_stock
-    @stock.shift || (@size < @limit && allocate)
-  end
+    def method_missing(sym, *args, &block)
+      acquire { |r| r.send(sym, *args, &block) }
+    end
 
-  def method_missing(sym, *args, &block)
-    acquire { |r| r.send(sym, *args, &block) }
-  end
+    def respond_to_missing?(*_args)
+      true
+    end
 
-  def respond_to_missing?(*_args)
-    true
-  end
+    # Extension to allow discarding of resources
+    module ResourceExtensions
+      def __discarded__
+        @__discarded__
+      end
 
-  # Extension to allow discarding of resources
-  module ResourceExtensions
-    def __discarded__
-      @__discarded__
+      def __discard__
+        @__discarded__ = true
+      end
     end
 
-    def __discard__
-      @__discarded__ = true
+    # Allocates a resource
+    # @return [any] allocated resource
+    def allocate
+      @size += 1
+      @allocator.().tap { |r| r.extend ResourceExtensions }
     end
-  end
-
-  # Allocates a resource
-  # @return [any] allocated resource
-  def allocate
-    @size += 1
-    @allocator.().tap { |r| r.extend ResourceExtensions }
-  end
 
-  def <<(resource)
-    @size += 1
-    resource.extend ResourceExtensions
-    @stock << resource
-    dequeue
-  end
+    def <<(resource)
+      @size += 1
+      resource.extend ResourceExtensions
+      @stock << resource
+      dequeue
+    end
 
-  def preheat!
-    (@limit - @size).times { @stock << allocate }
+    def preheat!
+      (@limit - @size).times { @stock << allocate }
+    end
   end
 end

data/lib/polyphony/core/sync.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-export :Mutex
+module Polyphony
+  # Implements mutex lock for synchronizing access to a shared resource
+  class Mutex
+    def initialize
+      @waiting_fibers = Polyphony::Queue.new
+    end
 
-# Implements mutex lock for synchronizing access to a shared resource
-class Mutex
-  def initialize
-    @waiting_fibers = []
-  end
-
-  def synchronize
-    fiber = Fiber.current
-    @waiting_fibers << fiber
-    suspend if @waiting_fibers.size > 1
-    yield
-  ensure
-    @waiting_fibers.delete(fiber)
-    @waiting_fibers.first&.schedule
-    snooze
+    def synchronize
+      fiber = Fiber.current
+      @waiting_fibers << fiber
+      suspend if @waiting_fibers.size > 1
+      yield
+    ensure
+      @waiting_fibers.delete(fiber)
+      @waiting_fibers.first&.schedule
+      snooze
+    end
   end
 end

data/lib/polyphony/core/thread_pool.rb

@@ -1,52 +1,64 @@
 # frozen_string_literal: true
 
-export_default :ThreadPool
-
 require 'etc'
 
-# Implements a pool of threads
-class ThreadPool
-  attr_reader :size
+module Polyphony
+  # Implements a pool of threads
+  class ThreadPool
+    attr_reader :size
 
-  def self.process(&block)
-    @default_pool ||= new
-    @default_pool.process(&block)
-  end
+    def self.process(&block)
+      @default_pool ||= new
+      @default_pool.process(&block)
+    end
 
-  def initialize(size = Etc.nprocessors)
-    @size = size
-    @task_queue = ::Queue.new
-    @threads = (1..@size).map { Thread.new { thread_loop } }
-  end
+    def self.reset
+      return unless @default_pool
 
-  def process(&block)
-    setup unless @task_queue
+      @default_pool.stop
+      @default_pool = nil
+    end
 
-    async = Fiber.current.auto_async
-    @task_queue << [block, async]
-    async.await
-  end
+    def initialize(size = Etc.nprocessors)
+      @size = size
+      @task_queue = Polyphony::Queue.new
+      @threads = (1..@size).map { Thread.new { thread_loop } }
+    end
 
-  def cast(&block)
-    setup unless @task_queue
+    def process(&block)
+      setup unless @task_queue
 
-    @task_queue << [block, nil]
-    self
-  end
+      watcher = Fiber.current.auto_watcher
+      @task_queue << [block, watcher]
+      watcher.await
+    end
 
-  def busy?
-    !@task_queue.empty?
-  end
+    def cast(&block)
+      setup unless @task_queue
 
-  def thread_loop
-    loop { run_queued_task }
-  end
+      @task_queue << [block, nil]
+      self
+    end
+
+    def busy?
+      !@task_queue.empty?
+    end
+
+    def thread_loop
+      loop { run_queued_task }
+    end
+
+    def run_queued_task
+      (block, watcher) = @task_queue.pop
+      result = block.()
+      watcher&.signal(result)
+    rescue Exception => e
+      watcher ? watcher.signal(e) : raise(e)
+    end
 
-  def run_queued_task
-    (block, watcher) = @task_queue.pop
-    result = block.()
-    watcher&.signal(result)
-  rescue Exception => e
-    watcher ? watcher.signal(e) : raise(e)
+    def stop
+      @threads.each(&:kill)
+      @threads.each(&:join)
+    end
   end
 end

data/lib/polyphony/core/throttler.rb

@@ -1,34 +1,41 @@
 # frozen_string_literal: true
 
-export_default :Throttler
+module Polyphony
+  # Implements general-purpose throttling
+  class Throttler
+    def initialize(rate)
+      @rate = rate_from_argument(rate)
+      @min_dt = 1.0 / @rate
+      @next_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
 
-# Implements general-purpose throttling
-class Throttler
-  def initialize(rate)
-    @rate = rate_from_argument(rate)
-    @min_dt = 1.0 / @rate
-  end
+    def call
+      now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      delta = @next_time - now
+      Thread.current.agent.sleep(delta) if delta > 0
+      yield self
 
-  def call(&block)
-    @timer ||= Gyro::Timer.new(0, @min_dt)
-    @timer.await
-    block.call(self)
-  end
-  alias_method :process, :call
+      loop do
+        @next_time += @min_dt
+        break if @next_time > now
+      end
+    end
+    alias_method :process, :call
 
-  def stop
-    @timer&.stop
-  end
+    def stop
+      @stop = true
+    end
 
-  private
+    private
 
-  def rate_from_argument(arg)
-    return arg if arg.is_a?(Numeric)
+    def rate_from_argument(arg)
+      return arg if arg.is_a?(Numeric)
 
-    if arg.is_a?(Hash)
-      return 1.0 / arg[:interval] if arg[:interval]
-      return arg[:rate] if arg[:rate]
+      if arg.is_a?(Hash)
+        return 1.0 / arg[:interval] if arg[:interval]
+        return arg[:rate] if arg[:rate]
+      end
+      raise "Invalid rate argument #{arg.inspect}"
     end
-    raise "Invalid rate argument #{arg.inspect}"
   end
 end

data/lib/polyphony/event.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Polyphony
+  # Event watcher for thread-safe synchronisation
+  class Event
+    def initialize
+      @i, @o = IO.pipe
+    end
+
+    def await
+      Thread.current.agent.read(@i, +'', 8192, false)
+      raise @value if @value.is_a?(Exception)
+
+      @value
+    end
+
+    def await_no_raise
+      Thread.current.agent.read(@i, +'', 8192, false)
+      @value
+    end
+
+    def signal(value = nil)
+      @value = value
+      Thread.current.agent.write(@o, '1')
+    end
+  end
+end

data/lib/polyphony/extensions/core.rb

@@ -4,12 +4,10 @@ require 'fiber'
 require 'timeout'
 require 'open3'
 
-Exceptions = import('../core/exceptions')
+require_relative '../core/exceptions'
 
 # Exeption overrides
 class ::Exception
-  EXIT_EXCEPTION_CLASSES = [::Interrupt, ::SystemExit].freeze
-
   class << self
     attr_accessor :__disable_sanitized_backtrace__
   end
@@ -22,9 +20,9 @@ class ::Exception
     orig_initialize(*args)
   end
 
-  alias_method_once :orig_backtrace, :backtrace
+  alias_method :orig_backtrace, :backtrace
   def backtrace
-    unless @first_backtrace_call || EXIT_EXCEPTION_CLASSES.include?(self.class)
+    unless @first_backtrace_call
       @first_backtrace_call = true
       return orig_backtrace
     end
@@ -52,10 +50,13 @@ end
 
 # Overrides for Process
 module ::Process
-  def self.detach(pid)
-    fiber = spin { Gyro::Child.new(pid).await }
-    fiber.define_singleton_method(:pid) { pid }
-    fiber
+  class << self
+    alias_method :orig_detach, :detach
+    def detach(pid)
+      fiber = spin { Thread.current.agent.waitpid(pid) }
+      fiber.define_singleton_method(:pid) { pid }
+      fiber
+    end
   end
 end
 
@@ -67,10 +68,9 @@ module ::Kernel
   def `(cmd)
     Open3.popen3(cmd) do |i, o, e, _t|
       i.close
-      while (l = e.readpartial(8192))
-        $stderr << l
-      end
-      o.read
+      err = e.read
+      $stderr << err if err
+      o.read || ''
     end
   end
 
@@ -91,6 +91,7 @@ module ::Kernel
   def gets(*_args)
     if !ARGV.empty? || @gets_fiber
       @gets_fiber ||= Fiber.new(&ARGV_GETS_LOOP)
+      @gets_fiber.thread = Thread.current
       result = @gets_fiber.alive? && @gets_fiber.safe_transfer(Fiber.current)
       return result if result
 
@@ -104,21 +105,28 @@ module ::Kernel
   def system(*args)
     Open3.popen2(*args) do |i, o, _t|
       i.close
-      while (l = o.readpartial(8192))
-        $stdout << l
-      end
+      pipe_to_eof(o, $stdout)
     end
     true
   rescue SystemCallError
     nil
   end
+
+  def pipe_to_eof(src, dest)
+    loop do
+      data = src.readpartial(8192)
+      dest << data
+    rescue EOFError
+      break
+    end
+  end
 end
 
 # Override Timeout to use cancel scope
 module ::Timeout
   def self.timeout(sec, klass = nil, message = nil, &block)
     cancel_after(sec, &block)
-  rescue Exceptions::Cancel => e
+  rescue Polyphony::Cancel => e
     error = klass ? klass.new(message) : ::Timeout::Error.new
     error.set_backtrace(e.backtrace)
     raise error