polyphony 0.45.2 → 0.47.0

data/ext/polyphony/runqueue_ring_buffer.h

@@ -0,0 +1,31 @@
+#ifndef RUNQUEUE_RING_BUFFER_H
+#define RUNQUEUE_RING_BUFFER_H
+
+#include "ruby.h"
+
+typedef struct runqueue_entry {
+  VALUE fiber;
+  VALUE value;
+} runqueue_entry;
+
+typedef struct runqueue_ring_buffer {
+  runqueue_entry *entries;
+  unsigned int size;
+  unsigned int count;
+  unsigned int head;
+  unsigned int tail;
+} runqueue_ring_buffer;
+
+void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer);
+void runqueue_ring_buffer_free(runqueue_ring_buffer *buffer);
+void runqueue_ring_buffer_mark(runqueue_ring_buffer *buffer);
+int runqueue_ring_buffer_empty_p(runqueue_ring_buffer *buffer);
+void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer);
+
+runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer);
+void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value);
+void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value);
+
+void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber);
+
+#endif /* RUNQUEUE_RING_BUFFER_H */

data/ext/polyphony/thread.c

@@ -4,17 +4,15 @@ ID ID_deactivate_all_watchers_post_fork;
 ID ID_ivar_backend;
 ID ID_ivar_join_wait_queue;
 ID ID_ivar_main_fiber;
-ID ID_ivar_result;
 ID ID_ivar_terminated;
-ID ID_run_queue;
-ID ID_runnable_next;
+ID ID_ivar_runqueue;
 ID ID_stop;
 
 static VALUE Thread_setup_fiber_scheduling(VALUE self) {
-  VALUE queue = rb_funcall(cQueue, ID_new, 0);
+  VALUE runqueue = rb_funcall(cRunqueue, ID_new, 0);
 
   rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
-  rb_ivar_set(self, ID_run_queue, queue);
+  rb_ivar_set(self, ID_ivar_runqueue, runqueue);
 
   return self;
 }
@@ -35,10 +33,10 @@ static VALUE SYM_pending_watchers;
 static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   VALUE backend = rb_ivar_get(self,ID_ivar_backend);
   VALUE stats = rb_hash_new();
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
   long pending_count;
 
-  long scheduled_count = RARRAY_LEN(queue);
+  long scheduled_count = Runqueue_len(runqueue);
   rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
 
   pending_count = __BACKEND__.pending_count(backend);
@@ -47,30 +45,18 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   return stats;
 }
 
-VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
-  VALUE queue;
-
-  if (rb_fiber_alive_p(fiber) != Qtrue) return self;
-
-  int already_runnable = rb_ivar_get(fiber, ID_runnable) != Qnil;
+void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
+  VALUE runqueue;
+  int already_runnable;
 
-  if (already_runnable) {
-    VALUE current_runnable_value = rb_ivar_get(fiber, ID_runnable_value);
-
-    // If the fiber is already runnable and the runnable value is an exception,
-    // we don't update the value, in order to prevent a race condition where
-    // exceptions will be lost (see issue #33)
-    if (TEST_EXCEPTION(current_runnable_value)) return self;
-  }
+  if (rb_fiber_alive_p(fiber) != Qtrue) return;
+  already_runnable = rb_ivar_get(fiber, ID_ivar_runnable) != Qnil;
 
-  rb_ivar_set(fiber, ID_runnable_value, value);
   COND_TRACE(3, SYM_fiber_schedule, fiber, value);
-
+  runqueue = rb_ivar_get(self, ID_ivar_runqueue);
+  (prioritize ? Runqueue_unshift : Runqueue_push)(runqueue, fiber, value, already_runnable);
   if (!already_runnable) {
-    queue = rb_ivar_get(self, ID_run_queue);
-    Queue_push(queue, fiber);
-    rb_ivar_set(fiber, ID_runnable, Qtrue);
-
+    rb_ivar_set(fiber, ID_ivar_runnable, Qtrue);
     if (rb_thread_current() != self) {
       // If the fiber scheduling is done across threads, we need to make sure the
       // target thread is woken up in case it is in the middle of running its
@@ -81,46 +67,22 @@ VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
       __BACKEND__.wakeup(backend);
     }
   }
