uringmachine 0.19.1 → 0.21.0

data/lib/uringmachine/fiber_scheduler.rb

@@ -1,32 +1,182 @@
 # frozen_string_literal: true
 
+require 'resolv'
+require 'etc'
+
 class UringMachine
+  # Implements a thread pool for running blocking operations.
+  class BlockingOperationThreadPool
+    def initialize
+      @blocking_op_queue = UM::Queue.new
+      @pending_count = 0
+      @worker_count = 0
+      @max_workers = Etc.nprocessors
+      @worker_mutex = UM::Mutex.new
+      @workers = []
+    end
+
+    def process(machine, job)
+      queue = UM::Queue.new
+
+      if @worker_count == 0 || (@pending_count > 0 && @worker_count < @max_workers)
+        start_worker(machine)
+      end
+      machine.push(@blocking_op_queue, [queue, job])
+      machine.shift(queue)
+    end
+
+    private
+
+    def start_worker(machine)
+      machine.synchronize(@worker_mutex) do
+        return if @worker_count == @max_workers
+
+        @workers << Thread.new { run_worker_thread }
+        @worker_count += 1
+      end
+    end
+
+    def run_worker_thread
+      machine = UM.new(4).mark(1)
+      loop do
+        q, op = machine.shift(@blocking_op_queue)
+        @pending_count += 1
+        res = begin
+          op.()
+        rescue Exception => e
+          e
+        end
+        @pending_count -= 1
+        machine.push(q, res)
+      rescue => e
+        UM.debug("worker e: #{e.inspect}")
+      end
+    end
+  end
+
+  # 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
+    @@blocking_operation_thread_pool = BlockingOperationThreadPool.new
+
+    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
+      @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 process_fork
+      @machine = UM.new
+      @fiber_map = ObjectSpace::WeakMap.new
+      self
     end
 
-    def join(*)
-      @machine.join(*)
+    # 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
 
-    def block(blocker, timeout)
-      p block: [blocker, timeout]
+    # 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
+
+    # 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)
+      # naive_blocking_peration_wait(blocking_operation)
+      @@blocking_operation_thread_pool.process(@machine, blocking_operation)
+    end
+
+    def naive_blocking_peration_wait(blocking_operation)
+      res = nil
+      Thread.new do
+        res = blocking_operation.()
+      rescue => e
+        res = e
+      end.join
+      res
+    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 [bool] was the operation successful
+    def block(blocker, timeout = nil)
+      if timeout
+        @machine.timeout(timeout, Timeout::Error) { @machine.yield }
+      else
+        @machine.yield
+      end
 
+      true
+    rescue Timeout::Error
+      false
     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)
+      @machine.wakeup
     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,71 +184,180 @@ 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 }
+          @machine.poll(io.fileno, events)
+        }
       else
-        p 5
-        @machine.poll(io.fileno, events).tap { p 6 }
+        @machine.poll(io.fileno, events)
+      end
+    end
 
+    def io_select(rios, wios, eios, timeout = nil)
+      map_r = map_io_fds(rios)
+      map_w = map_io_fds(wios)
+      map_e = map_io_fds(eios)
+
+      r, w, e = nil
+      if timeout
+        @machine.timeout(timeout, Timeout::Error) {
+          r, w, e = @machine.select(map_r.keys, map_w.keys, map_e.keys)
+        }
+      else
+        r, w, e = @machine.select(map_r.keys, map_w.keys, map_e.keys)
       end
-    rescue => e
-      p e: e
-      raise
+
+      [unmap_fds(r, map_r), unmap_fds(w, map_w), unmap_fds(e, map_e)]
     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
 
-    def io_write(io, buffer, length, offset)
-      p io_write: [io, buffer.get_string, length, offset]
-      @machine.write(io.fileno, buffer.get_string)
+    # 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] buffer offset
+    # @return [Integer] bytes read
+    def io_read(io, buffer, length, offset)
+      length = buffer.size if length == 0
+
+      if (timeout = io.timeout)
+				@machine.timeout(timeout, Timeout::Error) do
+          @machine.read(io.fileno, buffer, length, offset)
+        rescue Errno::EINTR
+          retry
+        end
+      else
+        @machine.read(io.fileno, buffer, length, offset)
+      end
+    rescue Errno::EINTR
+      retry
     end
 
