polyphony 0.45.0 → 0.46.0

data/ext/polyphony/polyphony_ext.c

@@ -2,22 +2,29 @@
 
 void Init_Fiber();
 void Init_Polyphony();
-void Init_LibevBackend();
+void Init_Backend();
 void Init_Queue();
 void Init_Event();
+void Init_Runqueue();
 void Init_Thread();
 void Init_Tracing();
 
-void Init_polyphony_ext() {
-  ev_set_allocator(xrealloc);
+#ifdef POLYPHONY_PLAYGROUND
+extern void playground();
+#endif
 
+void Init_polyphony_ext() {
   Init_Polyphony();
-  Init_LibevBackend();
+
+  Init_Backend();
   Init_Queue();
   Init_Event();
-
+  Init_Runqueue();
   Init_Fiber();
   Init_Thread();
-
   Init_Tracing();
+
+  #ifdef POLYPHONY_PLAYGROUND
+  playground();
+  #endif
 }

data/ext/polyphony/queue.c

@@ -85,12 +85,11 @@ VALUE Queue_shift(VALUE self) {
   while (1) {
     ring_buffer_push(&queue->shift_queue, fiber);
     if (queue->values.count > 0) Fiber_make_runnable(fiber, Qnil);
-    
+
     VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
     ring_buffer_delete(&queue->shift_queue, fiber);
 
-    if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException)))
-      return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+    RAISE_IF_EXCEPTION(switchpoint_result);
     RB_GC_GUARD(switchpoint_result);
 
     if (queue->values.count > 0)
@@ -152,7 +151,7 @@ VALUE Queue_flush_waiters(VALUE self, VALUE value) {
   while(1) {
     VALUE fiber = ring_buffer_shift(&queue->shift_queue);
     if (fiber == Qnil) return self;
-    
+
     Fiber_make_runnable(fiber, value);
   }
 }

data/ext/polyphony/ring_buffer.c

@@ -24,7 +24,6 @@ VALUE ring_buffer_shift(ring_buffer *buffer) {
   value = buffer->entries[buffer->head];
   buffer->head = (buffer->head + 1) % buffer->size;
   buffer->count--;
-  // INSPECT(value);
   return value;
 }
 

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

@@ -6,15 +6,14 @@ 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 +34,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 +46,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;
+void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
+  VALUE runqueue;
+  int already_runnable;
 
-  int already_runnable = rb_ivar_get(fiber, ID_runnable) != Qnil;
-
-  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 +68,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,48 +93,40 @@ 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 mechanism prevents event starvation in case the run queue never
-        // empties
-        __BACKEND__.poll(backend, Qtrue, current_fiber, queue);
+        // this prevents event starvation in case the run queue never empties
+        __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;
 }
 
-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);
@@ -194,25 +149,23 @@ 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",
     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);
 
-  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_result              = rb_intern("@result");
-  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");
+  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_result                        = rb_intern("@result");
+  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"));