+}
+
+VALUE 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) {
-  VALUE queue;
-
-  if (rb_fiber_alive_p(fiber) != Qtrue) return self;
-
-  COND_TRACE(3, SYM_fiber_schedule, fiber, value);
-  rb_ivar_set(fiber, ID_runnable_value, value);
-
-  queue = rb_ivar_get(self, ID_run_queue);
-
-  // if fiber is already scheduled, remove it from the run queue
-  if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
-    Queue_delete(queue, fiber);
-  } else {
-    rb_ivar_set(fiber, ID_runnable, Qtrue);
-  }
-
-  // the fiber is given priority by putting it at the front of the run queue
-  Queue_unshift(queue, fiber);
-
-  if (rb_thread_current() != self) {
-    // if the fiber scheduling is done across threads, we need to make sure the
-    // target thread is woken up in case it is in the middle of running its
-    // event loop. Otherwise it's gonna be stuck waiting for an event to
-    // happen, not knowing that it there's already a fiber ready to run in its
-    // run queue.
-    VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-    __BACKEND__.wakeup(backend);
-  }
+  schedule_fiber(self, fiber, value, 1);
   return self;
 }
 
 VALUE Thread_switch_fiber(VALUE self) {
   VALUE current_fiber = rb_fiber_current();
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  VALUE next_fiber;
-  VALUE value;
+  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
+  runqueue_entry next;
   VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   int ref_count;
   int backend_was_polled = 0;
@@ -130,47 +92,40 @@ VALUE Thread_switch_fiber(VALUE self) {
 
   ref_count = __BACKEND__.ref_count(backend);
   while (1) {
-    next_fiber = Queue_shift_no_wait(queue);
-    if (next_fiber != Qnil) {
+    next = Runqueue_shift(runqueue);
+    if (next.fiber != Qnil) {
       if (backend_was_polled == 0 && ref_count > 0) {
         // this prevents event starvation in case the run queue never empties
-        __BACKEND__.poll(backend, Qtrue, current_fiber, queue);
+        __BACKEND__.poll(backend, Qtrue, current_fiber, runqueue);
       }
       break;
     }
     if (ref_count == 0) break;
 
-    __BACKEND__.poll(backend, Qnil, current_fiber, queue);
+    __BACKEND__.poll(backend, Qnil, current_fiber, runqueue);
     backend_was_polled = 1;
   }
 
-  if (next_fiber == Qnil) return Qnil;
+  if (next.fiber == Qnil) return Qnil;
 
   // run next fiber
-  value = rb_ivar_get(next_fiber, ID_runnable_value);
-  COND_TRACE(3, SYM_fiber_run, next_fiber, value);
-
-  rb_ivar_set(next_fiber, ID_runnable, Qnil);
-  RB_GC_GUARD(next_fiber);
-  RB_GC_GUARD(value);
-  return (next_fiber == current_fiber) ?
-    value : rb_funcall(next_fiber, ID_transfer, 1, value);
-}
+  COND_TRACE(3, SYM_fiber_run, next.fiber, next.value);
 
-VALUE Thread_run_queue_trace(VALUE self) {
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  Queue_trace(queue);
-  return self;
+  rb_ivar_set(next.fiber, ID_ivar_runnable, Qnil);
+  RB_GC_GUARD(next.fiber);
+  RB_GC_GUARD(next.value);
+  return (next.fiber == current_fiber) ?
+    next.value : FIBER_TRANSFER(next.fiber, next.value);
 }
 
 VALUE Thread_reset_fiber_scheduling(VALUE self) {
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  Queue_clear(queue);
+  VALUE queue = rb_ivar_get(self, ID_ivar_runqueue);
+  Runqueue_clear(queue);
   Thread_fiber_reset_ref_count(self);
   return self;
 }
 
-VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE fiber, VALUE resume_obj) {
+VALUE Thread_fiber_schedule_and_wakeup(VALUE self, VALUE fiber, VALUE resume_obj) {
   VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   if (fiber != Qnil) {
     Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
@@ -193,25 +148,22 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
-  rb_define_method(rb_cThread, "break_out_of_ev_loop", Thread_fiber_break_out_of_ev_loop, 2);
+  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, "run_queue_trace", Thread_run_queue_trace, 0);
 
   rb_define_method(rb_cThread, "debug!", Thread_debug, 0);
 
-  ID_deactivate_all_watchers_post_fork = rb_intern("deactivate_all_watchers_post_fork");
-  ID_ivar_backend               = rb_intern("@backend");
-  ID_ivar_join_wait_queue     = rb_intern("@join_wait_queue");
-  ID_ivar_main_fiber          = rb_intern("@main_fiber");
-  ID_ivar_result              = rb_intern("@result");
-  ID_ivar_terminated          = rb_intern("@terminated");
-  ID_run_queue                = rb_intern("run_queue");
-  ID_runnable_next            = rb_intern("runnable_next");
-  ID_stop                     = rb_intern("stop");
+  ID_deactivate_all_watchers_post_fork  = rb_intern("deactivate_all_watchers_post_fork");
+  ID_ivar_backend                       = rb_intern("@backend");
+  ID_ivar_join_wait_queue               = rb_intern("@join_wait_queue");
+  ID_ivar_main_fiber                    = rb_intern("@main_fiber");
+  ID_ivar_terminated                    = rb_intern("@terminated");
+  ID_ivar_runqueue                      = rb_intern("@runqueue");
+  ID_stop                               = rb_intern("stop");
 
   SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));
   SYM_pending_watchers = ID2SYM(rb_intern("pending_watchers"));

data/lib/polyphony.rb

@@ -76,10 +76,10 @@ module Polyphony
     end
 
     def install_terminating_signal_handlers
-      trap('SIGTERM', SystemExit)
+      trap('SIGTERM') { raise SystemExit }
       orig_trap('SIGINT') do
         orig_trap('SIGINT') { exit! }
-        Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, Interrupt.new)
+        Fiber.schedule_priority_oob_fiber { raise Interrupt }
       end
     end
 

