polyphony 0.40 → 0.41

data/ext/polyphony/libev_queue.c

@@ -0,0 +1,214 @@
+#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 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 = Polyphony_switchpoint();
+    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,8 +1,8 @@
-#include "gyro.h"
+#include "polyphony.h"
 
-VALUE mGyro;
-int __gyro_current_generation__ = 0;
+VALUE mPolyphony;
 
+ID ID_await_no_raise;
 ID ID_call;
 ID ID_caller;
 ID ID_clear;
@@ -25,7 +25,7 @@ ID ID_R;
 ID ID_W;
 ID ID_RW;
 
-VALUE Gyro_snooze(VALUE self) {
+VALUE Polyphony_snooze(VALUE self) {
   VALUE ret;
   VALUE fiber = rb_fiber_current();
 
@@ -36,15 +36,15 @@ VALUE Gyro_snooze(VALUE self) {
   return ret;
 }
 
-static VALUE Gyro_ref(VALUE self) {
+static VALUE Polyphony_ref(VALUE self) {
   return Thread_ref(rb_thread_current());
 }
 
-static VALUE Gyro_unref(VALUE self) {
+static VALUE Polyphony_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);
@@ -52,27 +52,22 @@ static VALUE Gyro_suspend(VALUE self) {
   return ret;
 }
 
-VALUE Gyro_trace(VALUE self, VALUE enabled) {
+VALUE Polyphony_trace(VALUE self, VALUE enabled) {
   __tracing_enabled__ = RTEST(enabled) ? 1 : 0;
   return Qnil;
 }
 
-VALUE Gyro_incr_generation(VALUE self) {
-  __gyro_current_generation__++;
-  return Qnil;
-}
+void Init_Polyphony() {
+  mPolyphony = rb_define_module("Polyphony");
 
-void Init_Gyro() {
-  mGyro = rb_define_module("Gyro");
+  rb_define_singleton_method(mPolyphony, "ref", Polyphony_ref, 0);
+  rb_define_singleton_method(mPolyphony, "trace", Polyphony_trace, 1);
+  rb_define_singleton_method(mPolyphony, "unref", Polyphony_unref, 0);
 
-  rb_define_singleton_method(mGyro, "incr_generation", Gyro_incr_generation, 0);
-  rb_define_singleton_method(mGyro, "ref", Gyro_ref, 0);
-  rb_define_singleton_method(mGyro, "trace", Gyro_trace, 1);
-  rb_define_singleton_method(mGyro, "unref", Gyro_unref, 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");
@@ -91,8 +86,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/polyphony/polyphony.h

@@ -0,0 +1,90 @@
+#ifndef RUBY_EV_H
+#define RUBY_EV_H
+
+#include "ruby.h"
+#include "ruby/io.h"
+#include "libev.h"
+
+// 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_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 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;
+extern ID ID_raise;
+extern ID ID_runnable;
+extern ID ID_runnable_value;
+extern ID ID_signal;
+extern ID ID_size;
+extern ID ID_switch_fiber;
+extern ID ID_transfer;
+
+extern VALUE SYM_fiber_create;
+extern VALUE SYM_fiber_ev_loop_enter;
+extern VALUE SYM_fiber_ev_loop_leave;
+extern VALUE SYM_fiber_run;
+extern VALUE SYM_fiber_schedule;
+extern VALUE SYM_fiber_switchpoint;
+extern VALUE SYM_fiber_terminate;
+
+extern int __tracing_enabled__;
+
+enum {
+  FIBER_STATE_NOT_SCHEDULED = 0,
+  FIBER_STATE_WAITING       = 1,
+  FIBER_STATE_SCHEDULED     = 2
+};
+
+// watcher flags
+enum {
+  // a watcher's active field will be set to this after fork
+  GYRO_WATCHER_POST_FORK = 0xFF
+};
+
+VALUE Fiber_auto_watcher(VALUE self);
+void Fiber_make_runnable(VALUE fiber, VALUE value);
+
+VALUE Polyphony_switchpoint();
+
+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 Polyphony_snooze(VALUE self);
+
+VALUE Polyphony_Queue_push(VALUE self, VALUE value);
+
+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/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,7 +71,7 @@ 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);
 
@@ -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));
@@ -207,7 +207,7 @@ void Init_Socket() {
 
   cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
 
-  rb_define_method(cSocket, "accept", Socket_accept, 0);
+  // rb_define_method(cSocket, "accept", Socket_accept, 0);
 
   cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
 }