polyphony 0.34 → 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/polyphony/polyphony.c

@@ -0,0 +1,89 @@
+#include "polyphony.h"
+
+VALUE mPolyphony;
+
+ID ID_await_no_raise;
+ID ID_call;
+ID ID_caller;
+ID ID_clear;
+ID ID_each;
+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;
+ID ID_switch_fiber;
+ID ID_transfer;
+ID ID_R;
+ID ID_W;
+ID ID_RW;
+
+VALUE Polyphony_snooze(VALUE self) {
+  VALUE ret;
+  VALUE fiber = rb_fiber_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 Polyphony_ref(VALUE self) {
+  return Thread_ref(rb_thread_current());
+}
+
+static VALUE Polyphony_unref(VALUE self) {
+  return Thread_unref(rb_thread_current());
+}
+
+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 Polyphony_trace(VALUE self, VALUE enabled) {
+  __tracing_enabled__ = RTEST(enabled) ? 1 : 0;
+  return Qnil;
+}
+
+void Init_Polyphony() {
+  mPolyphony = rb_define_module("Polyphony");
+
+  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_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");
+  ID_each           = rb_intern("each");
+  ID_empty          = rb_intern("empty?");
+  ID_inspect        = rb_intern("inspect");
+  ID_ivar_running   = rb_intern("@running");
+  ID_ivar_thread    = rb_intern("@thread");
+  ID_new            = rb_intern("new");
+  ID_pop            = rb_intern("pop");
+  ID_push           = rb_intern("push");
+  ID_raise          = rb_intern("raise");
+  ID_runnable       = rb_intern("runnable");
+  ID_runnable_value = rb_intern("runnable_value");
+  ID_signal         = rb_intern("signal");
+  ID_size           = rb_intern("size");
+  ID_switch_fiber   = rb_intern("switch_fiber");
+  ID_transfer       = rb_intern("transfer");
+}

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

@@ -5,87 +5,41 @@
 #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__); \
 }
 
-extern VALUE mGyro;
-extern VALUE cGyro_Async;
-extern VALUE cGyro_IO;
-extern VALUE cGyro_Queue;
-extern VALUE cGyro_Selector;
-extern VALUE cGyro_Timer;
+#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_bang;
+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;
@@ -97,4 +51,40 @@ 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();
+}