polyphony 0.39 → 0.43.1

data/lib/polyphony/core/throttler.rb

@@ -6,17 +6,24 @@ module Polyphony
     def initialize(rate)
       @rate = rate_from_argument(rate)
       @min_dt = 1.0 / @rate
+      @next_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
     end
 
-    def call(&block)
-      @timer ||= Gyro::Timer.new(0, @min_dt)
-      @timer.await
-      block.call(self)
+    def call
+      now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      delta = @next_time - now
+      Thread.current.agent.sleep(delta) if delta > 0
+      yield self
+
+      loop do
+        @next_time += @min_dt
+        break if @next_time > now
+      end
     end
     alias_method :process, :call
 
     def stop
-      @timer&.stop
+      @stop = true
     end
 
     private
@@ -31,4 +38,4 @@ module Polyphony
       raise "Invalid rate argument #{arg.inspect}"
     end
   end
-end
+end

data/lib/polyphony/event.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Polyphony
+  # Event watcher for thread-safe synchronisation
+  class Event
+    def initialize
+      @i, @o = IO.pipe
+    end
+
+    def await
+      Thread.current.agent.read(@i, +'', 8192, false)
+      raise @value if @value.is_a?(Exception)
+
+      @value
+    end
+
+    def await_no_raise
+      Thread.current.agent.read(@i, +'', 8192, false)
+      @value
+    end
+
+    def signal(value = nil)
+      @value = value
+      Thread.current.agent.write(@o, '1')
+    end
+  end
+end

data/lib/polyphony/extensions/core.rb

@@ -8,8 +8,6 @@ require_relative '../core/exceptions'
 
 # Exeption overrides
 class ::Exception
-  EXIT_EXCEPTION_CLASSES = [::Interrupt, ::SystemExit].freeze
-
   class << self
     attr_accessor :__disable_sanitized_backtrace__
   end
@@ -24,7 +22,7 @@ class ::Exception
 
   alias_method :orig_backtrace, :backtrace
   def backtrace
-    unless @first_backtrace_call || EXIT_EXCEPTION_CLASSES.include?(self.class)
+    unless @first_backtrace_call
       @first_backtrace_call = true
       return orig_backtrace
     end
@@ -52,10 +50,13 @@ end
 
 # Overrides for Process
 module ::Process
-  def self.detach(pid)
-    fiber = spin { Gyro::Child.new(pid).await }
-    fiber.define_singleton_method(:pid) { pid }
-    fiber
+  class << self
+    alias_method :orig_detach, :detach
+    def detach(pid)
+      fiber = spin { Thread.current.agent.waitpid(pid) }
+      fiber.define_singleton_method(:pid) { pid }
+      fiber
+    end
   end
 end
 
