polyphony 0.26 → 0.27

data/ext/gyro/selector.c

@@ -0,0 +1,117 @@
+#include "gyro.h"
+
+struct Gyro_Selector {
+  struct  ev_loop *ev_loop;
+};
+
+VALUE cGyro_Selector = Qnil;
+
+static void Gyro_Selector_mark(void *ptr) {
+  // struct Gyro_Selector *selector = ptr;
+}
+
+static void Gyro_Selector_free(void *ptr) {
+  struct Gyro_Selector *selector = ptr;
+  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);
+}
+
+static size_t Gyro_Selector_size(const void *ptr) {
+  return sizeof(struct Gyro_Selector);
+}
+
+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,
+};
+
+static VALUE Gyro_Selector_allocate(VALUE klass) {
+  struct Gyro_Selector *selector = (struct Gyro_Selector *)xmalloc(sizeof(struct Gyro_Selector));
+  return TypedData_Wrap_Struct(klass, &Gyro_Selector_type, selector);
+}
+
+#define GetGyro_Selector(obj, selector) \
+  TypedData_Get_Struct((obj), struct Gyro_Selector, &Gyro_Selector_type, (selector))
+
+inline struct ev_loop *Gyro_Selector_ev_loop(VALUE self) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  return selector->ev_loop;
+}
+
+inline struct ev_loop *Gyro_Selector_current_thread_ev_loop() {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(Thread_current_event_selector(), selector);
+
+  return selector->ev_loop;
+}
+
+long Gyro_Selector_pending_count(VALUE self) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  return ev_pending_count(selector->ev_loop);
+}
+
+static VALUE Gyro_Selector_initialize(VALUE self, VALUE thread) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  int use_default_loop = (rb_thread_current() == rb_thread_main());
+  selector->ev_loop = use_default_loop ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
+
+  return Qnil;
+}
+
+inline VALUE Gyro_Selector_run(VALUE self) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+  if (selector->ev_loop) {
+    ev_run(selector->ev_loop, EVRUN_ONCE);
+  }
+  return Qnil;
+}
+
+VALUE Gyro_Selector_stop(VALUE self) {
+  struct Gyro_Selector *selector;
+  GetGyro_Selector(self, selector);
+
+  if (selector->ev_loop && !ev_is_default_loop(selector->ev_loop)) {
+    // ev_loop_destroy(selector->ev_loop);
+    // selector->ev_loop = 0;
+  }
+  return Qnil;
+}
+
+inline static VALUE Gyro_Selector_wait_readable(VALUE self, VALUE io) {
+  VALUE watcher = IO_read_watcher(io);
+  return Gyro_IO_await(watcher);
+}
+
+inline static VALUE Gyro_Selector_wait_writable(VALUE self, VALUE io) {
+  VALUE watcher = IO_write_watcher(io);
+  return Gyro_IO_await(watcher);
+}
+
+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);
+}
+
+void Init_Gyro_Selector() {
+  cGyro_Selector = rb_define_class_under(mGyro, "Selector", rb_cData);
+  rb_define_alloc_func(cGyro_Selector, Gyro_Selector_allocate);
+
+  rb_define_method(cGyro_Selector, "initialize", Gyro_Selector_initialize, 1);
+  rb_define_method(cGyro_Selector, "run", Gyro_Selector_run, 0);
+  rb_define_method(cGyro_Selector, "stop", Gyro_Selector_stop, 0);
+  rb_define_method(cGyro_Selector, "wait_readable", Gyro_Selector_wait_readable, 1);
+  rb_define_method(cGyro_Selector, "wait_writable", Gyro_Selector_wait_writable, 1);
+  rb_define_method(cGyro_Selector, "wait_timeout", Gyro_Selector_wait_timeout, 1);
+}

data/ext/gyro/signal.c

