polyphony 0.43.3 → 0.43.9

data/ext/polyphony/ring_buffer.c

@@ -0,0 +1,96 @@
+#include "polyphony.h"
+#include "ring_buffer.h"
+
+void ring_buffer_init(ring_buffer *buffer) {
+  buffer->size = 1;
+  buffer->count = 0;
+  buffer->entries = malloc(buffer->size * sizeof(VALUE));
+  buffer->head = 0;
+  buffer->tail = 0;
+}
+
+void ring_buffer_free(ring_buffer *buffer) {
+  free(buffer->entries);
+}
+
+int ring_buffer_empty_p(ring_buffer *buffer) {
+  return buffer->count == 0;
+}
+
+VALUE ring_buffer_shift(ring_buffer *buffer) {
+  VALUE value;
+  if (buffer->count == 0) return Qnil;
+
+  value = buffer->entries[buffer->head];
+  buffer->head = (buffer->head + 1) % buffer->size;
+  buffer->count--;
+  // INSPECT(value);
+  return value;
+}
+
+void ring_buffer_resize(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(VALUE));
+  for (unsigned int idx = 0; idx < buffer->head && idx < buffer->tail; idx++)
+    buffer->entries[old_size + idx] = buffer->entries[idx];
+  buffer->tail = buffer->head + buffer->count;
+}
+
+void ring_buffer_unshift(ring_buffer *buffer, VALUE value) {
+  if (buffer->count == buffer->size) ring_buffer_resize(buffer);
+
+  buffer->head = (buffer->head - 1) % buffer->size;
+  buffer->entries[buffer->head] = value;
+  buffer->count++;
+}
+
+void ring_buffer_push(ring_buffer *buffer, VALUE value) {
+  if (buffer->count == buffer->size) ring_buffer_resize(buffer);
+
+  buffer->entries[buffer->tail] = value;
+  buffer->tail = (buffer->tail + 1) % buffer->size;
+  buffer->count++;
+}
+
+void ring_buffer_mark(ring_buffer *buffer) {
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size]);
+}
+
+void ring_buffer_shift_each(ring_buffer *buffer) {
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_yield(buffer->entries[(buffer->head + i) % buffer->size]);
+
+  buffer->count = buffer->head = buffer->tail = 0;
+}
+
+VALUE ring_buffer_shift_all(ring_buffer *buffer) {
+  VALUE array = rb_ary_new_capa(buffer->count);
+  for (unsigned int i = 0; i < buffer->count; i++)
+    rb_ary_push(array, buffer->entries[(buffer->head + i) % buffer->size]);
+  buffer->count = buffer->head = buffer->tail = 0;
+  return array;
+}
+
+void ring_buffer_delete_at(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];
+  }
+  buffer->count--;
+  buffer->tail = (buffer->tail - 1) % buffer->size;
+}
+
+void ring_buffer_delete(ring_buffer *buffer, VALUE value) {
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    unsigned int idx = (buffer->head + i) % buffer->size;
+    if (buffer->entries[idx] == value) {
+      ring_buffer_delete_at(buffer, idx);
+      return;
+    }
+  }
+}
+
+void ring_buffer_clear(ring_buffer *buffer) {
+  buffer->count = buffer->head = buffer->tail = 0;
+}

data/ext/polyphony/ring_buffer.h

@@ -0,0 +1,28 @@
+#ifndef RING_BUFFER_H
+#define RING_BUFFER_H
+
+#include "ruby.h"
+
+typedef struct ring_buffer {
+  VALUE *entries;
+  unsigned int size;
+  unsigned int count;
+  unsigned int head;
+  unsigned int tail;
+} ring_buffer;
+
+void ring_buffer_init(ring_buffer *buffer);
+void ring_buffer_free(ring_buffer *buffer);
+void ring_buffer_mark(ring_buffer *buffer);
+int ring_buffer_empty_p(ring_buffer *buffer);
+void ring_buffer_clear(ring_buffer *buffer);
+
+VALUE ring_buffer_shift(ring_buffer *buffer);
+void ring_buffer_unshift(ring_buffer *buffer, VALUE value);
+void ring_buffer_push(ring_buffer *buffer, VALUE value);
+
+void ring_buffer_shift_each(ring_buffer *buffer);
+VALUE ring_buffer_shift_all(ring_buffer *buffer);
+void ring_buffer_delete(ring_buffer *buffer, VALUE value);
+
+#endif /* RING_BUFFER_H */

data/ext/polyphony/thread.c

