polyphony 0.36 → 0.42

data/ext/polyphony/libev_queue.c

@@ -0,0 +1,216 @@
+#include "polyphony.h"
+
+struct async_watcher {
+  ev_async async;
+  struct ev_loop *ev_loop;
+  VALUE fiber;
+};
+
+struct async_queue {
+  struct async_watcher **queue;
+  unsigned int len;
+  unsigned int count;
+  unsigned int push_idx;
+  unsigned int pop_idx;
+};
+
+void async_queue_init(struct async_queue *queue) {
+  queue->len = 4;
+  queue->count = 0;
+  queue->queue = malloc(sizeof(struct async_watcher *) * queue->len);
+  queue->push_idx = 0;
+  queue->pop_idx = 0;
+}
+
+void async_queue_free(struct async_queue *queue) {
+  free(queue->queue);
+}
+
+void async_queue_push(struct async_queue *queue, struct async_watcher *watcher) {
+  if (queue->push_idx == queue->len) {
+    queue->len = queue->len * 2;
+    queue->queue = realloc(queue->queue, sizeof(struct async_watcher *) * queue->len);
+  }
+  if (queue->count == 0) {
+    queue->push_idx = 0;
+    queue->pop_idx = 0;
+  }
+  queue->count++;
+  queue->queue[queue->push_idx++] = watcher;
+}
+
+struct async_watcher *async_queue_pop(struct async_queue *queue) {
+  if (queue->count == 0) return 0;
+
+  queue->count--;
+
+  return queue->queue[queue->pop_idx++];
+}
+
+void async_queue_remove_at_idx(struct async_queue *queue, unsigned int remove_idx) {
+  queue->count--;
+  queue->push_idx--;
+  if (remove_idx < queue->push_idx)
+    memmove(
+      queue->queue + remove_idx,
+      queue->queue + remove_idx + 1,
+      (queue->push_idx - remove_idx) * sizeof(struct async_watcher *)
+    );
+}
+
+void async_queue_remove_by_fiber(struct async_queue *queue, VALUE fiber) {
+  if (queue->count == 0) return;
+
+  for (unsigned idx = queue->pop_idx; idx < queue->push_idx; idx++) {
+    if (queue->queue[idx]->fiber == fiber) {
+      async_queue_remove_at_idx(queue, idx);
+      return; 
+    }
+  }
+}
+
+typedef struct queue {
+  VALUE items;
+  struct async_queue shift_queue;
+} LibevQueue_t;
+
+
+VALUE cLibevQueue = Qnil;
+
+static void LibevQueue_mark(void *ptr) {
+  LibevQueue_t *queue = ptr;
+  rb_gc_mark(queue->items);
+}
+
+static void LibevQueue_free(void *ptr) {
+  LibevQueue_t *queue = ptr;
+  async_queue_free(&queue->shift_queue);
+  xfree(ptr);
+}
+
+static size_t LibevQueue_size(const void *ptr) {
+  return sizeof(LibevQueue_t);
+}
+
+static const rb_data_type_t LibevQueue_type = {
+  "Queue",
+  {LibevQueue_mark, LibevQueue_free, LibevQueue_size,},
+  0, 0, 0
+};
+
+static VALUE LibevQueue_allocate(VALUE klass) {
+  LibevQueue_t *queue;
+
+  queue = ALLOC(LibevQueue_t);
+  return TypedData_Wrap_Struct(klass, &LibevQueue_type, queue);
+}
+
+#define GetQueue(obj, queue) \
+  TypedData_Get_Struct((obj), LibevQueue_t, &LibevQueue_type, (queue))
+
+static VALUE LibevQueue_initialize(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  queue->items = rb_ary_new();
+  async_queue_init(&queue->shift_queue);
+
+  return self;
+}
+
+VALUE LibevQueue_push(VALUE self, VALUE value) {
+  LibevQueue_t *queue;
+  struct async_watcher *watcher;
+  GetQueue(self, queue);
+  watcher = async_queue_pop(&queue->shift_queue);
+  if (watcher) {
+    ev_async_send(watcher->ev_loop, &watcher->async);
+  }
+  rb_ary_push(queue->items, value);
+  return self;
+}
+
+struct ev_loop *LibevAgent_ev_loop(VALUE self);
+
+void async_queue_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+  struct async_watcher *watcher = (struct async_watcher *)ev_async;
+  Fiber_make_runnable(watcher->fiber, Qnil);
+}
+
+VALUE libev_agent_await(VALUE self);
+
+VALUE LibevQueue_shift(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  if (RARRAY_LEN(queue->items) == 0) {
+    struct async_watcher watcher;
+    VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+    VALUE switchpoint_result = Qnil;
+
+    watcher.ev_loop = LibevAgent_ev_loop(agent);
+    watcher.fiber = rb_fiber_current();    
+    async_queue_push(&queue->shift_queue, &watcher);
+    ev_async_init(&watcher.async, async_queue_callback);
+    ev_async_start(watcher.ev_loop, &watcher.async);
+    
+    switchpoint_result = libev_agent_await(agent);
+    ev_async_stop(watcher.ev_loop, &watcher.async);
+
+    if (RTEST(rb_obj_is_kind_of(switchpoint_result, rb_eException))) {
+      async_queue_remove_by_fiber(&queue->shift_queue, watcher.fiber);
+      return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+    }
+    RB_GC_GUARD(watcher.fiber);
+    RB_GC_GUARD(agent);
+    RB_GC_GUARD(switchpoint_result);
+  }
+
+  return rb_ary_shift(queue->items);
+}
+
+VALUE LibevQueue_shift_each(VALUE self) {
+  LibevQueue_t *queue;
+  VALUE old_queue;
+  GetQueue(self, queue);
+  old_queue = queue->items;
+  queue->items = rb_ary_new();
+
+  if (rb_block_given_p()) {
+    long len = RARRAY_LEN(old_queue);
+    long i;
+    for (i = 0; i < len; i++) {
+      rb_yield(RARRAY_AREF(old_queue, i));
+    }
+    RB_GC_GUARD(old_queue);
+    return self;
+  }
+  else {
+    RB_GC_GUARD(old_queue);
+    return old_queue;
+  }
+}
+
+VALUE LibevQueue_empty_p(VALUE self) {
+  LibevQueue_t *queue;
+  GetQueue(self, queue);
+
+  return (RARRAY_LEN(queue->items) == 0) ? Qtrue : Qfalse;
+}
+
+void Init_LibevQueue() {
+  cLibevQueue = rb_define_class_under(mPolyphony, "LibevQueue", rb_cData);
+  rb_define_alloc_func(cLibevQueue, LibevQueue_allocate);
+
+  rb_define_method(cLibevQueue, "initialize", LibevQueue_initialize, 0);
+  rb_define_method(cLibevQueue, "push", LibevQueue_push, 1);
+  rb_define_method(cLibevQueue, "<<", LibevQueue_push, 1);
+
+  rb_define_method(cLibevQueue, "pop", LibevQueue_shift, 0);
+  rb_define_method(cLibevQueue, "shift", LibevQueue_shift, 0);
+
+  rb_define_method(cLibevQueue, "shift_each", LibevQueue_shift_each, 0);
+  rb_define_method(cLibevQueue, "empty?", LibevQueue_empty_p, 0);
+}
+
+