@@ -2,6 +2,7 @@
 
 struct Gyro_Signal {
   struct  ev_signal ev_signal;
+  struct  ev_loop *ev_loop;
   int     active;
   int     signum;
   VALUE   fiber;
@@ -9,26 +10,24 @@ struct Gyro_Signal {
 
 static VALUE cGyro_Signal = Qnil;
 
-/* Allocator/deallocator */
-static VALUE Gyro_Signal_allocate(VALUE klass);
-static void Gyro_Signal_mark(void *ptr);
-static void Gyro_Signal_free(void *ptr);
-static size_t Gyro_Signal_size(const void *ptr);
-
-/* Methods */
-static VALUE Gyro_Signal_initialize(VALUE self, VALUE sig);
-
-static VALUE Gyro_Signal_await(VALUE self);
-
-void Gyro_Signal_callback(struct ev_loop *ev_loop, struct ev_signal *signal, int revents);
+static void Gyro_Signal_mark(void *ptr) {
+  struct Gyro_Signal *signal = ptr;
+  if (signal->fiber != Qnil) {
+    rb_gc_mark(signal->fiber);
+  }
+}
 
-/* Signal encapsulates a signal watcher */
-void Init_Gyro_Signal() {
-  cGyro_Signal = rb_define_class_under(mGyro, "Signal", rb_cData);
-  rb_define_alloc_func(cGyro_Signal, Gyro_Signal_allocate);
+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);
+  }
+  xfree(signal);
+}
 
-  rb_define_method(cGyro_Signal, "initialize", Gyro_Signal_initialize, 1);
-  rb_define_method(cGyro_Signal, "await", Gyro_Signal_await, 0);
+static size_t Gyro_Signal_size(const void *ptr) {
+  return sizeof(struct Gyro_Signal);
 }
 
 static const rb_data_type_t Gyro_Signal_type = {
@@ -43,21 +42,17 @@ static VALUE Gyro_Signal_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Gyro_Signal_type, signal);
 }
 
-static void Gyro_Signal_mark(void *ptr) {
-  struct Gyro_Signal *signal = ptr;
-  if (signal->fiber != Qnil) {
-    rb_gc_mark(signal->fiber);
-  }
-}
+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;
 
-static void Gyro_Signal_free(void *ptr) {
-  struct Gyro_Signal *signal = ptr;
-  ev_signal_stop(EV_DEFAULT, &signal->ev_signal);
-  xfree(signal);
-}
+  if (signal->fiber != Qnil) {
+    VALUE fiber = signal->fiber;
 
-static size_t Gyro_Signal_size(const void *ptr) {
-  return sizeof(struct Gyro_Signal);
+    ev_signal_stop(signal->ev_loop, ev_signal);
+    signal->active = 0;
+    signal->fiber = Qnil;
+    Gyro_schedule_fiber(fiber, INT2NUM(signal->signum));
+  }
 }
 
 #define GetGyro_Signal(obj, signal) \
@@ -72,26 +67,9 @@ 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;
 }
 
-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(EV_DEFAULT, ev_signal);
-    signal->active = 0;
-    signal->fiber = Qnil;
-    Gyro_schedule_fiber(fiber, INT2NUM(signal->signum));
-  }
-}
-
 static VALUE Gyro_Signal_await(VALUE self) {
   struct Gyro_Signal *signal;
   VALUE ret;
@@ -100,19 +78,31 @@ static VALUE Gyro_Signal_await(VALUE self) {
 
   signal->fiber = rb_fiber_current();
   signal->active = 1;
-  ev_signal_start(EV_DEFAULT, &signal->ev_signal);
+  signal->ev_loop = Gyro_Selector_current_thread_ev_loop();
+  ev_signal_start(signal->ev_loop, &signal->ev_signal);
 
-  ret = Gyro_await();
+  ret = Fiber_await();
+  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))) {
-    if (signal->active) {
-      signal->active = 0;
-      ev_signal_stop(EV_DEFAULT, &signal->ev_signal);
-    }
     return rb_funcall(rb_mKernel, ID_raise, 1, ret);
   }
   else
     return ret;
 }
+
+void Init_Gyro_Signal() {
+  cGyro_Signal = rb_define_class_under(mGyro, "Signal", rb_cData);
+  rb_define_alloc_func(cGyro_Signal, Gyro_Signal_allocate);
+
+  rb_define_method(cGyro_Signal, "initialize", Gyro_Signal_initialize, 1);
+  rb_define_method(cGyro_Signal, "await", Gyro_Signal_await, 0);
+}

