uringmachine 0.20.0 → 0.22.0

data/lib/uringmachine/fiber_scheduler.rb

@@ -1,11 +1,88 @@
 # frozen_string_literal: true
 
+require 'resolv'
+require 'etc'
+require 'uringmachine'
+
 class UringMachine
+  # Implements a worker thread pool for running blocking operations. Worker
+  # threads are started as needed. Worker thread count is limited to the number
+  # of CPU cores available.
+  class BlockingOperationThreadPool
+
+    # Initializes a new worker pool.
+    #
+    # @return [void]
+    def initialize
+      @pending_count = 0
+      @worker_count = 0
+      @max_workers = Etc.nprocessors
+      @worker_mutex = UM::Mutex.new
+      @job_queue = UM::Queue.new
+      @workers = []
+    end
+
+    # Processes a request by submitting it to the job queue and waiting for the
+    # return value. Starts a worker if needed.
+    #
+    # @param machine [UringMachine] machine
+    # @param job [any] callable job object
+    # @return [any] return value
+    def process(machine, job)
+      queue = Fiber.current.mailbox
+      if @worker_count == 0 || (@pending_count > 0 && @worker_count < @max_workers)
+        start_worker(machine)
+      end
+      machine.push(@job_queue, [queue, job])
+      machine.shift(queue)
+    end
+
+    private
+
+    # @param machine [UringMachine] machine
+    # @return [void]
+    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
+
+    # @return [void]
+    def run_worker_thread
+      machine = UM.new(4)
+      loop do
+        q, op = machine.shift(@job_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}")
+        exit!
+      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
-    attr_reader :machine, :fiber_map
+
+    # The blocking operation thread pool is shared by all fiber schedulers.
+    @@blocking_operation_thread_pool = BlockingOperationThreadPool.new
+
+    # UringMachine instance associated with scheduler.
+    attr_reader :machine
+
+    # WeakMap holding references scheduler fibers as keys.
+    attr_reader :fiber_map
 
     # Instantiates a scheduler with the given UringMachine instance.
     #
@@ -17,48 +94,37 @@ class UringMachine
     # @return [void]
     def initialize(machine = nil)
       @machine = machine || UM.new
-      @ios = ObjectSpace::WeakMap.new
       @fiber_map = ObjectSpace::WeakMap.new
+      @thread = Thread.current
     end
 
+    # :nodoc:
     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).
+    # 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).
     #
-    # @return [self]
-    def post_fork
-      @machine = UM.new
-      @ios = ObjectSpace::WeakMap.new
-      @fiber_map = ObjectSpace::WeakMap.new
-      self
-    end
+    # @param block [Proc] fiber block @return [Fiber]
+    def fiber(&block)
+      fiber = Fiber.new(blocking: false) { @machine.run(fiber, &block) }
 
-    # 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
+      @fiber_map[fiber] = true
+      @machine.schedule(fiber, nil)
+      @machine.snooze
+      fiber
     end
 
-    # scheduler_close hook: Waits for all fiber to terminate. Called upon thread
-    # termination or when the thread's fiber scheduler is changed.
+    # 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
 
-    # fiber_interrupt hook: to be implemented.
-    def fiber_interrupt(fiber, exception)
-      raise NotImplementedError, "Implement me!"
-    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.
     #
@@ -70,36 +136,36 @@ class UringMachine
         @fiber_map = ObjectSpace::WeakMap.new
       end
 
-      @machine.join(*fibers)
+      @machine.await_fibers(fibers)
     end
 
-    # blocking_operation_wait hook: runs the given operation in a separate
-    # thread, so as not to block other fibers.
+    # Runs the given operation in a separate thread, so as not to block other
+    # fibers.
     #
-    # @param blocking_operation [callable] blocking operation
+    # @param op [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)
+    def blocking_operation_wait(op)
+      @@blocking_operation_thread_pool.process(@machine, op)
     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.
+    # 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]
+    # @param timeout [Number, nil] optional timeout
+    # @return [bool] was the operation successful
     def block(blocker, timeout = nil)
-      raise NotImplementedError, "Implement me!" if timeout
-
-      @machine.yield
+      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
+    # Unblocks the given fiber by scheduling it. This hook is
     # called when a synchronization mechanism unblocks, e.g. a mutex, a queue,
     # etc.
     #
@@ -108,55 +174,112 @@ class UringMachine
     # @return [void]
     def unblock(blocker, fiber)
       @machine.schedule(fiber, nil)
+      @machine.wakeup if Thread.current != @thread
     end
 
-    # kernel_sleep hook: sleeps for the given duration.
+    # Sleeps for the given duration.
     #
     # @param duration [Number, nil] sleep duration
     # @return [void]
     def kernel_sleep(duration = nil)
