uringmachine 0.19 → 0.20.0

data/lib/uringmachine/fiber_scheduler.rb

@@ -1,32 +1,120 @@
 # frozen_string_literal: true
 
 class UringMachine
+  # UringMachine::FiberScheduler implements the Fiber::Scheduler interface for
+  # creating fiber-based concurrent applications in Ruby, in tight integration
+  # with the standard Ruby I/O and locking APIs.
   class FiberScheduler
-    def initialize(machine)
-      @machine = machine
+    attr_reader :machine, :fiber_map
+
+    # Instantiates a scheduler with the given UringMachine instance.
+    #
+    #     machine = UM.new
+    #     scheduler = UM::FiberScheduler.new(machine)
+    #     Fiber.set_scheduler(scheduler)
+    #
+    # @param machine [UringMachine, nil] UringMachine instance
+    # @return [void]
+    def initialize(machine = nil)
+      @machine = machine || UM.new
+      @ios = ObjectSpace::WeakMap.new
+      @fiber_map = ObjectSpace::WeakMap.new
     end
 
-    def p(o)
-      @machine.write(1, "#{o.inspect}\n")
-    rescue Errno::EINTR
-      retry
+    def instance_variables_to_inspect
+      [:@machine]
+    end
+
+    # Should be called after a fork (eventually, we'll want Ruby to call this
+    # automatically after a fork).
+    #
+    # @return [self]
+    def post_fork
+      @machine = UM.new
+      @ios = ObjectSpace::WeakMap.new
+      @fiber_map = ObjectSpace::WeakMap.new
+      self
+    end
+
+    # For debugging purposes
+    def method_missing(sym, *a, **b)
+      @machine.write(1, "method_missing: #{sym.inspect} #{a.inspect} #{b.inspect}\n")
+      @machine.write(1, "#{caller.inspect}\n")
+      super
+    end
+
+    # scheduler_close hook: Waits for all fiber to terminate. Called upon thread
+    # termination or when the thread's fiber scheduler is changed.
+    #
+    # @return [void]
+    def scheduler_close
+      join()
     end
 
-    def join(*)
-      @machine.join(*)
+    # fiber_interrupt hook: to be implemented.
+    def fiber_interrupt(fiber, exception)
+      raise NotImplementedError, "Implement me!"
     end
 
-    def block(blocker, timeout)
-      p block: [blocker, timeout]
+    # For debugging purposes
+    def p(o) = UM.debug(o.inspect)
+
+    # Waits for the given fibers to terminate. If no fibers are given, waits for
+    # all fibers to terminate.
+    #
+    # @param fibers [Array<Fiber>] fibers to terminate
+    # @return [void]
+    def join(*fibers)
+      if fibers.empty?
+        fibers = @fiber_map.keys
+        @fiber_map = ObjectSpace::WeakMap.new
+      end
+
+      @machine.join(*fibers)
+    end
 
+    # blocking_operation_wait hook: runs the given operation in a separate
+    # thread, so as not to block other fibers.
+    #
+    # @param blocking_operation [callable] blocking operation
+    # @return [void]
+    def blocking_operation_wait(blocking_operation)
+      start_blocking_operation_thread if !@blocking_op_queue
+
+      queue = UM::Queue.new
+      @machine.push(@blocking_op_queue, [queue, blocking_operation])
+      @machine.shift(queue)
     end
 
+    # block hook: blocks the current fiber by yielding to the machine. This hook
+    # is called when a synchronization mechanism blocks, e.g. a mutex, a queue,
+    # etc.
+    #
+    # @param blocker [any] blocker object
+    # @param timeout [Number, nil] optional
+    # timeout @return [void]
+    def block(blocker, timeout = nil)
+      raise NotImplementedError, "Implement me!" if timeout
+
+      @machine.yield
+    end
+
+    # unblock hook: unblocks the given fiber by scheduling it. This hook is
+    # called when a synchronization mechanism unblocks, e.g. a mutex, a queue,
+    # etc.
+    #
+    # @param blocker [any] blocker object
+    # @param fiber [Fiber] fiber to resume
+    # @return [void]
     def unblock(blocker, fiber)
-      p unblock: [blocker, fiber]
+      @machine.schedule(fiber, nil)
     end
 
+    # kernel_sleep hook: sleeps for the given duration.
+    #
+    # @param duration [Number, nil] sleep duration
+    # @return [void]
     def kernel_sleep(duration = nil)
-      # p sleep: [duration]
       if duration
         @machine.sleep(duration)
       else
@@ -34,17 +122,19 @@ class UringMachine
       end
     end
 
