polyphony 1.4 → 1.6

data/lib/polyphony/extensions/process.rb

@@ -2,6 +2,81 @@
 
 # Overrides for Process module
 module ::Process
+  module StatusExtensions
+    def coredump?
+      @status ? nil : super
+    end
+
+    def exited?
+      @status ? WIFEXITED(@status[1]) : super
+    end
+
+    def exitstatus
+      @status ? WEXITSTATUS(@status[1]) : super
+    end
+
+    def inspect
+      @status ? "#<Process::Status: pid #{@status[0]} exit #{@status[1]}>" : super
+    end
+
+    def pid
+      @status ? @status[0] : super
+    end
+
+    def signaled?
+      @status ? WIFSIGNALED(@status[1]) : super
+    end
+
+    def stopped?
+      @status ? WIFSTOPPED(@status[1]) : super
+    end
+
+    def stopsig
+      @status ? WIFSTOPPED(@status[1]) && WEXITSTATUS(@status[1]) : super
+    end
+
+    def success?
+      @status ? @status[1] == 0 : super
+    end
+
+    def termsig
+      @status ? WIFSIGNALED(@status[1]) && WTERMSIG(@status[1]) : super
+    end
+
+    private
+
+    # The following helper methods are translated from the C source:
+    # https://github.com/ruby/ruby/blob/v3_2_0/process.c
+
+    def WIFEXITED(w)
+      (w & 0xff) == 0
+    end
+
+    def WEXITSTATUS(w)
+      (w >> 8) & 0xff
+    end
+
+    def WIFSIGNALED(w)
+      (w & 0x7f) > 0 && ((w & 0x7f) < 0x7f)
+    end
+
+    def WIFSTOPPED(w)
+      (w & 0xff) == 0x7f
+    end
+
+    def WTERMSIG(w)
+      w & 0x7f
+    end
+  end
+
+  class Status
+    prepend StatusExtensions
+
+    def self.from_status_array(arr)
+      allocate.tap { |s| s.instance_variable_set(:@status, arr) }
+    end
+  end
+
   class << self
     # @!visibility private
     alias_method :orig_detach, :detach
@@ -11,7 +86,7 @@ module ::Process
     # @param pid [Integer] child pid
     # @return [Fiber] new fiber waiting on pid
     def detach(pid)
-      fiber = spin { Polyphony.backend_waitpid(pid) }
+      fiber = spin { ::Process::Status.from_status_array(Polyphony.backend_waitpid(pid)) }
       fiber.define_singleton_method(:pid) { pid }
       fiber
     end

data/lib/polyphony/extensions/socket.rb

@@ -464,20 +464,6 @@ class ::TCPServer < ::TCPSocket
     Polyphony.backend_accept(@io, TCPSocket)
   end
 
-  if Polyphony.instance_methods(false).include?(:backend_multishot_accept)
-    # Starts a multishot accept operation (only available with io_uring
-    # backend). Example usage:
-    #
-    #   server.multishot_accept do
-    #     server.accept_loop { |c| handle_connection(c) }
-    #   end
-    #
-    # @return [any] return value of code block
-    def multishot_accept(&block)
-      Polyphony.backend_multishot_accept(@io, &block)
-    end
-  end
-
   # Accepts incoming connections in an infinite loop.
   #
   # @yield [TCPSocket] accepted socket

data/lib/polyphony/extensions/thread.rb

@@ -14,7 +14,6 @@ class ::Thread
   # @param args [Array] arguments to pass to thread block
   def initialize(*args, &block)
     @join_wait_queue = []
-    @finalization_mutex = Mutex.new
     @args = args
     @block = block
     orig_initialize { execute }
@@ -41,16 +40,7 @@ class ::Thread
   # @param timeout [Number] timeout interval
   # @return [any] thread's return value
   def join(timeout = nil)
-    watcher = Fiber.current.auto_watcher
-
-    @finalization_mutex.synchronize do
-      if @terminated
-        @result.is_a?(Exception) ? (raise @result) : (return @result)
-      else
-        @join_wait_queue << watcher
-      end
-    end
-    timeout ? move_on_after(timeout) { watcher.await } : watcher.await
+    timeout ? move_on_after(timeout) { await_done } : await_done
   end
   alias_method :await, :join
 
@@ -62,13 +52,14 @@ class ::Thread
   #
   # @param error [Exception, Class, nil] exception spec
   def raise(error = nil)
-    Thread.pass until @main_fiber
-    error = RuntimeError.new if error.nil?
-    error = RuntimeError.new(error) if error.is_a?(String)
-    error = error.new if error.is_a?(Class)
-
     sleep 0.0001 until @ready
-    main_fiber&.raise(error)
+
+    error = Exception.instantiate(error)
+    if Thread.current == self
+      Kernel.raise(error)
+    else
+      @main_fiber&.raise(error)
+    end
   end
 
   # @!visibility private
@@ -77,11 +68,7 @@ class ::Thread
   # Terminates the thread.
   #
   # @return [Thread] self
-  def kill
-    return self if @terminated
-
-    raise Polyphony::Terminate
-  end
+  alias_method :kill, :kill_safe
 
   # @!visibility private
   alias_method :orig_inspect, :inspect
@@ -128,6 +115,11 @@ class ::Thread
     backend.idle_proc = block
   end
 
+  def value
+    join
+    @result.is_a?(Exception) ? raise(@result) : @result
+  end
+
   private
 
   # Runs the thread's block, handling any uncaught exceptions.
