polyphony 0.43.4 → 0.43.10

data/ext/polyphony/polyphony.c

@@ -2,7 +2,6 @@
 
 VALUE mPolyphony;
 
-ID ID_await_no_raise;
 ID ID_call;
 ID ID_caller;
 ID ID_clear;
@@ -22,6 +21,8 @@ ID ID_R;
 ID ID_W;
 ID ID_RW;
 
+agent_interface_t agent_interface;
+
 VALUE Polyphony_snooze(VALUE self) {
   VALUE ret;
   VALUE fiber = rb_fiber_current();
@@ -54,7 +55,6 @@ void Init_Polyphony() {
   rb_define_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);
 
-  ID_await_no_raise = rb_intern("await_no_raise");
   ID_call           = rb_intern("call");
   ID_caller         = rb_intern("caller");
   ID_clear          = rb_intern("clear");

data/ext/polyphony/polyphony.h

@@ -1,9 +1,10 @@
-#ifndef RUBY_EV_H
-#define RUBY_EV_H
+#ifndef POLYPHONY_H
+#define POLYPHONY_H
 
 #include "ruby.h"
 #include "ruby/io.h"
 #include "libev.h"
+#include "agent.h"
 
 // debugging
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
@@ -18,11 +19,16 @@
   return rb_funcall(rb_mKernel, ID_raise, 1, ret); \
 }
 
+extern agent_interface_t agent_interface;
+// #define __AGENT_PASTER__(call) (agent_interface ## . ## call)
+// #define __AGENT__(call) __AGENT_PASTER__(call)
+#define __AGENT__ (agent_interface)
+
+
 extern VALUE mPolyphony;
-extern VALUE cLibevQueue;
+extern VALUE cQueue;
 extern VALUE cEvent;
 
-extern ID ID_await_no_raise;
 extern ID ID_call;
 extern ID ID_caller;
 extern ID ID_clear;
@@ -66,20 +72,17 @@ enum {
 VALUE Fiber_auto_watcher(VALUE self);
 void Fiber_make_runnable(VALUE fiber, VALUE value);
 
-VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue);
-VALUE LibevAgent_break(VALUE self);
-VALUE LibevAgent_pending_count(VALUE self);
-VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write);
-
-VALUE LibevAgent_ref(VALUE self);
-VALUE LibevAgent_unref(VALUE self);
-int LibevAgent_ref_count(VALUE self);
-void LibevAgent_reset_ref_count(VALUE self);
+VALUE Queue_push(VALUE self, VALUE value);
+VALUE Queue_unshift(VALUE self, VALUE value);
+VALUE Queue_shift(VALUE self);
+VALUE Queue_shift_no_wait(VALUE self);
+VALUE Queue_clear(VALUE self);
+VALUE Queue_delete(VALUE self, VALUE value);
+long Queue_len(VALUE self);
+void Queue_trace(VALUE self);
 
 VALUE Polyphony_snooze(VALUE self);
 
-VALUE Polyphony_Queue_push(VALUE self, VALUE value);
-
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
 
@@ -87,4 +90,4 @@ int io_setstrbuf(VALUE *str, long len);
 void io_set_read_length(VALUE str, long n, int shrinkable);
 VALUE io_enc_str(VALUE str, rb_io_t *fptr);
 
-#endif /* RUBY_EV_H */
+#endif /* POLYPHONY_H */

data/ext/polyphony/polyphony_ext.c

@@ -3,7 +3,8 @@
 void Init_Fiber();
 void Init_Polyphony();
 void Init_LibevAgent();
-void Init_LibevQueue();
+void Init_Queue();
+void Init_Event();
 void Init_Thread();
 void Init_Tracing();
 