-    def io_read(io, buffer, length, offset)
-      # p io_read: [io, buffer, length, offset]
-      s = +''
+    # io_pread hook: reads from the given IO at the given offset
+    #
+    # @param io [IO] IO object
+    # @param buffer [IO::Buffer] read buffer
+    # @param from [Integer] read offset
+    # @param length [Integer] read length
+    # @param offset [Integer] buffer offset
+    # @return [Integer] bytes read
+    def io_pread(io, buffer, from, length, offset)
+      length = buffer.size if length == 0
+
+      if (timeout = io.timeout)
+				@machine.timeout(timeout, Timeout::Error) do
+          @machine.read(io.fileno, buffer, length, offset, from)
+        rescue Errno::EINTR
+          retry
+        end
+      else
+        @machine.read(io.fileno, buffer, length, offset, from)
+      end
+    rescue Errno::EINTR
+      retry
+    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, length:, offset:, timeout: io.timeout)
       length = buffer.size if length == 0
-      bytes = @machine.read(io.fileno, s, length)
-      buffer.set_string(s)
-      bytes
-    rescue SystemCallError => e
-      -e.errno
+      buffer = buffer.slice(offset) if offset > 0
+
+      if (timeout = io.timeout)
+				@machine.timeout(timeout, Timeout::Error) do
+          @machine.write(io.fileno, buffer, length)
+        rescue Errno::EINTR
+          retry
+        end
+      else
+        @machine.write(io.fileno, buffer, length)
+      end
+    rescue Errno::EINTR
+      retry
     end
 
+    # io_pwrite hook: writes to the given IO at the given offset.
+    #
+    # @param io [IO] IO object
+    # @param buffer [IO::Buffer] write buffer
+    # @param length [Integer] file offset
+    # @param length [Integer] write length
+    # @param offset [Integer] buffer offset
+    # @return [Integer] bytes written
     def io_pwrite(io, buffer, from, length, offset)
-      p io_pwrite: [io, buffer, from, length, offset]
+      # p(io_pwrite: io, from:, length:, offset:, timeout: io.timeout)
+      length = buffer.size if length == 0
+      buffer = buffer.slice(offset) if offset > 0
+
+      if (timeout = io.timeout)
+				@machine.timeout(timeout, Timeout::Error) do
+          @machine.write(io.fileno, buffer, length, from)
+        rescue Errno::EINTR
+          retry
+        end
+      else
+        @machine.write(io.fileno, buffer, length, from)
+      end
+    rescue Errno::EINTR
+      retry
+    end
+
+    if UM.method_defined?(:waitid_status)
+      def process_wait(pid, flags)
+        flags = UM::WEXITED if flags == 0
+        @machine.waitid_status(UM::P_PID, pid, flags)
+      end
+    end
+
+    def fiber_interrupt(fiber, exception)
+      @machine.schedule(fiber, exception)
+      @machine.wakeup
+    end
+
+		def address_resolve(hostname)
+			Resolv.getaddresses(hostname)
+		end
+
+    def timeout_after(duration, exception, message, &block)
+      @machine.timeout(duration, exception, &block)
+    end
+
+    private
+
+    def map_io_fds(ios)
+      ios.each_with_object({}) { |io, h| h[io.fileno] = io }
+    end
+
+    def unmap_fds(fds, map)
+      fds.map { map[it] }
     end
 
-    def io_pread(io, buffer, from, length, offset)
-      p io_pread: [io, buffer, from, length, offset]
-    end
-
-    # def fiber(&block)
-    #   fiber = Fiber.new(blocking: false, &block)
-    #   unblock(nil, fiber)
-    #   # fiber.resume
-    #   return fiber
-    # end
-
-    # def kernel_sleep(duration = nil)
-    #   block(:sleep, duration)
-    # 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.1'
+  VERSION = '0.21.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