polyphony 0.45.4 → 0.45.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f8ebf1104d921c9e3b0afa0b4605ee8f912eabe8b6264898f23905d2cb6c6f
-  data.tar.gz: 38f0f7cd62997ba5681185c3c4859f57d86de875d8292faf67fffa53c7160181
+  metadata.gz: fe5d86b07fc6f29d01897a7790deac8f0544bb61dbd486fb8ea104dd315b0e80
+  data.tar.gz: 3e1086b9395d63835a09051c52b7f8496013f190149df35532333b6c27b74169
 SHA512:
-  metadata.gz: 2429259a2e79757ec879c4c00db8fd8b87302b9e0a61c6ae2ddd5fdb6e1a3a06ac63d551ed33a4c77480e156eb1247a0fab4a263179a60fd2e9a2d3173831a58
-  data.tar.gz: 04f58dafb5faf1e21b08fd85d508ceb6e9869b0a69d63c133661a834f169eb750b599639ffdbff474abf7f92bc6bfee3a43b9442c2885a6dd88328657b0e1d36
+  metadata.gz: d6c7a78a46b9084f60ee838e82b7cde6f287eea2c500f779e5014103a400da98dc066adef58631033591a8de5278cc4f7b95ba8dcdac3ad22ecd68668a7d68e4
+  data.tar.gz: d32e7def9aa63ecb5c53b46020079e3384809ff786478e0b87fce1b141abb85d3c69d1f490b1d0a3bcbfaf972a3779939ac42bec512b12132d3b46b159754de5

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.45.5
+
+* Fix compilation error (#43)
+* Add support for resetting move_on_after, cancel_after timeouts
+* Optimize anti-event starvation polling
+* Implement optimized runqueue for better performance
+* Schedule parent with priority on uncaught exception
+* Fix race condition in `Mutex#synchronize` (#41)
+
 ## 0.45.4
 
 * Improve signal trapping mechanism

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.45.4)
+    polyphony (0.45.5)
 
 GEM
   remote: https://rubygems.org/

data/TODO.md

@@ -1,11 +1,6 @@
-(
-  io_uring: some work has been done on an io_uring based scheduler here:
-    https://github.com/dsh0416/evt
-  
-  This can serve as a starting point for doing stuff with io_uring
-)
+- io_uring
 
-0.45.4
+0.46
 
 - Adapter for io/console (what does `IO#raw` do?)
 - Adapter for Pry and IRB (Which fixes #5 and #6)
@@ -14,7 +9,7 @@
 - Fix backtrace for `Timeout.timeout` API (see timeout example).
 - Check why worker-thread example doesn't work.
 
-0.46.0
+0.47
 
 - Debugging
   - Eat your own dogfood: need a good tool to check what's going on when some
@@ -128,8 +123,6 @@
   - discuss using `snooze` for ensuring responsiveness when executing CPU-bound work
 
 
-## 0.47
-
 ### Some more API work, more docs
 
 - sintra app with database access (postgresql)
@@ -141,14 +134,10 @@
   - proceed from there
 
 
-## 0.48
-
 ### Sinatra / Sidekiq
 
 - Pull out redis/postgres code, put into new `polyphony-xxx` gems
 
-## 0.49
-
 ### Testing && Docs
 
 - More tests
@@ -159,8 +148,6 @@
   - `IO.foreach`
   - `Process.waitpid`
 
-## 0.50 DNS
-
 ### DNS client
 
 ```ruby

data/examples/performance/multi_snooze.rb

@@ -18,7 +18,6 @@ def bm(fibers, iterations)
   Fiber.current.await_all_children
   dt = Time.now - t0
   puts "#{[fibers, iterations].inspect} setup: #{t0 - t_pre}s count: #{count} #{count / dt.to_f}/s"
-  Thread.current.run_queue_trace
 end
 
 GC.disable

data/ext/polyphony/backend.h

@@ -18,7 +18,7 @@
 // VALUE LibevBackend_write(int argc, VALUE *argv, VALUE self);
 
 typedef VALUE (* backend_pending_count_t)(VALUE self);
-typedef VALUE (*backend_poll_t)(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue);
+typedef VALUE (*backend_poll_t)(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue);
 typedef VALUE (* backend_ref_t)(VALUE self);
 typedef int (* backend_ref_count_t)(VALUE self);
 typedef void (* backend_reset_ref_count_t)(VALUE self);

data/ext/polyphony/fiber.c

@@ -3,7 +3,6 @@
 ID ID_fiber_trace;
 ID ID_ivar_auto_watcher;
 ID ID_ivar_mailbox;
-ID ID_ivar_result;
 ID ID_ivar_waiting_fibers;
 
 VALUE SYM_dead;
@@ -39,31 +38,49 @@ inline VALUE Fiber_auto_watcher(VALUE self) {
   return watcher;
 }
 
+void Fiber_make_runnable(VALUE fiber, VALUE value) {
+  VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
+  if (thread == Qnil) {
+    // rb_raise(rb_eRuntimeError, "No thread set for fiber");
+    rb_warn("No thread set for fiber");
+    return;
+  }
+
+  Thread_schedule_fiber(thread, fiber, value);
+}
+
+void Fiber_make_runnable_with_priority(VALUE fiber, VALUE value) {
+  VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
+  if (thread == Qnil) {
+    // rb_raise(rb_eRuntimeError, "No thread set for fiber");
+    rb_warn("No thread set for fiber");
+    return;
+  }
+
+  Thread_schedule_fiber_with_priority(thread, fiber, value);
+}
+
 static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
   VALUE value = (argc == 0) ? Qnil : argv[0];
   Fiber_make_runnable(self, value);
   return self;
 }
 
+static VALUE Fiber_schedule_with_priority(int argc, VALUE *argv, VALUE self) {
+  VALUE value = (argc == 0) ? Qnil : argv[0];
+  Fiber_make_runnable_with_priority(self, value);
+  return self;
+}
+
 static VALUE Fiber_state(VALUE self) {
   if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_ivar_running) == Qfalse))
     return SYM_dead;
   if (rb_fiber_current() == self) return SYM_running;
-  if (rb_ivar_get(self, ID_runnable) != Qnil) return SYM_runnable;
+  if (rb_ivar_get(self, ID_ivar_runnable) != Qnil) return SYM_runnable;
 
   return SYM_waiting;
 }
 
-void Fiber_make_runnable(VALUE fiber, VALUE value) {
-  VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
-  if (thread != Qnil) {
-    Thread_schedule_fiber(thread, fiber, value);
-  }
-  else {
-    rb_warn("No thread set for fiber (fiber, value, caller):");
-  }
-}
-
 VALUE Fiber_await(VALUE self) {
   VALUE result;
 
@@ -119,6 +136,7 @@ void Init_Fiber() {
   VALUE cFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
   rb_define_method(cFiber, "safe_transfer", Fiber_safe_transfer, -1);
   rb_define_method(cFiber, "schedule", Fiber_schedule, -1);
+  rb_define_method(cFiber, "schedule_with_priority", Fiber_schedule_with_priority, -1);
   rb_define_method(cFiber, "state", Fiber_state, 0);
   rb_define_method(cFiber, "auto_watcher", Fiber_auto_watcher, 0);
 
@@ -143,7 +161,6 @@ void Init_Fiber() {
   ID_fiber_trace          = rb_intern("__fiber_trace__");
   ID_ivar_auto_watcher    = rb_intern("@auto_watcher");
   ID_ivar_mailbox         = rb_intern("@mailbox");
-  ID_ivar_result          = rb_intern("@result");
   ID_ivar_waiting_fibers  = rb_intern("@waiting_fibers");
 
   SYM_fiber_create        = ID2SYM(rb_intern("fiber_create"));

data/ext/polyphony/libev_backend.c

@@ -126,16 +126,17 @@ VALUE LibevBackend_pending_count(VALUE self) {
   return INT2NUM(count);
 }
 
-VALUE LibevBackend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue) {
+VALUE LibevBackend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
   int is_nowait = nowait == Qtrue;
   LibevBackend_t *backend;
   GetLibevBackend(self, backend);
 
   if (is_nowait) {
-    long runnable_count = Queue_len(queue);
     backend->run_no_wait_count++;
-    if (backend->run_no_wait_count < runnable_count || backend->run_no_wait_count < 10)
-      return self;
+    if (backend->run_no_wait_count < 10) return self;
+
+    long runnable_count = Runqueue_len(runqueue);
+    if (backend->run_no_wait_count < runnable_count) return self;
   }
 
   backend->run_no_wait_count = 0;

data/ext/polyphony/polyphony.c

@@ -9,10 +9,10 @@ ID ID_each;
 ID ID_inspect;
 ID ID_invoke;
 ID ID_new;
+ID ID_ivar_result;
+ID ID_ivar_runnable;
 ID ID_ivar_running;
 ID ID_ivar_thread;
-ID ID_runnable;
-ID ID_runnable_value;
 ID ID_size;
 ID ID_signal;
 ID ID_switch_fiber;
@@ -61,11 +61,11 @@ void Init_Polyphony() {
   ID_each           = rb_intern("each");
   ID_inspect        = rb_intern("inspect");
   ID_invoke         = rb_intern("invoke");
+  ID_ivar_result    = rb_intern("@result");
+  ID_ivar_runnable  = rb_intern("runnable");
   ID_ivar_running   = rb_intern("@running");
   ID_ivar_thread    = rb_intern("@thread");
   ID_new            = rb_intern("new");
-  ID_runnable       = rb_intern("runnable");
-  ID_runnable_value = rb_intern("runnable_value");
   ID_signal         = rb_intern("signal");
   ID_size           = rb_intern("size");
   ID_switch_fiber   = rb_intern("switch_fiber");

data/ext/polyphony/polyphony.h

@@ -5,6 +5,7 @@
 #include "ruby/io.h"
 #include "libev.h"
 #include "backend.h"
+#include "runqueue_ring_buffer.h"
 
 // debugging
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
@@ -30,6 +31,7 @@ extern backend_interface_t backend_interface;
 extern VALUE mPolyphony;
 extern VALUE cQueue;
 extern VALUE cEvent;
+extern VALUE cRunqueue;
 
 extern ID ID_call;
 extern ID ID_caller;
@@ -39,12 +41,12 @@ extern ID ID_fiber_trace;
 extern ID ID_inspect;
 extern ID ID_invoke;
 extern ID ID_ivar_backend;
+extern ID ID_ivar_result;
+extern ID ID_ivar_runnable;
 extern ID ID_ivar_running;
 extern ID ID_ivar_thread;
 extern ID ID_new;
 extern ID ID_raise;
-extern ID ID_runnable;
-extern ID ID_runnable_value;
 extern ID ID_signal;
 extern ID ID_size;
 extern ID ID_switch_fiber;
@@ -79,7 +81,17 @@ VALUE Queue_delete(VALUE self, VALUE value);
 long Queue_len(VALUE self);
 void Queue_trace(VALUE self);
 
+
+void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule);
+void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule);
+runqueue_entry Runqueue_shift(VALUE self);
+void Runqueue_delete(VALUE self, VALUE fiber);
+void Runqueue_clear(VALUE self);
+long Runqueue_len(VALUE self);
+int Runqueue_empty_p(VALUE self);
+
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
+VALUE Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
 
 #endif /* POLYPHONY_H */

data/ext/polyphony/polyphony_ext.c

@@ -5,6 +5,7 @@ void Init_Polyphony();
 void Init_LibevBackend();
 void Init_Queue();
 void Init_Event();
+void Init_Runqueue();
 void Init_Thread();
 void Init_Tracing();
 
@@ -16,6 +17,7 @@ void Init_polyphony_ext() {
   Init_LibevBackend();
   Init_Queue();
   Init_Event();
+  Init_Runqueue();
   Init_Fiber();
   Init_Thread();
   Init_Tracing();

data/ext/polyphony/runqueue.c

@@ -0,0 +1,102 @@
+#include "polyphony.h"
+#include "runqueue_ring_buffer.h"
+
+typedef struct queue {
+  runqueue_ring_buffer entries;
+} Runqueue_t;
+
+VALUE cRunqueue = Qnil;
+
+static void Runqueue_mark(void *ptr) {
+  Runqueue_t *runqueue = ptr;
+  runqueue_ring_buffer_mark(&runqueue->entries);
+}
+
+static void Runqueue_free(void *ptr) {
+  Runqueue_t *runqueue = ptr;
+  runqueue_ring_buffer_free(&runqueue->entries);
+  xfree(ptr);
+}
+
+static size_t Runqueue_size(const void *ptr) {
+  return sizeof(Runqueue_t);
+}
+
+static const rb_data_type_t Runqueue_type = {
+  "Runqueue",
+  {Runqueue_mark, Runqueue_free, Runqueue_size,},
+  0, 0, 0
+};
+
+static VALUE Runqueue_allocate(VALUE klass) {
+  Runqueue_t *runqueue;
+
+  runqueue = ALLOC(Runqueue_t);
+  return TypedData_Wrap_Struct(klass, &Runqueue_type, runqueue);
+}
+
+#define GetRunqueue(obj, runqueue) \
+  TypedData_Get_Struct((obj), Runqueue_t, &Runqueue_type, (runqueue))
+
+static VALUE Runqueue_initialize(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  runqueue_ring_buffer_init(&runqueue->entries);
+
+  return self;
+}
+
+void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  if (reschedule) runqueue_ring_buffer_delete(&runqueue->entries, fiber);
+  runqueue_ring_buffer_push(&runqueue->entries, fiber, value);
+}
+
+void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  if (reschedule) runqueue_ring_buffer_delete(&runqueue->entries, fiber);
+  runqueue_ring_buffer_unshift(&runqueue->entries, fiber, value);
+}
+
+runqueue_entry Runqueue_shift(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  return runqueue_ring_buffer_shift(&runqueue->entries);
+}
+
+void Runqueue_delete(VALUE self, VALUE fiber) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  runqueue_ring_buffer_delete(&runqueue->entries, fiber);
+}
+
+void Runqueue_clear(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  runqueue_ring_buffer_clear(&runqueue->entries);
+}
+
+long Runqueue_len(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  return runqueue->entries.count;
+}
+
+int Runqueue_empty_p(VALUE self) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+
+  return (runqueue->entries.count == 0);
+}
+
+void Init_Runqueue() {
+  cRunqueue = rb_define_class_under(mPolyphony, "Runqueue", rb_cData);
+  rb_define_alloc_func(cRunqueue, Runqueue_allocate);
+
+  rb_define_method(cRunqueue, "initialize", Runqueue_initialize, 0);
+}

data/ext/polyphony/runqueue_ring_buffer.c

@@ -0,0 +1,85 @@
+#include "polyphony.h"
+#include "runqueue_ring_buffer.h"
+
+void runqueue_ring_buffer_init(runqueue_ring_buffer *buffer) {
+  buffer->size = 1;
+  buffer->count = 0;
+  buffer->entries = malloc(buffer->size * sizeof(runqueue_entry));
+  buffer->head = 0;
+  buffer->tail = 0;
+}
+
+void runqueue_ring_buffer_free(runqueue_ring_buffer *buffer) {
+  free(buffer->entries);
+}
+
+int runqueue_ring_buffer_empty_p(runqueue_ring_buffer *buffer) {
+  return buffer->count == 0;
+}
+
+static runqueue_entry nil_runqueue_entry = {(Qnil), (Qnil)};
+
+runqueue_entry runqueue_ring_buffer_shift(runqueue_ring_buffer *buffer) {
+  if (buffer->count == 0) return nil_runqueue_entry;
+
+  runqueue_entry value = buffer->entries[buffer->head];
+  buffer->head = (buffer->head + 1) % buffer->size;
+  buffer->count--;
+  return value;
+}
+
+void runqueue_ring_buffer_resize(runqueue_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(runqueue_entry));
+  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 runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
+  if (buffer->count == buffer->size) runqueue_ring_buffer_resize(buffer);
+
+  buffer->head = (buffer->head - 1) % buffer->size;
+  buffer->entries[buffer->head].fiber = fiber;
+  buffer->entries[buffer->head].value = value;
+  buffer->count++;
+}
+
+void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value) {
+  if (buffer->count == buffer->size) runqueue_ring_buffer_resize(buffer);
+
+  buffer->entries[buffer->tail].fiber = fiber;
+  buffer->entries[buffer->tail].value = value;
+  buffer->tail = (buffer->tail + 1) % buffer->size;
+  buffer->count++;
+}
+
+void runqueue_ring_buffer_mark(runqueue_ring_buffer *buffer) {
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size].fiber);
+    rb_gc_mark(buffer->entries[(buffer->head + i) % buffer->size].value);
+  }
+}
+
+void runqueue_ring_buffer_delete_at(runqueue_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 runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    unsigned int idx = (buffer->head + i) % buffer->size;
+    if (buffer->entries[idx].fiber == fiber) {
+      runqueue_ring_buffer_delete_at(buffer, idx);
+      return;
+    }
+  }
+}
+
+void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
+  buffer->count = buffer->head = buffer->tail = 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,42 +92,35 @@ 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 : rb_funcall(next.fiber, ID_transfer, 1, 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;
 }
@@ -199,7 +154,6 @@ 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);
 
   rb_define_method(rb_cThread, "debug!", Thread_debug, 0);
 
@@ -207,10 +161,8 @@ void Init_Thread() {
   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_runqueue            = rb_intern("@runqueue");
   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");
 
   SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));

data/lib/polyphony/core/global_api.rb

@@ -32,7 +32,7 @@ module Polyphony
     end
 
     def cancel_after_wrap_block(canceller, &block)
-      block.call
+      block.call(canceller)
     ensure
       canceller.stop
     end
@@ -81,7 +81,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

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/fiber.rb

@@ -187,9 +187,9 @@ module Polyphony
       (@children ||= {}).keys
     end
 
-    def spin(tag = nil, orig_caller = Kernel.caller, do_schedule: true, &block)
+    def spin(tag = nil, orig_caller = Kernel.caller, &block)
       f = Fiber.new { |v| f.run(v) }
-      f.prepare(tag, block, orig_caller, self, do_schedule: do_schedule)
+      f.prepare(tag, block, orig_caller, self)
       (@children ||= {})[f] = true
       f
     end
@@ -227,14 +227,14 @@ module Polyphony
 
   # Fiber life cycle methods
   module FiberLifeCycle
-    def prepare(tag, block, caller, parent, do_schedule: true)
+    def prepare(tag, block, caller, parent)
       @thread = Thread.current
       @tag = tag
       @parent = parent
       @caller = caller
       @block = block
       __fiber_trace__(:fiber_create, self)
-      schedule if do_schedule
+      schedule
     end
 
     def run(first_value)
@@ -308,7 +308,7 @@ module Polyphony
       @waiting_fibers&.each_key { |f| f.schedule(result) }
       
       # propagate unaught exception to parent
-      @parent&.schedule(result) if uncaught_exception && !@waiting_fibers
+      @parent&.schedule_with_priority(result) if uncaught_exception && !@waiting_fibers
     end
 
     def when_done(&block)

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.45.4'
+  VERSION = '0.45.5'
 end

data/test/test_global_api.rb

@@ -122,6 +122,21 @@ class MoveOnAfterTest < MiniTest::Test
     assert_equal :bar, v
   end
 
+  def test_move_on_after_with_reset
+    t0 = Time.now
+    v = move_on_after(0.01, with_value: :moved_on) do |timeout|
+      sleep 0.007
+      timeout.reset
+      sleep 0.007
+      nil
+    end
+    t1 = Time.now
+
+    assert_nil v
+    assert t1 - t0 >= 0.014
+    assert t1 - t0 < 0.02
+  end
+
   def test_move_on_after_without_block
     t0 = Time.now
     f = move_on_after(0.01, with_value: 'foo')
@@ -160,6 +175,20 @@ class CancelAfterTest < MiniTest::Test
     assert t1 - t0 < 0.1
   end
 
+  def test_cancel_after_with_reset
+    t0 = Time.now
+    cancel_after(0.01) do |f|
+      assert_kind_of Fiber, f
+      assert_equal Fiber.current, f.parent
+      sleep 0.007
+      f.reset
+      sleep 0.007
+    end
+    t1 = Time.now
+    assert t1 - t0 >= 0.014
+    assert t1 - t0 < 0.02
+  end
+
   class CustomException < Exception
   end
 

data/test/test_sync.rb

@@ -20,6 +20,27 @@ class MutexTest < MiniTest::Test
     assert_equal ['>> 1', '<< 1', '>> 2', '<< 2', '>> 3', '<< 3'], buf
   end
 
+  def test_mutex_race_condition
+    lock = Polyphony::Mutex.new
+    buf = []
+    f1 = spin do
+      lock.synchronize { buf << 1; snooze; lock.synchronize { buf << 1.1 }; snooze }
+    end
+    f2 = spin do
+      lock.synchronize { buf << 2 }
+    end
+    f3 = spin do
+      lock.synchronize { buf << 3 }
+    end
+
+    snooze
+    f2.terminate
+
+    f3.await
+
+    assert_equal [1, 1.1, 3], buf
+  end
+
   def test_condition_variable
     buf = []
     lock1 = Polyphony::Mutex.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.45.4
+  version: 0.45.5
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-06 00:00:00.000000000 Z
+date: 2020-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -428,6 +428,9 @@ files:
 - ext/polyphony/queue.c
 - ext/polyphony/ring_buffer.c
 - ext/polyphony/ring_buffer.h
+- ext/polyphony/runqueue.c
+- ext/polyphony/runqueue_ring_buffer.c
+- ext/polyphony/runqueue_ring_buffer.h
 - ext/polyphony/thread.c
 - ext/polyphony/tracing.c
 - lib/polyphony.rb
@@ -507,7 +510,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Fine grained concurrency for Ruby