+    # io_wait hook: waits for the given io to become ready.
+    #
+    # @param io [IO] IO object
+    # @param events [Number] readiness bitmask
+    # @param timeout [Number, nil] optional timeout
+    # @param return
     def io_wait(io, events, timeout = nil)
       timeout ||= io.timeout
-      p timeout: timeout
       if timeout
-        p 1
         @machine.timeout(timeout, Timeout::Error) {
-          p 2
           @machine.poll(io.fileno, events).tap { p 3 }
-      }.tap { p 4 }
+        }
       else
-        p 5
         @machine.poll(io.fileno, events).tap { p 6 }
 
       end
@@ -53,52 +143,94 @@ class UringMachine
       raise
     end
 
+    # fiber hook: creates a new fiber with the given block. The created fiber is
+    # added to the fiber map, scheduled on the scheduler machine, and started
+    # before this method returns (by calling snooze).
+    #
+    # @param block [Proc] fiber block @return [Fiber]
     def fiber(&block)
-      f = @machine.spin(&block)
+      fiber = Fiber.new(blocking: false) { @machine.run(fiber, &block) }
+      @fiber_map[fiber] = true
+      @machine.schedule(fiber, nil)
       @machine.snooze
-      f
+      fiber
     end
 
+    # io_write hook: writes to the given IO.
+    #
+    # @param io [IO] IO object
+    # @param buffer [IO::Buffer] write buffer
+    # @param length [Integer] write length
+    # @param offset [Integer] write offset
+    # @return [Integer] bytes written
     def io_write(io, buffer, length, offset)
-      p io_write: [io, buffer.get_string, length, offset]
-      @machine.write(io.fileno, buffer.get_string)
+      if offset > 0
+        raise NotImplementedError, "UringMachine currently does not support writing at an offset"
+      end
+
+      ensure_nonblock(io)
+      @machine.write(io.fileno, buffer)
+    rescue Errno::EINTR
+      retry
     end
 
+    # io_read hook: reads from the given IO.
+    #
+    # @param io [IO] IO object
+    # @param buffer [IO::Buffer] read buffer
+    # @param length [Integer] read length
+    # @param offset [Integer] read offset
+    # @return [Integer] bytes read
     def io_read(io, buffer, length, offset)
-      # p io_read: [io, buffer, length, offset]
-      s = +''
+      if offset > 0
+        raise NotImplementedError, "UringMachine currently does not support reading at an offset"
+      end
+
+      ensure_nonblock(io)
       length = buffer.size if length == 0
-      bytes = @machine.read(io.fileno, s, length)
-      buffer.set_string(s)
-      bytes
-    rescue SystemCallError => e
-      -e.errno
+      @machine.read(io.fileno, buffer, length)
+    rescue Errno::EINTR
+      retry
     end
 
-    def io_pwrite(io, buffer, from, length, offset)
-      p io_pwrite: [io, buffer, from, length, offset]
+    if UM.instance_methods.include?(:waitid_status)
+      def process_wait(pid, flags)
+        flags = UM::WEXITED if flags == 0
+        @machine.waitid_status(UM::P_PID, pid, flags)
+      end
     end
 
-    def io_pread(io, buffer, from, length, offset)
-      p io_pread: [io, buffer, from, length, offset]
-    end
+    private
+
+    # Ensures the given IO is in blocking mode.
+    #
+    # @param io [IO] IO object
+    # @return [void]
+    def ensure_nonblock(io)
+      return if @ios.key?(io)
 
-    # def fiber(&block)
-    #   fiber = Fiber.new(blocking: false, &block)
-    #   unblock(nil, fiber)
-    #   # fiber.resume
-    #   return fiber
-    # end
+      @ios[io] = true
+      UM.io_set_nonblock(io, false)
+    end
 
-    # def kernel_sleep(duration = nil)
-    #   block(:sleep, duration)
-    # end
+    # Starts a background thread for running blocking operations.
+    #
+    # @return [void]
+    def start_blocking_operation_thread
+      @blocking_op_queue = UM::Queue.new
+      @blocking_op_thread = Thread.new do
+        m = UM.new
+        loop do
+          q, op = m.shift(@blocking_op_queue)
+          res = begin
+            op.()
+          rescue Exception => e
+            e
+          end
+          m.push(q, res)
+        end
+      end
+    end
 
-    # def process_wait(pid, flags)
-    #   # This is a very simple way to implement a non-blocking wait:
-    #   Thread.new do
-    #     Process::Status.wait(pid, flags)
-    #   end.value
-    # end
   end
 end

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.19'
+  VERSION = '0.20.0'
 end

data/lib/uringmachine.rb

@@ -23,6 +23,12 @@ class UringMachine
     @@fiber_map[fiber] = fiber
   end
 