data/ext/{gyro/gyro.c → polyphony/polyphony.c}

@@ -1,7 +1,8 @@
-#include "gyro.h"
+#include "polyphony.h"
 
-VALUE mGyro;
+VALUE mPolyphony;
 
+ID ID_await_no_raise;
 ID ID_call;
 ID ID_caller;
 ID ID_clear;
@@ -24,66 +25,39 @@ ID ID_R;
 ID ID_W;
 ID ID_RW;
 
-static VALUE Gyro_break_set(VALUE self) {
-  // break_flag = 1;
-  ev_break(Gyro_Selector_current_thread_ev_loop(), EVBREAK_ALL);
-  return Qnil;
-}
-
-// static VALUE Gyro_break_get(VALUE self) {
-//   return (break_flag == 0) ? Qfalse : Qtrue;
-// }
-
-VALUE Gyro_snooze(VALUE self) {
+VALUE Polyphony_snooze(VALUE self) {
+  VALUE ret;
   VALUE fiber = rb_fiber_current();
-  Fiber_make_runnable(fiber, Qnil);
 
-  VALUE ret = Thread_switch_fiber(rb_thread_current());
+  Fiber_make_runnable(fiber, Qnil);
+  ret = Thread_switch_fiber(rb_thread_current());
   TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
-static VALUE Gyro_post_fork(VALUE self) {
-  Thread_post_fork(rb_thread_current());
-  return Qnil;
-}
-
-static VALUE Gyro_ref(VALUE self) {
-  return Thread_ref(rb_thread_current());
-}
-
-static VALUE Gyro_unref(VALUE self) {
-  return Thread_unref(rb_thread_current());
-}
-
-static VALUE Gyro_suspend(VALUE self) {
+static VALUE Polyphony_suspend(VALUE self) {
   VALUE ret = Thread_switch_fiber(rb_thread_current());
-  
+
   TEST_RESUME_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
-VALUE Gyro_trace(VALUE self, VALUE enabled) {
+VALUE Polyphony_trace(VALUE self, VALUE enabled) {
   __tracing_enabled__ = RTEST(enabled) ? 1 : 0;
   return Qnil;
 }
 
-void Init_Gyro() {
-  mGyro = rb_define_module("Gyro");
+void Init_Polyphony() {
+  mPolyphony = rb_define_module("Polyphony");
 
-  rb_define_singleton_method(mGyro, "post_fork", Gyro_post_fork, 0);
-  rb_define_singleton_method(mGyro, "ref", Gyro_ref, 0);
-  rb_define_singleton_method(mGyro, "unref", Gyro_unref, 0);
-  rb_define_singleton_method(mGyro, "trace", Gyro_trace, 1);
+  rb_define_singleton_method(mPolyphony, "trace", Polyphony_trace, 1);
 
-  rb_define_singleton_method(mGyro, "break!", Gyro_break_set, 0);
-  // rb_define_singleton_method(mGyro, "break?", Gyro_break_get, 0);
-
-  rb_define_global_function("snooze", Gyro_snooze, 0);
-  rb_define_global_function("suspend", Gyro_suspend, 0);
+  rb_define_global_function("snooze", Polyphony_snooze, 0);
+  rb_define_global_function("suspend", Polyphony_suspend, 0);
 
+  ID_await_no_raise = rb_intern("await_no_raise");
   ID_call           = rb_intern("call");
   ID_caller         = rb_intern("caller");
   ID_clear          = rb_intern("clear");
@@ -102,8 +76,4 @@ void Init_Gyro() {
   ID_size           = rb_intern("size");
   ID_switch_fiber   = rb_intern("switch_fiber");
   ID_transfer       = rb_intern("transfer");
-
-  ID_R              = rb_intern("r");
-  ID_RW             = rb_intern("rw");
-  ID_W              = rb_intern("w");
 }

data/ext/{gyro/gyro.h → polyphony/polyphony.h}

@@ -7,28 +7,29 @@
 
 // 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 INSPECT(obj) { VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf("%s\n", StringValueCStr(s));}
 #define FIBER_TRACE(...) if (__tracing_enabled__) { \
   rb_funcall(rb_cObject, ID_fiber_trace, __VA_ARGS__); \
 }
 
+#define TEST_EXCEPTION(ret) (RTEST(rb_obj_is_kind_of(ret, rb_eException)))
+
 #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;
-extern VALUE cGyro_Queue;
-extern VALUE cGyro_Selector;
-extern VALUE cGyro_Timer;
+extern VALUE mPolyphony;
+extern VALUE cLibevQueue;
+extern VALUE cEvent;
 
+extern ID ID_await_no_raise;
 extern ID ID_call;
 extern ID ID_caller;
 extern ID ID_clear;
 extern ID ID_each;
 extern ID ID_fiber_trace;
 extern ID ID_inspect;
+extern ID ID_ivar_agent;
 extern ID ID_ivar_running;
 extern ID ID_ivar_thread;
 extern ID ID_new;
@@ -39,9 +40,6 @@ extern ID ID_signal;
 extern ID ID_size;
 extern ID ID_switch_fiber;
 extern ID ID_transfer;
-extern ID ID_R;
-extern ID ID_W;
-extern ID ID_RW;
 
 extern VALUE SYM_fiber_create;
 extern VALUE SYM_fiber_ev_loop_enter;
@@ -59,43 +57,31 @@ enum {
   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);
+// watcher flags
+enum {
+  // a watcher's active field will be set to this after fork
+  GYRO_WATCHER_POST_FORK = 0xFF
+};
 
-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 Fiber_auto_watcher(VALUE self);
+void Fiber_make_runnable(VALUE fiber, VALUE value);
 
+VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue);
+VALUE LibevAgent_break(VALUE self);
+VALUE LibevAgent_pending_count(VALUE self);
+VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write);
 
-VALUE Gyro_snooze(VALUE self);
-VALUE Gyro_Timer_await(VALUE self);
+VALUE LibevAgent_ref(VALUE self);
+VALUE LibevAgent_unref(VALUE self);
+int LibevAgent_ref_count(VALUE self);
+void LibevAgent_reset_ref_count(VALUE self);
 
-VALUE IO_read_watcher(VALUE io);
-VALUE IO_write_watcher(VALUE io);
+VALUE Polyphony_snooze(VALUE self);
 
-VALUE Gyro_Queue_push(VALUE self, VALUE value);
+VALUE Polyphony_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);

data/ext/polyphony/polyphony_ext.c

@@ -0,0 +1,23 @@
+#include "polyphony.h"
+
+void Init_Fiber();
+void Init_Polyphony();
+void Init_LibevAgent();
+void Init_LibevQueue();
+void Init_Socket();
+void Init_Thread();
+void Init_Tracing();
+
+void Init_polyphony_ext() {
+  ev_set_allocator(xrealloc);
+
+  Init_Polyphony();
+  Init_LibevAgent();
+  Init_LibevQueue();
+
+  Init_Fiber();
+  Init_Socket();
+  Init_Thread();
+
+  Init_Tracing();
+}

data/ext/{gyro → polyphony}/socket.c

@@ -1,4 +1,4 @@
-#include "gyro.h"
+#include "polyphony.h"
 #include <sys/socket.h>
 
 static VALUE cTCPSocket;
@@ -71,8 +71,8 @@ static VALUE BasicSocket_send(int argc, VALUE *argv, VALUE sock) {
   ssize_t n;
   rb_blocking_function_t *func;
   const char *funcname;
-  VALUE write_watcher = Qnil;
-  
+  VALUE agent = Qnil;
+
   rb_scan_args(argc, argv, "21", &arg.mesg, &flags, &to);
 
   StringValue(arg.mesg);
@@ -94,9 +94,9 @@ 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 (NIL_P(write_watcher))
-      write_watcher = Gyro_IO_auto_io(fptr->fd, EV_WRITE);
-    Gyro_IO_await(write_watcher);
+    if (NIL_P(agent))
+      agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+    LibevAgent_wait_io(agent, sock, Qtrue);
   }
   return SSIZET2NUM(n);
 }
@@ -112,7 +112,7 @@ static VALUE BasicSocket_recv(int argc, VALUE *argv, VALUE sock) {
   rb_io_t *fptr;
   long n;
   int shrinkable;
-  VALUE read_watcher = Qnil;
+  VALUE agent = Qnil;
 
 
   VALUE str = argc >= 3 ? argv[2] : Qnil;
@@ -131,9 +131,9 @@ static VALUE BasicSocket_recv(int argc, VALUE *argv, VALUE sock) {
     if (n < 0) {
       int e = errno;
       if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (NIL_P(read_watcher))
-          read_watcher = Gyro_IO_auto_io(fptr->fd, EV_READ);
-        Gyro_IO_await(read_watcher);
+        if (NIL_P(agent))
+          agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+        LibevAgent_wait_io(agent, sock, Qnil);
       }
       else
         rb_syserr_fail(e, strerror(e));
@@ -157,7 +157,7 @@ static VALUE Socket_accept(VALUE sock) {
   int fd;
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
-  VALUE read_watcher = Qnil;
+  VALUE agent = Qnil;
 
   GetOpenFile(sock, fptr);
   rb_io_set_nonblock(fptr);
@@ -168,9 +168,9 @@ static VALUE Socket_accept(VALUE sock) {
     if (fd < 0) {
       int e = errno;
       if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (NIL_P(read_watcher))
-          read_watcher = Gyro_IO_auto_io(fptr->fd, EV_READ);
-        Gyro_IO_await(read_watcher);
+        if (NIL_P(agent))
+          agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+        LibevAgent_wait_io(agent, sock, Qnil);
       }
       else
         rb_syserr_fail(e, strerror(e));
@@ -196,15 +196,18 @@ static VALUE Socket_accept(VALUE sock) {
 }
 
 void Init_Socket() {
+  VALUE cBasicSocket;
+  VALUE cSocket;
+  
   rb_require("socket");
-  VALUE cBasicSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
+  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);
+  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"));
 }