data/ext/gyro/socket.c

@@ -1,27 +1,8 @@
 #include "gyro.h"
 #include <sys/socket.h>
 
-static VALUE BasicSocket_send(int argc, VALUE *argv, VALUE io);
-static VALUE BasicSocket_recv(int argc, VALUE *argv, VALUE io);
-
-static VALUE Socket_accept(VALUE sock);
-
 static VALUE cTCPSocket;
 
-void Init_Socket() {
-  rb_require("socket");
-  VALUE cBasicSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
-
-  rb_define_method(cBasicSocket, "send", BasicSocket_send, -1);
-  rb_define_method(cBasicSocket, "recv", BasicSocket_recv, -1);
-
-  VALUE cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
-  
-  rb_define_method(cSocket, "accept", Socket_accept, 0);
-
-  cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
-}
-
 ///////////////////////////////////////////////////////////////////////////
 
 struct rsock_send_arg {
@@ -213,4 +194,18 @@ static VALUE Socket_accept(VALUE sock) {
       return connection;
     }
   }
-}
+}
+
+void Init_Socket() {
+  rb_require("socket");
+  VALUE cBasicSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
+
+  rb_define_method(cBasicSocket, "send", BasicSocket_send, -1);
+  rb_define_method(cBasicSocket, "recv", BasicSocket_recv, -1);
+
+  VALUE cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
+  
+  rb_define_method(cSocket, "accept", Socket_accept, 0);
+
+  cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
+}

data/ext/gyro/thread.c

