polyphony 0.24 → 0.25

data/lib/polyphony/core/global_api.rb

@@ -3,8 +3,8 @@
 export_default :API
 
 import '../extensions/core'
+import '../extensions/fiber'
 
-Coprocess   = import '../core/coprocess'
 Exceptions  = import '../core/exceptions'
 Supervisor  = import '../core/supervisor'
 Throttler   = import '../core/throttler'
@@ -29,13 +29,10 @@ module API
     canceller.stop
   end
 
-  def defer(&block)
-    ::Fiber.new(&block).schedule
-  end
-
   def spin(&block)
-    Coprocess.new(&block).run
+    Fiber.spin(caller, &block)
   end
+  alias_method :defer, :spin
 
   def spin_loop(&block)
     spin { loop(&block) }
@@ -63,10 +60,12 @@ module API
   end
 
   def receive
-    Fiber.current.coprocess.receive
+    Fiber.current.receive
   end
 
-  def sleep(duration)
+  def sleep(duration = nil)
+    return suspend unless duration
+
     timer = Gyro::Timer.new(duration, 0)
     timer.await
   end

data/lib/polyphony/core/supervisor.rb

@@ -2,13 +2,13 @@
 
 export_default :Supervisor
 
-Coprocess   = import('./coprocess')
-Exceptions  = import('./exceptions')
+import '../extensions/fiber'
+Exceptions = import './exceptions'
 
-# Implements a supervision mechanism for controlling multiple coprocesses
+# Implements a supervision mechanism for controlling multiple fibers
 class Supervisor
   def initialize
-    @coprocesses = []
+    @fibers = []
     @pending = {}
   end
 
@@ -17,7 +17,7 @@ class Supervisor
     @supervisor_fiber = Fiber.current
     block&.(self)
     suspend
-    @coprocesses.map(&:result)
+    @fibers.map(&:result)
   rescue Exceptions::MoveOn => e
     e.value
   ensure
@@ -27,11 +27,11 @@ class Supervisor
 
   def select(&block)
     @mode = :select
-    @select_coproc = nil
+    @select_fiber = nil
     @supervisor_fiber = Fiber.current
     block&.(self)
     suspend
-    [@select_coproc.result, @select_coproc]
+    [@select_fiber.result, @select_fiber]
   rescue Exceptions::MoveOn => e
     e.value
   ensure
@@ -52,21 +52,15 @@ class Supervisor
     @supervisor_fiber = nil
   end
 
-  def spin(coproc = nil, &block)
-    coproc = Coprocess.new(&(coproc || block)) unless coproc.is_a?(Coprocess)
-    @coprocesses << coproc
-    @pending[coproc] = true
-    coproc.when_done { task_completed(coproc) }
-    coproc.run unless coproc.alive?
-    coproc
+  def spin(orig_caller = caller, &block)
+    add Fiber.spin(orig_caller, &block)
   end
 
-  def add(coproc)
-    @coprocesses << coproc
-    @pending[coproc] = true
-    coproc.when_done { task_completed(coproc) }
-    coproc.run unless coproc.alive?
-    coproc
+  def add(fiber)
+    @fibers << fiber
+    @pending[fiber] = true
+    fiber.when_done { task_completed(fiber) }
+    fiber
   end
   alias_method :<<, :add
 
@@ -89,30 +83,30 @@ class Supervisor
     end
   end
 
-  def task_completed(coprocess)
-    return unless @pending[coprocess]
+  def task_completed(fiber)
+    return unless @pending[fiber]
 
-    @pending.delete(coprocess)
-    return unless @pending.empty? || (@mode == :select && !@select_coproc)
+    @pending.delete(fiber)
+    return unless @pending.empty? || (@mode == :select && !@select_fiber)
 
-    @select_coproc = coprocess if @mode == :select
+    @select_fiber = fiber if @mode == :select
     @supervisor_fiber&.schedule
   end
 end
 
-# Extension for Coprocess class
-class Coprocess
+# Supervision extensions for Fiber class
+class ::Fiber
   class << self
-    def await(*coprocs)
+    def await(*fibers)
       supervisor = Supervisor.new
-      coprocs.each { |cp| supervisor << cp }
+      fibers.each { |f| supervisor << f }
       supervisor.await
     end
     alias_method :join, :await
 
-    def select(*coprocs)
+    def select(*fibers)
       supervisor = Supervisor.new
-      coprocs.each { |cp| supervisor << cp }
+      fibers.each { |f| supervisor << f }
       supervisor.select
     end
   end

data/lib/polyphony/extensions/core.rb

@@ -4,81 +4,7 @@ require 'fiber'
 require 'timeout'
 require 'open3'
 