@@ -12,7 +13,8 @@ void Init_polyphony_ext() {
 
   Init_Polyphony();
   Init_LibevAgent();
-  Init_LibevQueue();
+  Init_Queue();
+  Init_Event();
 
   Init_Fiber();
   Init_Thread();

data/ext/polyphony/queue.c

@@ -0,0 +1,194 @@
+#include "polyphony.h"
+#include "ring_buffer.h"
+
+typedef struct queue {
+  ring_buffer values;
+  ring_buffer shift_queue;
+} Queue_t;
+
+VALUE cQueue = Qnil;
+
+static void Queue_mark(void *ptr) {
+  Queue_t *queue = ptr;
+  ring_buffer_mark(&queue->values);
+  ring_buffer_mark(&queue->shift_queue);
+}
+
+static void Queue_free(void *ptr) {
+  Queue_t *queue = ptr;
+  ring_buffer_free(&queue->values);
+  ring_buffer_free(&queue->shift_queue);
+  xfree(ptr);
+}
+
+static size_t Queue_size(const void *ptr) {
+  return sizeof(Queue_t);
+}
+
+static const rb_data_type_t Queue_type = {
+  "Queue",
+  {Queue_mark, Queue_free, Queue_size,},
+  0, 0, 0
+};
+
+static VALUE Queue_allocate(VALUE klass) {
+  Queue_t *queue;
+
+  queue = ALLOC(Queue_t);
+  return TypedData_Wrap_Struct(klass, &Queue_type, queue);
+}
+
+#define GetQueue(obj, queue) \
+  TypedData_Get_Struct((obj), Queue_t, &Queue_type, (queue))
+
+static VALUE Queue_initialize(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_init(&queue->values);
+  ring_buffer_init(&queue->shift_queue);
+
+  return self;
+}
+
+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);
+  }
+  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);
+  }
+  ring_buffer_unshift(&queue->values, value);
+  return self;
+}
+
+VALUE Queue_shift(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  if (queue->values.count == 0) {
+    VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+    VALUE fiber = rb_fiber_current();
+    VALUE switchpoint_result = Qnil;
+    ring_buffer_push(&queue->shift_queue, fiber);
+    switchpoint_result = __AGENT__.wait_event(agent, Qnil);
+    if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException))) {
+      ring_buffer_delete(&queue->shift_queue, fiber);
+      return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+    }
+    RB_GC_GUARD(agent);
+    RB_GC_GUARD(switchpoint_result);
+  }
+
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE Queue_shift_no_wait(VALUE self) {
+    Queue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift(&queue->values);
+}
+
+VALUE Queue_delete(VALUE self, VALUE value) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_delete(&queue->values, value);
+  return self;
+}
+
+VALUE Queue_clear(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_clear(&queue->values);
+  return self;
+}
+
+long Queue_len(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return queue->values.count;
+}
+
+VALUE Queue_shift_each(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  ring_buffer_shift_each(&queue->values);
+  return self;
+}
+
+VALUE Queue_shift_all(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return ring_buffer_shift_all(&queue->values);
+}
+
+VALUE Queue_flush_waiters(VALUE self, VALUE value) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  while(1) {
+    VALUE fiber = ring_buffer_shift(&queue->shift_queue);
+    if (fiber == Qnil) return self;
+    
+    Fiber_make_runnable(fiber, value);
+  }
+}
+
+VALUE Queue_empty_p(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  return (queue->values.count == 0) ? Qtrue : Qfalse;
+}
+
+VALUE Queue_size_m(VALUE self) {
+  Queue_t *queue;
+  GetQueue(self, queue);
+
+  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, "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, "shift_each", Queue_shift_each, 0);
+  rb_define_method(cQueue, "shift_all", Queue_shift_all, 0);
+  rb_define_method(cQueue, "flush_waiters", Queue_flush_waiters, 1);
+  rb_define_method(cQueue, "empty?", Queue_empty_p, 0);
+  rb_define_method(cQueue, "size", Queue_size_m, 0);
+}

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;
@@ -22,12 +21,12 @@ static VALUE Thread_setup_fiber_scheduling(VALUE self) {
 
 int Thread_fiber_ref_count(VALUE self) {
   VALUE agent = rb_ivar_get(self, ID_ivar_agent);
-  return NUM2INT(LibevAgent_ref_count(agent));
+  return NUM2INT(__AGENT__.ref_count(agent));
 }
 
 inline void Thread_fiber_reset_ref_count(VALUE self) {
   VALUE agent = rb_ivar_get(self, ID_ivar_agent);
-  LibevAgent_reset_ref_count(agent);
+  __AGENT__.reset_ref_count(agent);
 }
 
 static VALUE SYM_scheduled_fibers;
@@ -42,7 +41,7 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   long scheduled_count = RARRAY_LEN(queue);
   rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
 
-  pending_count = LibevAgent_pending_count(agent);
+  pending_count = __AGENT__.pending_count(agent);
   rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
 
   return stats;
@@ -53,25 +52,34 @@ 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;
+  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;
   }
 
-  queue = rb_ivar_get(self, ID_run_queue);
-  rb_ary_push(queue, fiber);
-  rb_ivar_set(fiber, ID_runnable, Qtrue);
+  rb_ivar_set(fiber, ID_runnable_value, value);
+  FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
 
-  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 selector. 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 agent = rb_ivar_get(self,ID_ivar_agent);
-    LibevAgent_break(agent);
+  if (!already_runnable) {
+    queue = rb_ivar_get(self, ID_run_queue);
+    Queue_push(queue, fiber);
+    rb_ivar_set(fiber, ID_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
+      // event selector. 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 agent = rb_ivar_get(self,ID_ivar_agent);
+      __AGENT__.wakeup(agent);
+    }
   }
   return self;
 }
@@ -88,13 +96,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
@@ -103,7 +111,7 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
     // happen, not knowing that it there's already a fiber ready to run in its
     // run queue.
     VALUE agent = rb_ivar_get(self, ID_ivar_agent);
-    LibevAgent_break(agent);
+    __AGENT__.wakeup(agent);
   }
   return self;
 }
@@ -115,6 +123,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) {
@@ -122,20 +131,21 @@ VALUE Thread_switch_fiber(VALUE self) {
     }
   }
 
-  ref_count = LibevAgent_ref_count(agent);
+  ref_count = __AGENT__.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);
+        __AGENT__.poll(agent, Qtrue, current_fiber, queue);
       }
       break;
     }
     if (ref_count == 0) break;
 
-    LibevAgent_poll(agent, Qnil, current_fiber, queue);
+    __AGENT__.poll(agent, Qnil, current_fiber, queue);
+    agent_was_polled = 1;
   }
 
   if (next_fiber == Qnil) return Qnil;
@@ -151,9 +161,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;
 }
@@ -164,7 +180,7 @@ VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE fiber, VALUE resume_ob
     Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
   }
 
-  if (LibevAgent_break(agent) == Qnil) {
+  if (__AGENT__.wakeup(agent) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
@@ -182,6 +198,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");