polyphony 0.57.0 → 0.60

data/lib/polyphony/core/timer.rb

@@ -3,8 +3,8 @@
 module Polyphony
   # Implements a common timer for running multiple timeouts
   class Timer
-    def initialize(resolution:)
-      @fiber = spin_loop(interval: resolution) { update }
+    def initialize(tag = nil, resolution:)
+      @fiber = spin_loop(tag, interval: resolution) { update }
       @timeouts = {}
     end
 

data/lib/polyphony/extensions/fiber.rb

@@ -22,9 +22,9 @@ module Polyphony
         return self
       end
 
-      parent.spin(@tag, @caller, &@block).tap do |f|
-        f.schedule(value) unless value.nil?
-      end
+      fiber = parent.spin(@tag, @caller, &@block)
+      fiber.schedule(value) unless value.nil?
+      fiber
     end
     alias_method :reset, :restart
 
@@ -66,6 +66,11 @@ module Polyphony
     def interject(&block)
       raise Polyphony::Interjection.new(block)
     end
+
+    def await
+      Fiber.await(self).first
+    end
+    alias_method :join, :await
   end
 
   # Fiber supervision
@@ -78,7 +83,7 @@ module Polyphony
       while true
         supervise_perform(opts)
       end
-    rescue Polyphony::MoveOn
+  rescue Polyphony::MoveOn
       # generated in #supervise_perform to stop supervisor
     ensure
       @on_child_done = nil
@@ -119,72 +124,62 @@ module Polyphony
     def await(*fibers)
       return [] if fibers.empty?
 
-      state = setup_await_select_state(fibers)
-      await_setup_monitoring(fibers, state)
-      suspend
-      fibers.map(&:result)
-    ensure
-      await_select_cleanup(state) if state
-    end
-    alias_method :join, :await
-
-    def setup_await_select_state(fibers)
-      {
-        awaiter: Fiber.current,
-        pending: fibers.each_with_object({}) { |f, h| h[f] = true }
-      }
-    end
-
-    def await_setup_monitoring(fibers, state)
+      Fiber.current.message_on_child_termination = true
+      results = {}
       fibers.each do |f|
-        f.when_done { |r| await_fiber_done(f, r, state) }
+        results[f] = nil
+        if f.dead?
+          # fiber already terminated, so queue message
+          Fiber.current.send [f, f.result]
+        else
+          f.monitor
+        end
       end
-    end
-
-    def await_fiber_done(fiber, result, state)
-      state[:pending].delete(fiber)
-
-      if state[:cleanup]
-        state[:awaiter].schedule if state[:pending].empty?
-      elsif !state[:done] && (result.is_a?(Exception) || state[:pending].empty?)
-        state[:awaiter].schedule(result)
-        state[:done] = true
+      exception = nil
+      while !fibers.empty?
+        (fiber, result) = receive
+        next unless fibers.include?(fiber)
+
+        fibers.delete(fiber)
+        if result.is_a?(Exception)
+          exception ||= result
+          fibers.each { |f| f.terminate }
+        else
+          results[fiber] = result
+        end
       end
-    end
-
-    def await_select_cleanup(state)
-      return if state[:pending].empty?
-
-      terminate = Polyphony::Terminate.new
-      state[:cleanup] = true
-      state[:pending].each_key { |f| f.schedule(terminate) }
-      suspend
-    end
-
-    def select(*fibers)
-      state = setup_await_select_state(fibers)
-      select_setup_monitoring(fibers, state)
-      suspend
+      results.values
     ensure
-      await_select_cleanup(state)
+      Fiber.current.message_on_child_termination = false
+      raise exception if exception
     end
+    alias_method :join, :await
 
-    def select_setup_monitoring(fibers, state)
+    def select(*fibers)
+      return nil if fibers.empty?
+  
       fibers.each do |f|
-        f.when_done { |r| select_fiber_done(f, r, state) }
+        if f.dead?
+          result = f.result
+          result.is_a?(Exception) ? (raise result) : (return [f, result])
+        end
       end
-    end
 
-    def select_fiber_done(fiber, result, state)
-      state[:pending].delete(fiber)
-      if state[:cleanup]
-        # in cleanup mode the selector is resumed if no more pending fibers
-        state[:awaiter].schedule if state[:pending].empty?
-      elsif !state[:selected]
-        # first fiber to complete, we schedule the result
-        state[:awaiter].schedule([fiber, result])
-        state[:selected] = true
+      Fiber.current.message_on_child_termination = true
+      fibers.each { |f| f.monitor }
+      while true
+        (fiber, result) = receive
+        next unless fibers.include?(fiber)
+  
+        fibers.each { |f| f.unmonitor }
+        if result.is_a?(Exception)
+          raise result
+        else
+          return [fiber, result]
+        end
       end
