polyphony 0.34 → 0.36

data/ext/gyro/queue.c

@@ -29,12 +29,11 @@ static size_t Gyro_Queue_size(const void *ptr) {
 static const rb_data_type_t Gyro_Queue_type = {
     "Gyro_Queue",
     {Gyro_Queue_mark, Gyro_Queue_free, Gyro_Queue_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
+    0, 0, 0
 };
 
 static VALUE Gyro_Queue_allocate(VALUE klass) {
-  struct Gyro_Queue *queue = (struct Gyro_Queue *)xmalloc(sizeof(struct Gyro_Queue));
+  struct Gyro_Queue *queue = ALLOC(struct Gyro_Queue);
   return TypedData_Wrap_Struct(klass, &Gyro_Queue_type, queue);
 }
 #define GetGyro_Queue(obj, queue) \
@@ -56,7 +55,7 @@ VALUE Gyro_Queue_push(VALUE self, VALUE value) {
 
   if (RARRAY_LEN(queue->wait_queue) > 0) {
     VALUE async = rb_ary_shift(queue->wait_queue);
-    rb_funcall(async, ID_signal_bang, 1, Qnil);
+    rb_funcall(async, ID_signal, 1, Qnil);
   }
   
   rb_ary_push(queue->queue, value);
@@ -68,13 +67,14 @@ VALUE Gyro_Queue_shift(VALUE self) {
   GetGyro_Queue(self, queue);
 
   if (RARRAY_LEN(queue->queue) == 0) {
-    VALUE async = rb_funcall(cGyro_Async, ID_new, 0);
+    VALUE async = Fiber_auto_async(rb_fiber_current());
     rb_ary_push(queue->wait_queue, async);
     VALUE ret = Gyro_Async_await_no_raise(async);
     if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
       rb_ary_delete(queue->wait_queue, async);
       return rb_funcall(rb_mKernel, ID_raise, 1, ret);
     }
+    RB_GC_GUARD(ret);
   }
 
   return rb_ary_shift(queue->queue);

data/ext/gyro/selector.c

@@ -5,19 +5,20 @@ struct Gyro_Selector {
   long    run_no_wait_count;
   int     ev_loop_running;
   struct  ev_async async;
+  VALUE   active_watchers;
 };
 
 VALUE cGyro_Selector = Qnil;
 
 static void Gyro_Selector_mark(void *ptr) {
-  // struct Gyro_Selector *selector = ptr;
+  struct Gyro_Selector *selector = ptr;
+  rb_gc_mark(selector->active_watchers);
 }
 
 static void Gyro_Selector_free(void *ptr) {
   struct Gyro_Selector *selector = ptr;
   ev_async_stop(selector->ev_loop, &selector->async);
   if (selector->ev_loop && !ev_is_default_loop(selector->ev_loop)) {
-    // printf("Selector garbage collected before being stopped!\n");
     ev_loop_destroy(selector->ev_loop);
   }
   xfree(selector);
@@ -30,12 +31,11 @@ static size_t Gyro_Selector_size(const void *ptr) {
 static const rb_data_type_t Gyro_Selector_type = {
     "Gyro_Selector",
     {Gyro_Selector_mark, Gyro_Selector_free, Gyro_Selector_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
+    0, 0, 0
 };
 
 static VALUE Gyro_Selector_allocate(VALUE klass) {
-  struct Gyro_Selector *selector = (struct Gyro_Selector *)xmalloc(sizeof(struct Gyro_Selector));
+  struct Gyro_Selector *selector = ALLOC(struct Gyro_Selector);
   return TypedData_Wrap_Struct(klass, &Gyro_Selector_type, selector);
 }
 
@@ -75,6 +75,12 @@ void dummy_async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, in
   // up the event loop.
 }
 
+inline void Gyro_Selector_run_ev_loop(struct Gyro_Selector *selector, int flags) {
+  selector->ev_loop_running = 1;
+  ev_run(selector->ev_loop, flags);
+  selector->ev_loop_running = 0;
+}
+
 static VALUE Gyro_Selector_initialize(VALUE self, VALUE thread) {
   struct Gyro_Selector *selector;
   GetGyro_Selector(self, selector);
@@ -83,21 +89,35 @@ static VALUE Gyro_Selector_initialize(VALUE self, VALUE thread) {
   selector->ev_loop = use_default_loop ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
   selector->run_no_wait_count = 0;
 
+  selector->active_watchers = rb_hash_new();
+
   ev_async_init(&selector->async, dummy_async_callback);
   ev_async_start(selector->ev_loop, &selector->async);
-  ev_run(selector->ev_loop, EVRUN_NOWAIT);
+  Gyro_Selector_run_ev_loop(selector, EVRUN_NOWAIT);
   return Qnil;
 }
 
+inline void Gyro_Selector_add_active_watcher(VALUE self, VALUE watcher) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  rb_hash_aset(selector->active_watchers, watcher, Qtrue);
+}
+
+inline void Gyro_Selector_remove_active_watcher(VALUE self, VALUE watcher) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  rb_hash_delete(selector->active_watchers, watcher);
+}
+
 inline VALUE Gyro_Selector_run(VALUE self, VALUE current_fiber) {
   struct Gyro_Selector *selector;
   GetGyro_Selector(self, selector);
   if (selector->ev_loop) {
     selector->run_no_wait_count = 0;
     FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
-    selector->ev_loop_running = 1;
-    ev_run(selector->ev_loop, EVRUN_ONCE);
-    selector->ev_loop_running = 0;
+    Gyro_Selector_run_ev_loop(selector, EVRUN_ONCE);
     FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
   }
   return Qnil;
@@ -114,7 +134,7 @@ inline void Gyro_Selector_run_no_wait(VALUE self, VALUE current_fiber, long runn
 
   selector->run_no_wait_count = 0;
   FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
-  ev_run(selector->ev_loop, EVRUN_NOWAIT);
+  Gyro_Selector_run_ev_loop(selector, EVRUN_NOWAIT);
   FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
 }
 
@@ -166,7 +186,9 @@ inline static VALUE Gyro_Selector_wait_writable(VALUE self, VALUE io) {
 
 inline static VALUE Gyro_Selector_wait_timeout(VALUE self, VALUE duration) {
   VALUE watcher = rb_funcall(cGyro_Timer, ID_new, 2, duration, Qnil);
-  return Gyro_Timer_await(watcher);
+  VALUE ret = Gyro_Timer_await(watcher);
+  RB_GC_GUARD(watcher);
+  return ret;
 }
 
 void Init_Gyro_Selector() {

data/ext/gyro/signal.c

@@ -5,7 +5,9 @@ struct Gyro_Signal {
   struct  ev_loop *ev_loop;
   int     active;
   int     signum;
+  VALUE   self;
   VALUE   fiber;
+  VALUE   selector;
 };
 
 static VALUE cGyro_Signal = Qnil;
@@ -15,13 +17,16 @@ static void Gyro_Signal_mark(void *ptr) {
   if (signal->fiber != Qnil) {
     rb_gc_mark(signal->fiber);
   }
+  if (signal->selector != Qnil) {
+    rb_gc_mark(signal->selector);
+  }
 }
 
 static void Gyro_Signal_free(void *ptr) {
   struct Gyro_Signal *signal = ptr;
   if (signal->active) {
-    printf("Signal watcher garbage collected while still active!\n");
-    // ev_signal_stop(signal->ev_loop, &signal->ev_signal);
+    ev_clear_pending(signal->ev_loop, &signal->ev_signal);
+    ev_signal_stop(signal->ev_loop, &signal->ev_signal);
   }
   xfree(signal);
 }
@@ -33,26 +38,41 @@ static size_t Gyro_Signal_size(const void *ptr) {
 static const rb_data_type_t Gyro_Signal_type = {
     "Gyro_Signal",
     {Gyro_Signal_mark, Gyro_Signal_free, Gyro_Signal_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
+    0, 0, 0
 };
 
 static VALUE Gyro_Signal_allocate(VALUE klass) {
-  struct Gyro_Signal *signal = (struct Gyro_Signal *)xmalloc(sizeof(struct Gyro_Signal));
+  struct Gyro_Signal *signal = ALLOC(struct Gyro_Signal);
   return TypedData_Wrap_Struct(klass, &Gyro_Signal_type, signal);
 }
 
+inline void Gyro_Signal_activate(struct Gyro_Signal *signal) {
+  if (signal->active) return;
+
+  signal->active = 1;
+  signal->fiber = rb_fiber_current();
+  signal->selector = Thread_current_event_selector();
+  signal->ev_loop = Gyro_Selector_ev_loop(signal->selector);
+  Gyro_Selector_add_active_watcher(signal->selector, signal->self);
+  ev_signal_start(signal->ev_loop, &signal->ev_signal);
+}
+
+inline void Gyro_Signal_deactivate(struct Gyro_Signal *signal) {
+  if (!signal->active) return;
+
+  ev_signal_stop(signal->ev_loop, &signal->ev_signal);
+  Gyro_Selector_remove_active_watcher(signal->selector, signal->self);
+  signal->active = 0;
+  signal->ev_loop = 0;
+  signal->selector = Qnil;
+  signal->fiber = Qnil;
+}
+
 void Gyro_Signal_callback(struct ev_loop *ev_loop, struct ev_signal *ev_signal, int revents) {
   struct Gyro_Signal *signal = (struct Gyro_Signal*)ev_signal;
 
-  if (signal->fiber != Qnil) {
-    VALUE fiber = signal->fiber;
-
-    ev_signal_stop(signal->ev_loop, ev_signal);
-    signal->active = 0;
-    signal->fiber = Qnil;
-    Gyro_schedule_fiber(fiber, INT2NUM(signal->signum));
-  }
+  Fiber_make_runnable(signal->fiber, INT2NUM(signal->signum));
+  Gyro_Signal_deactivate(signal);
 }
 
 #define GetGyro_Signal(obj, signal) \
@@ -63,7 +83,13 @@ static VALUE Gyro_Signal_initialize(VALUE self, VALUE sig) {
   VALUE signum = sig;
  
   GetGyro_Signal(self, signal);
+  
+  signal->self = self;
+  signal->fiber = Qnil;
+  signal->selector = Qnil;
   signal->signum = NUM2INT(signum);
+  signal->active = 0;
+  signal->ev_loop = 0;
 
   ev_signal_init(&signal->ev_signal, Gyro_Signal_callback, signal->signum);
 
@@ -72,31 +98,15 @@ static VALUE Gyro_Signal_initialize(VALUE self, VALUE sig) {
 
 static VALUE Gyro_Signal_await(VALUE self) {
   struct Gyro_Signal *signal;
-  VALUE ret;
-  
   GetGyro_Signal(self, signal);
 
-  signal->fiber = rb_fiber_current();
-  signal->active = 1;
-  signal->ev_loop = Gyro_Selector_current_thread_ev_loop();
-  ev_signal_start(signal->ev_loop, &signal->ev_signal);
+  Gyro_Signal_activate(signal);
+  VALUE ret = Gyro_switchpoint();
+  Gyro_Signal_deactivate(signal);
 
-  ret = Fiber_await();
+  TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-
-  if (signal->active) {
-    signal->active = 0;
-    signal->fiber = Qnil;
-    ev_signal_stop(signal->ev_loop, &signal->ev_signal);
-  }
-
-  // fiber is resumed, check if resumed value is an exception
-  signal->fiber = Qnil;
-  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_Signal() {

data/ext/gyro/socket.c

@@ -94,9 +94,8 @@ static VALUE BasicSocket_send(int argc, VALUE *argv, VALUE sock) {
   arg.fd = fptr->fd;
   arg.flags = NUM2INT(flags);
   while ((n = (ssize_t)func(&arg)) < 0) {
-    if (write_watcher == Qnil) {
-      write_watcher = IO_write_watcher(sock);
-    }
+    if (NIL_P(write_watcher))
+      write_watcher = Gyro_IO_auto_io(fptr->fd, EV_WRITE);
     Gyro_IO_await(write_watcher);
   }
   return SSIZET2NUM(n);
@@ -132,8 +131,8 @@ static VALUE BasicSocket_recv(int argc, VALUE *argv, VALUE sock) {
     if (n < 0) {
       int e = errno;
       if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (read_watcher == Qnil)
-          read_watcher = IO_read_watcher(sock);
+        if (NIL_P(read_watcher))
+          read_watcher = Gyro_IO_auto_io(fptr->fd, EV_READ);
         Gyro_IO_await(read_watcher);
       }
       else
@@ -169,8 +168,8 @@ static VALUE Socket_accept(VALUE sock) {
     if (fd < 0) {
       int e = errno;
       if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (read_watcher == Qnil)
-          read_watcher = IO_read_watcher(sock);
+        if (NIL_P(read_watcher))
+          read_watcher = Gyro_IO_auto_io(fptr->fd, EV_READ);
         Gyro_IO_await(read_watcher);
       }
       else

data/ext/gyro/thread.c

@@ -227,7 +227,7 @@ VALUE Thread_post_fork(VALUE self) {
   return self;
 }
 
-VALUE Fiber_await() {
+VALUE Gyro_switchpoint() {
   VALUE thread = rb_thread_current();
   Thread_ref(thread);
   VALUE ret = Thread_switch_fiber(thread);

data/ext/gyro/timer.c

@@ -6,7 +6,6 @@ struct Gyro_Timer {
   int     active;
   double  after;
   double  repeat;
-  int     should_free;
   VALUE   self;
   VALUE   fiber;
   VALUE   selector;
@@ -27,11 +26,10 @@ static void Gyro_Timer_mark(void *ptr) {
 static void Gyro_Timer_free(void *ptr) {
   struct Gyro_Timer *timer = ptr;
   if (timer->active) {
-    printf("Timer watcher garbage collected while still active (%g, %g)!\n", timer->after, timer->repeat);
-    timer->should_free = 1;
-  } else {
-    xfree(timer);
+    ev_clear_pending(timer->ev_loop, &timer->ev_timer);
+    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
   }
+  xfree(timer);
 }
 
 static size_t Gyro_Timer_size(const void *ptr) {
@@ -41,34 +39,50 @@ static size_t Gyro_Timer_size(const void *ptr) {
 static const rb_data_type_t Gyro_Timer_type = {
     "Gyro_Timer",
     {Gyro_Timer_mark, Gyro_Timer_free, Gyro_Timer_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
+    0, 0, 0
 };
 
 static VALUE Gyro_Timer_allocate(VALUE klass) {
-  struct Gyro_Timer *timer = (struct Gyro_Timer *)xmalloc(sizeof(struct Gyro_Timer));
+  struct Gyro_Timer *timer = ALLOC(struct Gyro_Timer);
   return TypedData_Wrap_Struct(klass, &Gyro_Timer_type, timer);
 }
+
 #define GetGyro_Timer(obj, timer) \
   TypedData_Get_Struct((obj), struct Gyro_Timer, &Gyro_Timer_type, (timer))
 
-void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int revents) {
-  struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
+inline void Gyro_Timer_activate(struct Gyro_Timer *timer) {
+  timer->fiber = rb_fiber_current();
+  timer->selector = Thread_current_event_selector();
+  timer->ev_loop = Gyro_Selector_ev_loop(timer->selector);
 
-  if (timer->should_free) {
-    ev_timer_stop(timer->ev_loop, ev_timer);
-    xfree(timer);
-    return;
-  }
+  if (timer->active) return;
+
+  timer->active = 1;
+  Gyro_Selector_add_active_watcher(timer->selector, timer->self);
+  ev_timer_start(timer->ev_loop, &timer->ev_timer);
+}
+
+inline void Gyro_Timer_deactivate(struct Gyro_Timer *timer, int non_recurring_only) {
+  if (!timer->active) return;
 
-  if (!timer->repeat) {
+  if (!timer->repeat || !non_recurring_only) {
+    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
+    if (RTEST(timer->selector)) {
+      Gyro_Selector_remove_active_watcher(timer->selector, timer->self);
+      timer->selector = Qnil;
+    }
+    timer->ev_loop = 0;
     timer->active = 0;
-    timer->selector = Qnil;
   }
 
-  if (timer->fiber != Qnil) {
-    Gyro_schedule_fiber(timer->fiber, DBL2NUM(timer->after));
-  }
+  timer->fiber = Qnil;
+}
+
+void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int revents) {
+  struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
+
+  Fiber_make_runnable(timer->fiber, DBL2NUM(timer->after));
+  Gyro_Timer_deactivate(timer, 1);
 }
 
 static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
@@ -78,15 +92,13 @@ static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
 
   timer->self     = self;
   timer->fiber    = Qnil;
+  timer->selector = Qnil;
   timer->after    = NUM2DBL(after);
   timer->repeat   = NUM2DBL(repeat);
   timer->active   = 0;
-
-  timer->should_free    = 0;
+  timer->ev_loop  = 0;
 
   ev_timer_init(&timer->ev_timer, Gyro_Timer_callback, timer->after, timer->repeat);
-  timer->ev_loop = 0;
-  timer->selector = Qnil;
 
   return Qnil;
 }
@@ -95,53 +107,21 @@ VALUE Gyro_Timer_stop(VALUE self) {
   struct Gyro_Timer *timer;
   GetGyro_Timer(self, timer);
 
-  if (timer->active) {
-    timer->active = 0;
-    timer->fiber = Qnil;
-    timer->selector = Qnil;
-    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-    timer->ev_loop = 0;
-  }
-
+  Gyro_Timer_deactivate(timer, 0);
   return self;
 }
 
 VALUE Gyro_Timer_await(VALUE self) {
   struct Gyro_Timer *timer;
-  VALUE ret;
-  
   GetGyro_Timer(self, timer);
 
-  timer->fiber = rb_fiber_current();
-  timer->selector = Thread_current_event_selector();
-  timer->ev_loop = Gyro_Selector_ev_loop(timer->selector);
-
-  if (timer->active != 1) {
-    timer->active = 1;
-    ev_timer_start(timer->ev_loop, &timer->ev_timer);
-  }
+  Gyro_Timer_activate(timer);
+  VALUE ret = Gyro_switchpoint();
+  Gyro_Timer_deactivate(timer, 1);
 
-  ret = Fiber_await();
+  TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-
-  if (timer->active && (timer->repeat == .0)) {
-    timer->active = 0;
-    timer->fiber = Qnil;
-    timer->selector = Qnil;
-    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-    timer->ev_loop = 0;
-  }
-
-  // fiber is resumed, check if resumed value is an exception
-  timer->fiber = Qnil;
-  timer->selector = Qnil;
-
-  RB_GC_GUARD(self);
-  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_Timer() {