@@ -67,10 +68,9 @@ module ::Kernel
   def `(cmd)
     Open3.popen3(cmd) do |i, o, e, _t|
       i.close
-      while (l = e.readpartial(8192))
-        $stderr << l
-      end
-      o.read
+      err = e.read
+      $stderr << err if err
+      o.read || ''
     end
   end
 
@@ -91,6 +91,7 @@ module ::Kernel
   def gets(*_args)
     if !ARGV.empty? || @gets_fiber
       @gets_fiber ||= Fiber.new(&ARGV_GETS_LOOP)
+      @gets_fiber.thread = Thread.current
       result = @gets_fiber.alive? && @gets_fiber.safe_transfer(Fiber.current)
       return result if result
 
@@ -104,14 +105,21 @@ module ::Kernel
   def system(*args)
     Open3.popen2(*args) do |i, o, _t|
       i.close
-      while (l = o.readpartial(8192))
-        $stdout << l
-      end
+      pipe_to_eof(o, $stdout)
     end
     true
   rescue SystemCallError
     nil
   end
+
+  def pipe_to_eof(src, dest)
+    loop do
+      data = src.readpartial(8192)
+      dest << data
+    rescue EOFError
+      break
+    end
+  end
 end
 
 # Override Timeout to use cancel scope

data/lib/polyphony/extensions/fiber.rb

@@ -238,7 +238,7 @@ module Polyphony
       @parent = parent
       @caller = caller
       @block = block
-      @mailbox = Gyro::Queue.new
+      @mailbox = Polyphony::Queue.new
       __fiber_trace__(:fiber_create, self)
       schedule
     end
@@ -268,7 +268,7 @@ module Polyphony
     # allows the fiber to be scheduled and to receive messages.
     def setup_raw
       @thread = Thread.current
-      @mailbox = Gyro::Queue.new
+      @mailbox = Polyphony::Queue.new
     end
 
     def setup_main_fiber
@@ -277,11 +277,11 @@ module Polyphony
       @thread = Thread.current
       @running = true
       @children&.clear
-      @mailbox = Gyro::Queue.new
+      @mailbox = Polyphony::Queue.new
     end
 
     def restart_self(first_value)
-      @mailbox = Gyro::Queue.new
+      @mailbox = Polyphony::Queue.new
       @when_done_procs = nil
       @waiting_fibers = nil
       run(first_value)

data/lib/polyphony/extensions/io.rb

@@ -2,7 +2,7 @@
 
 require 'open3'
 
-# IO overrides
+# IO class method patches
 class ::IO
   class << self
     alias_method :orig_binread, :binread
@@ -72,7 +72,10 @@ class ::IO
       Open3.popen2(cmd) { |_i, o, _t| yield o }
     end
   end
+end
 
+# IO instance method patches
+class ::IO
   # def each(sep = $/, limit = nil, chomp: nil)
   #   sep, limit = $/, sep if sep.is_a?(Integer)
   # end
@@ -93,6 +96,39 @@ class ::IO
   # def getc
   # end
 
+  alias_method :orig_read, :read
+  def read(len = 1 << 30)
+    @read_buffer ||= +''
+    result = Thread.current.agent.read(self, @read_buffer, len, true)
+    return nil unless result
+
+    already_read = @read_buffer
+    @read_buffer = +''
+    already_read
+  end
+
+  alias_method :orig_readpartial, :read
+  def readpartial(len)
+    @read_buffer ||= +''
+    result = Thread.current.agent.read(self, @read_buffer, len, false)
+    raise EOFError unless result
+
+    already_read = @read_buffer
+    @read_buffer = +''
+    already_read
+  end
+
+  alias_method :orig_write, :write
+  def write(str)
+    Thread.current.agent.write(self, str)
+  end
+
+  alias_method :orig_write_chevron, :<<
+  def <<(str)
+    Thread.current.agent.write(self, str)
+    self
+  end
+
   alias_method :orig_gets, :gets
   def gets(sep = $/, _limit = nil, _chomp: nil)
     if sep.is_a?(Integer)
@@ -101,23 +137,17 @@ class ::IO
     end
     sep_size = sep.bytesize
 
-    @gets_buffer ||= +''
+    @read_buffer ||= +''
 
     loop do
-      idx = @gets_buffer.index(sep)
-      return @gets_buffer.slice!(0, idx + sep_size) if idx
-
-      if (data = readpartial(8192))
-        @gets_buffer << data
-      else
-        return nil if @gets_buffer.empty?
+      idx = @read_buffer.index(sep)
+      return @read_buffer.slice!(0, idx + sep_size) if idx
 
-        line = @gets_buffer.freeze
-        @gets_buffer = +''
-        return line
-      end
+      data = readpartial(8192)
+      @read_buffer << data
+    rescue EOFError
+      return nil
     end
-    # orig_gets(sep, limit, chomp: chomp)
   end
 
   # def print(*args)
@@ -171,16 +201,20 @@ class ::IO
     buf ? readpartial(maxlen, buf) : readpartial(maxlen)
   end
 
-  alias_method :orig_read, :read
-  def read(length = nil, outbuf = nil)
-    if length
-      return outbuf ? readpartial(length) : readpartial(length, outbuf)
-    end
-
-    until eof?
-      outbuf ||= +''
-      outbuf << readpartial(8192)
-    end
-    outbuf
+  def read_loop(&block)
+    Thread.current.agent.read_loop(self, &block)
   end
+
+  # alias_method :orig_read, :read
+  # def read(length = nil, outbuf = nil)
+  #   if length
+  #     return outbuf ? readpartial(length) : readpartial(length, outbuf)
+  #   end
+
+  #   until eof?
+  #     outbuf ||= +''
+  #     outbuf << readpartial(8192)
+  #   end
+  #   outbuf
+  # end
 end

data/lib/polyphony/extensions/openssl.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'openssl'
-
 require_relative './socket'
 
 # Open ssl socket helper methods (to make it compatible with Socket API)
@@ -18,14 +17,36 @@ class ::OpenSSL::SSL::SSLSocket
     io.reuse_addr
   end
 
-  def sysread(maxlen, buf)
-    read_watcher = nil
-    write_watcher = nil
+  alias_method :orig_accept, :accept
+  def accept
+    loop do
+      result = accept_nonblock(exception: false)
+      case result
+      when :wait_readable then Thread.current.agent.wait_io(io, false)
+      when :wait_writable then Thread.current.agent.wait_io(io, true)
+      else
+        return result
+      end
+    end
+  end
+
+  alias_method :orig_sysread, :sysread
+  def sysread(maxlen, buf = +'')
     loop do
       case (result = read_nonblock(maxlen, buf, exception: false))
-      when :wait_readable then (read_watcher ||= io.read_watcher).await
-      when :wait_writable then (write_watcher ||= io.write_watcher).await
-      else result
+      when :wait_readable then Thread.current.agent.wait_io(io, false)
+      else return result
+      end
+    end
+  end
+
+  alias_method :orig_syswrite, :syswrite
+  def syswrite(buf)
+    loop do
+      case (result = write_nonblock(buf, exception: false))
+      when :wait_writable then Thread.current.agent.wait_io(io, true)
+      else
+        return result
       end
     end
   end
@@ -39,15 +60,14 @@ class ::OpenSSL::SSL::SSLSocket
     # @sync = osync
   end
 
-  def syswrite(buf)
-    read_watcher = nil
-    write_watcher = nil
-    loop do
-      case (result = write_nonblock(buf, exception: false))
-      when :wait_readable then (read_watcher ||= io.read_watcher).await
-      when :wait_writable then (write_watcher ||= io.write_watcher).await
-      else result
-      end
+  def readpartial(maxlen, buf = +'')
+    result = sysread(maxlen, buf)
+    result || (raise EOFError)
+  end
+
+  def read_loop
+    while (data = sysread(8192))
+      yield data
     end
   end
 end

data/lib/polyphony/extensions/socket.rb

@@ -7,14 +7,21 @@ require_relative '../core/thread_pool'
 
 # Socket overrides (eventually rewritten in C)
 class ::Socket
+  def accept
+    Thread.current.agent.accept(self)
+  end
+
   NO_EXCEPTION = { exception: false }.freeze
 
   def connect(remotesockaddr)
     loop do
       result = connect_nonblock(remotesockaddr, **NO_EXCEPTION)
-      return if result == 0
-
-      result == :wait_writable ? write_watcher.await : (raise IOError)
+      case result
+      when 0 then return
+      when :wait_writable then Thread.current.agent.wait_io(self, true)
+      else
+        raise IOError
+      end
     end
   end
 
@@ -22,9 +29,12 @@ class ::Socket
     outbuf ||= +''
     loop do
       result = recv_nonblock(maxlen, flags, outbuf, **NO_EXCEPTION)
-      raise IOError unless result
-
-      result == :wait_readable ? read_watcher.await : (return result)
+      case result
+      when nil then raise IOError
+      when :wait_readable then Thread.current.agent.wait_io(self, false)
+      else
+        return result
+      end
     end
   end
 
@@ -32,9 +42,12 @@ class ::Socket
     @read_buffer ||= +''
     loop do
       result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
-      raise IOError unless result
-
-      result == :wait_readable ? read_watcher.await : (return result)
+      case result
+      when nil then raise IOError
+      when :wait_readable then Thread.current.agent.wait_io(self, false)
+      else
+        return result
+      end
     end
   end
 
@@ -115,6 +128,11 @@ class ::TCPServer
 
   alias_method :orig_accept, :accept
   def accept
-    @io ? @io.accept : orig_accept
+    @io.accept
+  end
+
+  alias_method :orig_close, :close
+  def close
+    @io.close
   end
 end

data/lib/polyphony/extensions/thread.rb

@@ -8,26 +8,30 @@ class ::Thread
 
   alias_method :orig_initialize, :initialize
   def initialize(*args, &block)
-    @join_wait_queue = Gyro::Queue.new
+    @join_wait_queue = []
+    @finalization_mutex = Mutex.new
     @args = args
     @block = block
-    @finalization_mutex = Mutex.new
     orig_initialize { execute }
   end
 
   def execute
+    # agent must be created in the context of the new thread, therefore it
+    # cannot be created in Thread#initialize
+    @agent = Polyphony::LibevAgent.new
     setup
     @ready = true
     result = @block.(*@args)
   rescue Polyphony::MoveOn, Polyphony::Terminate => e
     result = e.value
-  rescue Exception => e
-    result = e
+  rescue Exception => result
   ensure
     @ready = true
     finalize(result)
   end
 
+  attr_accessor :agent
+
   def setup
     @main_fiber = Fiber.current
     @main_fiber.setup_main_fiber
@@ -44,24 +48,25 @@ class ::Thread
       @result = result
       signal_waiters(result)
     end
-    stop_event_selector
+    @agent.finalize
   end
 
   def signal_waiters(result)
-    @join_wait_queue.shift_each { |w| w.signal(result) }
+    @join_wait_queue.each { |w| w.signal(result) }
   end
 
   alias_method :orig_join, :join
   def join(timeout = nil)
-    async = Fiber.current.auto_async
+    watcher = Fiber.current.auto_watcher
+
     @finalization_mutex.synchronize do
       if @terminated
         @result.is_a?(Exception) ? (raise @result) : (return @result)
       else
-        @join_wait_queue.push(async)
+        @join_wait_queue << watcher
       end
     end
-    timeout ? move_on_after(timeout) { async.await } : async.await
+    timeout ? move_on_after(timeout) { watcher.await } : watcher.await
   end
   alias_method :await, :join
 
@@ -78,6 +83,8 @@ class ::Thread
 
   alias_method :orig_kill, :kill
   def kill
+    return if @terminated
+
     raise Polyphony::Terminate
   end