polyphony 0.39 → 0.43.1

data/ext/polyphony/libev_queue.c

@@ -0,0 +1,216 @@
+#include "polyphony.h"
+
+struct async_watcher {
+  ev_async async;
+  struct ev_loop *ev_loop;
+  VALUE fiber;
+};
+
+struct async_queue {
+  struct async_watcher **queue;
+  unsigned int len;
+  unsigned int count;
+  unsigned int push_idx;
+  unsigned int pop_idx;
+};
+
+void async_queue_init(struct async_queue *queue) {
+  queue->len = 4;
+  queue->count = 0;
+  queue->queue = malloc(sizeof(struct async_watcher *) * queue->len);
+  queue->push_idx = 0;
+  queue->pop_idx = 0;
+}
+
+void async_queue_free(struct async_queue *queue) {
+  free(queue->queue);
+}
+
+void async_queue_push(struct async_queue *queue, struct async_watcher *watcher) {
+  if (queue->push_idx == queue->len) {
+    queue->len = queue->len * 2;
+    queue->queue = realloc(queue->queue, sizeof(struct async_watcher *) * queue->len);
+  }
+  if (queue->count == 0) {
+    queue->push_idx = 0;
+    queue->pop_idx = 0;
+  }
+  queue->count++;
+  queue->queue[queue->push_idx++] = watcher;
+}
+
+struct async_watcher *async_queue_pop(struct async_queue *queue) {
+  if (queue->count == 0) return 0;
+
+  queue->count--;
+
+  return queue->queue[queue->pop_idx++];
+}
+
+void async_queue_remove_at_idx(struct async_queue *queue, unsigned int remove_idx) {
+  queue->count--;
+  queue->push_idx--;
+  if (remove_idx < queue->push_idx)
+    memmove(
+      queue->queue + remove_idx,
+      queue->queue + remove_idx + 1,
+      (queue->push_idx - remove_idx) * sizeof(struct async_watcher *)
+    );
+}
+
+void async_queue_remove_by_fiber(struct async_queue *queue, VALUE fiber) {
+  if (queue->count == 0) return;
+
+  for (unsigned idx = queue->pop_idx; idx < queue->push_idx; idx++) {
+    if (queue->queue[idx]->fiber == fiber) {
+      async_queue_remove_at_idx(queue, idx);
+      return; 
+    }
+  }
+}
+
+typedef struct queue {
+  VALUE items;
+  struct async_queue shift_queue;
+} LibevQueue_t;
+
+
+VALUE cLibevQueue = Qnil;
+
+static void LibevQueue_mark(void *ptr) {
+  LibevQueue_t *queue = ptr;
+  rb_gc_mark(queue->items);
+}
+
+static void LibevQueue_free(void *ptr) {
+  LibevQueue_t *queue = ptr;
+  async_queue_free(&queue->shift_queue);
+  xfree(ptr);
+}
+
+static size_t LibevQueue_size(const void *ptr) {
+  return sizeof(LibevQueue_t);
+}
+
+static const rb_data_type_t LibevQueue_type = {
+  "Queue",
+  {LibevQueue_mark, LibevQueue_free, LibevQueue_size,},
+  0, 0, 0
+};
+
+static VALUE LibevQueue_allocate(VALUE klass) {
+  LibevQueue_t *queue;
+
+  queue = ALLOC(LibevQueue_t);
+  return TypedData_Wrap_Struct(klass, &LibevQueue_type, queue);
+}
+
+#define GetQueue(obj, queue) \
+  TypedData_Get_Struct((obj), LibevQueue_t, &LibevQueue_type, (queue))
+
+static VALUE LibevQueue_initialize(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  queue->items = rb_ary_new();
+  async_queue_init(&queue->shift_queue);
+
+  return self;
+}
+
+VALUE LibevQueue_push(VALUE self, VALUE value) {
+  LibevQueue_t *queue;
+  struct async_watcher *watcher;
+  GetQueue(self, queue);
+  watcher = async_queue_pop(&queue->shift_queue);
+  if (watcher) {
+    ev_async_send(watcher->ev_loop, &watcher->async);
+  }
+  rb_ary_push(queue->items, value);
+  return self;
+}
+
+struct ev_loop *LibevAgent_ev_loop(VALUE self);
+
+void async_queue_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+  struct async_watcher *watcher = (struct async_watcher *)ev_async;
+  Fiber_make_runnable(watcher->fiber, Qnil);
+}
+
+VALUE libev_agent_await(VALUE self);
+
+VALUE LibevQueue_shift(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  if (RARRAY_LEN(queue->items) == 0) {
+    struct async_watcher watcher;
+    VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+    VALUE switchpoint_result = Qnil;
+
+    watcher.ev_loop = LibevAgent_ev_loop(agent);
+    watcher.fiber = rb_fiber_current();    
+    async_queue_push(&queue->shift_queue, &watcher);
+    ev_async_init(&watcher.async, async_queue_callback);
+    ev_async_start(watcher.ev_loop, &watcher.async);
+    
+    switchpoint_result = libev_agent_await(agent);
+    ev_async_stop(watcher.ev_loop, &watcher.async);
+
+    if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException))) {
+      async_queue_remove_by_fiber(&queue->shift_queue, watcher.fiber);
+      return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+    }
+    RB_GC_GUARD(watcher.fiber);
+    RB_GC_GUARD(agent);
+    RB_GC_GUARD(switchpoint_result);
+  }
+
+  return rb_ary_shift(queue->items);
+}
+
+VALUE LibevQueue_shift_each(VALUE self) {
+  LibevQueue_t *queue;
+  VALUE old_queue;
+  GetQueue(self, queue);
+  old_queue = queue->items;
+  queue->items = rb_ary_new();
+
+  if (rb_block_given_p()) {
+    long len = RARRAY_LEN(old_queue);
+    long i;
+    for (i = 0; i < len; i++) {
+      rb_yield(RARRAY_AREF(old_queue, i));
+    }
+    RB_GC_GUARD(old_queue);
+    return self;
+  }
+  else {
+    RB_GC_GUARD(old_queue);
+    return old_queue;
+  }
+}
+
+VALUE LibevQueue_empty_p(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  return (RARRAY_LEN(queue->items) == 0) ? Qtrue : Qfalse;
+}
+
+void Init_LibevQueue() {
+  cLibevQueue = rb_define_class_under(mPolyphony, "LibevQueue", rb_cData);
+  rb_define_alloc_func(cLibevQueue, LibevQueue_allocate);
+
+  rb_define_method(cLibevQueue, "initialize", LibevQueue_initialize, 0);
+  rb_define_method(cLibevQueue, "push", LibevQueue_push, 1);
+  rb_define_method(cLibevQueue, "<<", LibevQueue_push, 1);
+
+  rb_define_method(cLibevQueue, "pop", LibevQueue_shift, 0);
+  rb_define_method(cLibevQueue, "shift", LibevQueue_shift, 0);
+
+  rb_define_method(cLibevQueue, "shift_each", LibevQueue_shift_each, 0);
+  rb_define_method(cLibevQueue, "empty?", LibevQueue_empty_p, 0);
+}
+
+

