polyphony 0.59 → 0.62

data/ext/polyphony/polyphony.h

@@ -91,10 +91,10 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class);
 VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class);
 VALUE Backend_connect(VALUE self, VALUE io, VALUE addr, VALUE port);
 VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
-VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof);
-VALUE Backend_read_loop(VALUE self, VALUE io);
-VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length);
-VALUE Backend_recv_loop(VALUE self, VALUE io);
+VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos);
+VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen);
+VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos);
+VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen);
 VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
 VALUE Backend_send(VALUE self, VALUE io, VALUE msg, VALUE flags);
 VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);
@@ -114,7 +114,6 @@ VALUE Backend_wakeup(VALUE self);
 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);
-struct backend_stats Backend_stats(VALUE self);
 void Backend_unschedule_fiber(VALUE self, VALUE fiber);
 
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);

data/ext/polyphony/queue.c

@@ -57,21 +57,21 @@ static VALUE Queue_initialize(int argc, VALUE *argv, VALUE self) {
   return self;
 }
 
-inline void queue_resume_first_blocked_fiber(ring_buffer *queue) {
+inline void queue_schedule_first_blocked_fiber(ring_buffer *queue) {
   if (queue->count) {
     VALUE fiber = ring_buffer_shift(queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
   }
 }
 
-inline void queue_resume_all_blocked_fibers(ring_buffer *queue) {
+inline void queue_schedule_all_blocked_fibers(ring_buffer *queue) {
   while (queue->count) {
     VALUE fiber = ring_buffer_shift(queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
   }
 }
 
-inline void queue_resume_blocked_fibers_to_capacity(Queue_t *queue) {
+inline void queue_schedule_blocked_fibers_to_capacity(Queue_t *queue) {
   for (unsigned int i = queue->values.count; (i < queue->capacity) && queue->push_queue.count; i++) {
     VALUE fiber = ring_buffer_shift(&queue->push_queue);
     if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
@@ -101,7 +101,7 @@ VALUE Queue_push(VALUE self, VALUE value) {
 
   if (queue->capacity) capped_queue_block_push(queue);
 
-  queue_resume_first_blocked_fiber(&queue->shift_queue);
+  queue_schedule_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_push(&queue->values, value);
 
   return self;
@@ -113,7 +113,7 @@ VALUE Queue_unshift(VALUE self, VALUE value) {
 
   if (queue->capacity) capped_queue_block_push(queue);
 
-  queue_resume_first_blocked_fiber(&queue->shift_queue);
+  queue_schedule_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_unshift(&queue->values, value);
 
   return self;
@@ -140,7 +140,7 @@ VALUE Queue_shift(VALUE self) {
   }
   VALUE value = ring_buffer_shift(&queue->values);
   if ((queue->capacity) && (queue->capacity > queue->values.count))
-    queue_resume_first_blocked_fiber(&queue->push_queue);
+    queue_schedule_first_blocked_fiber(&queue->push_queue);
   RB_GC_GUARD(value);
   return value;
 }
@@ -152,7 +152,7 @@ VALUE Queue_delete(VALUE self, VALUE value) {
   ring_buffer_delete(&queue->values, value);
 
   if (queue->capacity && (queue->capacity > queue->values.count))
-    queue_resume_first_blocked_fiber(&queue->push_queue);
+    queue_schedule_first_blocked_fiber(&queue->push_queue);
 
   return self;
 }
@@ -164,9 +164,9 @@ VALUE Queue_cap(VALUE self, VALUE cap) {
   queue->capacity = new_capacity;
   
   if (queue->capacity)
-    queue_resume_blocked_fibers_to_capacity(queue);
+    queue_schedule_blocked_fibers_to_capacity(queue);
   else
-    queue_resume_all_blocked_fibers(&queue->push_queue);
+    queue_schedule_all_blocked_fibers(&queue->push_queue);
   
   return self;
 }
@@ -183,7 +183,7 @@ VALUE Queue_clear(VALUE self) {
   GetQueue(self, queue);
 
   ring_buffer_clear(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
 
   return self;
 }
@@ -200,7 +200,7 @@ VALUE Queue_shift_each(VALUE self) {
   GetQueue(self, queue);
 
   ring_buffer_shift_each(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
   return self;
 }
 
@@ -209,7 +209,7 @@ VALUE Queue_shift_all(VALUE self) {
   GetQueue(self, queue);
 
   VALUE result = ring_buffer_shift_all(&queue->values);
-  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  if (queue->capacity) queue_schedule_blocked_fibers_to_capacity(queue);
   return result;
 }
 

data/ext/polyphony/runqueue.c

@@ -4,7 +4,6 @@
 inline void runqueue_initialize(runqueue_t *runqueue) {
   runqueue_ring_buffer_init(&runqueue->entries);
   runqueue->high_watermark = 0;
-  runqueue->switch_count = 0;
 }
 
 inline void runqueue_finalize(runqueue_t *runqueue) {
@@ -30,12 +29,7 @@ inline void runqueue_unshift(runqueue_t *runqueue, VALUE fiber, VALUE value, int
 }
 
 inline runqueue_entry runqueue_shift(runqueue_t *runqueue) {
-  runqueue_entry entry = runqueue_ring_buffer_shift(&runqueue->entries);
-  if (entry.fiber == Qnil)
-    runqueue->high_watermark = 0;
-  else
-    runqueue->switch_count += 1;
-  return entry;
+  return runqueue_ring_buffer_shift(&runqueue->entries);
 }
 
 inline void runqueue_delete(runqueue_t *runqueue, VALUE fiber) {
@@ -50,22 +44,20 @@ inline void runqueue_clear(runqueue_t *runqueue) {
   runqueue_ring_buffer_clear(&runqueue->entries);
 }
 
+inline long runqueue_size(runqueue_t *runqueue) {
+  return runqueue->entries.size;
+}
+
 inline long runqueue_len(runqueue_t *runqueue) {
   return runqueue->entries.count;
 }
 
-inline int runqueue_empty_p(runqueue_t *runqueue) {
-  return (runqueue->entries.count == 0);
+inline long runqueue_max_len(runqueue_t *runqueue) {
+  unsigned int max_len = runqueue->high_watermark;
+  runqueue->high_watermark = 0;
+  return max_len;
 }
 
-static const unsigned int ANTI_STARVE_HIGH_WATERMARK_THRESHOLD = 128;
-static const unsigned int ANTI_STARVE_SWITCH_COUNT_THRESHOLD = 64;
-
-inline int runqueue_should_poll_nonblocking(runqueue_t *runqueue) {
-  if (runqueue->high_watermark < ANTI_STARVE_HIGH_WATERMARK_THRESHOLD) return 0;
-  if (runqueue->switch_count < ANTI_STARVE_SWITCH_COUNT_THRESHOLD) return 0;
-
-  // the 
-  runqueue->switch_count = 0;
-  return 1;
+inline int runqueue_empty_p(runqueue_t *runqueue) {
+  return (runqueue->entries.count == 0);
 }

data/ext/polyphony/runqueue.h

@@ -7,7 +7,6 @@
 typedef struct runqueue {
   runqueue_ring_buffer entries;
   unsigned int high_watermark;
-  unsigned int switch_count;
 } runqueue_t;
 
 void runqueue_initialize(runqueue_t *runqueue);
@@ -20,8 +19,9 @@ 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_size(runqueue_t *runqueue);
 long runqueue_len(runqueue_t *runqueue);
+long runqueue_max_len(runqueue_t *runqueue);
 int runqueue_empty_p(runqueue_t *runqueue);
-int runqueue_should_poll_nonblocking(runqueue_t *runqueue);
 
 #endif /* RUNQUEUE_H */

data/ext/polyphony/thread.c

@@ -13,18 +13,6 @@ static VALUE Thread_setup_fiber_scheduling(VALUE self) {
   return self;
 }
 
-static VALUE SYM_scheduled_fibers;
-static VALUE SYM_pending_watchers;
-
-static VALUE Thread_fiber_scheduling_stats(VALUE self) {
-  struct backend_stats backend_stats = Backend_stats(rb_ivar_get(self, ID_ivar_backend));
-
-  VALUE stats = rb_hash_new();
-  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(backend_stats.scheduled_fibers));
-  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(backend_stats.pending_ops));
-  return stats;
-}
-
 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);
 }
@@ -72,7 +60,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, "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);
@@ -91,9 +78,4 @@ void Init_Thread() {
   ID_ivar_main_fiber                    = rb_intern("@main_fiber");
   ID_ivar_terminated                    = rb_intern("@terminated");
   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
@@ -304,8 +315,6 @@ module Polyphony
 
     def restart_self(first_value)
       @mailbox = nil
-      @when_done_procs = nil
-      @waiting_fibers = nil
       run(first_value)
     end
 
@@ -313,8 +322,9 @@ module Polyphony
       result, uncaught_exception = finalize_children(result, uncaught_exception)
       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