polyphony 0.49.2 → 0.53.0

data/lib/polyphony/core/exceptions.rb

@@ -13,6 +13,7 @@ module Polyphony
     def initialize(value = nil)
       @caller_backtrace = caller
       @value = value
+      super
     end
   end
 

data/lib/polyphony/core/global_api.rb

@@ -21,7 +21,7 @@ module Polyphony
       elsif block.arity > 0
         cancel_after_with_block(Fiber.current, interval, with_exception, &block)
       else
-        Thread.current.backend.timeout(interval, with_exception, &block)
+        Polyphony.backend_timeout(interval, with_exception, &block)
       end
     end
 
@@ -29,7 +29,7 @@ module Polyphony
       spin do
         sleep interval
         exception = cancel_exception(with_exception)
-        exception.__raising_fiber__ = nil
+        exception.raising_fiber = nil
         fiber.schedule exception
       end
     end
@@ -82,7 +82,7 @@ module Polyphony
     end
 
     def every(interval, &block)
-      Thread.current.backend.timer_loop(interval, &block)
+      Polyphony.backend_timer_loop(interval, &block)
     end
 
     def move_on_after(interval, with_value: nil, &block)
@@ -91,7 +91,7 @@ module Polyphony
       elsif block.arity > 0
         move_on_after_with_block(Fiber.current, interval, with_value, &block)
       else
-        Thread.current.backend.timeout(interval, nil, with_value, &block)
+        Polyphony.backend_timeout(interval, nil, with_value, &block)
       end
     end
 
@@ -129,11 +129,11 @@ module Polyphony
     def sleep(duration = nil)
       return sleep_forever unless duration
 
-      Thread.current.backend.sleep duration
+      Polyphony.backend_sleep duration
     end
 
     def sleep_forever
-      Thread.current.backend.wait_event(true)
+      Polyphony.backend_wait_event(true)
     end
 
     def throttled_loop(rate = nil, **opts, &block)

data/lib/polyphony/core/sync.rb

@@ -46,7 +46,7 @@ module Polyphony
     def wait(mutex, _timeout = nil)
       mutex.conditional_release
       @queue << Fiber.current
-      Thread.current.backend.wait_event(true)
+      Polyphony.backend_wait_event(true)
       mutex.conditional_reacquire
     end
 

data/lib/polyphony/core/throttler.rb

@@ -12,7 +12,7 @@ module Polyphony
     def call
       now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       delta = @next_time - now
-      Thread.current.backend.sleep(delta) if delta > 0
+      Polyphony.backend_sleep(delta) if delta > 0
       yield self
 
       while true

data/lib/polyphony/core/timer.rb

@@ -11,12 +11,45 @@ module Polyphony
     def stop
       @fiber.stop
     end
+
+    def sleep(duration)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        interval: duration,
+        target_stamp: now + duration
+      }
+      Polyphony.backend_wait_event(true)
+    ensure
+      @timeouts.delete(fiber)
+    end
+
+    def after(interval, &block)
+      spin do
+        self.sleep interval
+        block.()
+      end
+    end
+
+    def every(interval)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        interval: interval,
+        target_stamp: now + interval,
+        recurring: true
+      }
+      while true
+        Polyphony.backend_wait_event(true)
+        yield
+      end
+    ensure
+      @timeouts.delete(fiber)
+    end
   
-    def cancel_after(duration, with_exception: Polyphony::Cancel)
+    def cancel_after(interval, with_exception: Polyphony::Cancel)
       fiber = Fiber.current
       @timeouts[fiber] = {
-        duration: duration,
-        target_stamp: Time.now + duration,
+        interval: interval,
+        target_stamp: now + interval,
         exception: with_exception
       }
       yield
@@ -24,12 +57,12 @@ module Polyphony
       @timeouts.delete(fiber)
     end
 
-    def move_on_after(duration, with_value: nil)
+    def move_on_after(interval, with_value: nil)
       fiber = Fiber.current
       @timeouts[fiber] = {
-        duration: duration,
-        target_stamp: Time.now + duration,
-        value: with_value
+        interval: interval,
+        target_stamp: now + interval,
+        exception: [Polyphony::MoveOn, with_value]
       }
       yield
     rescue Polyphony::MoveOn => e
