polyphony 0.45.5 → 0.47.2

data/ext/polyphony/queue.c

@@ -4,6 +4,8 @@
 typedef struct queue {
   ring_buffer values;
   ring_buffer shift_queue;
+  ring_buffer push_queue;
+  unsigned int capacity;
 } Queue_t;
 
 VALUE cQueue = Qnil;
@@ -12,12 +14,14 @@ static void Queue_mark(void *ptr) {
   Queue_t *queue = ptr;
   ring_buffer_mark(&queue->values);
   ring_buffer_mark(&queue->shift_queue);
+  ring_buffer_mark(&queue->push_queue);
 }
 
 static void Queue_free(void *ptr) {
   Queue_t *queue = ptr;
   ring_buffer_free(&queue->values);
   ring_buffer_free(&queue->shift_queue);
+  ring_buffer_free(&queue->push_queue);
   xfree(ptr);
 }
 
@@ -41,36 +45,77 @@ static VALUE Queue_allocate(VALUE klass) {
 #define GetQueue(obj, queue) \
   TypedData_Get_Struct((obj), Queue_t, &Queue_type, (queue))
 
-static VALUE Queue_initialize(VALUE self) {
+static VALUE Queue_initialize(int argc, VALUE *argv, VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
   ring_buffer_init(&queue->values);
   ring_buffer_init(&queue->shift_queue);
+  ring_buffer_init(&queue->push_queue);
+  queue->capacity = (argc == 1) ?  NUM2UINT(argv[0]) : 0;
 
   return self;
 }
 
+inline void queue_resume_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) {
+  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) {
+  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);
+  }
+}
+
+inline void capped_queue_block_push(Queue_t *queue) {
+  VALUE fiber = rb_fiber_current();
+  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  VALUE switchpoint_result;
+  while (1) {
+    if (queue->capacity > queue->values.count) Fiber_make_runnable(fiber, Qnil);
+
+    ring_buffer_push(&queue->push_queue, fiber);
+    switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+    ring_buffer_delete(&queue->push_queue, fiber);
+
+    RAISE_IF_EXCEPTION(switchpoint_result);
+    RB_GC_GUARD(switchpoint_result);
+    if (queue->capacity > queue->values.count) break;
+  }
+}
+
 VALUE Queue_push(VALUE self, VALUE value) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  if (queue->shift_queue.count > 0) {
-    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
-    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
-  }
+  if (queue->capacity) capped_queue_block_push(queue);
+
+  queue_resume_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_push(&queue->values, value);
+
   return self;
 }
 
 VALUE Queue_unshift(VALUE self, VALUE value) {
   Queue_t *queue;
   GetQueue(self, queue);
-  if (queue->shift_queue.count > 0) {
-    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
-    if (fiber != Qnil) Fiber_make_runnable(fiber, Qnil);
-  }
+
+  if (queue->capacity) capped_queue_block_push(queue);
+
+  queue_resume_first_blocked_fiber(&queue->shift_queue);
   ring_buffer_unshift(&queue->values, value);
+
   return self;
 }
 
