polyphony 0.21 → 0.22

data/ext/gyro/child.c

@@ -82,19 +82,16 @@ static VALUE Gyro_Child_initialize(VALUE self, VALUE pid) {
 }
 
 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;
+    VALUE fiber = child->fiber;
+    VALUE resume_value = INT2NUM(child->pid);
     child->fiber = Qnil;
-    SCHEDULE_FIBER(fiber, 1, resume_value);
+    Gyro_schedule_fiber(fiber, resume_value);
   }
 }
 
@@ -107,12 +104,12 @@ static VALUE Gyro_Child_await(VALUE self) {
   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();
+  ret = Gyro_yield();
 
   // fiber is resumed, check if resumed value is an exception
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
+    printf("* child error\n");
     if (child->active) {
       child->active = 0;
       ev_child_stop(EV_DEFAULT, &child->ev_child);

data/ext/gyro/extconf.rb

@@ -16,5 +16,7 @@ $defs << "-DHAVE_SYS_RESOURCE_H" if have_header("sys/resource.h")
 
 CONFIG["optflags"] << " -fno-strict-aliasing" unless RUBY_PLATFORM =~ /mswin/
 
+CONFIG["optflags"] << " -Wcomment"
+
 dir_config "gyro_ext"
 create_makefile "gyro_ext"

data/ext/gyro/gyro.c

@@ -1,48 +1,40 @@
 #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_break_set(VALUE self);
+static VALUE Gyro_break_get(VALUE self);
 
 static VALUE Gyro_ref(VALUE self);
 static VALUE Gyro_unref(VALUE self);
 
-static VALUE Gyro_defer(VALUE self);
+static VALUE Gyro_reset(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);
+static VALUE Fiber_state(VALUE self);
+static VALUE Fiber_mark_as_done(VALUE self);
 
-void Gyro_defer_callback(struct ev_loop *ev_loop, struct ev_idle *watcher, int revents);
+static void Gyro_clear_scheduled_fibers();
 
 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;
+int break_flag = 0;
+int ref_count = 0;
 
-static struct ev_idle idle_watcher;
-static int deferred_active;
-static int deferred_in_callback;
-static int break_flag;
+static VALUE scheduled_head;
+static VALUE scheduled_tail;
 
 ID ID_call;
 ID ID_caller;
 ID ID_clear;
-ID ID_deferred_next;
-ID ID_deferred_prev;
+ID ID_done;
 ID ID_each;
 ID ID_inspect;
 ID ID_raise;
 ID ID_read_watcher;
+ID ID_scheduled;
+ID ID_scheduled_next;
 ID ID_scheduled_value;
 ID ID_transfer;
 ID ID_write_watcher;
@@ -50,267 +42,230 @@ ID ID_R;
 ID ID_W;
 ID ID_RW;
 
+VALUE SYM_DEAD;
+VALUE SYM_RUNNING;
+VALUE SYM_PAUSED;
+VALUE SYM_SCHEDULED;
+
 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_singleton_method(mGyro, "reset!", Gyro_reset, 0);
+  rb_define_singleton_method(mGyro, "post_fork", Gyro_post_fork, 0);
+  rb_define_singleton_method(mGyro, "snooze", Gyro_snooze, 0);
+
+  rb_define_singleton_method(mGyro, "break!", Gyro_break_set, 0);
+  rb_define_singleton_method(mGyro, "break?", Gyro_break_get, 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);
+  rb_define_method(cFiber, "state", Fiber_state, 0);
+  rb_define_method(cFiber, "mark_as_done!", Fiber_mark_as_done, 0);
 
   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_done             = rb_intern("done");
   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_scheduled        = rb_intern("scheduled");
+  ID_scheduled_next   = rb_intern("scheduled_next");
+  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);
+  SYM_DEAD = ID2SYM(rb_intern("dead"));
+  SYM_RUNNING = ID2SYM(rb_intern("running"));
+  SYM_PAUSED = ID2SYM(rb_intern("paused"));
+  SYM_SCHEDULED = ID2SYM(rb_intern("scheduled"));
+  rb_global_variable(&SYM_DEAD);
+  rb_global_variable(&SYM_RUNNING);
+  rb_global_variable(&SYM_PAUSED);
+  rb_global_variable(&SYM_SCHEDULED);
+
+  scheduled_head = Qnil;
+  scheduled_tail = Qnil;
+  rb_global_variable(&scheduled_head);
+}
 
