fiber-scheduler 0.0.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5314cb38a585c244f7b789f576bd210884ce3e5502885d55cd5733c702efa33
-  data.tar.gz: 10ba33be002eb6a5fff98f5326a3ec5278de8b6d9c5eba3ed3815f5c76e4c71b
+  metadata.gz: f7fa0c2f81a443cd6c852a51ad9c8d89d30ee080013980c94c2d16335aa074f1
+  data.tar.gz: 83b4f910992b1f5d44976095d51c822acac07b98eb795ed1208cfd41e935e320
 SHA512:
-  metadata.gz: 495f8feca5e5695c285bbfc7aec699afafb7b4a3500f3c7b40f189a2488dd3815914f1485825567b6d4b8a236e1a85037c3dbc072d2ea7ce2a39aa771e4efc28
-  data.tar.gz: 1c04427896b4eac157f3a2c2915d034fa02d429ed287001ab2d1eb4780ad17590aa1ac2431bf307af8da527288273b04f77971061bae3140df3af9c767effe4b
+  metadata.gz: 41c1fed81c488cb5e4044688bc80b2b95136b5e8401260a35d3abdb8d05e8603ea40087d96f9f730417543783729cc713dbaafe46eaa3f7b5a8936cfd617857b
+  data.tar.gz: 7f712132eedc368609578b6f07073aa4be1d4db11305e6b70b9627807f8acee48fd41f1a6876f214062d7da5c1bdd881c2a65830a2fe84b5ea202dc2079ae969

data/lib/fiber_scheduler/compatibility.rb

@@ -0,0 +1,49 @@
+class FiberScheduler
+  module Compatibility
+    def fiber(*args, **opts, &block)
+      return super unless Compatibility.internal?
+
+      # This is `Fiber.schedule` call inside `FiberScheduler { ... }` block.
+      if opts[:blocking]
+        Fiber.new(blocking: true) {
+          Compatibility.set_internal!
+          yield
+        }.tap(&:resume)
+
+      elsif opts[:waiting]
+        parent = Fiber.current
+        finished = false # prevents races
+        blocking = false # prevents #unblock-ing a fiber that never blocked
+
+        # Don't pass *args and **opts to an unknown fiber scheduler class.
+        super() do
+          Compatibility.set_internal!
+          yield
+        ensure
+          finished = true
+          unblock(nil, parent) if blocking
+        end
+
+        unless finished
+          blocking = true
+          block(nil, nil)
+        end
+
+      else
+        # Don't pass *args and **opts to an unknown fiber scheduler class.
+        super() do
+          Compatibility.set_internal!
+          yield
+        end
+      end
+    end
+
+    def self.set_internal!
+      Thread.current[:_fiber_scheduler] = true # Sets a FIBER local var!
+    end
+
+    def self.internal?
+      Thread.current[:_fiber_scheduler]
+    end
+  end
+end

data/lib/fiber_scheduler/selector.rb

