polyphony 0.64 → 0.68

data/ext/polyphony/runqueue_ring_buffer.h

@@ -29,4 +29,6 @@ void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE
 void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber);
 int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber);
 
+void runqueue_ring_buffer_migrate(runqueue_ring_buffer *src, runqueue_ring_buffer *dest, VALUE fiber);
+
 #endif /* RUNQUEUE_RING_BUFFER_H */

data/ext/polyphony/thread.c

@@ -22,14 +22,12 @@ VALUE Thread_fiber_unschedule(VALUE self, VALUE fiber) {
   return self;
 }
 
-VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
+inline void Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
   schedule_fiber(self, fiber, value, 0);
-  return self;
 }
 
-VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value) {
+inline void Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value) {
   schedule_fiber(self, fiber, value, 1);
-  return self;
 }
 
 VALUE Thread_switch_fiber(VALUE self) {
@@ -61,10 +59,6 @@ VALUE Thread_class_backend(VALUE _self) {
 void Init_Thread() {
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "schedule_and_wakeup", Thread_fiber_schedule_and_wakeup, 2);
-
-  rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 2);
-  rb_define_method(rb_cThread, "schedule_fiber_with_priority",
-    Thread_schedule_fiber_with_priority, 2);
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
   rb_define_method(rb_cThread, "fiber_unschedule", Thread_fiber_unschedule, 1);
 

data/lib/polyphony.rb

@@ -121,3 +121,9 @@ end
 
 Polyphony.install_terminating_signal_handlers
 Polyphony.install_at_exit_handler
+
+if (debug_socket_path = ENV['POLYPHONY_DEBUG_SOCKET_PATH'])
+  puts "Starting debug server on #{debug_socket_path}"
+  require 'polyphony/debugger'
+  Polyphony.start_debug_server(debug_socket_path)
+end

data/lib/polyphony/debugger.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'polyphony/extensions/debug'
+
+module Polyphony
+  TP_EVENTS = [
+    :line,
+    :call,
+    :return,
+    :b_call,
+    :b_return
+  ]    
+
+  def self.start_debug_server(socket_path)
+    server = DebugServer.new(socket_path)
+    controller = DebugController.new(server)      
+    trace = TracePoint.new(*TP_EVENTS) { |tp| controller.handle_tp(trace, tp) }
+    trace.enable
+
+    at_exit do
+      Kernel.trace "program terminated"
+      trace.disable
+      server.stop
+    end
+  end
+
+  class DebugController
+    def initialize(server)
+      @server = server
+      @server.wait_for_client
+      @state = { fibers: {} }
+      @control_fiber = Fiber.new { |f| control_loop(f) }
+      @control_fiber.transfer Fiber.current
+    end
+
+    def control_loop(source_fiber)
+      @peer = source_fiber
+      cmd = { cmd: :initial }
+      loop do
+        cmd = send(:"cmd_#{cmd[:cmd]}", cmd)
+      end
+    end
+
+    POLYPHONY_LIB_DIR = File.expand_path('..', __dir__)
+
+    def get_next_trace_event
+      @peer.transfer.tap { |e| update_state(e) }
+    end
+
+    def update_state(event)
+      trace update_state: event
+      @state[:fiber] = event[:fiber]
+      @state[:path] = event[:path]
+      @state[:lineno] = event[:lineno]
+      update_fiber_state(event)
+    end
+
+    def update_fiber_state(event)
+      fiber_state = @state[:fibers][event[:fiber]] ||= { stack: [] }
+      case event[:kind]
+      when :call, :c_call, :b_call
+        fiber_state[:stack] << event
+      when :return, :c_return, :b_return
+        fiber_state[:stack].pop
+      end
+      fiber_state[:binding] = event[:binding]
+      fiber_state[:path] = event[:path]
+      fiber_state[:lineno] = event[:lineno]
+    end
+
+    def state_presentation(state)
+      {
+        fiber:  fiber_id(state[:fiber]),
+        path:   state[:path],
+        lineno: state[:lineno]
+      }
+    end
+
+    def fiber_id(fiber)
+      {
+        object_id: fiber.object_id,
+        tag: fiber.tag
+      }
+    end
+
+    def fiber_representation(fiber)
+      {
+        object_id: fiber.object_id,
+        tag: fiber.tag,
+        parent: fiber.parent && fiber_id(fiber.parent),
+        children: fiber.children.map { |c| fiber_id(c) }
+      }
+    end
+
+    def get_next_command(info)
+      @server.get_command(info)
+    end
+
+    def cmd_initial(cmd)
+      get_next_command(nil)
+    end
+
+    def info_listing(state)
+      {
+        kind: :listing,
+        fiber: fiber_id(state[:fiber]),
+        path: state[:path],
+        lineno: state[:lineno]
+      }
+    end
+
+    def info_state(state)
+      info_listing(state).merge(
+        kind: :state,
+        fibers: info_fiber_states(state[:fibers])
+      )
+    end
+
+    def info_fiber_states(fiber_states)
+      fiber_states.inject({}) do |h, (f, s)|
+        h[fiber_id(f)] = {
+          stack: s[:stack].map { |e| { path: e[:path], lineno: e[:lineno] } }
+        }
+        h
+      end
+    end
+    
+    def cmd_step(cmd)
+      tp = nil
+      fiber = nil
+      while true
+        event = get_next_trace_event
+        @peer = event[:fiber]
+        if event[:kind] == :line && event[:path] !~ /#{POLYPHONY_LIB_DIR}/
+          return get_next_command(info_listing(@state))
+        end
+      end
+    rescue => e
+      trace "Uncaught error: #{e.inspect}"
+      @trace&.disable
+    end
+
+    def cmd_help(cmd)
+      get_next_command(kind: :help)
+    end
+
+    def cmd_list(cmd)
+      get_next_command(info_listing(@state))
+    end
+
+    def cmd_state(cmd)
+      get_next_command(info_state(@state))
+    end
+
+    def handle_tp(trace, tp)
+      return if Thread.current == @server.thread
+      return if Fiber.current == @control_fiber
+
+      kind = tp.event
+      event = {
+        fiber: Fiber.current,
+        kind: kind,
+        path: tp.path,
+        lineno: tp.lineno,
+        binding: tp.binding
+      }
+      case kind
+      when :call, :c_call, :b_call
+        event[:method_id] = tp.method_id
+        event[:parameters] = tp.parameters
+      when :return, :c_return, :b_return
+        event[:method_id] = tp.method_id
+        event[:return_value] = tp.return_value
+      end
+      @control_fiber.transfer(event)
+    end
+  end
+
+  class DebugServer
+    attr_reader :thread
+
+    def initialize(socket_path)
+      @socket_path = socket_path
+      @fiber = Fiber.current
+      start_server_thread
+    end
+
+    def start_server_thread
+      @thread = Thread.new do
+        puts("Listening on #{@socket_path}")
+        FileUtils.rm(@socket_path) if File.exists?(@socket_path)
+        socket = UNIXServer.new(@socket_path)
+        loop do
+          @client = socket.accept
+        end
+      end
+    end
+
+    def stop
+      @thread.kill
+    end
+
+    def handle_client(client)
+      @client = client
+    end
+
+    def wait_for_client
+      sleep 0.1 until @client
+      msg = @client.gets
+      @client.puts msg
+    end
+
+    def get_command(info)
+      @client&.orig_write "#{info.inspect}\n"
+      cmd = @client&.orig_gets&.chomp
+      eval(cmd)
+    rescue SystemCallError
+      nil
+    rescue => e
+      trace "Error in interact_with_client: #{e.inspect}"
+      e.backtrace[0..3].each { |l| trace l }
+      @client = nil
+    end
+  end
+end

data/lib/polyphony/extensions/debug.rb

@@ -10,4 +10,4 @@ module ::Kernel
       format("%p\n", args.size == 1 ? args.first : args)
     end
   end
-end
+end

data/lib/polyphony/extensions/fiber.rb

@@ -7,6 +7,10 @@ require_relative '../core/exceptions'
 module Polyphony
   # Fiber control API
   module FiberControl
+    def monitor_mailbox
+      @monitor_mailbox ||= Polyphony::Queue.new
+    end
+
     def interrupt(value = nil)
       return if @running == false
 
@@ -75,47 +79,26 @@ module Polyphony
 
   # Fiber supervision
   module FiberSupervision
-    def supervise(opts = {})
-      @counter = 0
-      @on_child_done = proc do |fiber, result|
-        self << fiber unless result.is_a?(Exception)
-      end
-      while true
-        supervise_perform(opts)
-      end
-  rescue Polyphony::MoveOn
-      # generated in #supervise_perform to stop supervisor
-    ensure
-      @on_child_done = nil
-    end
+    def supervise(*fibers, **opts, &block)
+      block ||= opts[:on_done] ||
+                (opts[:on_error] && supervise_on_error_proc(opts[:on_error]))
+      raise "No block given" unless block
 
-    def supervise_perform(opts)
-      fiber = receive
-      if fiber && opts[:restart]
-        restart_fiber(fiber, opts)
-      elsif Fiber.current.children.empty?
-        Fiber.current.stop
+      fibers.each do |f|
+        f.attach_to(self) unless f.parent == self
+        f.monitor(self)
       end
-    rescue Polyphony::Restart
-      restart_all_children
-    rescue Exception => e
-      Kernel.raise e if e.source_fiber.nil? || e.source_fiber == self
 
-      if opts[:restart]
-        restart_fiber(e.source_fiber, opts)
-      elsif Fiber.current.children.empty?
-        Fiber.current.stop
+      mailbox = monitor_mailbox
+
+      while true
+        (fiber, result) = mailbox.shift
+        block&.call(fiber, result)
       end
     end
 
-    def restart_fiber(fiber, opts)
-      opts[:watcher]&.send [:restart, fiber]
-      case opts[:restart]
-      when true
-        fiber.restart
-      when :one_for_all
-        @children.keys.each(&:restart)
-      end
+    def supervise_on_error_proc(on_error)
+      ->(f, r) { opts[:on_error].(f, r) if r.is_a?(Exception) }
     end
   end
 
@@ -124,23 +107,24 @@ module Polyphony
     def await(*fibers)
       return [] if fibers.empty?
 
-      Fiber.current.message_on_child_termination = true
+      current_fiber = self.current
+      mailbox = current_fiber.monitor_mailbox
       results = {}
       fibers.each do |f|
         results[f] = nil
         if f.dead?
           # fiber already terminated, so queue message
-          Fiber.current.send [f, f.result]
+          mailbox << [f, f.result]
         else
-          f.monitor
+          f.monitor(current_fiber)
         end
       end
       exception = nil
       while !fibers.empty?
-        (fiber, result) = receive
+        (fiber, result) = mailbox.shift
         next unless fibers.include?(fiber)
-
         fibers.delete(fiber)
+        current_fiber.remove_child(fiber) if fiber.parent == current_fiber
         if result.is_a?(Exception)
           exception ||= result
           fibers.each { |f| f.terminate }
@@ -148,16 +132,16 @@ module Polyphony
           results[fiber] = result
         end
       end
-      results.values
-    ensure
-      Fiber.current.message_on_child_termination = false
       raise exception if exception
+      results.values
     end
     alias_method :join, :await
 
     def select(*fibers)
       return nil if fibers.empty?
   
+      current_fiber = self.current
+      mailbox = current_fiber.monitor_mailbox
       fibers.each do |f|
         if f.dead?
           result = f.result
@@ -165,21 +149,18 @@ module Polyphony
         end
       end
 
-      Fiber.current.message_on_child_termination = true
-      fibers.each { |f| f.monitor }
+      fibers.each { |f| f.monitor(current_fiber) }
       while true
-        (fiber, result) = receive
+        (fiber, result) = mailbox.shift
         next unless fibers.include?(fiber)
   
-        fibers.each { |f| f.unmonitor }
+        fibers.each { |f| f.unmonitor(current_fiber) }
         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
@@ -219,14 +200,6 @@ module Polyphony
       f
     end
 
-    def child_done(child_fiber, result)
-      @children.delete(child_fiber)
-
-      if result.is_a?(Exception) && !@message_on_child_termination
-        schedule_with_priority(result)
-      end
-    end
-
     def terminate_all_children(graceful = false)
       return unless @children
 
@@ -240,16 +213,25 @@ module Polyphony
     def await_all_children
       return unless @children && !@children.empty?
 
-      Fiber.await(*@children.keys)
+      Fiber.await(*@children.keys.reject { |c| c.dead? })
     end
 
     def shutdown_all_children(graceful = false)
       return unless @children
 
       @children.keys.each do |c|
+        next if c.dead?
+
         c.terminate(graceful)
         c.await
       end
+      reap_dead_children
+    end
+
+    def reap_dead_children
+      return unless @children
+
+      @children.reject! { |f| f.dead? }
     end
 
     def detach
@@ -258,10 +240,17 @@ module Polyphony
       @parent.add_child(self)
     end
 
-    def attach(parent)
+    def attach_to(fiber)
       @parent.remove_child(self)
-      @parent = parent
-      @parent.add_child(self)
+      @parent = fiber
+      fiber.add_child(self)
+    end
+
+    def attach_and_monitor(fiber)
+      @parent.remove_child(self)
+      @parent = fiber
+      fiber.add_child(self)
+      monitor(fiber)
     end
   end
 
@@ -323,7 +312,7 @@ module Polyphony
       Thread.backend.trace(:fiber_terminate, self, result)
       @result = result
 
-      inform_dependants(result, uncaught_exception)
+      inform_monitors(result, uncaught_exception)
       @running = false
     ensure
       # Prevent fiber from being resumed after terminating
@@ -341,24 +330,28 @@ module Polyphony
       [e, true]
     end
 
-    def inform_dependants(result, uncaught_exception)
+    def inform_monitors(result, uncaught_exception)
       if @monitors
         msg = [self, result]
-        @monitors.each { |f| f << msg }
+        @monitors.each_key { |f| f.monitor_mailbox << msg }
       end
 
-      @parent&.child_done(self, result)
+      if uncaught_exception && @parent
+        parent_is_monitor = @monitors&.has_key?(@parent)
+        @parent.schedule_with_priority(result) unless parent_is_monitor
+      end
     end
 
-    attr_accessor :message_on_child_termination 
+    def monitor(fiber)
+      (@monitors ||= {})[fiber] = true
+    end
 
-    def monitor
-      @monitors ||= []
-      @monitors << Fiber.current
+    def unmonitor(fiber)
+      (@monitors ||= []).delete(fiber)
     end
 
-    def unmonitor
-      @monitors.delete(Fiber.current) if @monitors
+    def monitors
+      @monitors&.keys || []
     end
 
     def dead?