polyphony 0.19 → 0.20

data/ext/gyro/child.c

@@ -0,0 +1,167 @@
+#include "gyro.h"
+
+struct Gyro_Child {
+  struct  ev_child ev_child;
+  int     active;
+  int     pid;
+  VALUE   self;
+  VALUE   callback;
+  VALUE   fiber;
+};
+
+static VALUE cGyro_Child = Qnil;
+
+/* Allocator/deallocator */
+static VALUE Gyro_Child_allocate(VALUE klass);
+static void Gyro_Child_mark(void *ptr);
+static void Gyro_Child_free(void *ptr);
+static size_t Gyro_Child_size(const void *ptr);
+
+/* Methods */
+static VALUE Gyro_Child_initialize(VALUE self, VALUE pid);
+
+static VALUE Gyro_Child_start(VALUE self);
+static VALUE Gyro_Child_stop(VALUE self);
+static VALUE Gyro_Child_await(VALUE self);
+
+void Gyro_Child_callback(struct ev_loop *ev_loop, struct ev_child *child, int revents);
+
+/* Child encapsulates an child watcher */
+void Init_Gyro_Child() {
+  cGyro_Child = rb_define_class_under(mGyro, "Child", rb_cData);
+  rb_define_alloc_func(cGyro_Child, Gyro_Child_allocate);
+
+  rb_define_method(cGyro_Child, "initialize", Gyro_Child_initialize, 1);
+  rb_define_method(cGyro_Child, "start", Gyro_Child_start, 0);
+  rb_define_method(cGyro_Child, "stop", Gyro_Child_stop, 0);
+  rb_define_method(cGyro_Child, "await", Gyro_Child_await, 0);
+}
+
+static const rb_data_type_t Gyro_Child_type = {
+    "Gyro_Child",
+    {Gyro_Child_mark, Gyro_Child_free, Gyro_Child_size,},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE Gyro_Child_allocate(VALUE klass) {
+  struct Gyro_Child *child = (struct Gyro_Child *)xmalloc(sizeof(struct Gyro_Child));
+  return TypedData_Wrap_Struct(klass, &Gyro_Child_type, child);
+}
+
+static void Gyro_Child_mark(void *ptr) {
+  struct Gyro_Child *child = ptr;
+  if (child->callback != Qnil) {
+    rb_gc_mark(child->callback);
+  }
+  if (child->fiber != Qnil) {
+    rb_gc_mark(child->fiber);
+  }
+}
+
+static void Gyro_Child_free(void *ptr) {
+  struct Gyro_Child *child = ptr;
+  if (child->active) {
+    ev_child_stop(EV_DEFAULT, &child->ev_child);
+  }
+  xfree(child);
+}
+
+static size_t Gyro_Child_size(const void *ptr) {
+  return sizeof(struct Gyro_Child);
+}
+
+#define GetGyro_Child(obj, child) \
+  TypedData_Get_Struct((obj), struct Gyro_Child, &Gyro_Child_type, (child))
+
+static VALUE Gyro_Child_initialize(VALUE self, VALUE pid) {
+  struct Gyro_Child *child;
+
+  GetGyro_Child(self, child);
+
+  child->self     = self;
+  child->callback = Qnil;
+  child->fiber    = Qnil;
+  child->pid      = NUM2INT(pid);
+  child->active   = 0;
+  
+  ev_child_init(&child->ev_child, Gyro_Child_callback, child->pid, 0);
+
+  return Qnil;
+}
+
+void Gyro_Child_callback(struct ev_loop *ev_loop, struct ev_child *ev_child, int revents) {
+  VALUE fiber;
+  VALUE resume_value;
+  struct Gyro_Child *child = (struct Gyro_Child*)ev_child;
+  resume_value = INT2NUM(child->pid);
+
+  child->active = 0;
+  ev_child_stop(EV_DEFAULT, ev_child);
+  Gyro_del_watcher_ref(child->self);
+
+  if (child->fiber != Qnil) {
+    fiber = child->fiber;
+    child->fiber = Qnil;
+    SCHEDULE_FIBER(fiber, 1, resume_value);
+  }
+  else if (child->callback != Qnil) {
+    rb_funcall(child->callback, ID_call, 1, resume_value);
+  }
+}
+
+static VALUE Gyro_Child_start(VALUE self) {
+  struct Gyro_Child *child;
+  GetGyro_Child(self, child);
+
+  if (rb_block_given_p()) {
+    child->callback = rb_block_proc();
+  }
+
+  if (!child->active) {
+    ev_child_start(EV_DEFAULT, &child->ev_child);
+    child->active = 1;
+    Gyro_add_watcher_ref(self);
+  }
+
+  return self;
+}
+
+static VALUE Gyro_Child_stop(VALUE self) {
+  struct Gyro_Child *child;
+  GetGyro_Child(self, child);
+
+  if (child->active) {
+    ev_child_stop(EV_DEFAULT, &child->ev_child);
+    child->active = 0;
+    Gyro_del_watcher_ref(self);
+  }
+
+  return self;
+}
+
+static VALUE Gyro_Child_await(VALUE self) {
+  struct Gyro_Child *child;
+  VALUE ret;
+  
+  GetGyro_Child(self, child);
+
+  child->fiber = rb_fiber_current();
+  child->active = 1;
+  ev_child_start(EV_DEFAULT, &child->ev_child);
+  Gyro_add_watcher_ref(self);
+
+  ret = YIELD_TO_REACTOR();
+
+  // fiber is resumed, check if resumed value is an exception
+  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
+    if (child->active) {
+      child->active = 0;
+      ev_child_stop(EV_DEFAULT, &child->ev_child);
+    }
+    return rb_funcall(ret, ID_raise, 1, ret);
+  }
+  else {
+    return ret;
+  }
+}

