polyphony 0.34 → 0.41

data/lib/polyphony/core/exceptions.rb

@@ -1,36 +1,36 @@
 # frozen_string_literal: true
 
-export :BaseException, :MoveOn, :Cancel, :Terminate, :Restart
-
-# Common exception class for interrupting fibers. These exceptions allow
-# control of fibers. BaseException exceptions can encapsulate a value and thus
-# provide a way to interrupt long-running blocking operations while still
-# passing a value back to the call site. BaseException exceptions can also
-# references a cancel scope in order to allow correct bubbling of exceptions
-# through nested cancel scopes.
-class BaseException < ::Exception
-  attr_reader :value
-
-  def initialize(value = nil)
-    @caller_backtrace = caller
-    @value = value
-  end
-
-  def backtrace
-    sanitize(@caller_backtrace)
+module Polyphony
+  # Common exception class for interrupting fibers. These exceptions allow
+  # control of fibers. BaseException exceptions can encapsulate a value and thus
+  # provide a way to interrupt long-running blocking operations while still
+  # passing a value back to the call site. BaseException exceptions can also
+  # references a cancel scope in order to allow correct bubbling of exceptions
+  # through nested cancel scopes.
+  class BaseException < ::Exception
+    attr_reader :value
+
+    def initialize(value = nil)
+      @caller_backtrace = caller
+      @value = value
+    end
+
+    def backtrace
+      sanitize(@caller_backtrace)
+    end
   end
-end
 
-# MoveOn is used to interrupt a long-running blocking operation, while
-# continuing the rest of the computation.
-class MoveOn < BaseException; end
+  # MoveOn is used to interrupt a long-running blocking operation, while
+  # continuing the rest of the computation.
+  class MoveOn < BaseException; end
 
-# Cancel is used to interrupt a long-running blocking operation, bubbling the
-# exception up through cancel scopes and supervisors.
-class Cancel < BaseException; end
+  # Cancel is used to interrupt a long-running blocking operation, bubbling the
+  # exception up through cancel scopes and supervisors.
+  class Cancel < BaseException; end
 
-# Terminate is used to interrupt a fiber once its parent fiber has terminated.
-class Terminate < BaseException; end
+  # Terminate is used to interrupt a fiber once its parent fiber has terminated.
+  class Terminate < BaseException; end
 
-# Restart is used to restart a fiber
-class Restart < BaseException; end
+  # Restart is used to restart a fiber
+  class Restart < BaseException; end
+end

data/lib/polyphony/core/global_api.rb

@@ -1,119 +1,122 @@
 # frozen_string_literal: true
 
-export_default :API
-
-import '../extensions/core'
-import '../extensions/fiber'
-
-Exceptions  = import '../core/exceptions'
-Throttler   = import '../core/throttler'
+require_relative '../extensions/core'
+require_relative '../extensions/fiber'
+require_relative './exceptions'
+require_relative './throttler'
+
+module Polyphony
+  # Global API methods to be included in ::Object
+  module GlobalAPI
+    def after(interval, &block)
+      spin do
+        sleep interval
+        block.()
+      end
+    end
 
-# Global API methods to be included in ::Object
-module API
-  def after(interval, &block)
-    spin do
-      sleep interval
-      block.()
+    def cancel_after(interval, &block)
+      fiber = ::Fiber.current
+      canceller = spin do
+        sleep interval
+        fiber.schedule Polyphony::Cancel.new
+      end
+      block ? cancel_after_wrap_block(canceller, &block) : canceller
     end
-  end
 
-  def cancel_after(interval, &block)
-    fiber = ::Fiber.current
-    canceller = spin do
-      sleep interval
-      fiber.schedule Exceptions::Cancel.new
+    def cancel_after_wrap_block(canceller, &block)
+      block.call
+    ensure
+      canceller.stop
     end
-    block ? cancel_after_wrap_block(canceller, &block) : canceller
-  end
 
-  def cancel_after_wrap_block(canceller, &block)
-    block.call
-  ensure
-    canceller.stop
-  end
+    def spin(tag = nil, &block)
+      Fiber.current.spin(tag, caller, &block)
+    end
 