+    ensure
+      Fiber.current.message_on_child_termination = false
     end
 
     # Creates and schedules with priority an out-of-band fiber that runs the
@@ -209,6 +204,14 @@ module Polyphony
       (@children ||= {}).keys
     end
 
+    def add_child(child_fiber)
+      (@children ||= {})[child_fiber] = true
+    end
+
+    def remove_child(child_fiber)
+      @children.delete(child_fiber) if @children
+    end
+
     def spin(tag = nil, orig_caller = Kernel.caller, &block)
       f = Fiber.new { |v| f.run(v) }
       f.prepare(tag, block, orig_caller, self)
@@ -218,7 +221,10 @@ module Polyphony
 
     def child_done(child_fiber, result)
       @children.delete(child_fiber)
-      @on_child_done&.(child_fiber, result)
+
+      if result.is_a?(Exception) && !@message_on_child_termination
+        schedule_with_priority(result)
+      end
     end
 
     def terminate_all_children(graceful = false)
@@ -234,14 +240,7 @@ module Polyphony
     def await_all_children
       return unless @children && !@children.empty?
 
-      results = @children.dup
-      @on_child_done = proc do |c, r|
-        results[c] = r
-        schedule if @children.empty?
-      end
-      suspend
-      @on_child_done = nil
-      results.values
+      Fiber.await(*@children.keys)
     end
 
     def shutdown_all_children(graceful = false)
@@ -252,6 +251,18 @@ module Polyphony
         c.await
       end
     end
+
+    def detach
+      @parent.remove_child(self)
+      @parent = @thread.main_fiber
+      @parent.add_child(self)
+    end
+
+    def attach(parent)
+      @parent.remove_child(self)
+      @parent = parent
+      @parent.add_child(self)
+    end
   end
 
   # Fiber life cycle methods
@@ -262,7 +273,7 @@ module Polyphony
       @parent = parent
       @caller = caller
       @block = block
-      __fiber_trace__(:fiber_create, self)
+      Thread.backend.trace(:fiber_create, self)
       schedule
     end
 
@@ -304,17 +315,16 @@ module Polyphony
 
     def restart_self(first_value)
       @mailbox = nil
-      @when_done_procs = nil
-      @waiting_fibers = nil
       run(first_value)
     end
 
     def finalize(result, uncaught_exception = false)
       result, uncaught_exception = finalize_children(result, uncaught_exception)
-      __fiber_trace__(:fiber_terminate, self, result)
+      Thread.backend.trace(:fiber_terminate, self, result)
       @result = result
-      @running = false
+
       inform_dependants(result, uncaught_exception)
+      @running = false
     ensure
       # Prevent fiber from being resumed after terminating
       @thread.fiber_unschedule(self)
@@ -332,17 +342,27 @@ module Polyphony
     end
 
     def inform_dependants(result, uncaught_exception)
+      if @monitors
+        msg = [self, result]
+        @monitors.each { |f| f << msg }
+      end
+
       @parent&.child_done(self, result)
-      @when_done_procs&.each { |p| p.(result) }
-      @waiting_fibers&.each_key { |f| f.schedule(result) }
-      
-      # propagate unaught exception to parent
-      @parent&.schedule_with_priority(result) if uncaught_exception && !@waiting_fibers
     end
 
-    def when_done(&block)
-      @when_done_procs ||= []
-      @when_done_procs << block
+    attr_accessor :message_on_child_termination 
+
+    def monitor
+      @monitors ||= []
+      @monitors << Fiber.current
+    end
+
+    def unmonitor
+      @monitors.delete(Fiber.current) if @monitors
+    end
+
+    def dead?
+      state == :dead
     end
   end
 end

data/lib/polyphony/extensions/io.rb

@@ -101,7 +101,7 @@ class ::IO
     return @read_buffer.slice!(0) if @read_buffer && !@read_buffer.empty?
     
     @read_buffer ||= +''
-    Polyphony.backend_read(self, @read_buffer, 8192, false)
+    Polyphony.backend_read(self, @read_buffer, 8192, false, -1)
     return @read_buffer.slice!(0) if !@read_buffer.empty?
 
     nil
@@ -110,7 +110,7 @@ class ::IO
   alias_method :orig_read, :read
   def read(len = nil)
     @read_buffer ||= +''
-    result = Polyphony.backend_read(self, @read_buffer, len, true)
+    result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
     return nil unless result
 
     already_read = @read_buffer