-  deferred_eol_marker = rb_funcall(rb_cObject, rb_intern("new"), 0);
-  rb_global_variable(&deferred_eol_marker);
+static VALUE Gyro_ref(VALUE self) {
+  Gyro_ref_count_incr();
+  return Qnil;
+}
 
-  ev_idle_init(&idle_watcher, Gyro_defer_callback);
-  deferred_active = 0;
-  deferred_in_callback = 0;
+static VALUE Gyro_unref(VALUE self) {
+  Gyro_ref_count_decr();
+  return Qnil;
 }
 
-static VALUE Gyro_run(VALUE self) {
+static VALUE Gyro_reset(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);
-  }
+  ref_count = 0;
 
+  Gyro_clear_scheduled_fibers();
   return Qnil;
 }
 
-static VALUE Gyro_break(VALUE self) {
+static VALUE Gyro_break_set(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();
+  // printf("\n");
   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_break_get(VALUE self) {
+  return (break_flag == 0) ? Qfalse : Qtrue;
 }
 
-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);
+VALUE Gyro_snooze(VALUE self) {
+  VALUE fiber = rb_fiber_current();
+  Gyro_schedule_fiber(fiber, Qnil);
 
-  return Qnil;
+  VALUE ret = Gyro_run();
+  if (RTEST(rb_obj_is_kind_of(ret, rb_eException)))
+    return rb_funcall(ret, ID_raise, 1, ret);
+  else
+    return ret;
 }
 
-static VALUE Gyro_ref(VALUE self) {
-  ev_ref(EV_DEFAULT);
-  return Qnil;
-}
+static VALUE Gyro_post_fork(VALUE self) {
+  ev_loop_fork(EV_DEFAULT);
+  break_flag = 0;
+  ref_count = 0;
+  
+  Gyro_clear_scheduled_fibers();
 
-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 VALUE Gyro_suspend(VALUE self) {
+  VALUE ret = Gyro_run();
+  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
+    return rb_funcall(ret, ID_raise, 1, ret);
   }
+  else
+    return ret;
 }
 
-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 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 Gyro_defer(VALUE self) {
-  VALUE proc = rb_block_proc();
-  if (RTEST(proc)) {
-    defer_add(proc);
-  }
-  return Qnil;
+static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
+  VALUE value = (argc == 0) ? Qnil : argv[0];
+  Gyro_schedule_fiber(self, value);
+  return self;
 }
 
-VALUE Gyro_snooze(VALUE self) {
-  VALUE ret;
-  VALUE fiber = rb_fiber_current();
-  defer_add(fiber);
-
-  ret = YIELD_TO_REACTOR();
+static VALUE Fiber_state(VALUE self) {
+  if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_done) != Qnil))
+    return SYM_DEAD;
+  if (rb_fiber_current() == self) return SYM_RUNNING;
+  if (rb_ivar_get(self, ID_scheduled) != Qnil) return SYM_SCHEDULED;
   
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    defer_remove(fiber);
-    return rb_funcall(ret, ID_raise, 1, ret);
-  }
-  else {
-    return ret;
-  }
+  return SYM_PAUSED;
 }
 
-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;
+static VALUE Fiber_mark_as_done(VALUE self) {
+  rb_ivar_set(self, ID_done, Qtrue);
+  return self;
 }
 
-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;
+VALUE Gyro_yield() {
+  Gyro_ref_count_incr();
+  VALUE ret = Gyro_run();
+  Gyro_ref_count_decr();
+  return ret;
 }
 
