polyphony 0.58 → 0.61

data/ext/polyphony/runqueue.h

@@ -0,0 +1,26 @@
+#ifndef RUNQUEUE_H
+#define RUNQUEUE_H
+
+#include "polyphony.h"
+#include "runqueue_ring_buffer.h"
+
+typedef struct runqueue {
+  runqueue_ring_buffer entries;
+  unsigned int high_watermark;
+} runqueue_t;
+
+void runqueue_initialize(runqueue_t *runqueue);
+void runqueue_finalize(runqueue_t *runqueue);
+void runqueue_mark(runqueue_t *runqueue);
+
+void runqueue_push(runqueue_t *runqueue, VALUE fiber, VALUE value, int reschedule);
+void runqueue_unshift(runqueue_t *runqueue, VALUE fiber, VALUE value, int reschedule);
+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_clear(runqueue_t *runqueue);
+long runqueue_len(runqueue_t *runqueue);
+long runqueue_max_len(runqueue_t *runqueue);
+int runqueue_empty_p(runqueue_t *runqueue);
+
+#endif /* RUNQUEUE_H */

data/ext/polyphony/thread.c

@@ -1,73 +1,24 @@
 #include "polyphony.h"
+#include "backend_common.h"
 
 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_terminated;
-ID ID_ivar_runqueue;
 ID ID_stop;
 
 static VALUE Thread_setup_fiber_scheduling(VALUE self) {
-  VALUE runqueue = rb_funcall(cRunqueue, ID_new, 0);
-
   rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
-  rb_ivar_set(self, ID_ivar_runqueue, runqueue);
-
   return self;
 }
 
-static VALUE SYM_scheduled_fibers;
-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 runqueue = rb_ivar_get(self, ID_ivar_runqueue);
-  long pending_count;
-
-  long scheduled_count = Runqueue_len(runqueue);
-  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
-
-  pending_count = Backend_pending_count(backend);
-  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
-
-  return stats;
-}
-
-void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
-  VALUE runqueue;
-  int already_runnable;
-
-  if (rb_fiber_alive_p(fiber) != Qtrue) return;
-  already_runnable = rb_ivar_get(fiber, ID_ivar_runnable) != Qnil;
-
-  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) {
-    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
-      // event selector. 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);
-    }
-  }
-}
-
-VALUE Thread_fiber_scheduling_index(VALUE self, VALUE fiber) {
-  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
-
-  return INT2NUM(Runqueue_index_of(runqueue, fiber));
+inline void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
+  Backend_schedule_fiber(self, rb_ivar_get(self, ID_ivar_backend), fiber, value, prioritize);
 }
 
 VALUE Thread_fiber_unschedule(VALUE self, VALUE fiber) {
-  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
-  Runqueue_delete(runqueue, fiber);
+  Backend_unschedule_fiber(rb_ivar_get(self, ID_ivar_backend), fiber);
   return self;
 }
 
@@ -82,65 +33,15 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
 }
 
 VALUE Thread_switch_fiber(VALUE self) {
-  VALUE current_fiber = rb_fiber_current();
-  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
-  runqueue_entry next;
-  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-  unsigned int pending_ops_count = Backend_pending_count(backend);
-  unsigned int backend_was_polled = 0;
-  unsigned int idle_tasks_run_count = 0;
-
-  if (__tracing_enabled__ && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
-    TRACE(2, SYM_fiber_switchpoint, current_fiber);
-
-  while (1) {
-    next = Runqueue_shift(runqueue);
-    if (next.fiber != Qnil) {
-      // Polling for I/O op completion is normally done when the run queue is
-      // empty, but if the runqueue never empties, we'll never get to process
-      // any event completions. In order to prevent this, an anti-starve
-      // mechanism is employed, under the following conditions:
-      // - a blocking poll was not yet performed
-      // - there are pending blocking operations
-      // - the runqueue has signalled that a non-blocking poll should be
-      //   performed
-      //   - the run queue length high watermark has reached its threshold (currently 128)
-      //   - the run queue switch counter has reached its threshold (currently 64) 
-      if (!backend_was_polled && pending_ops_count && Runqueue_should_poll_nonblocking(runqueue)) {
-        // this prevents event starvation in case the run queue never empties
-        Backend_poll(backend, Qtrue, current_fiber, runqueue);
-      }
-      break;
-    }
-    
-    if (!idle_tasks_run_count) {
-      idle_tasks_run_count++;
-      Backend_run_idle_tasks(backend);
-    }
-    if (pending_ops_count == 0) break;
-    Backend_poll(backend, Qnil, current_fiber, runqueue);
-    backend_was_polled = 1;
-  }
-
-  if (next.fiber == Qnil) return Qnil;
-
-  // run next fiber
-  COND_TRACE(3, SYM_fiber_run, next.fiber, next.value);
-
-  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);
+  return Backend_switch_fiber(rb_ivar_get(self, ID_ivar_backend));
 }
 
 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);
   }
 
-  if (Backend_wakeup(backend) == Qnil) {
+  if (Backend_wakeup(rb_ivar_get(self, ID_ivar_backend)) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
@@ -159,14 +60,12 @@ 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, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 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_scheduling_index", Thread_fiber_scheduling_index, 1);
   rb_define_method(rb_cThread, "fiber_unschedule", Thread_fiber_unschedule, 1);
 
   rb_define_singleton_method(rb_cThread, "backend", Thread_class_backend, 0);
@@ -178,11 +77,5 @@ void Init_Thread() {
   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"));
-  rb_global_variable(&SYM_scheduled_fibers);
-  rb_global_variable(&SYM_pending_watchers);
 }

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