@@ -37,36 +70,46 @@ module Polyphony
     ensure
       @timeouts.delete(fiber)
     end
-  
+
     def reset
       record = @timeouts[Fiber.current]
       return unless record
   
-      record[:target_stamp] = Time.now + record[:duration]
+      record[:target_stamp] = now + record[:interval]
     end
-  
+
     private
 
+    def now
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
+
     def timeout_exception(record)
       case (exception = record[:exception])
-      when Class then exception.new
-      when Array then exception[0].new(exception[1])
-      when nil then Polyphony::MoveOn.new(record[:value])
-      else RuntimeError.new(exception)
+      when Array
+        exception[0].new(exception[1])
+      when Class
+        exception.new
+      else
+        RuntimeError.new(exception)
       end
     end
 
     def update
-      now = Time.now
-      # elapsed = nil
+      return if @timeouts.empty?
+
       @timeouts.each do |fiber, record|
         next if record[:target_stamp] > now
 
-        exception = timeout_exception(record)
-        # (elapsed ||= []) << fiber
-        fiber.schedule exception
+        value = record[:exception] ? timeout_exception(record) : record[:value]
+        fiber.schedule value
+
+        next unless record[:recurring]
+
+        while record[:target_stamp] <= now
+          record[:target_stamp] += record[:interval]
+        end
       end
-      # elapsed&.each { |f| @timeouts.delete(f) }
     end
   end
 end

data/lib/polyphony/extensions/core.rb

@@ -12,11 +12,11 @@ class ::Exception
     attr_accessor :__disable_sanitized_backtrace__
   end
 
-  attr_accessor :source_fiber, :__raising_fiber__
+  attr_accessor :source_fiber, :raising_fiber
 
   alias_method :orig_initialize, :initialize
   def initialize(*args)
-    @__raising_fiber__ = Fiber.current
+    @raising_fiber = Fiber.current
     orig_initialize(*args)
   end
 
@@ -31,10 +31,10 @@ class ::Exception
   end
 
   def sanitized_backtrace
-    return sanitize(orig_backtrace) unless @__raising_fiber__
+    return sanitize(orig_backtrace) unless @raising_fiber
 
     backtrace = orig_backtrace || []
-    sanitize(backtrace + @__raising_fiber__.caller)
+    sanitize(backtrace + @raising_fiber.caller)
   end
 
   POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))
@@ -55,7 +55,7 @@ module ::Process
   class << self
     alias_method :orig_detach, :detach
     def detach(pid)
-      fiber = spin { Thread.current.backend.waitpid(pid) }
+      fiber = spin { Polyphony.backend_waitpid(pid) }
       fiber.define_singleton_method(:pid) { pid }
       fiber
     end

data/lib/polyphony/extensions/fiber.rb

@@ -316,6 +316,8 @@ module Polyphony
       @running = false
       inform_dependants(result, uncaught_exception)
     ensure
+      # Prevent fiber from being resumed after terminating
+      @thread.fiber_unschedule(self)
       Thread.current.switch_fiber
     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 ||= +''
-    Thread.current.backend.read(self, @read_buffer, 8192, false)
+    Polyphony.backend_read(self, @read_buffer, 8192, false)
     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 = Thread.current.backend.read(self, @read_buffer, len, true)
+    result = Polyphony.backend_read(self, @read_buffer, len, true)
     return nil unless result
 
     already_read = @read_buffer
@@ -120,7 +120,7 @@ class ::IO
 
   alias_method :orig_readpartial, :read
   def readpartial(len, str = +'')
-    result = Thread.current.backend.read(self, str, len, false)
+    result = Polyphony.backend_read(self, str, len, false)
     raise EOFError unless result
 
     result
@@ -128,12 +128,12 @@ class ::IO
 
   alias_method :orig_write, :write
   def write(str, *args)
-    Thread.current.backend.write(self, str, *args)
+    Polyphony.backend_write(self, str, *args)
   end
 
   alias_method :orig_write_chevron, :<<
   def <<(str)
-    Thread.current.backend.write(self, str)
+    Polyphony.backend_write(self, str)
     self
   end
 
@@ -217,30 +217,21 @@ class ::IO
   end
 
   def read_loop(&block)