-Coprocess   = import('../core/coprocess')
-Exceptions  = import('../core/exceptions')
-Supervisor  = import('../core/supervisor')
-Throttler   = import('../core/throttler')
-
-# Fiber extensions
-class ::Fiber
-  attr_accessor :__calling_fiber__
-  attr_accessor :__caller__
-  attr_accessor :__location__
-  attr_writer :cancelled
-  attr_accessor :coprocess
-
-  def location
-    __location__ || (__caller__ && __caller__[0])
-  end
-
-  def inspect
-    "#<Fiber:#{object_id} #{location} (#{state})"
-  end
-  alias_method :to_s, :inspect
-
-  def set_calling_context(location, calling_fiber, fiber_caller)
-    @__location__ = location
-    @__calling_fiber__ = calling_fiber
-    @__caller__ = fiber_caller
-    self
-  end
-
-  class << self
-    alias_method :orig_new, :new
-    def new(location = nil, &block)
-      fiber = create_fiber_with_block(&block)
-      fiber.set_calling_context(location, Fiber.current, caller)
-      fiber
-    end
-
-    def create_fiber_with_block(&block)
-      fiber = orig_new do |v|
-        block.call(v)
-      rescue Exception => e
-        __calling_fiber__.transfer e if __calling_fiber__.alive?
-      ensure
-        fiber.mark_as_done!
-        Gyro.run
-      end
-    end
-
-    def root
-      @root_fiber
-    end
-
-    def set_root_fiber
-      @root_fiber = current
-    
-      # Associate a (pseudo-)coprocess with the root fiber
-      Coprocess.map[current] = current.coprocess = Coprocess.new(current)
-    end
-  end
-
-  def caller
-    @__caller__ ||= []
-    if @__calling_fiber__
-      @__caller__ + @__calling_fiber__.caller
-    else
-      @__caller__
-    end
-  end
-
-  def cancelled?
-    @cancelled
-  end
-
-  set_root_fiber
-end
+Exceptions = import('../core/exceptions')
 
 # Exeption overrides
 class ::Exception
@@ -120,9 +46,9 @@ end
 # Overrides for Process
 module ::Process
   def self.detach(pid)
-    spin do
-      Gyro::Child.new(pid).await
-    end.tap { |coproc| coproc.define_singleton_method(:pid) { pid } }
+    fiber = spin { Gyro::Child.new(pid).await }
+    fiber.define_singleton_method(:pid) { pid }
+    fiber
   end
 end
 

data/lib/polyphony/extensions/fiber.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+Exceptions = import '../core/exceptions'
+
+# Fiber control API
+module FiberControl
+  def await
+    if @running == false
+      return @result.is_a?(Exception) ? (raise @result) : @result
+    end
+
+    @waiting_fiber = Fiber.current
+    suspend
+  ensure
+    @waiting_fiber = nil
+  end
+  alias_method :join, :await
+
+  def interrupt(value = nil)
+    return if @running == false
+
+    schedule Exceptions::MoveOn.new(nil, value)
+    snooze
+  end
+  alias_method :stop, :interrupt
+
+  def cancel!
+    return if @running == false
+
+    schedule Exceptions::Cancel.new
+    snooze
+  end
+end
+
+# Messaging functionality
+module FiberMessaging
+  def <<(value)
+    if @receive_waiting && @running
+      schedule value
+    else
+      @queued_messages ||= []
+      @queued_messages << value
+    end
+    snooze
+  end
+
+  def receive
+    if !@queued_messages || @queued_messages&.empty?
+      wait_for_message
+    else
+      value = @queued_messages.shift
+      snooze
+      value
+    end
+  end
+
+  def wait_for_message
+    Gyro.ref
+    @receive_waiting = true
+    suspend
+  ensure
+    Gyro.unref
+    @receive_waiting = nil
+  end
+end
+
+# Fiber extensions
+class ::Fiber
+  include FiberControl
+  include FiberMessaging
+
+  # map of currently running fibers
+  def self.root
+    @root_fiber
+  end
+
+  def self.reset!
+    @root_fiber = current
+    @running_fibers_map = { @root_fiber => true }
+  end
+
+  reset!
+
+  def self.map
+    @running_fibers_map
+  end
+
+  def self.list
+    @running_fibers_map.keys
+  end
+
+  def self.count
+    @running_fibers_map.size
+  end
+
+  def self.spin(orig_caller = caller, &block)
+    f = new { |v| f.run(v) }
+    f.setup(block, orig_caller)
+    f
+  end
+
+  def setup(block, caller)
+    @calling_fiber = Fiber.current
+    @caller = caller
+    @block = block
+    schedule
+  end
+
+  def run(first_value)
+    raise first_value if first_value.is_a?(Exception)
+
+    @running = true
+    self.class.map[self] = true
+    result = @block.(first_value)
+    finish_execution(result)
+  rescue Exceptions::MoveOn => e
+    finish_execution(e.value)
+  rescue Exception => e
+    finish_execution(e, true)
+  end
+
+  def finish_execution(result, uncaught_exception = false)
+    @result = result
+    @running = false
+    self.class.map.delete(self)
+    @when_done&.(result)
+    @waiting_fiber&.schedule(result)
+
+    return unless uncaught_exception && !@waiting_fiber
+
+    parent_fiber = @calling_fiber.running? ? @calling_fiber : Fiber.root
+    parent_fiber.schedule(result)
+  ensure
+    Gyro.run
+  end
+
+  attr_reader :result
+
+  def running?
+    @running
+  end
+
+  def when_done(&block)
+    @when_done = block
+  end
+
+  def inspect
+    "#<Fiber:#{object_id} #{location} (#{state})>"
+  end
+  alias_method :to_s, :inspect
+
+  def location
+    @caller ? @caller[0] : '(root)'
+  end
+
+  def caller
+    @caller ||= []
+    if @calling_fiber
+      @caller + @calling_fiber.caller
+    else
+      @caller
+    end
+  end
+end

