polyphony 0.26 → 0.27

data/ext/gyro/gyro.h

@@ -15,25 +15,48 @@ enum {
 // void Gyro_del_watcher_ref(VALUE obj);
 VALUE Gyro_snooze(VALUE self);
 
-VALUE Gyro_run_next_fiber();
-VALUE Gyro_await();
 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 IO_read_watcher(VALUE io);
 VALUE IO_write_watcher(VALUE io);
 VALUE Gyro_IO_await(VALUE self);
 
+VALUE Gyro_Selector_run(VALUE self);
+
+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);
+struct ev_loop *Gyro_Selector_current_thread_ev_loop();
+long Gyro_Selector_pending_count(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 Thread_post_fork(VALUE thread);
+
+
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
+#define INSPECT(...) (rb_funcall(rb_cObject, rb_intern("p"), __VA_ARGS__))
 
 extern VALUE mGyro;
+extern VALUE cGyro_Async;
+extern VALUE cGyro_IO;
+extern VALUE cGyro_Queue;
+extern VALUE cGyro_Selector;
+extern VALUE cGyro_Timer;
 
 extern VALUE Gyro_reactor_fiber;
 extern VALUE Gyro_root_fiber;
@@ -43,8 +66,12 @@ extern ID ID_caller;
 extern ID ID_clear;
 extern ID ID_each;
 extern ID ID_inspect;
+extern ID ID_new;
 extern ID ID_raise;
 extern ID ID_scheduled_value;
+extern ID ID_signal_bang;
+extern ID ID_size;
+extern ID ID_switch_fiber;
 extern ID ID_transfer;
 extern ID ID_R;
 extern ID ID_W;

data/ext/gyro/gyro_ext.c

@@ -4,9 +4,12 @@ void Init_Gyro();
 void Init_Gyro_Async();
 void Init_Gyro_Child();
 void Init_Gyro_IO();
+void Init_Gyro_Queue();
+void Init_Gyro_Selector();
 void Init_Gyro_Signal();
 void Init_Gyro_Timer();
 void Init_Socket();
+void Init_Thread();
 
 void Init_gyro_ext() {
   ev_set_allocator(xrealloc);
@@ -15,8 +18,11 @@ void Init_gyro_ext() {
   Init_Gyro_Async();
   Init_Gyro_Child();
   Init_Gyro_IO();
+  Init_Gyro_Queue();
+  Init_Gyro_Selector();
   Init_Gyro_Signal();
   Init_Gyro_Timer();
 
   Init_Socket();
+  Init_Thread();
 }

data/ext/gyro/io.c

@@ -8,56 +8,36 @@
 
 struct Gyro_IO {
   struct  ev_io ev_io;
+  struct  ev_loop *ev_loop;
   int     active;
   int     event_mask;
   VALUE   fiber;
 };
 
-static VALUE cGyro_IO = Qnil;
+VALUE cGyro_IO = Qnil;
 
-static VALUE Gyro_IO_allocate(VALUE klass);
-static void Gyro_IO_mark(void *ptr);
-static void Gyro_IO_free(void *ptr);
-static size_t Gyro_IO_size(const void *ptr);
-
-static VALUE Gyro_IO_initialize(VALUE self, VALUE io, VALUE event_mask);
-
-void Gyro_IO_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
-
-static int Gyro_IO_symbol2event_mask(VALUE sym);
-
-// static VALUE IO_gets(int argc, VALUE *argv, VALUE io);
-static VALUE IO_read(int argc, VALUE *argv, VALUE io);
-static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io);
-static VALUE IO_write(int argc, VALUE *argv, VALUE io);
-static VALUE IO_write_chevron(VALUE io, VALUE str);
-
-ID ID_read_watcher;
-ID ID_write_watcher;
+ID ID_ivar_read_watcher;
+ID ID_ivar_write_watcher;
 VALUE SYM_r;
 VALUE SYM_w;
 
-void Init_Gyro_IO() {
-  cGyro_IO = rb_define_class_under(mGyro, "IO", rb_cData);
-  rb_define_alloc_func(cGyro_IO, Gyro_IO_allocate);
-
-  rb_define_method(cGyro_IO, "initialize", Gyro_IO_initialize, 2);
-  rb_define_method(cGyro_IO, "await", Gyro_IO_await, 0);
+static void Gyro_IO_mark(void *ptr) {
+  struct Gyro_IO *io = ptr;
+  if (io->fiber != Qnil) {
+    rb_gc_mark(io->fiber);
+  }
+}
 
-  VALUE cIO = rb_const_get(rb_cObject, rb_intern("IO"));
-  // rb_define_method(cIO, "gets", IO_gets, -1);
-  rb_define_method(cIO, "read", IO_read, -1);
-  rb_define_method(cIO, "readpartial", IO_readpartial, -1);
-  rb_define_method(cIO, "write", IO_write, -1);
-  rb_define_method(cIO, "write_nonblock", IO_write, -1);
-  rb_define_method(cIO, "<<", IO_write_chevron, 1);
-  rb_define_method(cIO, "read_watcher", IO_read_watcher, 0);
-  rb_define_method(cIO, "write_watcher", IO_write_watcher, 0);
+static void Gyro_IO_free(void *ptr) {
+  struct Gyro_IO *io = ptr;
+  if (io->active) {
+    printf("IO watcher garbage collected while still active!\n");
+  }
+  xfree(io);
+}
 
-  ID_read_watcher = rb_intern("@read_watcher");
-  ID_write_watcher = rb_intern("@write_watcher");
-  SYM_r = ID2SYM(rb_intern("r"));
-  SYM_w = ID2SYM(rb_intern("w"));
+static size_t Gyro_IO_size(const void *ptr) {
+  return sizeof(struct Gyro_IO);
 }
 
 static const rb_data_type_t Gyro_IO_type = {
@@ -73,25 +53,42 @@ static VALUE Gyro_IO_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &Gyro_IO_type, io);
 }
 
-static void Gyro_IO_mark(void *ptr) {
-  struct Gyro_IO *io = ptr;
+static const char * S_IO = "IO";
+static const char * S_to_io = "to_io";
+
+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;
+
+  ev_io_stop(io->ev_loop, ev_io);
+  io->active = 0;
+
   if (io->fiber != Qnil) {
-    rb_gc_mark(io->fiber);
+    VALUE fiber = io->fiber;
+    io->fiber = Qnil;
+    Gyro_schedule_fiber(fiber, Qnil);
   }
 }
 
-static void Gyro_IO_free(void *ptr) {
-  struct Gyro_IO *io = ptr;
-  ev_io_stop(EV_DEFAULT, &io->ev_io);
-  xfree(io);
-}
+static int Gyro_IO_symbol2event_mask(VALUE sym) {
+  ID sym_id;
 
-static size_t Gyro_IO_size(const void *ptr) {
-  return sizeof(struct Gyro_IO);
-}
+  if (NIL_P(sym)) {
+    return 0;
+  }
 
-static const char * S_IO = "IO";
-static const char * S_to_io = "to_io";
+  sym_id = SYM2ID(sym);
+
+  if(sym_id == ID_R) {
+    return EV_READ;
+  } else if(sym_id == ID_W) {
+    return EV_WRITE;
+  } else if(sym_id == ID_RW) {
+    return EV_READ | EV_WRITE;
+  } else {
+    rb_raise(rb_eArgError, "invalid interest type %s (must be :r, :w, or :rw)",
+      RSTRING_PTR(rb_funcall(sym, ID_inspect, 0)));
+  }
+}
 
 #define GetGyro_IO(obj, io) TypedData_Get_Struct((obj), struct Gyro_IO, &Gyro_IO_type, (io))
 
@@ -111,19 +108,6 @@ static VALUE Gyro_IO_initialize(VALUE self, VALUE io_obj, VALUE event_mask) {
   return 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;
-
-  ev_io_stop(EV_DEFAULT, ev_io);
-  io->active = 0;
-
-  if (io->fiber != Qnil) {
-    VALUE fiber = io->fiber;
-    io->fiber = Qnil;
-    Gyro_schedule_fiber(fiber, Qnil);
-  }
-}
-
 VALUE Gyro_IO_await(VALUE self) {
   struct Gyro_IO *io;
   VALUE ret;
@@ -132,14 +116,16 @@ VALUE Gyro_IO_await(VALUE self) {
 
   io->fiber = rb_fiber_current();
   io->active = 1;
-  ev_io_start(EV_DEFAULT, &io->ev_io);
-  ret = Gyro_await();
+  io->ev_loop = Gyro_Selector_current_thread_ev_loop();
+  ev_io_start(io->ev_loop, &io->ev_io);
+
+  ret = Fiber_await();
+  RB_GC_GUARD(ret);
 
-  // make sure io watcher is stopped
-  io->fiber = Qnil;
   if (io->active) {
     io->active = 0;
-    ev_io_stop(EV_DEFAULT, &io->ev_io);
+    io->fiber = Qnil;
+    ev_io_stop(io->ev_loop, &io->ev_io);
   }
 
   // fiber is resumed, check if resumed value is an exception
@@ -151,27 +137,6 @@ VALUE Gyro_IO_await(VALUE self) {
   }
 }
 
-static int Gyro_IO_symbol2event_mask(VALUE sym) {
-  ID sym_id;
-
-  if (NIL_P(sym)) {
-    return 0;
-  }
-
-  sym_id = SYM2ID(sym);
-
-  if(sym_id == ID_R) {
-    return EV_READ;
-  } else if(sym_id == ID_W) {
-    return EV_WRITE;
-  } else if(sym_id == ID_RW) {
-    return EV_READ | EV_WRITE;
-  } else {
-    rb_raise(rb_eArgError, "invalid interest type %s (must be :r, :w, or :rw)",
-      RSTRING_PTR(rb_funcall(sym, ID_inspect, 0)));
-  }
-}
-
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 // the following is copied verbatim from the Ruby source code (io.c)
@@ -436,21 +401,47 @@ static VALUE IO_write_chevron(VALUE io, VALUE str) {
 }
 
 VALUE IO_read_watcher(VALUE self) {
-  VALUE watcher = rb_ivar_get(self, ID_read_watcher);
+  VALUE watcher = rb_ivar_get(self, ID_ivar_read_watcher);
   if (watcher == Qnil) {
     VALUE args[] = {self, SYM_r};
     watcher = rb_class_new_instance(2, args, cGyro_IO);
-    rb_ivar_set(self, ID_read_watcher, watcher);
+    rb_ivar_set(self, ID_ivar_read_watcher, watcher);
   }
   return watcher;
 }
 
 VALUE IO_write_watcher(VALUE self) {
-  VALUE watcher = rb_ivar_get(self, ID_write_watcher);
+  VALUE watcher = rb_ivar_get(self, ID_ivar_write_watcher);
   if (watcher == Qnil) {
     VALUE args[] = {self, SYM_w};
     watcher = rb_class_new_instance(2, args, cGyro_IO);
-    rb_ivar_set(self, ID_write_watcher, watcher);
+    rb_ivar_set(self, ID_ivar_write_watcher, watcher);
   }
   return watcher;
-}
+}
+
+void Init_Gyro_IO() {
+  cGyro_IO = rb_define_class_under(mGyro, "IO", rb_cData);
+  rb_define_alloc_func(cGyro_IO, Gyro_IO_allocate);
+
+  rb_define_method(cGyro_IO, "initialize", Gyro_IO_initialize, 2);
+  rb_define_method(cGyro_IO, "await", Gyro_IO_await, 0);
+
+  VALUE cIO = rb_const_get(rb_cObject, rb_intern("IO"));
+  // rb_define_method(cIO, "gets", IO_gets, -1);
+  rb_define_method(cIO, "read", IO_read, -1);
+  rb_define_method(cIO, "readpartial", IO_readpartial, -1);
+  rb_define_method(cIO, "write", IO_write, -1);
+  rb_define_method(cIO, "write_nonblock", IO_write, -1);
+  rb_define_method(cIO, "<<", IO_write_chevron, 1);
+  rb_define_method(cIO, "read_watcher", IO_read_watcher, 0);
+  rb_define_method(cIO, "write_watcher", IO_write_watcher, 0);
+
+  ID_ivar_read_watcher = rb_intern("@read_watcher");
+  ID_ivar_write_watcher = rb_intern("@write_watcher");
+  SYM_r = ID2SYM(rb_intern("r"));
+  SYM_w = ID2SYM(rb_intern("w"));
+
+  rb_global_variable(&SYM_r);
+  rb_global_variable(&SYM_w);
+}

data/ext/gyro/queue.c

@@ -0,0 +1,109 @@
+#include "gyro.h"
+
+struct Gyro_Queue {
+  VALUE self;
+  VALUE queue;
+  VALUE wait_queue;
+};
+
+VALUE cGyro_Queue = Qnil;
+
+static void Gyro_Queue_mark(void *ptr) {
+  struct Gyro_Queue *queue = ptr;
+  if (queue->queue != Qnil) {
+    rb_gc_mark(queue->queue);
+  }
+  if (queue->wait_queue != Qnil) {
+    rb_gc_mark(queue->wait_queue);
+  }
+}
+
+static void Gyro_Queue_free(void *ptr) {
+  struct Gyro_Queue *queue = ptr;
+  xfree(queue);
+}
+
+static size_t Gyro_Queue_size(const void *ptr) {
+  return sizeof(struct Gyro_Queue);
+}
+
+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,
+};
+
+static VALUE Gyro_Queue_allocate(VALUE klass) {
+  struct Gyro_Queue *queue = (struct Gyro_Queue *)xmalloc(sizeof(struct Gyro_Queue));
+  return TypedData_Wrap_Struct(klass, &Gyro_Queue_type, queue);
+}
+#define GetGyro_Queue(obj, queue) \
+  TypedData_Get_Struct((obj), struct Gyro_Queue, &Gyro_Queue_type, (queue))
+
+static VALUE Gyro_Queue_initialize(VALUE self) {
+  struct Gyro_Queue *queue;
+  GetGyro_Queue(self, queue);
+
+  queue->self       = self;
+  queue->queue      = rb_ary_new();
+  queue->wait_queue = rb_ary_new();
+  
+  return Qnil;
+}
+
+VALUE Gyro_Queue_push(VALUE self, VALUE value) {
+  struct Gyro_Queue *queue;
+  GetGyro_Queue(self, queue);
+
+  if (RARRAY_LEN(queue->wait_queue) > 0) {
+    VALUE async = rb_ary_shift(queue->wait_queue);
+    return rb_funcall(async, ID_signal_bang, 1, value);
+  }
+  
+  rb_ary_push(queue->queue, value);
+  return self;
+}
+
+VALUE Gyro_Queue_shift(VALUE self) {
+  struct Gyro_Queue *queue;
+  GetGyro_Queue(self, queue);
+
+  if (RARRAY_LEN(queue->queue) > 0) {
+    return rb_ary_shift(queue->queue);
+  }
+  
+  VALUE async = rb_funcall(cGyro_Async, ID_new, 0);
+  rb_ary_push(queue->wait_queue, async);
+  return Gyro_Async_await(async);
+}
+
+VALUE Gyro_Queue_shift_all(VALUE self) {
+  struct Gyro_Queue *queue;
+  GetGyro_Queue(self, queue);
+
+  if (rb_block_given_p()) {
+    while (RARRAY_LEN(queue->queue) > 0) {
+      rb_yield(rb_ary_shift(queue->queue));
+    }
+  }
+  else {
+    rb_ary_clear(queue->queue);
+  }
+
+  return self;
+}
+
+void Init_Gyro_Queue() {
+  cGyro_Queue = rb_define_class_under(mGyro, "Queue", rb_cData);
+  rb_define_alloc_func(cGyro_Queue, Gyro_Queue_allocate);
+
+  rb_define_method(cGyro_Queue, "initialize", Gyro_Queue_initialize, 0);
+  rb_define_method(cGyro_Queue, "push", Gyro_Queue_push, 1);
+  rb_define_method(cGyro_Queue, "<<", Gyro_Queue_push, 1);
+
+  rb_define_method(cGyro_Queue, "pop", Gyro_Queue_shift, 0);
+  rb_define_method(cGyro_Queue, "shift", Gyro_Queue_shift, 0);
+
+  rb_define_method(cGyro_Queue, "shift_each", Gyro_Queue_shift_all, 0);
+}