@@ -83,42 +128,63 @@ VALUE Queue_shift(VALUE self) {
   VALUE backend = rb_ivar_get(thread, ID_ivar_backend);
 
   while (1) {
-    ring_buffer_push(&queue->shift_queue, fiber);
-    if (queue->values.count > 0) Fiber_make_runnable(fiber, Qnil);
+    if (queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
+    ring_buffer_push(&queue->shift_queue, fiber);
     VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
     ring_buffer_delete(&queue->shift_queue, fiber);
 
-    TEST_RESUME_EXCEPTION(switchpoint_result);
+    RAISE_IF_EXCEPTION(switchpoint_result);
     RB_GC_GUARD(switchpoint_result);
-
-    if (queue->values.count > 0)
-      return ring_buffer_shift(&queue->values);
+    if (queue->values.count) break;
   }
-
-  return Qnil;
+  VALUE value = ring_buffer_shift(&queue->values);
+  if ((queue->capacity) && (queue->capacity > queue->values.count))
+    queue_resume_first_blocked_fiber(&queue->push_queue);
+  RB_GC_GUARD(value);
+  return value;
 }
 
-VALUE Queue_shift_no_wait(VALUE self) {
-    Queue_t *queue;
+VALUE Queue_delete(VALUE self, VALUE value) {
+  Queue_t *queue;
   GetQueue(self, queue);
 
-  return ring_buffer_shift(&queue->values);
+  ring_buffer_delete(&queue->values, value);
+
+  if (queue->capacity && (queue->capacity > queue->values.count))
+    queue_resume_first_blocked_fiber(&queue->push_queue);
+
+  return self;
 }
 
-VALUE Queue_delete(VALUE self, VALUE value) {
+VALUE Queue_cap(VALUE self, VALUE cap) {
+  unsigned int new_capacity = NUM2UINT(cap);
   Queue_t *queue;
   GetQueue(self, queue);
-
-  ring_buffer_delete(&queue->values, value);
+  queue->capacity = new_capacity;
+  
+  if (queue->capacity)
+    queue_resume_blocked_fibers_to_capacity(queue);
+  else
+    queue_resume_all_blocked_fibers(&queue->push_queue);
+  
   return self;
 }
 
+VALUE Queue_capped_p(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return queue->capacity ? UINT2NUM(queue->capacity) : Qnil;
+}
+
 VALUE Queue_clear(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
   ring_buffer_clear(&queue->values);
+  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+
   return self;
 }
 
@@ -134,6 +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);
   return self;
 }
 
@@ -141,7 +208,9 @@ VALUE Queue_shift_all(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return ring_buffer_shift_all(&queue->values);
+  VALUE result = ring_buffer_shift_all(&queue->values);
+  if (queue->capacity) queue_resume_blocked_fibers_to_capacity(queue);
+  return result;
 }
 
 VALUE Queue_flush_waiters(VALUE self, VALUE value) {
@@ -160,14 +229,14 @@ VALUE Queue_empty_p(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return (queue->values.count == 0) ? Qtrue : Qfalse;
+  return (!queue->values.count) ? Qtrue : Qfalse;
 }
 
 VALUE Queue_pending_p(VALUE self) {
   Queue_t *queue;
   GetQueue(self, queue);
 
-  return (queue->shift_queue.count > 0) ? Qtrue : Qfalse;
+  return (queue->shift_queue.count) ? Qtrue : Qfalse;
 }
 
 VALUE Queue_size_m(VALUE self) {
@@ -177,26 +246,22 @@ VALUE Queue_size_m(VALUE self) {
   return INT2NUM(queue->values.count);
 }
 
-void Queue_trace(VALUE self) {
-  Queue_t *queue;
-  GetQueue(self, queue);
-
-  printf("run queue size: %d count: %d\n", queue->values.size, queue->values.count);
-}
-
 void Init_Queue() {
   cQueue = rb_define_class_under(mPolyphony, "Queue", rb_cData);
   rb_define_alloc_func(cQueue, Queue_allocate);
 
-  rb_define_method(cQueue, "initialize", Queue_initialize, 0);
+  rb_define_method(cQueue, "initialize", Queue_initialize, -1);
   rb_define_method(cQueue, "push", Queue_push, 1);
   rb_define_method(cQueue, "<<", Queue_push, 1);
   rb_define_method(cQueue, "unshift", Queue_unshift, 1);
 
   rb_define_method(cQueue, "shift", Queue_shift, 0);
   rb_define_method(cQueue, "pop", Queue_shift, 0);
-  rb_define_method(cQueue, "shift_no_wait", Queue_shift_no_wait, 0);
   rb_define_method(cQueue, "delete", Queue_delete, 1);
+  rb_define_method(cQueue, "clear", Queue_clear, 0);
+
+  rb_define_method(cQueue, "cap", Queue_cap, 1);
+  rb_define_method(cQueue, "capped?", Queue_capped_p, 0);
 
   rb_define_method(cQueue, "shift_each", Queue_shift_each, 0);
   rb_define_method(cQueue, "shift_all", Queue_shift_all, 0);

data/ext/polyphony/thread.c

@@ -115,7 +115,7 @@ VALUE Thread_switch_fiber(VALUE self) {
   RB_GC_GUARD(next.fiber);
   RB_GC_GUARD(next.value);
   return (next.fiber == current_fiber) ?
-    next.value : rb_funcall(next.fiber, ID_transfer, 1, next.value);
+    next.value : FIBER_TRANSFER(next.fiber, next.value);
 }
 
 VALUE Thread_reset_fiber_scheduling(VALUE self) {
@@ -125,7 +125,7 @@ VALUE Thread_reset_fiber_scheduling(VALUE 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);
@@ -148,7 +148,7 @@ 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",
@@ -157,13 +157,13 @@ void Init_Thread() {
 
   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_runqueue            = rb_intern("@runqueue");
-  ID_ivar_terminated          = rb_intern("@terminated");
-  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/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)
+    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)
@@ -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/resource_pool.rb

@@ -58,7 +58,18 @@ module Polyphony
     # Discards the currently-acquired resource
     # instead of returning it to the pool when done.
     def discard!
-      @size -= 1 if @acquired_resources.delete(Fiber.current)
+      if block_given?
+        @size.times do
+          acquire do |r|
+            next if yield(r)
+
+            @size -= 1
+            @acquired_resources.delete(Fiber.current)
+          end
+        end
+      else
+        @size -= 1 if @acquired_resources.delete(Fiber.current)
+      end
     end
 
     def preheat!