-    Thread.current.backend.read_loop(self, &block)
+    Polyphony.backend_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
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_feed_loop(self, receiver, method, &block)
+  end
 
   def wait_readable(timeout = nil)
     if timeout
       move_on_after(timeout) do
-        Thread.current.backend.wait_io(self, false)
+        Polyphony.backend_wait_io(self, false)
         self
       end
     else
-      Thread.current.backend.wait_io(self, false)
+      Polyphony.backend_wait_io(self, false)
       self
     end
   end
@@ -248,12 +239,20 @@ class ::IO
   def wait_writable(timeout = nil)
     if timeout
       move_on_after(timeout) do
-        Thread.current.backend.wait_io(self, true)
+        Polyphony.backend_wait_io(self, true)
         self
       end
     else
-      Thread.current.backend.wait_io(self, true)
+      Polyphony.backend_wait_io(self, true)
       self
     end
   end
+
+  def splice(src, maxlen)
+    Polyphony.backend_splice(src, self, maxlen)
+  end
+
+  def splice_to_eof(src, chunksize = 8192)
+    Polyphony.backend_splice_to_eof(src, self, chunksize)
+  end
 end

data/lib/polyphony/extensions/openssl.rb

@@ -28,8 +28,8 @@ class ::OpenSSL::SSL::SSLSocket
     while true
       result = accept_nonblock(exception: false)
       case result
-      when :wait_readable then Thread.current.backend.wait_io(io, false)
-      when :wait_writable then Thread.current.backend.wait_io(io, true)
+      when :wait_readable then Polyphony.backend_wait_io(io, false)
+      when :wait_writable then Polyphony.backend_wait_io(io, true)
       else
         return result
       end
@@ -46,8 +46,8 @@ class ::OpenSSL::SSL::SSLSocket
   def sysread(maxlen, buf = +'')
     while true
       case (result = read_nonblock(maxlen, buf, exception: false))
-      when :wait_readable then Thread.current.backend.wait_io(io, false)
-      when :wait_writable then Thread.current.backend.wait_io(io, true)
+      when :wait_readable then Polyphony.backend_wait_io(io, false)
+      when :wait_writable then Polyphony.backend_wait_io(io, true)
       else return result
       end
     end
@@ -57,8 +57,8 @@ class ::OpenSSL::SSL::SSLSocket
   def syswrite(buf)
     while true
       case (result = write_nonblock(buf, exception: false))
-      when :wait_readable then Thread.current.backend.wait_io(io, false)
-      when :wait_writable then Thread.current.backend.wait_io(io, true)
+      when :wait_readable then Polyphony.backend_wait_io(io, false)
+      when :wait_writable then Polyphony.backend_wait_io(io, true)
       else
         return result
       end

data/lib/polyphony/extensions/socket.rb

@@ -8,57 +8,60 @@ require_relative '../core/thread_pool'
 # Socket overrides (eventually rewritten in C)
 class ::Socket
   def accept
-    Thread.current.backend.accept(self, TCPSocket)
+    Polyphony.backend_accept(self, TCPSocket)
   end
 
   def accept_loop(&block)
-    Thread.current.backend.accept_loop(self, TCPSocket, &block)
+    Polyphony.backend_accept_loop(self, TCPSocket, &block)
   end
 
   NO_EXCEPTION = { exception: false }.freeze
 
   def connect(addr)
     addr = Addrinfo.new(addr) if addr.is_a?(String)
-    Thread.current.backend.connect(self, addr.ip_address, addr.ip_port)
+    Polyphony.backend_connect(self, addr.ip_address, addr.ip_port)
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    Thread.current.backend.recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen)
   end
 
   def recv_loop(&block)
-    Thread.current.backend.recv_loop(self, &block)
+    Polyphony.backend_recv_loop(self, &block)
   end
   alias_method :read_loop, :recv_loop
 
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_recv_feed_loop(self, receiver, method, &block)
+  end
+
   def recvfrom(maxlen, flags = 0)
     @read_buffer ||= +''
     while true
       result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
       case result
       when nil then raise IOError
-      when :wait_readable then Thread.current.backend.wait_io(self, false)
+      when :wait_readable then Polyphony.backend_wait_io(self, false)
       else
         return result
       end
     end
   end
 