data/lib/polyphony/adapters/process.rb

@@ -24,9 +24,6 @@ module Polyphony
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
         Thread.current.backend.waitpid(pid)
-      rescue SystemCallError
-        # ignore
-        puts 'SystemCallError in kill_and_await'
       end
     end
   end

data/lib/polyphony/adapters/trace.rb

@@ -118,13 +118,13 @@ module Polyphony
 
         ALL_FIBER_EVENTS = %i[
           fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
-          fiber_ev_loop_enter fiber_ev_loop_leave
+          fiber_event_poll_enter fiber_event_poll_leave
         ].freeze
 
         def event_masks(events)
           events.each_with_object([[], []]) do |e, masks|
             case e
-            when /fiber_/
+            when /^fiber_/
               masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
               masks[0] << :c_return unless masks[0].include?(:c_return)
             else

data/lib/polyphony/core/exceptions.rb

@@ -14,10 +14,6 @@ module Polyphony
       @caller_backtrace = caller
       @value = value
     end
-
-    def backtrace
-      sanitize(@caller_backtrace)
-    end
   end
 
   # MoveOn is used to interrupt a long-running blocking operation, while

data/lib/polyphony/core/global_api.rb

@@ -16,27 +16,39 @@ module Polyphony
     end
 
     def cancel_after(interval, with_exception: Polyphony::Cancel, &block)
-      fiber = ::Fiber.current
-      canceller = spin do
+      if !block
+        cancel_after_blockless_canceller(Fiber.current, interval, with_exception)
+      elsif block.arity > 0
+        cancel_after_with_block(Fiber.current, interval, with_exception, &block)
+      else
+        Thread.current.backend.timeout(interval, with_exception, &block)
+      end
+    end
+
+    def cancel_after_blockless_canceller(fiber, interval, with_exception)
+      spin do
         sleep interval
         exception = cancel_exception(with_exception)
+        exception.__raising_fiber__ = nil
         fiber.schedule exception
       end
-      block ? cancel_after_wrap_block(canceller, &block) : canceller
     end
 
-    def cancel_exception(exception)
-      return exception.new if exception.is_a?(Class)
-
-      RuntimeError.new(exception)
-    end
-
-    def cancel_after_wrap_block(canceller, &block)
-      block.call
+    def cancel_after_with_block(fiber, interval, with_exception, &block)
+      canceller = cancel_after_blockless_canceller(fiber, interval, with_exception)
+      block.call(canceller)
     ensure
       canceller.stop
     end
 
+    def cancel_exception(exception)
+      case exception
+      when Class then exception.new
+      when Array then exception[0].new(exception[1])
+      else RuntimeError.new(exception)
+      end
+    end
+
     def spin(tag = nil, &block)
       Fiber.current.spin(tag, caller, &block)
     end
@@ -51,6 +63,16 @@ module Polyphony
       end
     end
 
+    def spin_scope
+      raise unless block_given?
+    
+      spin do
+        result = yield
+        Fiber.current.await_all_children
+        result
+      end.await
+    end
+
     def every(interval)
       next_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + interval
       loop do
@@ -65,15 +87,20 @@ module Polyphony
     end
 
     def move_on_after(interval, with_value: nil, &block)
