polyphony 0.36 → 0.42

data/lib/polyphony/adapters/trace.rb

@@ -1,132 +1,137 @@
 # frozen_string_literal: true
 
-export :new, :analyze, :STOCK_EVENTS
-
-require 'polyphony'
+require_relative '../../polyphony'
 
 STOCK_EVENTS = %i[line call return c_call c_return b_call b_return].freeze
 
-def new(*events)
-  start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-  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,
-    path: trp.path, parameters: tp_params(trp),
-    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
+module Polyphony
+  # Tracing functionality for Polyphony
+  module Trace
+    class << self
+      def new(*events)
+        start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        events = STOCK_EVENTS if events.empty?
+        ::TracePoint.new(*events) { |tp| yield trace_record(tp, start_stamp) }
+      end
 
-SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
+      def trace_record(trp, start_stamp)
+        stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_stamp
 
-def tp_schedule_value(trp)
-  SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
-end
+        { 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,
+          path: trp.path, parameters: tp_params(trp),
+          return_value: tp_return_value(trp), schedule_value: tp_schedule_value(trp),
+          exception: tp_raised_exception(trp) }
+      end
 
-def tp_raised_exception(trp)
-  trp.event == :raise && trp.raised_exception
-end
+      def tp_fiber(trp)
+        trp.is_a?(FiberTracePoint) ? trp.fiber : Fiber.current
+      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
+      PARAMS_EVENTS = %i[call c_call b_call].freeze
 
-# Implements fake TracePoint instances for fiber-related events
-class FiberTracePoint
-  attr_reader :event, :fiber, :value
+      def tp_params(trp)
+        PARAMS_EVENTS.include?(trp.event) ? trp.parameters : nil
+      end
 
-  def initialize(tpoint)
-    @tp = tpoint
-    @event = tpoint.return_value[0]
-    @fiber = tpoint.return_value[1]
-    @value = tpoint.return_value[2]
-  end
+      RETURN_VALUE_EVENTS = %i[return c_return b_return].freeze
 
-  def lineno
-    @tp.lineno
-  end
+      def tp_return_value(trp)
+        RETURN_VALUE_EVENTS.include?(trp.event) ? trp.return_value : nil
+      end
 
-  def method_id
-    @tp.method_id
-  end
+      SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
 
-  def path
-    @tp.path
-  end
+      def tp_schedule_value(trp)
+        SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
+      end
 
-  def self
-    @tp.self
-  end
+      def tp_raised_exception(trp)
+        trp.event == :raise && trp.raised_exception
+      end
 
-  def binding
-    @tp.binding
-  end
-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
 
-class << ::TracePoint
-  POLYPHONY_FILE_REGEXP = /^#{::Exception::POLYPHONY_DIR}/.freeze
+      # Implements fake TracePoint instances for fiber-related events
+      class FiberTracePoint
+        attr_reader :event, :fiber, :value
 
-  alias_method :orig_new, :new
-  def new(*args, &block)
-    events_mask, fiber_events_mask = event_masks(args)
+        def initialize(tpoint)
+          @tp = tpoint
+          @event = tpoint.return_value[0]
+          @fiber = tpoint.return_value[1]
+          @value = tpoint.return_value[2]
+        end
 
-    orig_new(*events_mask) do |tp|
-      handle_tp_event(tp, fiber_events_mask, &block)
-    end
-  end
+        def lineno
+          @tp.lineno
+        end
 
-  def handle_tp_event(tpoint, fiber_events_mask)
-    # next unless !$watched_fiber || Fiber.current == $watched_fiber
+        def method_id
+          @tp.method_id
+        end
 
-    if tpoint.method_id == :__fiber_trace__
-      return if tpoint.event != :c_return
-      return unless fiber_events_mask.include?(tpoint.return_value[0])
+        def path
+          @tp.path
+        end
 
-      tpoint = FiberTracePoint.new(tpoint)
-    elsif tpoint.path =~ POLYPHONY_FILE_REGEXP
-      return
-    end
+        def self
+          @tp.self
+        end
 
-    yield tpoint
-  end
+        def binding
+          @tp.binding
+        end
+      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
-      when /fiber_/
-        masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
-        masks[0] << :c_return unless masks[0].include?(:c_return)
-      else
-        masks[0] << e
+      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
+            when /fiber_/
+              masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
+              masks[0] << :c_return unless masks[0].include?(:c_return)
+            else
+              masks[0] << e
+            end
+          end
+        end
       end
     end
   end

data/lib/polyphony/core/channel.rb

@@ -1,46 +1,46 @@
 # frozen_string_literal: true
 
-export_default :Channel
+require_relative './exceptions'
 
-Exceptions = import('./exceptions')
-
-# Implements a unidirectional communication channel along the lines of Go
-# (buffered) channels.
-class Channel
-  def initialize
-    @payload_queue = []
-    @waiting_queue = []
-  end
+module Polyphony
+  # Implements a unidirectional communication channel along the lines of Go
+  # (buffered) channels.
+  class Channel
+    def initialize
+      @payload_queue = []
+      @waiting_queue = []
+    end
 
-  def close
-    stop = Exceptions::MoveOn.new
-    @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
-  end
+    def close
+      stop = Polyphony::MoveOn.new
+      @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
+    end
 
-  def <<(value)
-    if @waiting_queue.empty?
-      @payload_queue << value
-    else
-      @waiting_queue.shift&.schedule(value)
+    def <<(value)
+      if @waiting_queue.empty?
+        @payload_queue << value
+      else
+        @waiting_queue.shift&.schedule(value)
+      end
+      snooze
     end
-    snooze
-  end
 
-  def receive
-    Gyro.ref
-    if @payload_queue.empty?
-      @waiting_queue << Fiber.current
-      suspend
-    else
-      receive_from_queue
+    def receive
+      Thread.current.agent.ref
+      if @payload_queue.empty?
+        @waiting_queue << Fiber.current
+        suspend
+      else
+        receive_from_queue
+      end
+    ensure
+      Thread.current.agent.unref
     end
-  ensure
-    Gyro.unref
-  end
 
-  def receive_from_queue
-    payload = @payload_queue.shift
-    snooze
-    payload
+    def receive_from_queue
+      payload = @payload_queue.shift
+      snooze
+      payload
+    end
   end
 end

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.agent.ref
+      suspend
+    ensure
+      Thread.current.agent.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