@@ -0,0 +1,230 @@
+# Copyright, 2021, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# The code in this class has been taken from io-event gem. It has been cleaned
+# up and appropriated for use in this gem.
+
+class FiberScheduler
+  class Selector
+    EAGAIN = Errno::EAGAIN::Errno
+
+    class Waiter
+      def initialize(fiber, events, tail)
+        @fiber = fiber
+        @events = events
+        @tail = tail
+      end
+
+      def alive?
+        @fiber&.alive?
+      end
+
+      def transfer(events)
+        if (fiber = @fiber)
+          @fiber = nil
+
+          fiber.transfer(events & @events) if fiber.alive?
+        end
+
+        @tail&.transfer(events)
+      end
+
+      def invalidate
+        @fiber = nil
+      end
+
+      def each(&block)
+        if (fiber = @fiber)
+          yield fiber, @events
+        end
+
+        @tail&.each(&block)
+      end
+    end
+
+    def initialize(fiber)
+      @fiber = fiber
+
+      @waiting = {}.compare_by_identity
+      @ready = []
+    end
+
+    def close
+      @fiber = nil
+      @waiting = nil
+      @ready = nil
+    end
+
+    def transfer
+      @fiber.transfer
+    end
+
+    def push(fiber)
+      @ready.push(fiber)
+    end
+
+    def io_wait(fiber, io, events)
+      waiter = @waiting[io] = Waiter.new(fiber, events, @waiting[io])
+
+      @fiber.transfer
+    ensure
+      waiter&.invalidate
+    end
+
+    def io_read(fiber, io, buffer, length)
+      offset = 0
+
+      loop do
+        maximum_size = buffer.size - offset
+
+        result = Fiber.new(blocking: true) {
+          io.read_nonblock(maximum_size, exception: false)
+        }.resume
+
+        case result
+        when :wait_readable
+          if length > 0
+            io_wait(fiber, io, IO::READABLE)
+          else
+            return -EAGAIN
+          end
+        when :wait_writable
+          if length > 0
+            io_wait(fiber, io, IO::WRITABLE)
+          else
+            return -EAGAIN
+          end
+        when nil
+          break
+        else
+          buffer.set_string(result, offset)
+
+          size = result.bytesize
+          offset += size
+          break if size >= length
+          length -= size
+        end
+      end
+
+      offset
+    end
+
+    def io_write(fiber, io, buffer, length)
+      offset = 0
+
+      loop do
+        maximum_size = buffer.size - offset
+
+        chunk = buffer.get_string(offset, maximum_size)
+        result = Fiber.new(blocking: true) {
+          io.write_nonblock(chunk, exception: false)
+        }.resume
+
+        case result
+        when :wait_readable
+          if length > 0
+            io_wait(fiber, io, IO::READABLE)
+          else
+            return -EAGAIN
+          end
+        when :wait_writable
+          if length > 0
+            io_wait(fiber, io, IO::WRITABLE)
+          else
+            return -EAGAIN
+          end
+        else
+          offset += result
+          break if result >= length
+          length -= result
+        end
+      end
+
+      offset
+    end
+
+    def process_wait(fiber, pid, flags)
+      reader, writer = IO.pipe
+
+      thread = Thread.new do
+        Process::Status.wait(pid, flags)
+      ensure
+        writer.close
+      end
+
+      io_wait(fiber, reader, IO::READABLE)
+
+      thread.value
+    ensure
+      reader.close
+      writer.close
+      thread&.kill
+    end
+
+    def select(duration = nil)
+      if @ready.any?
+        # If we have popped items from the ready list, they may influence the
+        # duration calculation, so we don't delay the event loop:
+        duration = 0
+
+        count = @ready.size
+        count.times do
+          fiber = @ready.shift
+          fiber.transfer if fiber.alive?
+        end
+      end
+
+      readable = []
+      writable = []
+
+      @waiting.each do |io, waiter|
+        waiter.each do |fiber, events|
+          if (events & IO::READABLE) > 0
+            readable << io
+          end
+
+          if (events & IO::WRITABLE) > 0
+            writable << io
+          end
+        end
+      end
+
+      duration = 0 if @ready.any?
+      readable, writable, _ = IO.select(readable, writable, nil, duration)
+
+      ready = Hash.new(0)
+
+      readable&.each do |io|
+        ready[io] |= IO::READABLE
+      end
+
+      writable&.each do |io|
+        ready[io] |= IO::WRITABLE
+      end
+
+      ready.each do |io, events|
+        waiter = @waiting.delete(io)
+        waiter.transfer(events)
+      end
+
+      ready.size
+    end
+  end
+end

data/lib/fiber_scheduler/{trigger.rb → timeout.rb}

@@ -1,12 +1,18 @@
 class FiberScheduler
-  class Trigger
+  Error = Class.new(RuntimeError)
+
+  class Timeout
     include Comparable
 
+    Error = Class.new(FiberScheduler::Error)
+
     attr_reader :time
 
-    def initialize(duration, &block)
+    def initialize(duration, fiber, method, *args)
       @time = Process.clock_gettime(Process::CLOCK_MONOTONIC) + duration