-  def spin(tag = nil, &block)
-    Fiber.current.spin(tag, caller, &block)
-  end
+    def spin_loop(tag = nil, rate: nil, &block)
+      if rate
+        Fiber.current.spin(tag, caller) do
+          throttled_loop(rate, &block)
+        end
+      else
+        Fiber.current.spin(tag, caller) { loop(&block) }
+      end
+    end
 
-  def spin_loop(tag = nil, rate: nil, &block)
-    if rate
-      Fiber.current.spin(tag, caller) do
-        throttled_loop(rate, &block)
+    def every(interval)
+      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)
+        yield
+        loop do
+          next_time += interval
+          break if next_time > now
+        end
       end
-    else
-      Fiber.current.spin(tag, caller) { loop(&block) }
     end
-  end
 
-  def every(interval)
-    timer = Gyro::Timer.new(interval, interval)
-    loop do
-      timer.await
-      yield
+    def move_on_after(interval, with_value: nil, &block)
+      fiber = ::Fiber.current
+      unless block
+        return spin do
+          sleep interval
+          fiber.schedule with_value
+        end
+      end
+
+      move_on_after_with_block(fiber, interval, with_value, &block)
     end
-  ensure
-    timer.stop
-  end
 
-  def move_on_after(interval, with_value: nil, &block)
-    fiber = ::Fiber.current
-    unless block
-      return spin do
+    def move_on_after_with_block(fiber, interval, with_value, &block)
+      canceller = spin do
         sleep interval
-        fiber.schedule with_value
+        fiber.schedule Polyphony::MoveOn.new(with_value)
       end
+      block.call
+    rescue Polyphony::MoveOn => e
+      e.value
+    ensure
+      canceller.stop
     end
 
-    move_on_after_with_block(fiber, interval, with_value, &block)
-  end
-
-  def move_on_after_with_block(fiber, interval, with_value, &block)
-    canceller = spin do
-      sleep interval
-      fiber.schedule Exceptions::MoveOn.new(with_value)
+    def receive
+      Fiber.current.receive
     end
-    block.call
-  rescue Exceptions::MoveOn => e
-    e.value
-  ensure
-    canceller.stop
-  end
 
-  def receive
-    Fiber.current.receive
-  end
-
-  def receive_pending
-    Fiber.current.receive_pending
-  end
+    def receive_pending
+      Fiber.current.receive_pending
+    end
 
-  def supervise(*args, &block)
-    Fiber.current.supervise(*args, &block)
-  end
+    def supervise(*args, &block)
+      Fiber.current.supervise(*args, &block)
+    end
 
-  def sleep(duration = nil)
-    return sleep_forever unless duration
+    def sleep(duration = nil)
+      return sleep_forever unless duration
 
-    timer = Gyro::Timer.new(duration, 0)
-    timer.await
-  end
+      Thread.current.agent.sleep duration
+    end
 
-  def sleep_forever
-    Thread.current.fiber_ref
-    suspend
-  ensure
-    Thread.current.fiber_unref
-  end
+    def sleep_forever
+      Thread.current.fiber_ref
+      suspend
+    ensure
+      Thread.current.fiber_unref
+    end
 
-  def throttled_loop(rate, count: nil, &block)
-    throttler = Throttler.new(rate)
-    if count
-      count.times { throttler.(&block) }
-    else
-      loop { throttler.(&block) }
+    def throttled_loop(rate, count: nil, &block)
+      throttler = Polyphony::Throttler.new(rate)
+      if count
+        count.times { |_i| throttler.(&block) }
+      else
+        loop { throttler.(&block) }
+      end
+    ensure
+      throttler&.stop
     end
-  ensure
-    throttler.stop
   end
 end
+
+Object.include Polyphony::GlobalAPI

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
+      Polyphony.ref
+      resource = wait_for_resource
+      return unless resource
 
-  def available
-    @stock.size
-  end
+      yield resource
+    ensure
+      Polyphony.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