-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;
+VALUE Gyro_run() {
+  while (1) {
+    if (break_flag != 0) {
+      return Qnil;
+    }
+    if ((scheduled_head != Qnil) || (ref_count == 0)) {
       break;
     }
-    run_deferred(deferred_head);
-    deferred_head = next;
+    ev_run(EV_DEFAULT, EVRUN_ONCE);
   }
 
-  if (NIL_P(deferred_head)) {
-    deferred_active = 0;
-    ev_idle_stop(EV_DEFAULT, &idle_watcher);
+  // return if no fiber is scheduled
+  if (scheduled_head == Qnil) {
+    return Qnil;
   }
 
-  deferred_in_callback = 0;
-}
+  // update scheduled linked list refs
+  VALUE next_fiber = scheduled_head;
+  VALUE next_next_fiber = rb_ivar_get(next_fiber, ID_scheduled_next);
+  rb_ivar_set(next_fiber, ID_scheduled_next, Qnil);
+  scheduled_head = next_next_fiber;
+  if (scheduled_head == Qnil) {
+    scheduled_tail = Qnil;
+  }
 
-static VALUE Gyro_suspend(VALUE self) {
-  if (!RTEST(rb_fiber_alive_p(Gyro_reactor_fiber))) {
+  if (rb_fiber_alive_p(next_fiber) != Qtrue)
     return Qnil;
-  }
 
-  VALUE ret = YIELD_TO_REACTOR();
+  // run next fiber
+  VALUE value = rb_ivar_get(next_fiber, ID_scheduled_value);
+  rb_ivar_set(next_fiber, ID_scheduled_value, Qnil);
+  rb_ivar_set(next_fiber, ID_scheduled, Qnil);
+  return rb_funcall(next_fiber, ID_transfer, 1, value);
+}
 
-  // 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;
+void Gyro_schedule_fiber(VALUE fiber, VALUE value) {
+  rb_ivar_set(fiber, ID_scheduled_value, value);
+  // if fiber is already scheduled, we just set the scheduled value, then return
+  if (rb_ivar_get(fiber, ID_scheduled) != Qnil)
+    return;
+
+  rb_ivar_set(fiber, ID_scheduled, Qtrue);
+
+  // put fiber on scheduled list
+  if (scheduled_head != Qnil) {
+    VALUE last = scheduled_tail;
+    rb_ivar_set(last, ID_scheduled_next, fiber);
+    scheduled_tail = fiber;
+  }
+  else {
+    scheduled_tail = scheduled_head = fiber;
+  }
 }
 
-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);
+int Gyro_ref_count() {
+  return ref_count;
+}
 
-  // 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;
+void Gyro_ref_count_incr() {
+  ref_count += 1;
 }
 
-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);
-    }
+void Gyro_ref_count_decr() {
+  ref_count -= 1;
+}
+
+static void Gyro_clear_scheduled_fibers() {
+  while (scheduled_head != Qnil) {
+    VALUE fiber = scheduled_head;
+    scheduled_head = rb_ivar_get(fiber, ID_scheduled_next);
+    rb_ivar_set(fiber, ID_scheduled_next, Qnil);
   }
-  defer_add(self);
-  return self;
+  scheduled_tail = Qnil;
 }

data/ext/gyro/gyro.h

@@ -5,10 +5,24 @@
 #include "ruby/io.h"
 #include "libev.h"
 
-void Gyro_add_watcher_ref(VALUE obj);
-void Gyro_del_watcher_ref(VALUE obj);
+enum {
+  FIBER_STATE_NOT_SCHEDULED = 0,
+  FIBER_STATE_WAITING       = 1,
+  FIBER_STATE_SCHEDULED     = 2
+};
+
+// void Gyro_add_watcher_ref(VALUE obj);
+// void Gyro_del_watcher_ref(VALUE obj);
 VALUE Gyro_snooze(VALUE self);
 