data/ext/polyphony/polyphony.c

@@ -0,0 +1,73 @@
+#include "polyphony.h"
+
+VALUE mPolyphony;
+
+ID ID_await_no_raise;
+ID ID_call;
+ID ID_caller;
+ID ID_clear;
+ID ID_each;
+ID ID_inspect;
+ID ID_new;
+ID ID_raise;
+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;
+ID ID_transfer;
+ID ID_R;
+ID ID_W;
+ID ID_RW;
+
+VALUE Polyphony_snooze(VALUE self) {
+  VALUE ret;
+  VALUE fiber = rb_fiber_current();
+
+  Fiber_make_runnable(fiber, Qnil);
+  ret = Thread_switch_fiber(rb_thread_current());
+  TEST_RESUME_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+static VALUE Polyphony_suspend(VALUE self) {
+  VALUE ret = Thread_switch_fiber(rb_thread_current());
+
+  TEST_RESUME_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+VALUE Polyphony_trace(VALUE self, VALUE enabled) {
+  __tracing_enabled__ = RTEST(enabled) ? 1 : 0;
+  return Qnil;
+}
+
+void Init_Polyphony() {
+  mPolyphony = rb_define_module("Polyphony");
+
+  rb_define_singleton_method(mPolyphony, "trace", Polyphony_trace, 1);
+
+  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");
+  ID_each           = rb_intern("each");
+  ID_inspect        = rb_intern("inspect");
+  ID_ivar_running   = rb_intern("@running");
+  ID_ivar_thread    = rb_intern("@thread");
+  ID_new            = rb_intern("new");
+  ID_raise          = rb_intern("raise");
+  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");
+  ID_transfer       = rb_intern("transfer");
+}

data/ext/{gyro/gyro.h → polyphony/polyphony.h}

@@ -7,28 +7,29 @@
 
 // debugging
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
-#define INSPECT(...) (rb_funcall(rb_cObject, rb_intern("p"), __VA_ARGS__))
+#define INSPECT(obj) { VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf("%s\n", StringValueCStr(s));}
 #define FIBER_TRACE(...) if (__tracing_enabled__) { \
   rb_funcall(rb_cObject, ID_fiber_trace, __VA_ARGS__); \
 }
 
+#define TEST_EXCEPTION(ret) (RTEST(rb_obj_is_kind_of(ret, rb_eException)))
+
 #define TEST_RESUME_EXCEPTION(ret) if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) { \
   return rb_funcall(rb_mKernel, ID_raise, 1, ret); \
 }
 
