polyphony 0.26 → 0.27

data/ext/gyro/child.c

@@ -2,6 +2,7 @@
 
 struct Gyro_Child {
   struct  ev_child ev_child;
+  struct  ev_loop *ev_loop;
   int     active;
   int     pid;
   VALUE   self;
@@ -10,26 +11,23 @@ struct Gyro_Child {
 
 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_await(VALUE self);
-
-void Gyro_Child_callback(struct ev_loop *ev_loop, struct ev_child *child, int revents);
+static void Gyro_Child_mark(void *ptr) {
+  struct Gyro_Child *child = ptr;
+  if (child->fiber != Qnil) {
+    rb_gc_mark(child->fiber);
+  }
+}
 
-/* 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);
+static void Gyro_Child_free(void *ptr) {
+  struct Gyro_Child *child = ptr;
+  if (child->active) {
+    printf("Child watcher garbage collected while still active!\n");
+  }
+  xfree(child);
+}
 
-  rb_define_method(cGyro_Child, "initialize", Gyro_Child_initialize, 1);
-  rb_define_method(cGyro_Child, "await", Gyro_Child_await, 0);
+static size_t Gyro_Child_size(const void *ptr) {
+  return sizeof(struct Gyro_Child);
 }
 
 static const rb_data_type_t Gyro_Child_type = {
@@ -44,23 +42,22 @@ static VALUE Gyro_Child_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Gyro_Child_type, child);
 }
 
-static void Gyro_Child_mark(void *ptr) {
-  struct Gyro_Child *child = ptr;
+void Gyro_Child_callback(struct ev_loop *ev_loop, struct ev_child *ev_child, int revents) {
+  struct Gyro_Child *child = (struct Gyro_Child*)ev_child;
+
+  child->active = 0;
+  ev_child_stop(child->ev_loop, ev_child);
+
   if (child->fiber != Qnil) {
-    rb_gc_mark(child->fiber);
-  }
-}
+    VALUE fiber = child->fiber;
+    int exit_status = ev_child->rstatus >> 8; // weird, why should we do this?
 
-static void Gyro_Child_free(void *ptr) {
-  struct Gyro_Child *child = ptr;
-  if (child->active) {
-    ev_child_stop(EV_DEFAULT, &child->ev_child);
+    VALUE resume_value = rb_ary_new_from_args(
+      2, INT2NUM(ev_child->rpid), INT2NUM(exit_status)
+    );
+    child->fiber = Qnil;
+    Gyro_schedule_fiber(fiber, resume_value);
   }
-  xfree(child);
-}
-
-static size_t Gyro_Child_size(const void *ptr) {
-  return sizeof(struct Gyro_Child);
 }
 
 #define GetGyro_Child(obj, child) \
@@ -81,46 +78,40 @@ static VALUE Gyro_Child_initialize(VALUE self, VALUE pid) {
   return Qnil;
 }
 
-void Gyro_Child_callback(struct ev_loop *ev_loop, struct ev_child *ev_child, int revents) {
-  struct Gyro_Child *child = (struct Gyro_Child*)ev_child;
-
-  child->active = 0;
-  ev_child_stop(EV_DEFAULT, ev_child);
-
-  if (child->fiber != Qnil) {
-    VALUE fiber = child->fiber;
-    int exit_status = ev_child->rstatus >> 8; // weird, why should we do this?
-
-    VALUE resume_value = rb_ary_new_from_args(
-      2, INT2NUM(ev_child->rpid), INT2NUM(exit_status)
-    );
-    child->fiber = Qnil;
-    Gyro_schedule_fiber(fiber, resume_value);
-  }
-}
-
 static VALUE Gyro_Child_await(VALUE self) {
   struct Gyro_Child *child;
   VALUE ret;
   
   GetGyro_Child(self, child);
 
-  child->fiber = rb_fiber_current();
+  if (child->active)
   child->active = 1;
-  ev_child_start(EV_DEFAULT, &child->ev_child);
+  child->fiber = rb_fiber_current();
+  child->ev_loop = Gyro_Selector_current_thread_ev_loop();
+  ev_child_start(child->ev_loop, &child->ev_child);
+
+  ret = Fiber_await();
+  RB_GC_GUARD(ret);
 
-  ret = Gyro_await();
+  if (child->active) {
+    child->active = 0;
+    child->fiber = Qnil;
+    ev_child_stop(child->ev_loop, &child->ev_child);
+  }
 
   // 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);
-    }
     return rb_funcall(rb_mKernel, ID_raise, 1, ret);
   }
   else {
     return ret;
   }
-}
+}
+
+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, "await", Gyro_Child_await, 0);
+}

data/ext/gyro/gyro.c

@@ -1,138 +1,49 @@
 #include "gyro.h"
 
-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_run(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 void Gyro_clear_scheduled_fibers();
-
 VALUE mGyro;
 
-int break_flag = 0;
-int ref_count = 0;
-
-static VALUE scheduled_head;
-static VALUE scheduled_tail;
-
 ID ID_call;
 ID ID_caller;
 ID ID_clear;
 ID ID_each;
 ID ID_inspect;
+ID ID_new;
 ID ID_raise;
-ID ID_running;
+ID ID_ivar_running;
 ID ID_scheduled;
-ID ID_scheduled_next;
 ID ID_scheduled_value;
+ID ID_size;
+ID ID_signal_bang;
+ID ID_switch_fiber;
 ID ID_transfer;
 ID ID_R;
 ID ID_W;
 ID ID_RW;
 
-VALUE SYM_DEAD;
-VALUE SYM_RUNNING;
-VALUE SYM_SCHEDULED;
-VALUE SYM_SUSPENDED;
-
-void Init_Gyro() {
-  mGyro = rb_define_module("Gyro");
-
-  rb_define_singleton_method(mGyro, "ref", Gyro_ref, 0);
-  rb_define_singleton_method(mGyro, "unref", Gyro_unref, 0);
-
-  rb_define_singleton_method(mGyro, "run", Gyro_run, 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);
-
-  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_raise            = rb_intern("raise");
-  ID_running          = rb_intern("@running");
-  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_R                = rb_intern("r");
-  ID_W                = rb_intern("w");
-  ID_RW               = rb_intern("rw");
-
-  SYM_DEAD = ID2SYM(rb_intern("dead"));
-  SYM_RUNNING = ID2SYM(rb_intern("running"));
-  SYM_SCHEDULED = ID2SYM(rb_intern("scheduled"));
-  SYM_SUSPENDED = ID2SYM(rb_intern("suspended"));
-  rb_global_variable(&SYM_DEAD);
-  rb_global_variable(&SYM_RUNNING);
-  rb_global_variable(&SYM_SCHEDULED);
-  rb_global_variable(&SYM_SUSPENDED);
-
-  scheduled_head = Qnil;
-  scheduled_tail = Qnil;
-  rb_global_variable(&scheduled_head);
-}
-
-static VALUE Gyro_ref(VALUE self) {
-  Gyro_ref_count_incr();
-  return Qnil;
-}
-
-static VALUE Gyro_unref(VALUE self) {
-  Gyro_ref_count_decr();
-  return Qnil;
-}
-
-static VALUE Gyro_run(VALUE self) {
-  return Gyro_run_next_fiber();
-}
+ID ID_empty;
+ID ID_pop;
+ID ID_push;
 
-static VALUE Gyro_reset(VALUE self) {
-  break_flag = 0;
-  ref_count = 0;
+VALUE SYM_dead;
+VALUE SYM_running;
+VALUE SYM_scheduled;
+VALUE SYM_suspended;
 
-  Gyro_clear_scheduled_fibers();
-  return Qnil;
-}
+// static VALUE Gyro_break_set(VALUE self) {
+//   break_flag = 1;
+//   ev_break(EV_DEFAULT, EVBREAK_ALL);
+//   return Qnil;
+// }
 
-static VALUE Gyro_break_set(VALUE self) {
-  break_flag = 1;
-  ev_break(EV_DEFAULT, EVBREAK_ALL);
-  return Qnil;
-}
-
-static VALUE Gyro_break_get(VALUE self) {
-  return (break_flag == 0) ? Qfalse : Qtrue;
-}
+// static VALUE Gyro_break_get(VALUE self) {
+//   return (break_flag == 0) ? Qfalse : Qtrue;
+// }
 
 VALUE Gyro_snooze(VALUE self) {
   VALUE fiber = rb_fiber_current();
   Gyro_schedule_fiber(fiber, Qnil);
 
-  VALUE ret = Gyro_run_next_fiber();
+  VALUE ret = Thread_switch_fiber(rb_thread_current());
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException)))
     return rb_funcall(rb_mKernel, ID_raise, 1, ret);
   else
@@ -140,18 +51,22 @@ VALUE Gyro_snooze(VALUE self) {
 }
 
 static VALUE Gyro_post_fork(VALUE self) {
-  ev_loop_fork(EV_DEFAULT);
-  break_flag = 0;
-  ref_count = 0;
-  
-  Gyro_clear_scheduled_fibers();
-
+  Thread_post_fork(rb_thread_current());
   return Qnil;
 }
 
+static VALUE Gyro_ref(VALUE self) {
+  return Thread_ref(rb_thread_current());
+}
+
+static VALUE Gyro_unref(VALUE self) {
+  return Thread_unref(rb_thread_current());
+}
+
 static VALUE Gyro_suspend(VALUE self) {
   rb_ivar_set(self, ID_scheduled_value, Qnil);
-  VALUE ret = Gyro_run_next_fiber();
+  VALUE ret = Thread_switch_fiber(rb_thread_current());
+  
   if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
     return rb_funcall(rb_mKernel, ID_raise, 1, ret);
   }
@@ -176,93 +91,70 @@ static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
 }
 
 static VALUE Fiber_state(VALUE self) {
-  if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_running) == Qfalse))
-    return SYM_DEAD;
-  if (rb_fiber_current() == self) return SYM_RUNNING;
-  if (rb_ivar_get(self, ID_scheduled) != Qnil) return SYM_SCHEDULED;
+  if (!rb_fiber_alive_p(self) || (rb_ivar_get(self, ID_ivar_running) == Qfalse))
+    return SYM_dead;
+  if (rb_fiber_current() == self) return SYM_running;
+  if (rb_ivar_get(self, ID_scheduled) != Qnil) return SYM_scheduled;
   
-  return SYM_SUSPENDED;
-}
-
-VALUE Gyro_await() {
-  Gyro_ref_count_incr();
-  VALUE ret = Gyro_run_next_fiber();
-  Gyro_ref_count_decr();
-  return ret;
-}
-
-VALUE Gyro_run_next_fiber() {
-  while (1) {
-    if (break_flag != 0) {
-      return Qnil;
-    }
-    if ((scheduled_head != Qnil) || (ref_count == 0)) {
-      break;
-    }
-    ev_run(EV_DEFAULT, EVRUN_ONCE);
-  }
-
-  // return if no fiber is scheduled
-  if (scheduled_head == Qnil) {
-    return Qnil;
-  }
-
-  // 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;
-  }
-
-  if (rb_fiber_alive_p(next_fiber) != Qtrue) {
-    return Qnil;
-  }
-
-  // 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);
+  return SYM_suspended;
 }
 
-void Gyro_schedule_fiber(VALUE fiber, VALUE value) {
+inline 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;
-  }
+  Thread_schedule_fiber(rb_thread_current(), fiber);
 }
 
-int Gyro_ref_count() {
-  return ref_count;
-}
+void Init_Gyro() {
+  mGyro = rb_define_module("Gyro");
 
-void Gyro_ref_count_incr() {
-  ref_count += 1;
-}
+  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, "unref", Gyro_unref, 0);
 
-void Gyro_ref_count_decr() {
-  ref_count -= 1;
-}
+  // rb_define_singleton_method(mGyro, "break!", Gyro_break_set, 0);
+  // rb_define_singleton_method(mGyro, "break?", Gyro_break_get, 0);
 
-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);
-  }
-  scheduled_tail = Qnil;
+  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);
+
+  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_new              = rb_intern("new");
+  ID_raise            = rb_intern("raise");
+  ID_ivar_running          = rb_intern("@running");
+  ID_scheduled        = rb_intern("scheduled");
+  ID_scheduled_value  = rb_intern("scheduled_value");
+  ID_size             = rb_intern("size");
+  ID_signal_bang      = rb_intern("signal!");
+  ID_switch_fiber     = rb_intern("switch_fiber");
+  ID_transfer         = rb_intern("transfer");
+  ID_R                = rb_intern("r");
+  ID_W                = rb_intern("w");
+  ID_RW               = rb_intern("rw");
+
+  ID_empty            = rb_intern("empty?");
+  ID_pop              = rb_intern("pop");
+  ID_push             = rb_intern("push");
+
+  SYM_dead = ID2SYM(rb_intern("dead"));
+  SYM_running = ID2SYM(rb_intern("running"));
+  SYM_scheduled = ID2SYM(rb_intern("scheduled"));
+  SYM_suspended = ID2SYM(rb_intern("suspended"));
+  rb_global_variable(&SYM_dead);
+  rb_global_variable(&SYM_running);
+  rb_global_variable(&SYM_scheduled);
+  rb_global_variable(&SYM_suspended);
 }