data/ext/{ev → gyro}/extconf.rb

@@ -6,6 +6,7 @@ require "mkmf"
 
 have_header("unistd.h")
 
+$defs << "-DEV_USE_LINUXAIO"     if have_header("linux/aio_abi.h")
 $defs << "-DEV_USE_SELECT"       if have_header("sys/select.h")
 $defs << "-DEV_USE_POLL"         if have_type("port_event_t", "poll.h")
 $defs << "-DEV_USE_EPOLL"        if have_header("sys/epoll.h")
@@ -13,7 +14,7 @@ $defs << "-DEV_USE_KQUEUE"       if have_header("sys/event.h") && have_header("s
 $defs << "-DEV_USE_PORT"         if have_type("port_event_t", "port.h")
 $defs << "-DHAVE_SYS_RESOURCE_H" if have_header("sys/resource.h")
 
-CONFIG["optflags"] << " -fno-strict-aliasing"
+CONFIG["optflags"] << " -fno-strict-aliasing" unless RUBY_PLATFORM =~ /mswin/
 
-dir_config "ev_ext"
-create_makefile "ev_ext"
+dir_config "gyro_ext"
+create_makefile "gyro_ext"

data/ext/gyro/gyro.c

@@ -0,0 +1,316 @@
+#include "gyro.h"
+
+static VALUE Gyro_run(VALUE self);
+static VALUE Gyro_break(VALUE self);
+static VALUE Gyro_start(VALUE self);
+static VALUE Gyro_restart(VALUE self);
+
+static VALUE Gyro_ref(VALUE self);
+static VALUE Gyro_unref(VALUE self);
+
+static VALUE Gyro_defer(VALUE self);
+static VALUE Gyro_post_fork(VALUE self);
+
+static VALUE Gyro_suspend(VALUE self);
+
+static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self);
+static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self);
+
+void Gyro_defer_callback(struct ev_loop *ev_loop, struct ev_idle *watcher, int revents);
+
+VALUE mGyro;
+
+VALUE Gyro_reactor_fiber;
+VALUE Gyro_root_fiber;
+VALUE Gyro_post_run_fiber;
+
+static VALUE watcher_refs;
+static VALUE deferred_head;
+static VALUE deferred_tail;
+static VALUE deferred_eol_marker;
+
+static struct ev_idle idle_watcher;
+static int deferred_active;
+static int deferred_in_callback;
+static int break_flag;
+
+ID ID_call;
+ID ID_caller;
+ID ID_clear;
+ID ID_deferred_next;
+ID ID_deferred_prev;
+ID ID_each;
+ID ID_inspect;
+ID ID_raise;
+ID ID_read_watcher;
+ID ID_scheduled_value;
+ID ID_transfer;
+ID ID_write_watcher;
+ID ID_R;
+ID ID_W;
+ID ID_RW;
+
+void Init_Gyro() {
+  mGyro = rb_define_module("Gyro");
+
+  rb_define_singleton_method(mGyro, "break", Gyro_break, 0);
+  rb_define_singleton_method(mGyro, "defer", Gyro_defer, 0);
+  rb_define_singleton_method(mGyro, "post_fork", Gyro_post_fork, 0);
+  rb_define_singleton_method(mGyro, "ref", Gyro_ref, 0);
+  rb_define_singleton_method(mGyro, "start", Gyro_start, 0);
+  rb_define_singleton_method(mGyro, "restart", Gyro_restart, 0);
+  rb_define_singleton_method(mGyro, "snooze", Gyro_snooze, 0);
+  rb_define_singleton_method(mGyro, "unref", Gyro_unref, 0);
+
+  rb_define_global_function("defer", Gyro_defer, 0);
+  rb_define_global_function("snooze", Gyro_snooze, 0);
+  rb_define_global_function("suspend", Gyro_suspend, 0);
+
+  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);
+
+  ID_call             = rb_intern("call");
+  ID_caller           = rb_intern("caller");
+  ID_clear            = rb_intern("clear");
+  ID_deferred_next    = rb_intern("deferred_next");
+  ID_deferred_prev    = rb_intern("deferred_prev");
+  ID_each             = rb_intern("each");
+  ID_inspect          = rb_intern("inspect");
+  ID_raise            = rb_intern("raise");
+  ID_read_watcher     = rb_intern("read_watcher");
+  ID_scheduled_value  = rb_intern("@scheduled_value");
+  ID_transfer         = rb_intern("transfer");
+  ID_write_watcher    = rb_intern("write_watcher");
+  ID_R                = rb_intern("r");
+  ID_W                = rb_intern("w");
+  ID_RW               = rb_intern("rw");
+
+  Gyro_root_fiber = rb_fiber_current();
+  Gyro_reactor_fiber = rb_fiber_new(Gyro_run, Qnil);
+  rb_gv_set("__reactor_fiber__", Gyro_reactor_fiber);
+
+  watcher_refs = rb_hash_new();
+  rb_global_variable(&watcher_refs);
+
+  deferred_head = Qnil;
+  deferred_tail = Qnil;
+  rb_global_variable(&deferred_head);
+
+  deferred_eol_marker = rb_funcall(rb_cObject, rb_intern("new"), 0);
+  rb_global_variable(&deferred_eol_marker);
+
+  ev_idle_init(&idle_watcher, Gyro_defer_callback);
+  deferred_active = 0;
+  deferred_in_callback = 0;
+}
+
+static VALUE Gyro_run(VALUE self) {
+  break_flag = 0;
+  Gyro_post_run_fiber = Qnil;
+  ev_run(EV_DEFAULT, 0);
+  rb_gv_set("__reactor_fiber__", Qnil);
+
+  if (Gyro_post_run_fiber != Qnil) {
+    rb_funcall(Gyro_post_run_fiber, ID_transfer, 0);
+  }
+
+  return Qnil;
+}
+
+static VALUE Gyro_break(VALUE self) {
+  break_flag = 1;
+  // make sure reactor fiber is alive
+  if (!RTEST(rb_fiber_alive_p(Gyro_reactor_fiber))) {
+    return Qnil;
+  }
+
+  if (deferred_active) {
+    deferred_active = 0;
+    ev_idle_stop(EV_DEFAULT, &idle_watcher);
+  }
+  ev_break(EV_DEFAULT, EVBREAK_ALL);
+  YIELD_TO_REACTOR();
+  return Qnil;
+}
+
+static VALUE Gyro_start(VALUE self) {
+  Gyro_post_run_fiber = Qnil;
+  deferred_head = Qnil;
+  Gyro_reactor_fiber = rb_fiber_new(Gyro_run, Qnil);
+  rb_gv_set("__reactor_fiber__", Gyro_reactor_fiber);
+  return Qnil;
+}
+
+static VALUE Gyro_restart(VALUE self) {
+  Gyro_post_run_fiber = rb_fiber_current();
+  Gyro_break(self);
+  // control will be transferred back to here after reactor loop is done
+  Gyro_start(self);
+
+  return Qnil;
+}
+
+static VALUE Gyro_ref(VALUE self) {
+  ev_ref(EV_DEFAULT);
+  return Qnil;
+}
+
+static VALUE Gyro_unref(VALUE self) {
+  ev_unref(EV_DEFAULT);
+  return Qnil;
+}
+
+void Gyro_add_watcher_ref(VALUE obj) {
+  rb_hash_aset(watcher_refs, rb_obj_id(obj), obj);
+}
+
+void Gyro_del_watcher_ref(VALUE obj) {
+  rb_hash_delete(watcher_refs, rb_obj_id(obj));
+}
+
+static void defer_add(VALUE item) {
+  if (NIL_P(deferred_head)) {
+    deferred_head = item;
+    deferred_tail = item;
+    rb_ivar_set(item, ID_deferred_next, Qnil);
+    rb_ivar_set(item, ID_deferred_prev, Qnil);
+  }
+  else {
+    rb_ivar_set(deferred_tail, ID_deferred_next, item);
+    rb_ivar_set(item, ID_deferred_prev, deferred_tail);
+    deferred_tail = item;
+  }
+
+  if (!deferred_active) {
+    deferred_active = 1;
+    ev_idle_start(EV_DEFAULT, &idle_watcher);
+  }
+}
+
+static void defer_remove(VALUE item) {
+  VALUE next = rb_ivar_get(item, ID_deferred_next);
+  VALUE prev = rb_ivar_get(item, ID_deferred_prev);
+  if (RTEST(prev)) {
+    rb_ivar_set(prev, ID_deferred_next, next);
+  }
+  if (RTEST(next)) {
+    rb_ivar_set(next, ID_deferred_prev, prev);
+  }
+
+}
+
+static VALUE Gyro_defer(VALUE self) {
+  VALUE proc = rb_block_proc();
+  if (RTEST(proc)) {
+    defer_add(proc);
+  }
+  return Qnil;
+}
+
+VALUE Gyro_snooze(VALUE self) {
+  VALUE ret;
+  VALUE fiber = rb_fiber_current();
+  defer_add(fiber);
+
+  ret = YIELD_TO_REACTOR();
+  
+  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
+    defer_remove(fiber);
+    return rb_funcall(ret, ID_raise, 1, ret);
+  }
+  else {
+    return ret;
+  }
+}
+
+static VALUE Gyro_post_fork(VALUE self) {
+  ev_loop_fork(EV_DEFAULT);
+  
+  Gyro_reactor_fiber = rb_fiber_new(Gyro_run, Qnil);
+  rb_gv_set("__reactor_fiber__", Gyro_reactor_fiber);
+  Gyro_root_fiber = rb_fiber_current();
+
+  deferred_head = Qnil;
+  deferred_active = 0;
+
+  return Qnil;
+}
+
+VALUE run_deferred(VALUE item) {
+  if (rb_obj_is_proc(item)) {
+    rb_funcall(item, ID_call, 1, Qtrue);
+  }
+  else {
+    VALUE arg = rb_ivar_get(item, ID_scheduled_value);
+    if (RTEST(rb_obj_is_kind_of(arg, rb_eException))) {
+      rb_ivar_set(item, ID_scheduled_value, Qnil);
+    }
+    SCHEDULE_FIBER(item, 1, arg);
+  }
+  return Qnil;
+}
+
+void Gyro_defer_callback(struct ev_loop *ev_loop, struct ev_idle *watcher, int revents) {
+  deferred_in_callback = 1;
+  defer_add(deferred_eol_marker);
+  rb_ivar_set(deferred_eol_marker, ID_deferred_next, Qnil);
+
+  while (RTEST(deferred_head) && !break_flag) {
+    VALUE next = rb_ivar_get(deferred_head, ID_deferred_next);
+    if (deferred_head == deferred_eol_marker) {
+      deferred_head = next;
+      break;
+    }
+    run_deferred(deferred_head);
+    deferred_head = next;
+  }
+
+  if (NIL_P(deferred_head)) {
+    deferred_active = 0;
+    ev_idle_stop(EV_DEFAULT, &idle_watcher);
+  }
+
+  deferred_in_callback = 0;
+}
+
+static VALUE Gyro_suspend(VALUE self) {
+  if (!RTEST(rb_fiber_alive_p(Gyro_reactor_fiber))) {
+    return Qnil;
+  }
+
+  VALUE ret = YIELD_TO_REACTOR();
+
+  // fiber is resumed, check if resumed value is an exception
+  return RTEST(rb_obj_is_kind_of(ret, rb_eException)) ? 
+    rb_funcall(ret, ID_raise, 1, ret) : ret;
+}
+
+static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
+  VALUE arg = (argc == 0) ? Qnil : argv[0];
+  VALUE ret = rb_funcall(self, ID_transfer, 1, arg);
+
+  // fiber is resumed, check if resumed value is an exception
+  return RTEST(rb_obj_is_kind_of(ret, rb_eException)) ? 
+    rb_funcall(ret, ID_raise, 1, ret) : ret;
+}
+
+static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
+  VALUE arg = (argc == 0) ? Qnil : argv[0];
+  rb_ivar_set(self, ID_scheduled_value, arg);
+  if (deferred_in_callback) {
+    // if a fiber is scheduled while processing deferred items, we want to avoid
+    // adding the same fiber again to the list of deferred item, since this will
+    // fuck up the linked list refs, and also lead to a race condition. To do
+    // this, we search the deferred items linked list for the given fiber, and
+    // return without readding it if found.
+    VALUE next = deferred_head;
+    while (RTEST(next)) {
+      if (next == self) return self;
+      if (next == deferred_eol_marker) break;
+      next = rb_ivar_get(next, ID_deferred_next);
+    }
+  }
+  defer_add(self);
+  return self;
+}