-      @block = block
+      @fiber = fiber
+      @method = method
+      @args = args
 
       @disabled = nil
     end
@@ -18,7 +24,9 @@ class FiberScheduler
     end
 
     def call
-      @block.call
+      return unless @fiber.alive?
+
+      @fiber.public_send(@method, *@args)
     end
 
     def interval

data/lib/fiber_scheduler/timeouts.rb

@@ -0,0 +1,79 @@
+require_relative "timeout"
+
+class FiberScheduler
+  class Timeouts
+    attr_reader :timeouts
+
+    def initialize
+      # Array is sorted by Timeout#time
+      @timeouts = []
+    end
+
+    def call
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      while @timeouts.any? && @timeouts.first.time <= now
+        timeout = @timeouts.shift
+        unless timeout.disabled?
+          timeout.call
+        end
+      end
+    end
+
+    def timeout(duration, *args, method: :raise, fiber: Fiber.current, &block)
+      timeout = Timeout.new(duration, fiber, method, *args)
+
+      if @timeouts.empty?
+        @timeouts << timeout
+      else
+        # binary search
+        min = 0
+        max = @timeouts.size - 1
+        while min <= max
+          index = (min + max) / 2
+          t = @timeouts[index]
+
+          if t > timeout
+            if index.zero? || @timeouts[index - 1] <= timeout
+              # found it
+              break
+            else
+              # @timeouts[index - 1] > timeout
+              max = index - 1
+            end
+          else
+            # t <= timeout
+            index += 1
+            min = index
+          end
+        end
+
+        @timeouts.insert(index, timeout)
+      end
+
+      begin
+        block.call
+      ensure
+        # Timeout is disabled if the block finishes earlier.
+        timeout.disable
+      end
+    end
+
+    def interval
+      # Prune disabled timeouts
+      while @timeouts.first&.disabled?
+        @timeouts.shift
+      end
+
+      return if @timeouts.empty?
+
+      interval = @timeouts.first.interval
+
+      interval >= 0 ? interval : 0
+    end
+
+    def inspect
+      @timeouts.inspect
+    end
+  end
+end

data/lib/fiber_scheduler/version.rb

@@ -1,3 +1,3 @@
 class FiberScheduler
-  VERSION = "0.0.2".freeze
+  VERSION = "0.10.0".freeze
 end

data/lib/fiber_scheduler.rb

@@ -1,9 +1,16 @@
-require "io/event"
 require "resolv"
-require_relative "fiber_scheduler/triggers"
+require_relative "fiber_scheduler/compatibility"
+require_relative "fiber_scheduler/selector"
+require_relative "fiber_scheduler/timeouts"
+
+begin
+  # Use io/event selector if available
+  require "io/event"
+rescue LoadError
+end
 
 module Kernel
-  def FiberScheduler(&block)
+  def FiberScheduler(blocking: false, waiting: true, &block)
     if Fiber.scheduler.nil?
       scheduler = FiberScheduler.new
       Fiber.set_scheduler(scheduler)
@@ -14,20 +21,73 @@ module Kernel
       ensure
         Fiber.set_scheduler(nil)
       end
+
     else