@@ -159,13 +151,13 @@ class ::Thread
   #
   # @param result [any] thread's return value
   def finalize(result)
+    # We need to make sure the fiber is not on the runqueue. This, in order to
+    # prevent a race condition between #finalize and #kill.
+    fiber_unschedule(Fiber.current)
     Fiber.current.shutdown_all_children if !Fiber.current.children.empty?
 
-    @finalization_mutex.synchronize do
-      @terminated = true
-      @result = result
-      signal_waiters(result)
-    end
+    @result = result
+    mark_as_done(result)
     @backend&.finalize
   end
 

data/lib/polyphony/extensions/timeout.rb

@@ -14,6 +14,10 @@ module ::Timeout
   # @param message [String] exception message
   # @return [any] block's return value
   def self.timeout(sec, klass = Timeout::Error, message = 'execution expired', &block)
-    cancel_after(sec, with_exception: [klass, message], &block)
+    if sec.nil? || sec == 0
+      block.call
+    else
+      cancel_after(sec, with_exception: [klass, message], &block)
+    end
   end
 end

data/lib/polyphony/version.rb

@@ -2,5 +2,5 @@
 
 module Polyphony
   # @!visibility private
-  VERSION = '1.4'
+  VERSION = '1.6'
 end

data/lib/polyphony.rb

@@ -14,6 +14,7 @@ require_relative './polyphony/core/sync'
 require_relative './polyphony/core/timer'
 require_relative './polyphony/net'
 require_relative './polyphony/adapters/process'
+require_relative './polyphony/adapters/open3'
 
 # Polyphony API
 module Polyphony
@@ -119,10 +120,10 @@ module Polyphony
       # processes,) we use a separate mechanism to terminate fibers in forked
       # processes (see Polyphony.fork).
       at_exit do
-        next unless @original_pid == ::Process.pid
-
-        terminate_threads
-        Fiber.current.shutdown_all_children
+        if @original_pid == ::Process.pid
+          terminate_threads
+          Fiber.current.shutdown_all_children
+        end
       end
     end
   end
@@ -131,12 +132,17 @@ module Polyphony
   verbose = $VERBOSE
   $VERBOSE = nil
   Object.const_set(:Queue, Polyphony::Queue)
+  Thread.const_set(:Queue, Polyphony::Queue)
+
   Object.const_set(:Mutex, Polyphony::Mutex)
+  Thread.const_set(:Mutex, Polyphony::Mutex)
 
   require 'monitor'
-  Object.const_set(:Monitor, Polyphony::Mutex)
+  Object.const_set(:Monitor, Polyphony::Monitor)
 
   Object.const_set(:ConditionVariable, Polyphony::ConditionVariable)
+  Thread.const_set(:ConditionVariable, Polyphony::ConditionVariable)
+
   $VERBOSE = verbose
 
   install_terminating_signal_handlers

data/test/helper.rb

@@ -17,6 +17,14 @@ require 'minitest/autorun'
 IS_LINUX = RUBY_PLATFORM =~ /linux/
 
 module ::Kernel
+  def debug(**h)
+    k, v = h.first
+    h.delete(k)
+
+    rest = h.inject(+'') { |s, (k, v)| s << "  #{k}: #{v.inspect}\n" }
+    STDOUT.orig_write("#{k}=>#{v} #{caller[0]}\n#{rest}")
+  end
+
   def trace(*args)
     STDOUT.orig_write(format_trace(args))
   end
@@ -41,20 +49,24 @@ end
 class MiniTest::Test
   def setup
     # trace "* setup #{self.name}"
-    Fiber.current.setup_main_fiber
+    @__stamp = Time.now
     Thread.current.backend.finalize
     Thread.current.backend = Polyphony::Backend.new
-    sleep 0.001
-    @__stamp = Time.now
+    Fiber.current.setup_main_fiber
+    Fiber.current.instance_variable_set(:@auto_watcher, nil)
+    sleep 0.0001
   end
 
   def teardown
-    # trace "* teardown #{self.name} (#{Time.now - @__stamp}s)"
+    Polyphony::ThreadPool.reset
+
+    # trace "* teardown #{self.name} (#{@__stamp ? (Time.now - @__stamp) : '?'}s)"
     Fiber.current.shutdown_all_children
     if Fiber.current.children.size > 0
       puts "Children left after #{self.name}: #{Fiber.current.children.inspect}"
       exit!
     end
+    # trace "* teardown done"
   rescue => e
     puts e
     puts e.backtrace.join("\n")
@@ -79,6 +91,36 @@ module Minitest::Assertions
     msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
     assert exp_range.include?(act), msg
   end
+
+  def assert_join_threads(threads, message = nil)
+    errs = []
+    values = []
+    while th = threads.shift
+      begin
+        values << th.value
+      rescue Exception
+        errs << [th, $!]
+        th = nil
+      end
+    end
+    values
+  ensure
+    if th&.alive?
+      th.raise(Timeout::Error.new)
+      th.join rescue errs << [th, $!]
+    end
+    if !errs.empty?
+      msg = "exceptions on #{errs.length} threads:\n" +
+        errs.map {|t, err|
+        "#{t.inspect}:\n" +
+          (err.respond_to?(:full_message) ? err.full_message(highlight: false, order: :top) : err.message)
+      }.join("\n---\n")
+      if message
+        msg = "#{message}\n#{msg}"
+      end
+      raise MiniTest::Assertion, msg
+    end
+  end
 end
 
 puts "Polyphony backend: #{Thread.current.backend.kind}"