polyphony 0.66 → 0.70

data/ext/polyphony/fiber.c

@@ -114,6 +114,22 @@ VALUE Fiber_receive_all_pending(VALUE self) {
   return (mailbox == Qnil) ? rb_ary_new() : Queue_shift_all(mailbox);
 }
 
+VALUE Fiber_park(VALUE self) {
+  rb_ivar_set(self, ID_ivar_parked, Qtrue);
+  Backend_park_fiber(BACKEND(), self);
+  return self;
+}
+
+VALUE Fiber_unpark(VALUE self) {
+  rb_ivar_set(self, ID_ivar_parked, Qnil);
+  Backend_unpark_fiber(BACKEND(), self);
+  return self;
+}
+
+VALUE Fiber_parked_p(VALUE self) {
+  return rb_ivar_get(self, ID_ivar_parked);
+}
+
 void Init_Fiber() {
   VALUE cFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
   rb_define_method(cFiber, "safe_transfer", Fiber_safe_transfer, -1);
@@ -128,6 +144,10 @@ void Init_Fiber() {
   rb_define_method(cFiber, "receive_all_pending", Fiber_receive_all_pending, 0);
   rb_define_method(cFiber, "mailbox", Fiber_mailbox, 0);
 
+  rb_define_method(cFiber, "__park__", Fiber_park, 0);
+  rb_define_method(cFiber, "__unpark__", Fiber_unpark, 0);
+  rb_define_method(cFiber, "__parked__?", Fiber_parked_p, 0);
+
   SYM_dead = ID2SYM(rb_intern("dead"));
   SYM_running = ID2SYM(rb_intern("running"));
   SYM_runnable = ID2SYM(rb_intern("runnable"));

data/ext/polyphony/polyphony.c

@@ -12,6 +12,7 @@ ID ID_invoke;
 ID ID_new;
 ID ID_ivar_blocking_mode;
 ID ID_ivar_io;
+ID ID_ivar_parked;
 ID ID_ivar_runnable;
 ID ID_ivar_running;
 ID ID_ivar_thread;
@@ -160,6 +161,7 @@ void Init_Polyphony() {
   ID_invoke             = rb_intern("invoke");
   ID_ivar_blocking_mode = rb_intern("@blocking_mode");
   ID_ivar_io            = rb_intern("@io");
+  ID_ivar_parked        = rb_intern("@parked");
   ID_ivar_runnable      = rb_intern("@runnable");
   ID_ivar_running       = rb_intern("@running");
   ID_ivar_thread        = rb_intern("@thread");

data/ext/polyphony/polyphony.h

@@ -44,6 +44,7 @@ extern ID ID_invoke;
 extern ID ID_ivar_backend;
 extern ID ID_ivar_blocking_mode;
 extern ID ID_ivar_io;
+extern ID ID_ivar_parked;
 extern ID ID_ivar_runnable;
 extern ID ID_ivar_running;
 extern ID ID_ivar_thread;
@@ -115,9 +116,11 @@ VALUE Backend_run_idle_tasks(VALUE self);
 VALUE Backend_switch_fiber(VALUE self);
 void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize);
 void Backend_unschedule_fiber(VALUE self, VALUE fiber);
+void Backend_park_fiber(VALUE self, VALUE fiber);
+void Backend_unpark_fiber(VALUE self, VALUE fiber);
 
-VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
-VALUE Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);
+void Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
+void Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
 
 VALUE Polyphony_snooze(VALUE self);

data/ext/polyphony/runqueue.c

@@ -40,6 +40,10 @@ inline int runqueue_index_of(runqueue_t *runqueue, VALUE fiber) {
   return runqueue_ring_buffer_index_of(&runqueue->entries, fiber);
 }
 
+inline void runqueue_migrate(runqueue_t *src, runqueue_t *dest, VALUE fiber) {
+  runqueue_ring_buffer_migrate(&src->entries, &dest->entries, fiber);
+}
+
 inline void runqueue_clear(runqueue_t *runqueue) {
   runqueue_ring_buffer_clear(&runqueue->entries);
 }

data/ext/polyphony/runqueue.h

@@ -18,6 +18,7 @@ void runqueue_unshift(runqueue_t *runqueue, VALUE fiber, VALUE value, int resche
 runqueue_entry runqueue_shift(runqueue_t *runqueue);
 void runqueue_delete(runqueue_t *runqueue, VALUE fiber);
 int runqueue_index_of(runqueue_t *runqueue, VALUE fiber);
+void runqueue_migrate(runqueue_t *src, runqueue_t *dest, VALUE fiber);
 void runqueue_clear(runqueue_t *runqueue);
 unsigned int runqueue_size(runqueue_t *runqueue);
 unsigned int runqueue_len(runqueue_t *runqueue);

data/ext/polyphony/runqueue_ring_buffer.c

@@ -1,7 +1,7 @@
 #include "polyphony.h"
 #include "runqueue_ring_buffer.h"
 
-void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
+inline void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
   buffer->size = 1;
   buffer->count = 0;
   buffer->entries = malloc(buffer->size * sizeof(runqueue_entry));
@@ -9,17 +9,21 @@ void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
   buffer->tail = 0;
 }
 
-void runqueue_ring_buffer_free(runqueue_ring_buffer *buffer) {
+inline void runqueue_ring_buffer_free(runqueue_ring_buffer *buffer) {
   free(buffer->entries);
 }
 
-int runqueue_ring_buffer_empty_p(runqueue_ring_buffer *buffer) {
+inline int runqueue_ring_buffer_empty_p(runqueue_ring_buffer *buffer) {
   return buffer->count == 0;
 }
 
+inline void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
+  buffer->count = buffer->head = buffer->tail = 0;
+}
+
 static runqueue_entry nil_runqueue_entry = {(Qnil), (Qnil)};
 
-runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
+inline runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
   if (buffer->count == 0) return nil_runqueue_entry;
 
   runqueue_entry value = buffer->entries[buffer->head];
@@ -28,7 +32,7 @@ runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
   return value;
 }
 
-void runqueue_ring_buffer_resize(runqueue_ring_buffer *buffer) {
+inline void runqueue_ring_buffer_resize(runqueue_ring_buffer *buffer) {
   unsigned int old_size = buffer->size;
   buffer->size = old_size == 1 ? 4 : old_size * 2;
   buffer->entries = realloc(buffer->entries, buffer->size * sizeof(runqueue_entry));
@@ -37,7 +41,7 @@ void runqueue_ring_buffer_resize(runqueue_ring_buffer *buffer) {
   buffer->tail = buffer->head + buffer->count;
 }
 
-void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
+inline void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
   if (buffer->count == buffer->size) runqueue_ring_buffer_resize(buffer);
 
   buffer->head = (buffer->head - 1) % buffer->size;
@@ -46,7 +50,7 @@ void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VAL
   buffer->count++;
 }
 
-void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
+inline void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
   if (buffer->count == buffer->size) runqueue_ring_buffer_resize(buffer);
 
   buffer->entries[buffer->tail].fiber = fiber;
@@ -55,14 +59,14 @@ void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE
   buffer->count++;
 }
 
-void runqueue_ring_buffer_mark(runqueue_ring_buffer *buffer) {
+inline void runqueue_ring_buffer_mark(runqueue_ring_buffer *buffer) {
   for (unsigned int i = 0; i < buffer->count; i++) {
     rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size].fiber);
     rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size].value);
   }
 }
 