-      fiber = ::Fiber.current
-      unless block
-        return spin do
-          sleep interval
-          fiber.schedule with_value
-        end
+      if !block
+        move_on_blockless_canceller(Fiber.current, interval, with_value)
+      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)
       end
+    end
 
-      move_on_after_with_block(fiber, interval, with_value, &block)
+    def move_on_blockless_canceller(fiber, interval, with_value)
+      spin do
+        sleep interval
+        fiber.schedule with_value
+      end
     end
 
     def move_on_after_with_block(fiber, interval, with_value, &block)
@@ -81,7 +108,7 @@ module Polyphony
         sleep interval
         fiber.schedule Polyphony::MoveOn.new(with_value)
       end
-      block.call
+      block.call(canceller)
     rescue Polyphony::MoveOn => e
       e.value
     ensure
@@ -107,10 +134,7 @@ module Polyphony
     end
 
     def sleep_forever
-      Thread.current.backend.ref
-      loop { sleep 60 }
-    ensure
-      Thread.current.backend.unref
+      Thread.current.backend.wait_event(true)
     end
 
     def throttled_loop(rate = nil, **opts, &block)

data/lib/polyphony/core/sync.rb

@@ -16,11 +16,13 @@ module Polyphony
 
     def synchronize_not_holding
       @token = @store.shift
-      @holding_fiber = Fiber.current
-      yield
-    ensure
-      @holding_fiber = nil
-      @store << @token if @token
+      begin
+        @holding_fiber = Fiber.current
+        yield
+      ensure
+        @holding_fiber = nil
+        @store << @token if @token
+      end
     end
 
     def conditional_release

data/lib/polyphony/extensions/core.rb

@@ -12,7 +12,7 @@ class ::Exception
     attr_accessor :__disable_sanitized_backtrace__
   end
 
-  attr_accessor :source_fiber
+  attr_accessor :source_fiber, :__raising_fiber__
 
   alias_method :orig_initialize, :initialize
   def initialize(*args)
@@ -22,8 +22,8 @@ class ::Exception
 
   alias_method :orig_backtrace, :backtrace
   def backtrace
-    unless @first_backtrace_call
-      @first_backtrace_call = true
+    unless @backtrace_called
+      @backtrace_called = true
       return orig_backtrace
     end
 
@@ -31,12 +31,10 @@ class ::Exception
   end
 
   def sanitized_backtrace
-    if @__raising_fiber__
-      backtrace = orig_backtrace || []
-      sanitize(backtrace + @__raising_fiber__.caller)
-    else
-      sanitize(orig_backtrace)
-    end
+    return sanitize(orig_backtrace) unless @__raising_fiber__
+
+    backtrace = orig_backtrace || []
+    sanitize(backtrace + @__raising_fiber__.caller)
   end
 
   POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))
@@ -149,39 +147,22 @@ module ::Kernel
     return orig_trap(sig, command) if command.is_a? String
 
     block = command if !block && command.respond_to?(:call)
-    exception = signal_exception(block, command)
 
     # The signal trap can be invoked at any time, including while the system
     # backend is blocking while polling for events. In order to deal with this
-    # correctly, we spin a fiber that will run the signal handler code, then
-    # call break_out_of_ev_loop, which will put the fiber at the front of the
-    # run queue, then wake up the backend.
-    #
-    # If the command argument is an exception class however, it will be raised
-    # directly in the context of the main fiber.
+    # correctly, we run the signal handler code in an out-of-band, priority
+    # scheduled fiber, that will pass any uncaught exception (including
+    # SystemExit and Interrupt) to the main thread's main fiber. See also
+    # `Fiber#schedule_priority_oob_fiber`.
     orig_trap(sig) do
-      Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, exception)
+      Fiber.schedule_priority_oob_fiber(&block)
     end
   end
 end
 
-def signal_exception(block, command)
-  if block
-    Polyphony::Interjection.new(block)
-  elsif command.is_a?(Class)
-    command.new
-  else
-    raise ArgumentError, 'Must supply block or exception or callable object'
-  end
-end
-
 # Override Timeout to use cancel scope
 module ::Timeout
-  def self.timeout(sec, klass = nil, message = nil, &block)
-    cancel_after(sec, &block)
-  rescue Polyphony::Cancel => e
-    error = klass ? klass.new(message) : ::Timeout::Error.new
-    error.set_backtrace(e.backtrace)
-    raise error
+  def self.timeout(sec, klass = Timeout::Error, message = 'execution expired', &block)
+    cancel_after(sec, with_exception: [klass, message], &block)
   end
 end