polyphony 0.34 → 0.36

data/examples/core/xx-timer-gc.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+timers = 10.times.map do
+  spin do
+    t = Gyro::Timer.new(1, 1)
+    t.await
+  end
+end
+
+sleep 0.1
+GC.start
+sleep 0.1

data/ext/gyro/async.c

@@ -4,8 +4,10 @@ struct Gyro_Async {
   struct  ev_async ev_async;
   struct  ev_loop *ev_loop;
   int     active;
+  VALUE   self;
   VALUE   fiber;
   VALUE   value;
+  VALUE   selector;
 };
 
 VALUE cGyro_Async = Qnil;
@@ -18,12 +20,16 @@ static void Gyro_Async_mark(void *ptr) {
   if (async->value != Qnil) {
     rb_gc_mark(async->value);
   }
+  if (async->selector != Qnil) {
+    rb_gc_mark(async->selector);
+  }
 }
 
 static void Gyro_Async_free(void *ptr) {
   struct Gyro_Async *async = ptr;
   if (async->active) {
-    printf("Async watcher garbage collected while still active!\n");
+    ev_clear_pending(async->ev_loop, &async->ev_async);
+    ev_async_stop(async->ev_loop, &async->ev_async);
   }
   xfree(async);
 }
@@ -35,26 +41,42 @@ static size_t Gyro_Async_size(const void *ptr) {
 static const rb_data_type_t Gyro_Async_type = {
     "Gyro_Async",
     {Gyro_Async_mark, Gyro_Async_free, Gyro_Async_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
+    0, 0, 0
 };
 
 static VALUE Gyro_Async_allocate(VALUE klass) {
-  struct Gyro_Async *async = (struct Gyro_Async *)xmalloc(sizeof(struct Gyro_Async));
+  struct Gyro_Async *async = ALLOC(struct Gyro_Async);
   return TypedData_Wrap_Struct(klass, &Gyro_Async_type, async);
 }
 
-void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
-  struct Gyro_Async *async = (struct Gyro_Async*)ev_async;
+inline void Gyro_Async_activate(struct Gyro_Async *async) {
+  if (async->active) return;
 
-  ev_async_stop(async->ev_loop, ev_async);
+  async->active = 1;
+  async->fiber = rb_fiber_current();
+  async->selector = Thread_current_event_selector();
+  async->ev_loop = Gyro_Selector_ev_loop(async->selector);
+  Gyro_Selector_add_active_watcher(async->selector, async->self);
+  ev_async_start(async->ev_loop, &async->ev_async);
+}
+
+inline void Gyro_Async_deactivate(struct Gyro_Async *async) {
+  if (!async->active) return;
+
+  ev_async_stop(async->ev_loop, &async->ev_async);
+  Gyro_Selector_remove_active_watcher(async->selector, async->self);
   async->active = 0;
+  async->ev_loop = 0;
+  async->selector = Qnil;
+  async->fiber = Qnil;
+  async->value = Qnil;
+}
 
-  if (async->fiber != Qnil) {
-    Gyro_schedule_fiber(async->fiber, async->value);
-    async->fiber = Qnil;
-    async->value = Qnil;
-  }
+void Gyro_Async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+  struct Gyro_Async *async = (struct Gyro_Async*)ev_async;
+
+  Fiber_make_runnable(async->fiber, async->value);
+  Gyro_Async_deactivate(async);
 }
 
 #define GetGyro_Async(obj, async) \
@@ -64,12 +86,14 @@ static VALUE Gyro_Async_initialize(VALUE self) {
   struct Gyro_Async *async;
   GetGyro_Async(self, async);
 
+  async->self = self;
   async->fiber = Qnil;
   async->value = Qnil;
+  async->selector = Qnil;
   async->active = 0;
+  async->ev_loop = 0;
 
   ev_async_init(&async->ev_async, Gyro_Async_callback);
-  async->ev_loop = 0;
 
   return Qnil;
 }
@@ -79,7 +103,7 @@ static VALUE Gyro_Async_signal(int argc, VALUE *argv, VALUE self) {
   GetGyro_Async(self, async);
 
   if (!async->active) {
-    // printf("signal! called before await\n");
+    // printf("signal called before await\n");
     return Qnil;
   }
 
@@ -91,68 +115,34 @@ static VALUE Gyro_Async_signal(int argc, VALUE *argv, VALUE self) {
 
 VALUE Gyro_Async_await(VALUE self) {
   struct Gyro_Async *async;
-  VALUE ret;
-  
   GetGyro_Async(self, async);
 
-  async->fiber = rb_fiber_current();
-  if (!async->active) {
-    async->active = 1;
-    async->ev_loop = Gyro_Selector_current_thread_ev_loop();
-    ev_async_start(async->ev_loop, &async->ev_async);
-  }
+  Gyro_Async_activate(async);
+  VALUE ret = Gyro_switchpoint();
+  Gyro_Async_deactivate(async);
 
-  ret = Fiber_await();
+  TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-
-  if (async->active) {
-    async->active = 0;
-    async->fiber = Qnil;
-    ev_async_stop(async->ev_loop, &async->ev_async);
-    async->value = Qnil;
-  }
-
-  // fiber is resumed
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-  }
-  else {
-    return ret;
-  }
+  return ret;
 }
 
 VALUE Gyro_Async_await_no_raise(VALUE self) {
   struct Gyro_Async *async;
-  VALUE ret;
-  
   GetGyro_Async(self, async);
 
-  async->fiber = rb_fiber_current();
-  if (!async->active) {
-    async->active = 1;
-    async->ev_loop = Gyro_Selector_current_thread_ev_loop();
-    ev_async_start(async->ev_loop, &async->ev_async);
-  }
-
-  ret = Fiber_await();
+  Gyro_Async_activate(async);
+  VALUE ret = Gyro_switchpoint();
+  Gyro_Async_deactivate(async);
+  
   RB_GC_GUARD(ret);
-
-  if (async->active) {
-    async->active = 0;
-    async->fiber = Qnil;
-    ev_async_stop(async->ev_loop, &async->ev_async);
-    async->value = Qnil;
-  }
-
   return ret;
 }
 
-
 void Init_Gyro_Async() {
   cGyro_Async = rb_define_class_under(mGyro, "Async", rb_cData);
   rb_define_alloc_func(cGyro_Async, Gyro_Async_allocate);
 
   rb_define_method(cGyro_Async, "initialize", Gyro_Async_initialize, 0);
-  rb_define_method(cGyro_Async, "signal!", Gyro_Async_signal, -1);
+  rb_define_method(cGyro_Async, "signal", Gyro_Async_signal, -1);
   rb_define_method(cGyro_Async, "await", Gyro_Async_await, 0);
 }

data/ext/gyro/child.c

@@ -7,6 +7,7 @@ struct Gyro_Child {
   int     pid;
   VALUE   self;
   VALUE   fiber;
+  VALUE   selector;
 };
 
 static VALUE cGyro_Child = Qnil;
@@ -16,12 +17,16 @@ static void Gyro_Child_mark(void *ptr) {
   if (child->fiber != Qnil) {
     rb_gc_mark(child->fiber);
   }
+  if (child->selector != Qnil) {
+    rb_gc_mark(child->selector);
+  }
 }
 
 static void Gyro_Child_free(void *ptr) {
   struct Gyro_Child *child = ptr;
   if (child->active) {
-    printf("Child watcher garbage collected while still active!\n");
+    ev_clear_pending(child->ev_loop, &child->ev_child);
+    ev_child_stop(child->ev_loop, &child->ev_child);
   }
   xfree(child);
 }
@@ -33,31 +38,51 @@ static size_t Gyro_Child_size(const void *ptr) {
 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,
+    0, 0, 0
 };
 
 static VALUE Gyro_Child_allocate(VALUE klass) {
-  struct Gyro_Child *child = (struct Gyro_Child *)xmalloc(sizeof(struct Gyro_Child));
+  struct Gyro_Child *child = ALLOC(struct Gyro_Child);
   return TypedData_Wrap_Struct(klass, &Gyro_Child_type, child);
 }
 
+inline void Gyro_Child_activate(struct Gyro_Child *child) {
+  if (child->active) return;
+
+  child->active = 1;
+  child->fiber = rb_fiber_current();
+  child->selector = Thread_current_event_selector();
+  child->ev_loop = Gyro_Selector_ev_loop(child->selector);
+  Gyro_Selector_add_active_watcher(child->selector, child->self);
+  ev_child_start(child->ev_loop, &child->ev_child);
+}
+
+inline void Gyro_Child_deactivate(struct Gyro_Child *child) {
+  if (!child->active) return;
+
+  ev_child_stop(child->ev_loop, &child->ev_child);
+  Gyro_Selector_remove_active_watcher(child->selector, child->self);
+  child->active = 0;
+  child->ev_loop = 0;
+  child->selector = Qnil;
+  child->fiber = Qnil;
+}
+
+VALUE Gyro_Child_resume_value(struct ev_child *ev_child) {
+  int exit_status = ev_child->rstatus >> 8; // weird, why should we do this?
+
+  return rb_ary_new_from_args(
+    2, INT2NUM(ev_child->rpid), INT2NUM(exit_status)
+  );
+}
+
 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);
+  VALUE resume_value = Gyro_Child_resume_value(ev_child);
+  Fiber_make_runnable(child->fiber, resume_value);
 
-  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);
-  }
+  Gyro_Child_deactivate(child);
 }
 
 #define GetGyro_Child(obj, child) \