@@ -11,10 +11,9 @@ ID ID_runnable_next;
 ID ID_stop;
 
 static VALUE Thread_setup_fiber_scheduling(VALUE self) {
-  VALUE queue;
+  VALUE queue = rb_funcall(cQueue, ID_new, 0);
   
   rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
-  queue = rb_ary_new();
   rb_ivar_set(self, ID_run_queue, queue);
 
   return self;
@@ -54,14 +53,12 @@ VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
   if (rb_fiber_alive_p(fiber) != Qtrue) return self;
 
   FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
-  // if fiber is already scheduled, just set the scheduled value, then return
   rb_ivar_set(fiber, ID_runnable_value, value);
-  if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
-    return self;
-  }
+  // if fiber is already scheduled, just set the scheduled value, then return
+  if (rb_ivar_get(fiber, ID_runnable) != Qnil) return self;
 
   queue = rb_ivar_get(self, ID_run_queue);
-  rb_ary_push(queue, fiber);
+  Queue_push(queue, fiber);
   rb_ivar_set(fiber, ID_runnable, Qtrue);
 
   if (rb_thread_current() != self) {
@@ -88,13 +85,13 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
 
   // if fiber is already scheduled, remove it from the run queue
   if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
-    rb_ary_delete(queue, fiber);
+    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
-  rb_ary_unshift(queue, fiber);
+  Queue_unshift(queue, fiber);
 
   if (rb_thread_current() != self) {
     // if the fiber scheduling is done across threads, we need to make sure the
@@ -115,6 +112,7 @@ VALUE Thread_switch_fiber(VALUE self) {
   VALUE value;
   VALUE agent = rb_ivar_get(self, ID_ivar_agent);
   int ref_count;
+  int agent_was_polled = 0;1;
 
   if (__tracing_enabled__) {
     if (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse) {
@@ -124,9 +122,9 @@ VALUE Thread_switch_fiber(VALUE self) {
 
   ref_count = LibevAgent_ref_count(agent);
   while (1) {
-    next_fiber = rb_ary_shift(queue);
+    next_fiber = Queue_shift_no_wait(queue);
     if (next_fiber != Qnil) {
-      if (ref_count > 0) {
+      if (agent_was_polled == 0 && ref_count > 0) {
         // this mechanism prevents event starvation in case the run queue never
         // empties
         LibevAgent_poll(agent, Qtrue, current_fiber, queue);
@@ -136,6 +134,7 @@ VALUE Thread_switch_fiber(VALUE self) {
     if (ref_count == 0) break;
 
     LibevAgent_poll(agent, Qnil, current_fiber, queue);
+    agent_was_polled = 1;
   }
 
   if (next_fiber == Qnil) return Qnil;
@@ -151,9 +150,15 @@ VALUE Thread_switch_fiber(VALUE self) {
     value : rb_funcall(next_fiber, ID_transfer, 1, value);
 }
 
+VALUE Thread_run_queue_trace(VALUE self) {
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  Queue_trace(queue);
+  return self;
+}
+
 VALUE Thread_reset_fiber_scheduling(VALUE self) {
   VALUE queue = rb_ivar_get(self, ID_run_queue);
-  rb_ary_clear(queue);
+  Queue_clear(queue);
   Thread_fiber_reset_ref_count(self);
   return self;
 }
@@ -182,6 +187,7 @@ void Init_Thread() {
   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);
 
   ID_deactivate_all_watchers_post_fork = rb_intern("deactivate_all_watchers_post_fork");
   ID_ivar_agent               = rb_intern("@agent");

data/lib/polyphony.rb

@@ -4,9 +4,6 @@ require 'fiber'
 require_relative './polyphony_ext'
 
 module Polyphony
-  # Map Queue to Libev queue implementation
-  Queue = LibevQueue
-
   # replace core Queue class with our own
   verbose = $VERBOSE
   $VERBOSE = nil
@@ -26,7 +23,6 @@ require_relative './polyphony/core/global_api'
 require_relative './polyphony/core/resource_pool'
 require_relative './polyphony/net'
 require_relative './polyphony/adapters/process'
-require_relative './polyphony/event'
 
 # Main Polyphony API
 module Polyphony
@@ -100,17 +96,12 @@ module Polyphony
       Polyphony::Process.watch(cmd, &block)
     end
 
-    def emit_signal_exception(exception, fiber = Thread.main.main_fiber)
-      Thread.current.break_out_of_ev_loop(fiber, exception)
-    end
-
-    def install_terminating_signal_handler(signal, exception_class)
-      trap(signal) { emit_signal_exception(exception_class.new) }
-    end
-
     def install_terminating_signal_handlers
-      install_terminating_signal_handler('SIGTERM', ::SystemExit)
-      install_terminating_signal_handler('SIGINT', ::Interrupt)
+      trap('SIGTERM', SystemExit)
+      orig_trap('SIGINT') do
+        orig_trap('SIGINT') { exit! }
+        Thread.current.break_out_of_ev_loop(Thread.main.main_fiber, Interrupt.new)
+      end
     end
 
     def terminate_threads

data/lib/polyphony/core/channel.rb

@@ -5,42 +5,11 @@ require_relative './exceptions'
 module Polyphony
   # Implements a unidirectional communication channel along the lines of Go
   # (buffered) channels.
-  class Channel
-    def initialize
-      @payload_queue = []
-      @waiting_queue = []
-    end
+  class Channel < Polyphony::Queue
+    alias_method :receive, :shift
 
     def close
-      stop = Polyphony::MoveOn.new
-      @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
-    end
-
-    def <<(value)
-      if @waiting_queue.empty?
-        @payload_queue << value
-      else
-        @waiting_queue.shift&.schedule(value)
-      end
-      snooze
-    end
-
-    def receive
-      Thread.current.agent.ref
-      if @payload_queue.empty?
-        @waiting_queue << Fiber.current
-        suspend
-      else
-        receive_from_queue
-      end
-    ensure
-      Thread.current.agent.unref
-    end
-
-    def receive_from_queue
-      payload = @payload_queue.shift
-      snooze
-      payload
+      flush_waiters(Polyphony::MoveOn.new)
     end
   end
 end

data/lib/polyphony/core/global_api.rb

@@ -103,7 +103,7 @@ module Polyphony
 
     def sleep_forever
       Thread.current.agent.ref
-      suspend
+      loop { sleep 60 }
     ensure
       Thread.current.agent.unref
     end

data/lib/polyphony/core/resource_pool.rb

@@ -10,13 +10,10 @@ module Polyphony
     # @param &block [Proc] allocator block
     def initialize(opts, &block)
       @allocator = block
-
-      @stock = []
-      @queue = []
-      @acquired_resources = {}
-
       @limit = opts[:limit] || 4
       @size = 0
+      @stock = Polyphony::Queue.new
+      @acquired_resources = {}
     end
 
     def available
@@ -25,58 +22,17 @@ module Polyphony
 
     def acquire
       fiber = Fiber.current
-      if @acquired_resources[fiber]
-        yield @acquired_resources[fiber]
-      else
-        begin
-          Thread.current.agent.ref
-          resource = wait_for_resource
-          return unless resource
-          
-          @acquired_resources[fiber] = resource
-          yield resource
-        ensure
-          @acquired_resources[fiber] = nil
-          Thread.current.agent.unref
-          release(resource) if resource
-        end
-      end
-    end
-        
-    def wait_for_resource
-      fiber = Fiber.current
-      @queue << fiber
-      ready_resource = from_stock
-      return ready_resource if ready_resource
+      return @acquired_resources[fiber] if @acquired_resources[fiber]
 
-      suspend
+      add_to_stock if @size < @limit && @stock.empty?
+      resource = @stock.shift
+      @acquired_resources[fiber] = resource
+      yield resource
     ensure
-      @queue.delete(fiber)
-    end
-
-    def release(resource)
-      if resource.__discarded__
-        @size -= 1
-      elsif resource
-        return_to_stock(resource)
-        dequeue
-      end
-    end
-
-    def dequeue
-      return if @queue.empty? || @stock.empty?
-
-      @queue.shift.schedule(@stock.shift)
+      @acquired_resources.delete(fiber)
+      @stock.push resource if resource
     end
-
-    def return_to_stock(resource)
-      @stock << resource
-    end
-
-    def from_stock
-      @stock.shift || (@size < @limit && allocate)
-    end
-
+        
     def method_missing(sym, *args, &block)
       acquire { |r| r.send(sym, *args, &block) }
     end
@@ -85,33 +41,15 @@ module Polyphony
       true
     end
 
-    # Extension to allow discarding of resources
-    module ResourceExtensions
-      def __discarded__
-        @__discarded__
-      end
-
-      def __discard__
-        @__discarded__ = true
-      end
-    end
-
     # Allocates a resource
     # @return [any] allocated resource
-    def allocate
-      @size += 1
-      @allocator.().tap { |r| r.extend ResourceExtensions }
-    end
-
-    def <<(resource)
+    def add_to_stock
       @size += 1
-      resource.extend ResourceExtensions
-      @stock << resource
-      dequeue
+      @stock << @allocator.call
     end
 
     def preheat!
-      (@limit - @size).times { @stock << allocate }
+      add_to_stock while @size < @limit
     end
   end
 end

data/lib/polyphony/core/sync.rb

@@ -4,18 +4,21 @@ module Polyphony
   # Implements mutex lock for synchronizing access to a shared resource
   class Mutex
     def initialize
-      @waiting_fibers = Polyphony::Queue.new
+      @store = Queue.new
+      @store << :token
     end
 
     def synchronize
-      fiber = Fiber.current
-      @waiting_fibers << fiber
-      suspend if @waiting_fibers.size > 1
-      yield
-    ensure
-      @waiting_fibers.delete(fiber)
-      @waiting_fibers.first&.schedule
-      snooze
+      return yield if @holding_fiber == Fiber.current
+
+      begin
+        token = @store.shift
+        @holding_fiber = Fiber.current
+        yield
+      ensure
+        @holding_fiber = nil
+        @store << token
+      end
     end
   end
 end