+  def run(fiber, &block)
+    run_block_in_fiber(block, fiber, nil)
+    self.schedule(fiber, nil)
+    @@fiber_map[fiber] = fiber
+  end
+
   def join(*fibers)
     results = fibers.inject({}) { |h, f| h[f] = nil; h }
     queue = nil

data/test/test_fiber_scheduler.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'uringmachine/fiber_scheduler'
+
+class FiberSchedulerTest < UMBaseTest
+  def setup
+    super
+    @scheduler = UM::FiberScheduler.new(@machine)
+    Fiber.set_scheduler(@scheduler)
+  end
+
+  def teardown
+    Fiber.set_scheduler(nil)
+    GC.start
+  end
+
+  def test_fiber_scheduler_initialize_without_machine
+    s = UM::FiberScheduler.new
+    assert_kind_of UringMachine, s.machine
+  end
+
+  def test_fiber_scheduler_post_fork
+    Fiber.schedule {}
+    assert_equal 1, @scheduler.fiber_map.size
+
+    machine_before = @scheduler.machine
+    @scheduler.post_fork
+    refute_equal machine_before, @scheduler.machine
+    assert_equal 0, @scheduler.fiber_map.size
+  end
+
+  def test_fiber_scheduler_spinning
+    f1 = Fiber.schedule do
+      sleep 0.001
+    end
+
+    f2 = Fiber.schedule do
+      sleep 0.001
+    end
+
+    assert_kind_of Fiber, f1
+    assert_kind_of Fiber, f2
+    assert_equal 2, @scheduler.fiber_map.size
+
+    # close scheduler
+    Fiber.set_scheduler nil
+    GC.start
+    assert_equal 0, @scheduler.fiber_map.size
+  end
+
+  def test_fiber_scheduler_basic_io
+    i, o = IO.pipe
+    buffer = []
+
+    f1 = Fiber.schedule do
+      sleep 0.001
+      o.write 'foo'
+      buffer << :f1
+    end
+
+    f2 = Fiber.schedule do
+      sleep 0.002
+      o.write 'bar'
+      buffer << :f2
+      o.close
+    end
+
+    f3 = Fiber.schedule do
+      str = i.read
+      buffer << str
+    end
+
+    @scheduler.join
+    assert_equal [true] * 3, [f1, f2, f3].map(&:done?)
+    assert_equal [:f1, :f2, 'foobar'], buffer
+  ensure
+    i.close rescue nil
+    o.close rescue nil
+  end
+
+  def test_fiber_scheduler_sleep
+    t0 = monotonic_clock
+    assert_equal 0, machine.pending_count
+    Fiber.schedule do
+      sleep(0.01)
+    end
+    Fiber.schedule do
+      sleep(0.02)
+    end
+    assert_equal 2, machine.pending_count
+    @scheduler.join
+    t1 = monotonic_clock
+    assert_in_range 0.02..0.025, t1 - t0
+  end
+
+  def test_fiber_scheduler_lock
+    mutex = Mutex.new
+    buffer = []
+    t0 = monotonic_clock
+    Fiber.schedule do
+      10.times { sleep 0.001; buffer << it }
+    end
+    Fiber.schedule do
+      mutex.synchronize { sleep(0.005) }
+    end
+    Fiber.schedule do
+      mutex.synchronize { sleep(0.005) }
+    end
+    @scheduler.join
+    t1 = monotonic_clock
+    assert_in_range 0.01..0.015, t1 - t0
+  end
+
+  def test_fiber_scheduler_process_wait
+    child_pid = nil
+    status = nil
+    f1 = Fiber.schedule do
+      child_pid = fork {
+        Fiber.scheduler.post_fork
+        Fiber.set_scheduler nil
+        sleep(0.01);
+        exit! 42
+      }
+      status = Process::Status.wait(child_pid)
+    rescue => e
+      p e
+    end
+    @scheduler.join(f1)
+    assert_kind_of Process::Status, status
+    assert_equal child_pid, status.pid
+    assert_equal 42, status.exitstatus
+  ensure
+    if child_pid
+      Process.wait(child_pid) rescue nil
+    end
+  end
+end

data/test/test_stream.rb

@@ -110,12 +110,12 @@ class StreamRespTest < StreamBaseTest
 
     machine.write(@wfd, "-foobar\r\n")
     o = @stream.resp_decode
-    assert_kind_of RuntimeError, o
+    assert_kind_of UM::Stream::RESPError, o
     assert_equal "foobar", o.message
 
     machine.write(@wfd, "!3\r\nbaz\r\n")
     o = @stream.resp_decode
-    assert_kind_of RuntimeError, o
+    assert_kind_of UM::Stream::RESPError, o
     assert_equal "baz", o.message
 
     machine.write(@wfd, ":123\r\n")