+VALUE Gyro_run();
+VALUE Gyro_yield();
+void Gyro_schedule_fiber(VALUE fiber, VALUE value);
+
+int Gyro_ref_count();
+void Gyro_ref_count_incr();
+void Gyro_ref_count_decr();
+
 VALUE IO_read_watcher(VALUE io);
 VALUE IO_write_watcher(VALUE io);
 VALUE Gyro_IO_await(VALUE self);
@@ -17,9 +31,6 @@ 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);
 
-#define SCHEDULE_FIBER(obj, args...) rb_funcall(obj, ID_transfer, args)
-#define YIELD_TO_REACTOR() rb_funcall(Gyro_reactor_fiber, ID_transfer, 0)
-
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
 
 extern VALUE mGyro;
@@ -32,7 +43,6 @@ extern ID ID_caller;
 extern ID ID_clear;
 extern ID ID_each;
 extern ID ID_inspect;
-extern ID ID_next_deferred;
 extern ID ID_raise;
 extern ID ID_read_watcher;
 extern ID ID_scheduled_value;

data/ext/gyro/io.c

@@ -102,18 +102,15 @@ static VALUE Gyro_IO_initialize(VALUE self, VALUE io_obj, VALUE event_mask) {
 }
 
 void Gyro_IO_callback(struct ev_loop *ev_loop, struct ev_io *ev_io, int revents) {
-  VALUE fiber;
   struct Gyro_IO *io = (struct Gyro_IO*)ev_io;
 
+  ev_io_stop(EV_DEFAULT, ev_io);
+  io->active = 0;
+
   if (io->fiber != Qnil) {
-    ev_io_stop(EV_DEFAULT, ev_io);
-    io->active = 0;
-    fiber = io->fiber;
+    VALUE fiber = io->fiber;
     io->fiber = Qnil;
-    SCHEDULE_FIBER(fiber, 0);
-  }
-  else {
-    ev_io_stop(EV_DEFAULT, ev_io);
+    Gyro_schedule_fiber(fiber, Qnil);
   }
 }
 
@@ -126,9 +123,10 @@ VALUE Gyro_IO_await(VALUE self) {
   io->fiber = rb_fiber_current();
   io->active = 1;
   ev_io_start(EV_DEFAULT, &io->ev_io);
-  ret = YIELD_TO_REACTOR();
+  ret = Gyro_yield();
 
   // make sure io watcher is stopped
+  io->fiber = Qnil;
   if (io->active) {
     io->active = 0;
     ev_io_stop(EV_DEFAULT, &io->ev_io);
@@ -376,7 +374,6 @@ static VALUE IO_write(int argc, VALUE *argv, VALUE io) {
         if (e == EWOULDBLOCK || e == EAGAIN) {
           if (write_watcher == Qnil)
             write_watcher = IO_write_watcher(io);
-            // write_watcher = rb_funcall(io, ID_write_watcher, 0);
           Gyro_IO_await(write_watcher);
         }
         else {

data/ext/gyro/signal.c

@@ -79,6 +79,7 @@ static VALUE Gyro_Signal_initialize(VALUE self, VALUE sig) {
   ev_signal_init(&signal->ev_signal, Gyro_Signal_callback, signal->signum);
 
   signal->active = 1;
+  Gyro_ref_count_incr();
   ev_signal_start(EV_DEFAULT, &signal->ev_signal);
 
   return Qnil;
@@ -97,6 +98,7 @@ static VALUE Gyro_Signal_start(VALUE self) {
   GetGyro_Signal(self, signal);
 
   if (!signal->active) {
+    Gyro_ref_count_incr();
     ev_signal_start(EV_DEFAULT, &signal->ev_signal);
     signal->active = 1;
   }
@@ -109,6 +111,7 @@ static VALUE Gyro_Signal_stop(VALUE self) {
   GetGyro_Signal(self, signal);
 
   if (signal->active) {
+    Gyro_ref_count_decr();
     ev_signal_stop(EV_DEFAULT, &signal->ev_signal);
     signal->active = 0;
   }