-      # Fiber.scheduler already set, just schedule a task.
-      Fiber.schedule(&block)
+      scheduler = Fiber.scheduler
+      # Fiber.scheduler already set, just schedule a fiber.
+      if scheduler.is_a?(FiberScheduler)
+        # The default waiting is 'true' as that is the most intuitive behavior
+        # for a nested FiberScheduler call.
+        Fiber.schedule(blocking: blocking, waiting: waiting, &block)
+
+        # Unknown fiber scheduler class; can't just pass options to
+        # Fiber.schedule, handle each option separately.
+      else
+        scheduler.singleton_class.prepend(FiberScheduler::Compatibility)
+
+        if blocking
+          fiber = Fiber.new(blocking: true) do
+            FiberScheduler::Compatibility.set_internal!
+            yield
+          end
+          fiber.tap(&:resume)
+
+        elsif waiting
+          parent = Fiber.current
+          finished = false # prevents races
+          blocking = false # prevents #unblock-ing a fiber that never blocked
+
+          Fiber.schedule do
+            FiberScheduler::Compatibility.set_internal!
+            yield
+          ensure
+            finished = true
+            scheduler.unblock(nil, parent) if blocking
+          end
+
+          if Fiber.blocking?
+            # In a blocking fiber, which is potentially also a loop fiber so
+            # there's nothing we can transfer to. Run other fibers (or just
+            # block) until waiting fiber finishes.
+            until finished
+              scheduler.run_once
+            end
+          elsif !finished
+            blocking = true
+            scheduler.block(nil, nil)
+          end
+
+        else
+          Fiber.schedule do
+            FiberScheduler::Compatibility.set_internal!
+            yield
+          end
+        end
+      end
     end
   end
 end
 
 class FiberScheduler
-  TimeoutError = Class.new(RuntimeError)
-  IOWaitTimeout = Class.new(TimeoutError)
-
   def initialize
-    @selector = IO::Event::Selector.new(Fiber.current)
-    @triggers = Triggers.new
+    @fiber = Fiber.current
+    @selector =
+      if defined?(IO::Event)
+        IO::Event::Selector.new(@fiber)
+      else
+        Selector.new(@fiber)
+      end
+    @timeouts = Timeouts.new
 
     @count = 0
     @nested = []
@@ -35,14 +95,18 @@ class FiberScheduler
 
   def run
     while @count > 0
-      if @nested.empty?
-        @selector.select(@triggers.interval)
-        @triggers.call
-      else
-        while @nested.any?
-          fiber = @nested.pop
-          fiber.transfer
-        end
+      run_once
+    end
+  end
+
+  def run_once
+    if @nested.empty?
+      @selector.select(@timeouts.interval)
+      @timeouts.call
+    else
+      while @nested.any?
+        fiber = @nested.pop
+        fiber.transfer
       end
     end
   end
@@ -60,18 +124,11 @@ class FiberScheduler
     end
   end
 
-  def block(blocker, timeout)
-    return @selector.transfer unless timeout
-
-    fiber = Fiber.current
-    trigger = @triggers.add(timeout) do
-      fiber.transfer if fiber.alive?
-    end
+  def block(blocker, duration = nil)
+    return @selector.transfer unless duration
 
-    begin
+    @timeouts.timeout(duration, method: :transfer) do
       @selector.transfer
-    ensure
-      trigger.disable
     end
   end
 
@@ -89,21 +146,11 @@ class FiberScheduler
     Resolv.getaddresses(hostname)
   end
 
-  def io_wait(io, events, timeout = nil)
-    fiber = Fiber.current
-    return @selector.io_wait(fiber, io, events) unless timeout
-
-    trigger = @triggers.raise_in(timeout, IOWaitTimeout)
-    # trigger = @triggers.add(timeout) do
-    #   fiber.raise(IOWaitTimeout) if fiber.alive?
-    # end
+  def io_wait(io, events, duration = nil)
+    return @selector.io_wait(Fiber.current, io, events) unless duration
 
-    begin
-      @selector.io_wait(fiber, io, events)
-    rescue IOWaitTimeout
-      false
-    ensure
-      trigger.disable
+    @timeouts.timeout(duration, method: :transfer) do
+      @selector.io_wait(Fiber.current, io, events)
     end
   end
 
@@ -119,32 +166,54 @@ class FiberScheduler
     @selector.process_wait(Fiber.current, pid, flags)
   end
 
-  def timeout_after(duration, exception = TimeoutError, message = "timeout")
-    fiber = Fiber.current
-    trigger = @triggers.add(duration) do
-      fiber.raise(exception, message) if fiber.alive?
-    end
-
-    begin
-      yield duration
-    ensure
-      trigger.disable
-    end
+  def timeout_after(duration, exception = Timeout::Error, message = "timeout", &block)
+    @timeouts.timeout(duration, exception, message, &block)
   end
 