-      if duration
-        @machine.sleep(duration)
-      else
-        @machine.yield
-      end
+      duration ? @machine.sleep(duration) : @machine.yield
     end
 
-    # io_wait hook: waits for the given io to become ready.
+    # Yields to the next runnable fiber.
+    def yield
+      @machine.snooze
+      # @machine.yield
+    end
+
+    # 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)
+      # p(io_wait: io, events:)
       timeout ||= io.timeout
       if timeout
         @machine.timeout(timeout, Timeout::Error) {
-          @machine.poll(io.fileno, events).tap { p 3 }
+          @machine.poll(io.fileno, events)
         }
       else
-        @machine.poll(io.fileno, events).tap { p 6 }
+        @machine.poll(io.fileno, events)
+      end
+    end
 
+    # Selects the first ready IOs from the given sets of IOs.
+    #
+    # @param rios [Array<IO>] readable IOs
+    # @param wios [Array<IO>] writable IOs
+    # @param eios [Array<IO>] exceptable IOs
+    # @param timeout [Number, nil] optional timeout
+    def io_select(rios, wios, eios, timeout = nil)
+      map_r = map_fds(rios)
+      map_w = map_fds(wios)
+      map_e = map_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).
+    # Reads from the given IO.
     #
-    # @param block [Proc] fiber block @return [Fiber]
-    def fiber(&block)
-      fiber = Fiber.new(blocking: false) { @machine.run(fiber, &block) }
-      @fiber_map[fiber] = true
-      @machine.schedule(fiber, nil)
-      @machine.snooze
-      fiber
+    # @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
+
+    # Reads from the given IO at the given file 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.
+    # Writes to the given IO.
     #
     # @param io [IO] IO object
     # @param buffer [IO::Buffer] write buffer
@@ -164,73 +287,123 @@ class UringMachine
     # @param offset [Integer] write offset
     # @return [Integer] bytes written
     def io_write(io, buffer, length, offset)
-      if offset > 0
-        raise NotImplementedError, "UringMachine currently does not support writing at an offset"
-      end
+      # p(io_write: io, length:, offset:, timeout: io.timeout)
+      length = buffer.size if length == 0
+      buffer = buffer.slice(offset) if offset > 0
 
-      ensure_nonblock(io)
-      @machine.write(io.fileno, buffer)
+      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_read hook: reads from the given IO.
+    # Writes to the given IO at the given file offset.
     #
     # @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)
-      if offset > 0
-        raise NotImplementedError, "UringMachine currently does not support reading at an offset"
-      end
-
-      ensure_nonblock(io)
+    # @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, from:, length:, offset:, timeout: io.timeout)
       length = buffer.size if length == 0
-      @machine.read(io.fileno, buffer, length)
+      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.instance_methods.include?(:waitid_status)
+    # Closes the given fd.
+    #
+    # @param fd [Integer] file descriptor
+    # @return [Integer] file descriptor
+    def io_close(fd)
+      # p(io_close: fd)
+      @machine.close_async(fd)
+    end
+
+    if UM.method_defined?(:waitid_status)
+
+      # Waits for a process to terminate.
+      #
+      # @param pid [Integer] process pid (0 for any child process)
+      # @param flags [Integer] waitpid flags
+      # @return [Process::Status] terminated process status
       def process_wait(pid, flags)
         flags = UM::WEXITED if flags == 0
         @machine.waitid_status(UM::P_PID, pid, flags)
       end
     end
 
-    private
-
-    # Ensures the given IO is in blocking mode.
+    # Interrupts the given fiber with an exception.
     #
-    # @param io [IO] IO object
+    # @param fiber [Fiber] fiber to interrupt
+    # @param exception [Exception] Exception
     # @return [void]
-    def ensure_nonblock(io)
-      return if @ios.key?(io)
+    def fiber_interrupt(fiber, exception)
+      @machine.schedule(fiber, exception)
+      @machine.wakeup
+    end
+
+    # Resolves an hostname.
+    #
+    # @param hostname [String] hostname to resolve
+    # @return [Array<Addrinfo>] array of resolved addresses
+		def address_resolve(hostname)
+			Resolv.getaddresses(hostname)
+		end
 
-      @ios[io] = true
-      UM.io_set_nonblock(io, false)
+		# Run the given block with a timeout.
+		#
+		# @param duration [Number] timeout duration
+		# @param exception [Class] exception Class
+		# @param message [String] exception message
+		# @param block [Proc] block to run
+		# @return [any] block return value
+    def timeout_after(duration, exception, message, &block)
+      @machine.timeout(duration, exception, &block)
     end
 
-    # Starts a background thread for running blocking operations.
+    private
+
+    # Prints the given object for debugging purposes.
     #
+    # @param o [any]
     # @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