-extern VALUE mGyro;
-extern VALUE cGyro_Async;
-extern VALUE cGyro_IO;
-extern VALUE cGyro_Queue;
-extern VALUE cGyro_Selector;
-extern VALUE cGyro_Timer;
+extern VALUE mPolyphony;
+extern VALUE cLibevQueue;
+extern VALUE cEvent;
 
+extern ID ID_await_no_raise;
 extern ID ID_call;
 extern ID ID_caller;
 extern ID ID_clear;
 extern ID ID_each;
 extern ID ID_fiber_trace;
 extern ID ID_inspect;
+extern ID ID_ivar_agent;
 extern ID ID_ivar_running;
 extern ID ID_ivar_thread;
 extern ID ID_new;
@@ -39,9 +40,6 @@ extern ID ID_signal;
 extern ID ID_size;
 extern ID ID_switch_fiber;
 extern ID ID_transfer;
-extern ID ID_R;
-extern ID ID_W;
-extern ID ID_RW;
 
 extern VALUE SYM_fiber_create;
 extern VALUE SYM_fiber_ev_loop_enter;
@@ -65,43 +63,25 @@ enum {
   GYRO_WATCHER_POST_FORK = 0xFF
 };
 
-VALUE Fiber_auto_async(VALUE self);
-VALUE Fiber_auto_io(VALUE self);
+VALUE Fiber_auto_watcher(VALUE self);
 void Fiber_make_runnable(VALUE fiber, VALUE value);
 
-VALUE Gyro_Async_await(VALUE async);
-VALUE Gyro_Async_await_no_raise(VALUE async);
-
-VALUE Gyro_IO_auto_io(int fd, int events);
-VALUE Gyro_IO_await(VALUE self);
-
-void Gyro_Selector_add_active_watcher(VALUE self, VALUE watcher);
-VALUE Gyro_Selector_break_out_of_ev_loop(VALUE self);
-struct ev_loop *Gyro_Selector_current_thread_ev_loop();
-struct ev_loop *Gyro_Selector_ev_loop(VALUE selector);
-ev_tstamp Gyro_Selector_now(VALUE selector);
-long Gyro_Selector_pending_count(VALUE self);
-VALUE Gyro_Selector_post_fork(VALUE self);
-void Gyro_Selector_remove_active_watcher(VALUE self, VALUE watcher);
-VALUE Gyro_Selector_run(VALUE self, VALUE current_fiber);
-void Gyro_Selector_run_no_wait(VALUE self, VALUE current_fiber, long runnable_count);
-VALUE Gyro_switchpoint();
-
+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 Gyro_snooze(VALUE self);
-VALUE Gyro_Timer_await(VALUE self);
+VALUE LibevAgent_ref(VALUE self);
+VALUE LibevAgent_unref(VALUE self);
+int LibevAgent_ref_count(VALUE self);
+void LibevAgent_reset_ref_count(VALUE self);
 
-VALUE IO_read_watcher(VALUE io);
-VALUE IO_write_watcher(VALUE io);
+VALUE Polyphony_snooze(VALUE self);
 
