polyphony 0.34 → 0.36

data/ext/gyro/gyro.c

@@ -6,47 +6,24 @@ ID ID_call;
 ID ID_caller;
 ID ID_clear;
 ID ID_each;
-ID ID_fiber_trace;
+ID ID_empty;
 ID ID_inspect;
 ID ID_new;
+ID ID_pop;
+ID ID_push;
 ID ID_raise;
 ID ID_ivar_running;
 ID ID_ivar_thread;
 ID ID_runnable;
 ID ID_runnable_value;
 ID ID_size;
-ID ID_signal_bang;
+ID ID_signal;
 ID ID_switch_fiber;
 ID ID_transfer;
 ID ID_R;
 ID ID_W;
 ID ID_RW;
 
-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;
-
-ID ID_empty;
-ID ID_pop;
-ID ID_push;
-
-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 Gyro_break_set(VALUE self) {
   // break_flag = 1;
   ev_break(Gyro_Selector_current_thread_ev_loop(), EVBREAK_ALL);
@@ -59,13 +36,12 @@ static VALUE Gyro_break_set(VALUE self) {
 
 VALUE Gyro_snooze(VALUE self) {
   VALUE fiber = rb_fiber_current();
-  Gyro_schedule_fiber(fiber, Qnil);
+  Fiber_make_runnable(fiber, Qnil);
 
   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
-    return ret;
+  TEST_RESUME_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
 }
 
 static VALUE Gyro_post_fork(VALUE self) {
@@ -84,46 +60,9 @@ static VALUE Gyro_unref(VALUE self) {
 static VALUE Gyro_suspend(VALUE self) {
   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 {
-    return 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(rb_mKernel, ID_raise, 1, ret) : ret;
-}
-
-static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
-  VALUE value = (argc == 0) ? Qnil : argv[0];
-  Gyro_schedule_fiber(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 Gyro_schedule_fiber(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");
-  }
+  TEST_RESUME_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
 }
 
 VALUE Gyro_trace(VALUE self, VALUE enabled) {
@@ -145,11 +84,6 @@ void Init_Gyro() {
   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");
@@ -164,7 +98,7 @@ void Init_Gyro() {
   ID_raise          = rb_intern("raise");
   ID_runnable       = rb_intern("runnable");
   ID_runnable_value = rb_intern("runnable_value");
-  ID_signal_bang    = rb_intern("signal!");
+  ID_signal         = rb_intern("signal");
   ID_size           = rb_intern("size");
   ID_switch_fiber   = rb_intern("switch_fiber");
   ID_transfer       = rb_intern("transfer");
@@ -172,32 +106,4 @@ void Init_Gyro() {
   ID_R              = rb_intern("r");
   ID_RW             = rb_intern("rw");
   ID_W              = rb_intern("w");
-
-  ID_fiber_trace          = rb_intern("__fiber_trace__");
-
-  #define GLOBAL_SYM(sym) var = ID2SYM(rb_intern(sym)); rb_global_variable(sym)
-
-  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);
-
-  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);
 }

data/ext/gyro/gyro.h

@@ -5,61 +5,17 @@
 #include "ruby/io.h"
 #include "libev.h"
 
-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);
-
-void Gyro_schedule_fiber(VALUE fiber, VALUE value);
-
-int Gyro_ref_count();
-void Gyro_ref_count_incr();
-void Gyro_ref_count_decr();
-
-VALUE Gyro_Async_await(VALUE async);
-VALUE Gyro_Async_await_no_raise(VALUE async);
-
-VALUE IO_read_watcher(VALUE io);
-VALUE IO_write_watcher(VALUE io);
-VALUE Gyro_IO_await(VALUE self);
-
-VALUE Gyro_Selector_run(VALUE self, VALUE current_fiber);
-void Gyro_Selector_run_no_wait(VALUE self, VALUE current_fiber, long runnable_count);
-
-VALUE Gyro_Timer_await(VALUE self);
-
-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);
-
-struct ev_loop *Gyro_Selector_ev_loop(VALUE selector);
-ev_tstamp Gyro_Selector_now(VALUE selector);
-struct ev_loop *Gyro_Selector_current_thread_ev_loop();
-long Gyro_Selector_pending_count(VALUE self);
-VALUE Gyro_Selector_post_fork(VALUE self);
-
-VALUE Thread_current_event_selector();
-VALUE Thread_ref(VALUE thread);
-VALUE Thread_unref(VALUE thread);
-VALUE Thread_switch_fiber(VALUE thread);
-VALUE Fiber_await();
-VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
-VALUE Thread_post_fork(VALUE thread);
-VALUE Gyro_Selector_break_out_of_ev_loop(VALUE self);
-
-VALUE Gyro_Queue_push(VALUE self, VALUE value);
-
+// debugging
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
 #define INSPECT(...) (rb_funcall(rb_cObject, rb_intern("p"), __VA_ARGS__))
 #define FIBER_TRACE(...) if (__tracing_enabled__) { \
   rb_funcall(rb_cObject, ID_fiber_trace, __VA_ARGS__); \
 }
 
+#define TEST_RESUME_EXCEPTION(ret) if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) { \
+  return rb_funcall(rb_mKernel, ID_raise, 1, ret); \
+}
+
 extern VALUE mGyro;
 extern VALUE cGyro_Async;
 extern VALUE cGyro_IO;
@@ -79,7 +35,7 @@ extern ID ID_new;
 extern ID ID_raise;
 extern ID ID_runnable;
 extern ID ID_runnable_value;
-extern ID ID_signal_bang;
+extern ID ID_signal;
 extern ID ID_size;
 extern ID ID_switch_fiber;
 extern ID ID_transfer;
@@ -97,4 +53,52 @@ extern VALUE SYM_fiber_terminate;
 
 extern int __tracing_enabled__;
 
+enum {
+  FIBER_STATE_NOT_SCHEDULED = 0,
+  FIBER_STATE_WAITING       = 1,
+  FIBER_STATE_SCHEDULED     = 2
+};
+
+VALUE Fiber_auto_async(VALUE self);
+VALUE Fiber_auto_io(VALUE self);
+void Fiber_make_runnable(VALUE fiber, VALUE value);
+
+VALUE Gyro_Async_await(VALUE async);
+VALUE Gyro_Async_await_no_raise(VALUE async);
+
+VALUE Gyro_IO_auto_io(int fd, int events);
+VALUE Gyro_IO_await(VALUE self);
+
+void Gyro_Selector_add_active_watcher(VALUE self, VALUE watcher);
+VALUE Gyro_Selector_break_out_of_ev_loop(VALUE self);
+struct ev_loop *Gyro_Selector_current_thread_ev_loop();
+struct ev_loop *Gyro_Selector_ev_loop(VALUE selector);
+ev_tstamp Gyro_Selector_now(VALUE selector);
+long Gyro_Selector_pending_count(VALUE self);
+VALUE Gyro_Selector_post_fork(VALUE self);
+void Gyro_Selector_remove_active_watcher(VALUE self, VALUE watcher);
+VALUE Gyro_Selector_run(VALUE self, VALUE current_fiber);
+void Gyro_Selector_run_no_wait(VALUE self, VALUE current_fiber, long runnable_count);
+VALUE Gyro_switchpoint();
+
+
+VALUE Gyro_snooze(VALUE self);
+VALUE Gyro_Timer_await(VALUE self);
+
+VALUE IO_read_watcher(VALUE io);
+VALUE IO_write_watcher(VALUE io);
+
+VALUE Gyro_Queue_push(VALUE self, VALUE value);
+
+VALUE Thread_current_event_selector();
+VALUE Thread_post_fork(VALUE thread);
+VALUE Thread_ref(VALUE thread);
+VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
+VALUE Thread_switch_fiber(VALUE thread);
+VALUE Thread_unref(VALUE thread);
+
+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);
+
 #endif /* RUBY_EV_H */

data/ext/gyro/gyro_ext.c

@@ -1,5 +1,6 @@
 #include "gyro.h"
 
+void Init_Fiber();
 void Init_Gyro();
 void Init_Gyro_Async();
 void Init_Gyro_Child();
@@ -24,6 +25,7 @@ void Init_gyro_ext() {
   Init_Gyro_Signal();
   Init_Gyro_Timer();
 
+  Init_Fiber();
   Init_Socket();
   Init_Thread();
 

data/ext/gyro/io.c

@@ -10,8 +10,9 @@ struct Gyro_IO {
   struct  ev_io ev_io;
   struct  ev_loop *ev_loop;
   int     active;
-  int     event_mask;
+  VALUE   self;
   VALUE   fiber;
+  VALUE   selector;
 };
 
 VALUE cGyro_IO = Qnil;
@@ -26,12 +27,16 @@ static void Gyro_IO_mark(void *ptr) {
   if (io->fiber != Qnil) {
     rb_gc_mark(io->fiber);
   }
+  if (io->selector != Qnil) {
+    rb_gc_mark(io->selector);
+  }
 }
 
 static void Gyro_IO_free(void *ptr) {
   struct Gyro_IO *io = ptr;
   if (io->active) {
-    printf("IO watcher garbage collected while still active!\n");
+    ev_clear_pending(io->ev_loop, &io->ev_io);
+    ev_io_stop(io->ev_loop, &io->ev_io);
   }
   xfree(io);
 }
@@ -43,30 +48,42 @@ static size_t Gyro_IO_size(const void *ptr) {
 static const rb_data_type_t Gyro_IO_type = {
     "Gyro_IO",
     {Gyro_IO_mark, Gyro_IO_free, Gyro_IO_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
+    0, 0, 0
 };
 
 static VALUE Gyro_IO_allocate(VALUE klass) {
-  struct Gyro_IO *io = (struct Gyro_IO *)xmalloc(sizeof(struct Gyro_IO));
+  struct Gyro_IO *io = ALLOC(struct Gyro_IO);
 
   return TypedData_Wrap_Struct(klass, &Gyro_IO_type, io);
 }
 
-static const char * S_IO = "IO";
-static const char * S_to_io = "to_io";
+inline void Gyro_IO_activate(struct Gyro_IO *io) {
+  if (io->active) return;
 
-void Gyro_IO_callback(struct ev_loop *ev_loop, struct ev_io *ev_io, int revents) {
-  struct Gyro_IO *io = (struct Gyro_IO*)ev_io;
+  io->active = 1;
+  io->fiber = rb_fiber_current();
+  io->selector = Thread_current_event_selector();
+  io->ev_loop = Gyro_Selector_ev_loop(io->selector);
+  Gyro_Selector_add_active_watcher(io->selector, io->self);
+  ev_io_start(io->ev_loop, &io->ev_io);
+}
+
+inline void Gyro_IO_deactivate(struct Gyro_IO *io) {
+  if (!io->active) return;
 
-  ev_io_stop(io->ev_loop, ev_io);
+  ev_io_stop(io->ev_loop, &io->ev_io);
+  Gyro_Selector_remove_active_watcher(io->selector, io->self);
   io->active = 0;
+  io->ev_loop = 0;
+  io->selector = Qnil;
+  io->fiber = Qnil;
+}
 
-  if (io->fiber != Qnil) {
-    VALUE fiber = io->fiber;
-    io->fiber = Qnil;
-    Gyro_schedule_fiber(fiber, Qnil);
-  }
+void Gyro_IO_callback(struct ev_loop *ev_loop, struct ev_io *ev_io, int revents) {
+  struct Gyro_IO *io = (struct Gyro_IO*)ev_io;
+
+  Fiber_make_runnable(io->fiber, Qnil);
+  Gyro_IO_deactivate(io);
 }
 
 static int Gyro_IO_symbol2event_mask(VALUE sym) {
@@ -92,51 +109,61 @@ static int Gyro_IO_symbol2event_mask(VALUE sym) {
 
 #define GetGyro_IO(obj, io) TypedData_Get_Struct((obj), struct Gyro_IO, &Gyro_IO_type, (io))
 
+static const char * S_IO = "IO";
+static const char * S_to_io = "to_io";
+
 static VALUE Gyro_IO_initialize(VALUE self, VALUE io_obj, VALUE event_mask) {
   struct Gyro_IO *io;
   rb_io_t *fptr;
 
   GetGyro_IO(self, io);
 
-  io->event_mask = Gyro_IO_symbol2event_mask(event_mask);
+  io->self = self;
   io->fiber = Qnil;
+  io->selector = Qnil;
   io->active = 0;
+  io->ev_loop = 0;
 
-  GetOpenFile(rb_convert_type(io_obj, T_FILE, S_IO, S_to_io), fptr);
-  ev_io_init(&io->ev_io, Gyro_IO_callback, FPTR_TO_FD(fptr), io->event_mask);
+  int fd;
+  if (NIL_P(io_obj)) {
+    fd = 0;
+  }
+  else {
+    GetOpenFile(rb_convert_type(io_obj, T_FILE, S_IO, S_to_io), fptr);
+    fd = FPTR_TO_FD(fptr);
+  }
+  int events = Gyro_IO_symbol2event_mask(event_mask);
+  
+  ev_io_init(&io->ev_io, Gyro_IO_callback, fd, events);
 
   return Qnil;
 }
 
 VALUE Gyro_IO_await(VALUE self) {
   struct Gyro_IO *io;
-  VALUE ret;
-  
   GetGyro_IO(self, io);
 
-  io->fiber = rb_fiber_current();
-  io->active = 1;
-  io->ev_loop = Gyro_Selector_current_thread_ev_loop();
-  ev_io_start(io->ev_loop, &io->ev_io);
+  Gyro_IO_activate(io);
+  VALUE ret = Gyro_switchpoint();
+  Gyro_IO_deactivate(io);
 
-  ret = Fiber_await();
+  TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
+  return ret;
+}
 
-  if (io->active) {
-    io->active = 0;
-    io->fiber = Qnil;
-    ev_io_stop(io->ev_loop, &io->ev_io);
-  }
+VALUE Gyro_IO_auto_io(int fd, int events) {
+  VALUE watcher = Fiber_auto_io(rb_fiber_current());
+  struct Gyro_IO *io;
+  GetGyro_IO(watcher, io);
 
-  // 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 Qnil;
-  }
+  ev_io_set(&io->ev_io, fd, events);
+
+  RB_GC_GUARD(watcher);
+  return watcher;
 }
 
+
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 // the following is copied verbatim from the Ruby source code (io.c)
@@ -233,8 +260,8 @@ static VALUE IO_read(int argc, VALUE *argv, VALUE io) {
     if (n < 0) {
       int e = errno;
       if ((e == EWOULDBLOCK || e == EAGAIN)) {
-        if (read_watcher == Qnil)
-          read_watcher = IO_read_watcher(io);
+        if (NIL_P(read_watcher))
+          read_watcher = Gyro_IO_auto_io(fptr->fd, EV_READ);
         Gyro_IO_await(read_watcher);
       }
       else
@@ -311,8 +338,8 @@ static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io) {
       if (n < 0) {
         int e = errno;
         if (e == EWOULDBLOCK || e == EAGAIN) {
-          if (read_watcher == Qnil)
-            read_watcher = IO_read_watcher(io);
+          if (NIL_P(read_watcher))
+            read_watcher = Gyro_IO_auto_io(fptr->fd, EV_READ);
           Gyro_IO_await(read_watcher);
         }
         else
@@ -367,8 +394,8 @@ static VALUE IO_write(int argc, VALUE *argv, VALUE io) {
       if (n < 0) {
         int e = errno;
         if (e == EWOULDBLOCK || e == EAGAIN) {
-          if (write_watcher == Qnil)
-            write_watcher = IO_write_watcher(io);
+          if (NIL_P(write_watcher))
+            write_watcher = Gyro_IO_auto_io(fptr->fd, EV_WRITE);
           Gyro_IO_await(write_watcher);
         }
         else {