data/lib/polyphony/extensions/io.rb

@@ -24,7 +24,8 @@ class ::IO
     EMPTY_HASH = {}.freeze
 
     alias_method :orig_foreach, :foreach
-    def foreach(name, sep = $/, limit = nil, getline_args = EMPTY_HASH, &block)
+    def foreach(_name, _sep = $/, _limit = nil, _getline_args = EMPTY_HASH,
+                &_block)
       # IO.orig_read(name).each_line(&block)
       raise NotImplementedError
 

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.24'
+  VERSION = '0.25'
 end

data/lib/polyphony.rb

@@ -8,6 +8,7 @@ require 'fiber'
 require_relative './gyro_ext'
 
 import './polyphony/extensions/core'
+import './polyphony/extensions/fiber'
 import './polyphony/extensions/io'
 
 # Main Polyphony API
@@ -16,11 +17,10 @@ module Polyphony
   ::Object.include GlobalAPI
 
   exceptions = import './polyphony/core/exceptions'
-  Cancel        = exceptions::Cancel
-  MoveOn        = exceptions::MoveOn
+  Cancel = exceptions::Cancel
+  MoveOn = exceptions::MoveOn
 
-  Coprocess = import './polyphony/core/coprocess'
-  Net       = import './polyphony/net'
+  Net = import './polyphony/net'
 
   auto_import(
     CancelScope:  './polyphony/core/cancel_scope',
@@ -67,16 +67,14 @@ module Polyphony
     def reset!
       # Fiber.root.scheduled_value = nil
       Gyro.reset!
-      Coprocess.map.clear
-      Fiber.set_root_fiber
+      Fiber.reset!
     end
 
     private
 
     def setup_forked_process
-      Coprocess.map.delete Fiber.root
       Gyro.post_fork
-      Fiber.set_root_fiber
+      Fiber.reset!
     end
   end
 end

data/test/test_async.rb

@@ -16,7 +16,7 @@ class AsyncTest < MiniTest::Test
       a.signal!
     end
     suspend
-    assert_equal(1, count)
+    assert_equal 1, count
   end
 
   def test_that_async_watcher_coalesces_signals
@@ -35,6 +35,6 @@ class AsyncTest < MiniTest::Test
       3.times { a.signal! }
     end
     coproc.await
-    assert_equal(1, count)
+    assert_equal 1, count
   end
 end

data/test/test_cancel_scope.rb

@@ -14,10 +14,10 @@ class CancelScopeTest < MiniTest::Test
     assert_equal [1], buffer
   end
 
-  def test_that_cancel_scope_can_cancel_multiple_coprocesses
+  def test_that_cancel_scope_can_cancel_multiple_fibers
     buffer = []
     scope = Polyphony::CancelScope.new
-    coprocs = (1..3).map { |i|
+    fibers = (1..3).map { |i|
       spin {
         scope.call do
           buffer << i
@@ -52,11 +52,11 @@ class CancelScopeTest < MiniTest::Test
     assert_nil scope.instance_variable_get(:@timeout_waiter)
   end
 
-  def test_that_cancel_scope_can_cancel_multiple_coprocs_with_timeout
+  def test_that_cancel_scope_can_cancel_multiple_fibers_with_timeout
     buffer = []
     t0 = Time.now
     scope = Polyphony::CancelScope.new(timeout: 0.02)
-    coprocs = (1..3).map { |i|
+    fibers = (1..3).map { |i|
       spin {
         scope.call do
           buffer << i
@@ -65,7 +65,7 @@ class CancelScopeTest < MiniTest::Test
         end
       }
     }
-    Polyphony::Coprocess.await(*coprocs)
+    Fiber.await(*fibers)
     assert Time.now - t0 < 0.05
     assert_equal [1, 2, 3], buffer
   end
@@ -77,7 +77,7 @@ class CancelScopeTest < MiniTest::Test
     scope.call {
       sleep 0.005
       scope.reset_timeout
-      sleep 0.010
+      sleep 0.008
     }
 
     assert !scope.cancelled?