-VALUE Gyro_Queue_push(VALUE self, VALUE value);
+VALUE Polyphony_Queue_push(VALUE self, VALUE value);
 
-VALUE Thread_current_event_selector();
-VALUE Thread_post_fork(VALUE thread);
-VALUE Thread_ref(VALUE thread);
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);
-VALUE Thread_unref(VALUE thread);
 
 int io_setstrbuf(VALUE *str, long len);
 void io_set_read_length(VALUE str, long n, int shrinkable);

data/ext/polyphony/polyphony_ext.c

@@ -0,0 +1,21 @@
+#include "polyphony.h"
+
+void Init_Fiber();
+void Init_Polyphony();
+void Init_LibevAgent();
+void Init_LibevQueue();
+void Init_Thread();
+void Init_Tracing();
+
+void Init_polyphony_ext() {
+  ev_set_allocator(xrealloc);
+
+  Init_Polyphony();
+  Init_LibevAgent();
+  Init_LibevQueue();
+
+  Init_Fiber();
+  Init_Thread();
+
+  Init_Tracing();
+}

data/ext/polyphony/thread.c

@@ -0,0 +1,200 @@
+#include "polyphony.h"
+
+ID ID_deactivate_all_watchers_post_fork;
+ID ID_ivar_agent;
+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_stop;
+
+static VALUE Thread_setup_fiber_scheduling(VALUE self) {
+  VALUE queue;
+  
+  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;
+}
+
+int Thread_fiber_ref_count(VALUE self) {
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  return NUM2INT(LibevAgent_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);
+}
+
+static VALUE SYM_scheduled_fibers;
+static VALUE SYM_pending_watchers;
+
+static VALUE Thread_fiber_scheduling_stats(VALUE self) {
+  VALUE agent = rb_ivar_get(self,ID_ivar_agent);
+  VALUE stats = rb_hash_new();
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  long pending_count;
+
+  long scheduled_count = RARRAY_LEN(queue);
+  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
+
+  pending_count = LibevAgent_pending_count(agent);
+  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
+
+  return stats;
+}
+
+VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
+  VALUE queue;
+
+  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;
+  }
+
+  queue = rb_ivar_get(self, ID_run_queue);
+  rb_ary_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);
+    LibevAgent_break(agent);
+  }
+  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;
+
+  FIBER_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) {
+    rb_ary_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);
+
+  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 agent = rb_ivar_get(self, ID_ivar_agent);
+    LibevAgent_break(agent);
+  }
+  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 agent = rb_ivar_get(self, ID_ivar_agent);
+  int ref_count;
+
+  if (__tracing_enabled__) {
+    if (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse) {
+      rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_switchpoint, current_fiber);
+    }
+  }
+
+  ref_count = LibevAgent_ref_count(agent);
+  while (1) {
+    next_fiber = rb_ary_shift(queue);
+    if (next_fiber != Qnil) {
+      if (ref_count > 0) {
+        // this mechanism prevents event starvation in case the run queue never
+        // empties
+        LibevAgent_poll(agent, Qtrue, current_fiber, queue);
+      }
+      break;
+    }
+    if (ref_count == 0) break;
+
+    LibevAgent_poll(agent, Qnil, current_fiber, queue);
+  }
+
+  if (next_fiber == Qnil) return Qnil;
+
+  // run next fiber
+  value = rb_ivar_get(next_fiber, ID_runnable_value);
+  FIBER_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);
+}
+
+VALUE Thread_reset_fiber_scheduling(VALUE self) {
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  rb_ary_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 agent = rb_ivar_get(self, ID_ivar_agent);
+  if (fiber != Qnil) {
+    Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
+  }
+
+  if (LibevAgent_break(agent) == Qnil) {
+    // we're not inside the ev_loop, so we just do a switchpoint
+    Thread_switch_fiber(self);
+  }
+
+  return self;
+}
+
+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_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);
+
+  ID_deactivate_all_watchers_post_fork = rb_intern("deactivate_all_watchers_post_fork");
+  ID_ivar_agent               = rb_intern("@agent");
+  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");
+
+  SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));
+  SYM_pending_watchers = ID2SYM(rb_intern("pending_watchers"));
+  rb_global_variable(&SYM_scheduled_fibers);
+  rb_global_variable(&SYM_pending_watchers);
+}