+    def p(o) = UM.debug(o.inspect)
+
+    # Maps the given ios to fds.
+    #
+    # @param ios [Array<IO>] IOs to map
+    # @return [Hash] hash mapping fds to IOs
+    def map_fds(ios)
+      ios.each_with_object({}) { |io, h| h[io.fileno] = io }
     end
 
+    # Maps the given fds to IOs using the given fd-to-IO map.
+    #
+    # @param fds [Array<Integer>] fds to map
+    # @param map [Hash] hash mapping fds to IOs
+    # @return [Array<IO>] IOs corresponding to fds
+    def unmap_fds(fds, map)
+      fds.map { map[it] }
+    end
   end
-end
+end

data/lib/uringmachine/version.rb

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

data/lib/uringmachine.rb

@@ -38,7 +38,7 @@ class UringMachine
         results[f] = f.result
       else
         (pending ||= []) << f
-        queue ||= UM::Queue.new
+        queue ||= Fiber.current.mailbox
         f.add_done_listener(queue)
       end
     end
@@ -53,6 +53,35 @@ class UringMachine
     fibers.size == 1 ? values.first : values
   end
 
+  def await_fibers(fibers)
+    if fibers.is_a?(Fiber)
+      f = fibers
+      if !f.done?
+        queue = Fiber.current.mailbox
+        f.add_done_listener(queue)
+        self.shift(queue)
+      end
+      return 1
+    end
+
+    queue = nil
+    pending = nil
+    fibers.each do |f|
+      if !f.done?
+        (pending ||= []) << f
+        queue ||= Fiber.current.mailbox
+        f.add_done_listener(queue)
+      end
+    end
+    if pending
+      while !pending.empty?
+        f = self.shift(queue)
+        pending.delete(f)
+      end
+    end
+    fibers.count
+  end
+
   def resolve(hostname, type = :A)
     @resolver ||= DNSResolver.new(self)
     @resolver.resolve(hostname, type)
@@ -71,8 +100,8 @@ class UringMachine
     @@fiber_map.delete(fiber)
     self.notify_done_listeners(fiber)
 
-    # transfer control to UM scheduler
-    self.yield
+    # switch away to a different fiber
+    self.switch
   end
 
   def notify_done_listeners(fiber)

data/test/helper.rb

@@ -5,6 +5,7 @@ require_relative './coverage' if ENV['COVERAGE']
 require 'uringmachine'
 require 'socket'
 require 'minitest/autorun'
+require 'securerandom'
 
 STDOUT.sync = true
 STDERR.sync = true
@@ -64,30 +65,18 @@ class UMBaseTest < Minitest::Test
   end
 
   def teardown
-    # @machine&.cleanup
+    pending_fibers = @machine.pending_fibers.keys
+    if pending_fibers.size > 0
+      raise "leaked fibers: #{pending_fibers}"
+    end
+    GC.start
   end
 
   def assign_port
     @@port_assign_mutex ||= Mutex.new
     @@port_assign_mutex.synchronize do
-      @@port ||= 1024 + rand(60000)
+      @@port ||= 1024 + SecureRandom.rand(60000)
       @@port += 1
     end
   end
-
-  def make_socket_pair
-    port = 10000 + rand(30000)
-    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
-    @machine.bind(server_fd, '127.0.0.1', port)
-    @machine.listen(server_fd, UM::SOMAXCONN)
-
-    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-    @machine.connect(client_conn_fd, '127.0.0.1', port)
-
-    server_conn_fd = @machine.accept(server_fd)
-
-    @machine.close(server_fd)
-    [client_conn_fd, server_conn_fd]
-  end
 end

data/test/test_actor.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'helper'
-require 'socket'
 require 'uringmachine/actor'
 
 class ActorTest < UMBaseTest
@@ -25,7 +24,7 @@ class ActorTest < UMBaseTest
 
   def test_basic_actor_functionality
     mailbox = UM::Queue.new
-    actor = @machine.spin_actor(Counter)
+    actor = machine.spin_actor(Counter)
 
     assert_kind_of Fiber, actor
 
@@ -35,6 +34,11 @@ class ActorTest < UMBaseTest
     assert_equal 2, actor.call(mailbox, :get)
     assert_equal actor, actor.cast(:reset)
     assert_equal 0, actor.call(mailbox, :get)
+  ensure
+    if actor
+      actor.stop
+      machine.join(actor)
+    end
   end
 
   module Counter2
@@ -56,10 +60,15 @@ class ActorTest < UMBaseTest
   end
 
 
-  def test_actor_with_args
+  def test_spin_actor_with_args
     actor = @machine.spin_actor(Counter2, 43)
     mailbox = UM::Queue.new
 
     assert_equal 43, actor.call(mailbox, :get)
+  ensure
+    if actor
+      actor.stop
+      machine.join(actor)
+    end
   end
 end