uringmachine 0.21.0 → 0.22.0

data/lib/uringmachine/dns_resolver.rb

@@ -10,7 +10,6 @@ class UringMachine
       @nameservers = get_nameservers
       @fiber = @machine.spin { handle_requests_loop }
       @last_id = 0
-      @cache = {}
     end
 
     def resolve(hostname, type)
@@ -59,7 +58,7 @@ class UringMachine
       msg = Resolv::DNS::Message.decode buf
       addrs = []
       msg.each_answer do |name, ttl, data|
-        p [name, ttl, data]
+        # p [name, ttl, data]
         if data.kind_of?(Resolv::DNS::Resource::IN::A) ||
           data.kind_of?(Resolv::DNS::Resource::IN::AAAA)
           addrs << data.address.to_s

data/lib/uringmachine/fiber_scheduler.rb

@@ -2,31 +2,45 @@
 
 require 'resolv'
 require 'etc'
+require 'uringmachine'
 
 class UringMachine
-  # Implements a thread pool for running blocking operations.
+  # 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
-      @blocking_op_queue = UM::Queue.new
       @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 = UM::Queue.new
-
+      queue = Fiber.current.mailbox
       if @worker_count == 0 || (@pending_count > 0 && @worker_count < @max_workers)
         start_worker(machine)
       end
-      machine.push(@blocking_op_queue, [queue, job])
+      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
@@ -36,10 +50,11 @@ class UringMachine
       end
     end
 
+    # @return [void]
     def run_worker_thread
-      machine = UM.new(4).mark(1)
+      machine = UM.new(4)
       loop do
-        q, op = machine.shift(@blocking_op_queue)
+        q, op = machine.shift(@job_queue)
         @pending_count += 1
         res = begin
           op.()
@@ -50,6 +65,7 @@ class UringMachine
         machine.push(q, res)
       rescue => e
         UM.debug("worker e: #{e.inspect}")
+        exit!
       end
     end
   end
@@ -58,9 +74,15 @@ class UringMachine
   # creating fiber-based concurrent applications in Ruby, in tight integration
   # with the standard Ruby I/O and locking APIs.
   class FiberScheduler
+
+    # The blocking operation thread pool is shared by all fiber schedulers.
     @@blocking_operation_thread_pool = BlockingOperationThreadPool.new
 
-    attr_reader :machine, :fiber_map
+    # 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.
     #
@@ -73,40 +95,36 @@ class UringMachine
     def initialize(machine = nil)
       @machine = machine || UM.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 process_fork
-      @machine = UM.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
 
-    # 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.
     #
@@ -118,49 +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)
-      # 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
+    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 [bool] was the operation successful
+    # @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
+    # Unblocks the given fiber by scheduling it. This hook is
     # called when a synchronization mechanism unblocks, e.g. a mutex, a queue,
     # etc.
     #
@@ -169,28 +174,31 @@ class UringMachine
     # @return [void]
     def unblock(blocker, fiber)
       @machine.schedule(fiber, nil)
-      @machine.wakeup
+      @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) {
@@ -201,10 +209,16 @@ class UringMachine
       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_io_fds(rios)
-      map_w = map_io_fds(wios)
-      map_e = map_io_fds(eios)
+      map_r = map_fds(rios)
+      map_w = map_fds(wios)
+      map_e = map_fds(eios)
 
       r, w, e = nil
       if timeout
@@ -218,20 +232,7 @@ class UringMachine
       [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)
-      fiber = Fiber.new(blocking: false) { @machine.run(fiber, &block) }
-      @fiber_map[fiber] = true
-      @machine.schedule(fiber, nil)
-      @machine.snooze
-      fiber
-    end
-
-    # io_read hook: reads from the given IO.
+    # Reads from the given IO.
     #
     # @param io [IO] IO object
     # @param buffer [IO::Buffer] read buffer
@@ -254,7 +255,7 @@ class UringMachine
       retry
     end
 
-    # io_pread hook: reads from the given IO at the given offset
+    # Reads from the given IO at the given file offset
     #
     # @param io [IO] IO object
     # @param buffer [IO::Buffer] read buffer
@@ -278,7 +279,7 @@ class UringMachine
       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
@@ -303,7 +304,7 @@ class UringMachine
       retry
     end
 
-    # io_pwrite hook: writes to the given IO at the given offset.
+    # Writes to the given IO at the given file offset.
     #
     # @param io [IO] IO object
     # @param buffer [IO::Buffer] write buffer
@@ -329,35 +330,80 @@ class UringMachine
       retry
     end
 
+    # 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
 
+    # Interrupts the given fiber with an exception.
+    #
+    # @param fiber [Fiber] fiber to interrupt
+    # @param exception [Exception] Exception
+    # @return [void]
     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
 
+		# 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
 
     private
 
-    def map_io_fds(ios)
+    # Prints the given object for debugging purposes.
+    #
+    # @param o [any]
+    # @return [void]
+    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.21.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

data/test/test_async_op.rb

@@ -11,22 +11,22 @@ class AsyncOpTest < UMBaseTest
   end
 
   def test_async_op_await
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     res = @op.await
     t1 = monotonic_clock
     assert_in_range 0.04..0.08, t1 - @t0
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal (-ETIME), res
     assert_equal true, @op.done?
     assert_equal false, @op.cancelled?
   end
 
   def test_async_op_join
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     res = @op.join
     t1 = monotonic_clock
     assert_in_range 0.04..0.08, t1 - @t0
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal (-ETIME), res
     assert_equal true, @op.done?
     assert_equal false, @op.cancelled?
@@ -34,13 +34,13 @@ class AsyncOpTest < UMBaseTest
 
   def test_async_op_cancel
     machine.sleep(0.01)
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     @op.cancel
     assert_equal false, @op.done?
 
     machine.sleep(0.01)
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal true, @op.done?
     assert_equal (-ECANCELED), @op.result
     assert_equal true, @op.cancelled?
@@ -53,7 +53,7 @@ class AsyncOpTest < UMBaseTest
 
     res = @op.await
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal true, @op.done?
     assert_equal (-ECANCELED), res
     assert_equal true, @op.cancelled?
@@ -71,7 +71,7 @@ class AsyncOpTest < UMBaseTest
     rescue => e
     end
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_kind_of TOError, e
     assert_equal true, @op.done?
     assert_equal (-ECANCELED), @op.result
@@ -89,7 +89,7 @@ class AsyncOpTest < UMBaseTest
     end
 
     # machine.timeout is cancelled async, so CQE is not yet reaped
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     assert_nil e
     assert_equal true, @op.done?
     assert_equal (-ETIME), @op.result
@@ -97,7 +97,7 @@ class AsyncOpTest < UMBaseTest
 
     # wait for timeout cancellation
     machine.sleep(0.01)
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 end