@@ -119,8 +119,8 @@ class ::IO
   end
 
   alias_method :orig_readpartial, :read
-  def readpartial(len, str = +'')
-    result = Polyphony.backend_read(self, str, len, false)
+  def readpartial(len, str = +'', buffer_pos = 0)
+    result = Polyphony.backend_read(self, str, len, false, buffer_pos)
     raise EOFError unless result
 
     result
@@ -151,9 +151,10 @@ class ::IO
       idx = @read_buffer.index(sep)
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
-      data = readpartial(8192, +'')
-      return nil unless data
-      @read_buffer << data
+      result = readpartial(8192, @read_buffer, -1)
+        
+      #Polyphony.backend_read(self, @read_buffer, 8192, false, -1)
+      return nil unless result
     end
   rescue EOFError
     return nil
@@ -216,8 +217,8 @@ class ::IO
     buf ? readpartial(maxlen, buf) : readpartial(maxlen)
   end
 
-  def read_loop(&block)
-    Polyphony.backend_read_loop(self, &block)
+  def read_loop(maxlen = 8192, &block)
+    Polyphony.backend_read_loop(self, maxlen, &block)
   end
 
   def feed_loop(receiver, method = :call, &block)

data/lib/polyphony/extensions/openssl.rb

@@ -64,13 +64,23 @@ class ::OpenSSL::SSL::SSLSocket
     # @sync = osync
   end
 
-  def readpartial(maxlen, buf = +'')
-    result = sysread(maxlen, buf)
+  def readpartial(maxlen, buf = +'', buffer_pos = 0)
+    if buffer_pos != 0
+      if (result = sysread(maxlen, +''))
+        if buffer_pos == -1
+          result = buf + result
+        else
+          result = buf[0...buffer_pos] + result
+        end
+      end
+    else
+      result = sysread(maxlen, buf)
+    end
     result || (raise EOFError)
   end
 
-  def read_loop
-    while (data = sysread(8192))
+  def read_loop(maxlen = 8192)
+    while (data = sysread(maxlen))
       yield data
     end
   end

data/lib/polyphony/extensions/socket.rb

@@ -23,11 +23,11 @@ class ::Socket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    Polyphony.backend_recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
 
-  def recv_loop(&block)
-    Polyphony.backend_recv_loop(self, &block)
+  def recv_loop(maxlen = 8192, &block)
+    Polyphony.backend_recv_loop(self, maxlen, &block)
   end
   alias_method :read_loop, :recv_loop
 
@@ -60,8 +60,8 @@ class ::Socket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = +'')
-    Polyphony.backend_recv(self, str, maxlen)
+  def readpartial(maxlen, str = +'', buffer_pos = 0)
+    Polyphony.backend_recv(self, str, maxlen, buffer_pos)
   end
 
   ZERO_LINGER = [0, 0].pack('ii').freeze
@@ -141,11 +141,11 @@ class ::TCPSocket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    Polyphony.backend_recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
 
-  def recv_loop(&block)
-    Polyphony.backend_recv_loop(self, &block)
+  def recv_loop(maxlen = 8192, &block)
+    Polyphony.backend_recv_loop(self, maxlen, &block)
   end
   alias_method :read_loop, :recv_loop
 
@@ -165,8 +165,8 @@ class ::TCPSocket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = +'')
-    result = Polyphony.backend_recv(self, str, maxlen)
+  def readpartial(maxlen, str = +'', buffer_pos = 0)
+    result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
     raise EOFError unless result
 
     str
@@ -218,11 +218,11 @@ end
 
 class ::UNIXSocket
   def recv(maxlen, flags = 0, outbuf = nil)
-    Polyphony.backend_recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
 
-  def recv_loop(&block)
-    Polyphony.backend_recv_loop(self, &block)
+  def recv_loop(maxlen = 8192, &block)
+    Polyphony.backend_recv_loop(self, maxlen, &block)
   end
   alias_method :read_loop, :recv_loop
 
@@ -242,8 +242,8 @@ class ::UNIXSocket
     Polyphony.backend_send(self, mesg, 0)
   end
 
-  def readpartial(maxlen, str = +'')
-    result = Polyphony.backend_recv(self, str, maxlen)
+  def readpartial(maxlen, str = +'', buffer_pos = 0)
+    result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
     raise EOFError unless result
 
     str

data/lib/polyphony/extensions/thread.rb

@@ -105,4 +105,12 @@ class ::Thread
     main_fiber << value
   end
   alias_method :send, :<<
+
+  def idle_gc_period=(period)
+    backend.idle_gc_period = period
+  end
+
+  def on_idle(&block)
+    backend.idle_proc = block
+  end
 end