@@ -0,0 +1,203 @@
+#include "gyro.h"
+
+static VALUE cQueue;
+
+static ID ID_create_event_selector;
+static ID ID_ivar_event_selector;
+static ID ID_ivar_event_selector_proc;
+static ID ID_fiber_ref_count;
+static ID ID_run_queue;
+static ID ID_ivar_main_fiber;
+static ID ID_stop;
+
+static ID ID_scheduled;
+
+static ID ID_empty;
+static ID ID_pop;
+static ID ID_push;
+
+VALUE event_selector_factory_proc(RB_BLOCK_CALL_FUNC_ARGLIST(args, klass)) {
+  return rb_funcall(klass, ID_new, 1, rb_ary_entry(args, 0));
+}
+
+static VALUE Thread_event_selector_set_proc(VALUE self, VALUE proc) {
+  if (!rb_obj_is_proc(proc)) {
+    proc = rb_proc_new(event_selector_factory_proc, proc);
+  }
+  rb_ivar_set(self, ID_ivar_event_selector_proc, proc);
+  return self;
+}
+
+static VALUE Thread_create_event_selector(VALUE self, VALUE thread) {
+  VALUE selector_proc = rb_ivar_get(self, ID_ivar_event_selector_proc);
+  if (selector_proc == Qnil) {
+    rb_raise(rb_eRuntimeError, "No event_selector_proc defined");
+  }
+
+  return rb_funcall(selector_proc, ID_call, 1, thread);
+}
+
+static VALUE Thread_setup_fiber_scheduling(VALUE self) {
+  rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
+  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
+  VALUE queue = rb_ary_new();
+  rb_ivar_set(self, ID_run_queue, queue);
+  VALUE selector = rb_funcall(rb_cThread, ID_create_event_selector, 1, self);
+  rb_ivar_set(self, ID_ivar_event_selector, selector);
+
+  return self;
+}
+
+static VALUE Thread_stop_event_selector(VALUE self) {
+  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+  if (selector != Qnil) {
+    rb_funcall(selector, ID_stop, 0);
+  }
+
+  return self;
+}
+
+inline VALUE Thread_ref(VALUE self) {
+  VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
+  int new_count = NUM2INT(count) + 1;
+  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(new_count));
+  return self;
+}
+
+inline VALUE Thread_unref(VALUE self) {
+  VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
+  int new_count = NUM2INT(count) - 1;
+  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(new_count));
+  return self;
+}
+
+inline int Thread_fiber_ref_count(VALUE self) {
+  VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
+  return NUM2INT(count);
+}
+
+inline void Thread_fiber_reset_ref_count(VALUE self) {
+  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
+}
+
+static VALUE SYM_scheduled_fibers;
+static VALUE SYM_pending_watchers;
+
+static VALUE Thread_fiber_scheduling_stats(VALUE self) {
+  VALUE stats = rb_hash_new();
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+  
+  long scheduled_count = RARRAY_LEN(queue);
+  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
+
+  long pending_count = Gyro_Selector_pending_count(selector);
+  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
+
+  return stats;
+}
+
+inline VALUE Thread_schedule_fiber(VALUE self, VALUE fiber) {
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  rb_ary_push(queue, fiber);
+  return self;
+}
+
+VALUE Thread_switch_fiber(VALUE self) {
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
+  long scheduled_count;
+
+  while (1) {
+    scheduled_count = RARRAY_LEN(queue);
+    // if (break_flag != 0) {
+    //   return Qnil;
+    // }
+    if ((scheduled_count > 0) || (Thread_fiber_ref_count(self) == 0)) {
+      break;
+    }
+
+    Gyro_Selector_run(selector);
+  }
+
+  VALUE next_fiber;
+  // while (1) {
+    if (scheduled_count == 0) {
+      return Qnil;
+    }
+    next_fiber = rb_ary_shift(queue);
+    // break;
+    // if (rb_fiber_alive_p(next_fiber) == Qtrue) {
+    //   break;
+    // }
+  // }
+
+  // run next fiber
+  VALUE value = rb_ivar_get(next_fiber, ID_scheduled_value);
+  rb_ivar_set(next_fiber, ID_scheduled, Qnil);
+  RB_GC_GUARD(next_fiber);
+  RB_GC_GUARD(value);
+  return rb_funcall(next_fiber, ID_transfer, 1, value);
+}
+
+VALUE Thread_reset_fiber_scheduling(VALUE self) {
+  VALUE queue = rb_ivar_get(self, ID_run_queue);
+  rb_ary_clear(queue);
+  Thread_fiber_reset_ref_count(self);
+  return self;
+}
+
+VALUE Thread_post_fork(VALUE self) {
+  ev_loop_fork(EV_DEFAULT);
+  Thread_setup_fiber_scheduling(self);
+  return self;
+}
+
+inline VALUE Fiber_await() {
+  VALUE thread = rb_thread_current();
+  Thread_ref(thread);
+  VALUE ret = Thread_switch_fiber(thread);
+  Thread_unref(thread);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+inline VALUE Thread_current_event_selector() {
+  return rb_ivar_get(rb_thread_current(), ID_ivar_event_selector);
+}
+
+void Init_Thread() {
+  cQueue = rb_const_get(rb_cObject, rb_intern("Queue"));
+
+  rb_define_singleton_method(rb_cThread, "event_selector=", Thread_event_selector_set_proc, 1);
+  rb_define_singleton_method(rb_cThread, "create_event_selector", Thread_create_event_selector, 1);
+
+  rb_define_method(rb_cThread, "fiber_ref", Thread_ref, 0);
+  rb_define_method(rb_cThread, "fiber_unref", Thread_unref, 0);
+
+  rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
+  rb_define_method(rb_cThread, "stop_event_selector", Thread_stop_event_selector, 0);
+  rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
+  rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
+
+  rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 1);
+  rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
+
+
+  ID_create_event_selector    = rb_intern("create_event_selector");
+  ID_ivar_event_selector      = rb_intern("@event_selector");
+  ID_ivar_event_selector_proc = rb_intern("@event_selector_proc");
+  ID_ivar_main_fiber          = rb_intern("@main_fiber");
+  ID_fiber_ref_count          = rb_intern("fiber_ref_count");
+  ID_run_queue                = rb_intern("run_queue");
+  ID_scheduled                = rb_intern("scheduled");
+  ID_empty                    = rb_intern("empty?");
+  ID_pop                      = rb_intern("pop");
+  ID_push                     = rb_intern("push");
+  ID_stop                     = rb_intern("stop");
+
+  SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));
+  SYM_pending_watchers = ID2SYM(rb_intern("pending_watchers"));
+  rb_global_variable(&SYM_scheduled_fibers);
+  rb_global_variable(&SYM_pending_watchers);
+}