-  def fiber(&block)
-    unless Fiber.blocking?
-      # nested Fiber.schedule
-      @nested << Fiber.current
-    end
+  def fiber(blocking: false, waiting: false, &block)
+    current = Fiber.current
+
+    if blocking
+      # All fibers wait on a blocking fiber, so 'waiting' option is ignored.
+      Fiber.new(blocking: true, &block).tap(&:resume)
+    elsif waiting
+      finished = false # prevents races
+      fiber = Fiber.new(blocking: false) do
+        @count += 1
+        block.call
+      ensure
+        @count -= 1
+        finished = true
+        # Resume waiting parent fiber
+        current.transfer
+      end
+      fiber.transfer
+
+      # Current fiber is waiting until waiting fiber finishes.
+      if current == @fiber
+        # In a top-level fiber, there's nothing we can transfer to, so run
+        # other fibers (or just block) until waiting fiber finishes.
+        until finished
+          run_once
+        end
+      elsif !finished
+        @selector.transfer
+      end
 
-    fiber = Fiber.new(blocking: false) do
-      @count += 1
-      block.call
-    ensure
-      @count -= 1
-    end
+      fiber
+    else
+      if current != @fiber
+        # nested Fiber.schedule
+        @nested << current
+      end
 
-    fiber.tap(&:transfer)
+      fiber = Fiber.new(blocking: false) do
+        @count += 1
+        block.call
+      ensure
+        @count -= 1
+      end
+      fiber.tap(&:transfer)
+    end
   end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: fiber-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Bruno Sutic
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-11 00:00:00.000000000 Z
+date: 2022-02-15 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: io-event
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -39,33 +25,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: fiber_scheduler_spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.11'
+        version: '0.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.11'
+        version: '0.0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rspec
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '3.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: '3.11'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -86,10 +72,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/fiber/scheduler.rb
 - lib/fiber_scheduler.rb
-- lib/fiber_scheduler/trigger.rb
-- lib/fiber_scheduler/triggers.rb
+- lib/fiber_scheduler/compatibility.rb
+- lib/fiber_scheduler/selector.rb
+- lib/fiber_scheduler/timeout.rb
+- lib/fiber_scheduler/timeouts.rb
 - lib/fiber_scheduler/version.rb
 homepage: https://github.com/bruno-/fiber_scheduler
 licenses:

data/lib/fiber/scheduler.rb

@@ -1 +0,0 @@
-require_relative "../fiber_scheduler"

data/lib/fiber_scheduler/triggers.rb

@@ -1,72 +0,0 @@
-require_relative "trigger"
-
-class FiberScheduler
-  class Triggers
-    def initialize
-      # Array is sorted by Trigger#time
-      @triggers = []
-    end
-
-    def call
-      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-      while @triggers.any? && @triggers.first.time <= now
-        trigger = @triggers.shift
-        unless trigger.disabled?
-          trigger.call
-        end
-      end
-    end
-
-    def add(duration, &block)
-      trigger = Trigger.new(duration, &block)
-
-      if @triggers.empty?
-        @triggers << trigger
-        return trigger
-      end
-
-      # binary search
-      min = 0
-      max = @triggers.size - 1
-      while min <= max
-        index = (min + max) / 2
-        t = @triggers[index]
-
-        if t > trigger
-          if index.zero? || @triggers[index - 1] <= trigger
-            # found it
-            break
-          else
-            # @triggers[index - 1] > trigger
-            max = index - 1
-          end
-        else
-          # t <= trigger
-          index += 1
-          min = index
-        end
-      end
-
-      @triggers.insert(index, trigger)
-      trigger
-    end
-
-    def interval
-      # Prune disabled triggers
-      while @triggers.first&.disabled?
-        @triggers.shift
-      end
-
-      return if @triggers.empty?
-
-      interval = @triggers.first.interval
-
-      interval >= 0 ? interval : 0
-    end
-
-    def inspect
-      @triggers.inspect
-    end
-  end
-end