-  def send(mesg, flags = 0)
-    Thread.current.backend.send(self, mesg)
-  end
+  # def send(mesg, flags)
+  #   Polyphony.backend_send(self, mesg, flags)
+  # end
 
-  def write(str, *args)
-    if args.empty?
-      Thread.current.backend.send(self, str)
-    else
-      Thread.current.backend.send(self, str + args.join)
-    end
-  end
-  alias_method :<<, :write
+  # def write(*args)
+  #   Polyphony.backend_sendv(self, args, 0)
+  # end
+
+  # def <<(mesg)
+  #   Polyphony.backend_send(self, mesg, 0)
+  # end
 
   def readpartial(maxlen, str = +'')
-    Thread.current.backend.recv(self, str, maxlen)
+    Polyphony.backend_recv(self, str, maxlen)
   end
 
   ZERO_LINGER = [0, 0].pack('ii').freeze
@@ -138,30 +141,33 @@ class ::TCPSocket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    Thread.current.backend.recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen)
   end
 
   def recv_loop(&block)
-    Thread.current.backend.recv_loop(self, &block)
+    Polyphony.backend_recv_loop(self, &block)
   end
   alias_method :read_loop, :recv_loop
 
-  def send(mesg, flags = 0)
-    Thread.current.backend.send(self, mesg)
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_recv_feed_loop(self, receiver, method, &block)
   end
 
-  def write(str, *args)
-    if args.empty?
-      Thread.current.backend.send(self, str)
-    else
-      Thread.current.backend.send(self, str + args.join)
-    end
-  end
-  alias_method :<<, :write
+  # def send(mesg, flags)
+  #   Polyphony.backend_send(self, mesg, flags)
+  # end
+
+  # def write(*args)
+  #   Polyphony.backend_sendv(self, args, 0)
+  # end
+
+  # def <<(mesg)
+  #   Polyphony.backend_send(self, mesg, 0)
+  # end
 
   def readpartial(maxlen, str = nil)
     @read_buffer ||= +''
-    result = Thread.current.backend.recv(self, @read_buffer, maxlen)
+    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
     raise EOFError unless result
 
     if str
@@ -192,12 +198,12 @@ class ::TCPServer
 
   alias_method :orig_accept, :accept
   def accept
-    Thread.current.backend.accept(@io, TCPSocket)
+    Polyphony.backend_accept(@io, TCPSocket)
     # @io.accept
   end
 
   def accept_loop(&block)
-    Thread.current.backend.accept_loop(@io, TCPSocket, &block)
+    Polyphony.backend_accept_loop(@io, TCPSocket, &block)
   end
 
   alias_method :orig_close, :close
@@ -209,40 +215,43 @@ end
 class ::UNIXServer
   alias_method :orig_accept, :accept
  def accept
-    Thread.current.backend.accept(self, UNIXSocket)
+    Polyphony.backend_accept(self, UNIXSocket)
   end
 
   def accept_loop(&block)
-    Thread.current.backend.accept_loop(self, UNIXSocket, &block)
+    Polyphony.backend_accept_loop(self, UNIXSocket, &block)
   end
 end
 
 class ::UNIXSocket
   def recv(maxlen, flags = 0, outbuf = nil)
-    Thread.current.backend.recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen)
   end
 
   def recv_loop(&block)
-    Thread.current.backend.recv_loop(self, &block)
+    Polyphony.backend_recv_loop(self, &block)
   end
   alias_method :read_loop, :recv_loop
 
-  def send(mesg, flags = 0)
-    Thread.current.backend.send(self, mesg)
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_recv_feed_loop(self, receiver, method, &block)
   end
 
-  def write(str, *args)
-    if args.empty?
-      Thread.current.backend.send(self, str)
-    else
-      Thread.current.backend.send(self, str + args.join)
-    end
+  def send(mesg, flags)
+    Polyphony.backend_send(self, mesg, flags)
+  end
+
+  def write(*args)
+    Polyphony.backend_sendv(self, args, 0)
+  end
+
+  def <<(mesg)
+    Polyphony.backend_send(self, mesg, 0)
   end
-  alias_method :<<, :write
 
   def readpartial(maxlen, str = nil)
     @read_buffer ||= +''
-    result = Thread.current.backend.recv(self, @read_buffer, maxlen)
+    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
     raise EOFError unless result
 
     if str