-void runqueue_ring_buffer_delete_at(runqueue_ring_buffer *buffer, unsigned int idx) {
+inline void runqueue_ring_buffer_delete_at(runqueue_ring_buffer *buffer, unsigned int idx) {
   for (unsigned int idx2 = idx; idx2 != buffer->tail; idx2 = (idx2 + 1) % buffer->size) {
     buffer->entries[idx2] = buffer->entries[(idx2 + 1) % buffer->size];
   }
@@ -70,7 +74,7 @@ void runqueue_ring_buffer_delete_at(runqueue_ring_buffer *buffer, unsigned int i
   buffer->tail = (buffer->tail - 1) % buffer->size;
 }
 
-void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
+inline void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
   for (unsigned int i = 0; i < buffer->count; i++) {
     unsigned int idx = (buffer->head + i) % buffer->size;
     if (buffer->entries[idx].fiber == fiber) {
@@ -80,7 +84,7 @@ void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
   }
 }
 
-int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber) {
+inline int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber) {
   for (unsigned int i = 0; i < buffer->count; i++) {
     unsigned int idx = (buffer->head + i) % buffer->size;
     if (buffer->entries[idx].fiber == fiber)
@@ -89,6 +93,13 @@ int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber) {
   return -1;
 }
 
-void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
-  buffer->count = buffer->head = buffer->tail = 0;
-}
+inline void runqueue_ring_buffer_migrate(runqueue_ring_buffer *src, runqueue_ring_buffer *dest, VALUE fiber) {
+  for (unsigned int i = 0; i < src->count; i++) {
+    unsigned int idx = (src->head + i) % src->size;
+    if (src->entries[idx].fiber == fiber) {
+      runqueue_ring_buffer_push(dest, src->entries[idx].fiber, src->entries[idx].value);
+      runqueue_ring_buffer_delete_at(src, idx);
+      return;
+    }
+  }
+}

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