@@ -70,8 +95,10 @@ static VALUE Gyro_Child_initialize(VALUE self, VALUE pid) {
 
   child->self     = self;
   child->fiber    = Qnil;
+  child->selector = Qnil;
   child->pid      = NUM2INT(pid);
   child->active   = 0;
+  child->ev_loop  = 0;
   
   ev_child_init(&child->ev_child, Gyro_Child_callback, child->pid, 0);
 
@@ -80,32 +107,15 @@ static VALUE Gyro_Child_initialize(VALUE self, VALUE pid) {
 
 static VALUE Gyro_Child_await(VALUE self) {
   struct Gyro_Child *child;
-  VALUE ret;
-  
   GetGyro_Child(self, child);
 
-  if (child->active)
-  child->active = 1;
-  child->fiber = rb_fiber_current();
-  child->ev_loop = Gyro_Selector_current_thread_ev_loop();
-  ev_child_start(child->ev_loop, &child->ev_child);
+  Gyro_Child_activate(child);
+  VALUE ret = Gyro_switchpoint();
+  Gyro_Child_deactivate(child);
 
-  ret = Fiber_await();
+  TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-
-  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))) {
-    return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-  }
-  else {
-    return ret;
-  }
+  return ret;
 }
 
 void Init_Gyro_Child() {

data/ext/gyro/fiber.c

@@ -0,0 +1,113 @@
+#include "gyro.h"
+
+ID ID_fiber_trace;
+ID ID_ivar_auto_async;
+ID ID_ivar_auto_io;
+ID ID_trace_ev_loop_enter;
+ID ID_trace_ev_loop_leave;
+ID ID_trace_run;
+ID ID_trace_runnable;
+ID ID_trace_terminate;
+ID ID_trace_wait;
+
+VALUE SYM_dead;
+VALUE SYM_running;
+VALUE SYM_runnable;
+VALUE SYM_waiting;
+
+VALUE SYM_fiber_create;
+VALUE SYM_fiber_ev_loop_enter;
+VALUE SYM_fiber_ev_loop_leave;
+VALUE SYM_fiber_run;
+VALUE SYM_fiber_schedule;
+VALUE SYM_fiber_switchpoint;
+VALUE SYM_fiber_terminate;
+
+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);
+  
+  TEST_RESUME_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+inline VALUE Fiber_auto_async(VALUE self) {
+  VALUE async = rb_ivar_get(self, ID_ivar_auto_async);
+  if (async == Qnil) {
+    async = rb_funcall(cGyro_Async, ID_new, 0);
+    rb_ivar_set(self, ID_ivar_auto_async, async);
+  }
+  return async;
+}
+
+inline VALUE Fiber_auto_io(VALUE self) {
+  VALUE io = rb_ivar_get(self, ID_ivar_auto_io);
+  if (io == Qnil) {
+    io = rb_funcall(cGyro_IO, ID_new, 2, Qnil, Qnil);
+    rb_ivar_set(self, ID_ivar_auto_io, io);
+  }
+  return io;
+}
+
+static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
+  VALUE value = (argc == 0) ? Qnil : argv[0];
+  Fiber_make_runnable(self, value);
+  return self;
+}
+
+static VALUE Fiber_state(VALUE self) {
+  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_runnable) != Qnil) return SYM_runnable;
+  
+  return SYM_waiting;
+}
+
+void Fiber_make_runnable(VALUE fiber, VALUE value) {
+  VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
+  if (thread != Qnil) {
+    Thread_schedule_fiber(thread, fiber, value);
+  }
+  else {
+    rb_warn("No thread set for fiber");
+  }
+}
+
+void Init_Fiber() {
+  VALUE cFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
+  rb_define_method(cFiber, "auto_async", Fiber_auto_async, 0);
+  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_ivar_auto_async = rb_intern("@auto_async");
+
+  SYM_dead = ID2SYM(rb_intern("dead"));
+  SYM_running = ID2SYM(rb_intern("running"));
+  SYM_runnable = ID2SYM(rb_intern("runnable"));
+  SYM_waiting = ID2SYM(rb_intern("waiting"));
+  rb_global_variable(&SYM_dead);
+  rb_global_variable(&SYM_running);
+  rb_global_variable(&SYM_runnable);
+  rb_global_variable(&SYM_waiting);
+
+  ID_fiber_trace          = rb_intern("__fiber_trace__");
+
+  SYM_fiber_create        = ID2SYM(rb_intern("fiber_create"));
+  SYM_fiber_ev_loop_enter = ID2SYM(rb_intern("fiber_ev_loop_enter"));
+  SYM_fiber_ev_loop_leave = ID2SYM(rb_intern("fiber_ev_loop_leave"));
+  SYM_fiber_run           = ID2SYM(rb_intern("fiber_run"));
+  SYM_fiber_schedule      = ID2SYM(rb_intern("fiber_schedule"));
+  SYM_fiber_switchpoint   = ID2SYM(rb_intern("fiber_switchpoint"));
+  SYM_fiber_terminate     = ID2SYM(rb_intern("fiber_terminate"));
+
+  rb_global_variable(&SYM_fiber_create);
+  rb_global_variable(&SYM_fiber_ev_loop_enter);
+  rb_global_variable(&SYM_fiber_ev_loop_leave);
+  rb_global_variable(&SYM_fiber_run);
+  rb_global_variable(&SYM_fiber_schedule);
+  rb_global_variable(&SYM_fiber_switchpoint);
+  rb_global_variable(&SYM_fiber_terminate);
+}