polyphony 0.40 → 0.41

data/ext/gyro/queue.c

@@ -1,146 +0,0 @@
-#include "gyro.h"
-
-typedef struct queue {
-  VALUE items;
-  VALUE shift_waiters;
-} Gyro_Queue_t;
-
-VALUE cGyro_Queue = Qnil;
-
-static void Gyro_Queue_mark(void *ptr) {
-  Gyro_Queue_t *queue = ptr;
-  if (queue->items != Qnil) {
-    rb_gc_mark(queue->items);
-  }
-  if (queue->shift_waiters != Qnil) {
-    rb_gc_mark(queue->shift_waiters);
-  }
-}
-
-static size_t Gyro_Queue_size(const void *ptr) {
-  return sizeof(Gyro_Queue_t);
-}
-
-static const rb_data_type_t Gyro_Queue_type = {
-  "Gyro_Queue",
-  {Gyro_Queue_mark, RUBY_DEFAULT_FREE, Gyro_Queue_size,},
-  0, 0, 0
-};
-
-static VALUE Gyro_Queue_allocate(VALUE klass) {
-  Gyro_Queue_t *queue;
-  // return Data_Make_Struct(klass, Gyro_Queue_t, Gyro_Queue_mark, free, queue);
-
-  queue = ALLOC(Gyro_Queue_t);
-  // struct Gyro_Queue *queue = ALLOC(struct Gyro_Queue);
-  return TypedData_Wrap_Struct(klass, &Gyro_Queue_type, queue);
-}
-
-#define GetGyro_Queue(obj, queue) \
-  TypedData_Get_Struct((obj), Gyro_Queue_t, &Gyro_Queue_type, (queue))
-
-static VALUE Gyro_Queue_initialize(VALUE self) {
-  Gyro_Queue_t *queue;
-  GetGyro_Queue(self, queue);
-
-  queue->items = rb_ary_new();
-  queue->shift_waiters = rb_ary_new();
-
-  return self;
-}
-
-VALUE Gyro_Queue_push(VALUE self, VALUE value) {
-  Gyro_Queue_t *queue;
-  GetGyro_Queue(self, queue);
-
-  if (RARRAY_LEN(queue->shift_waiters) > 0) {
-    VALUE async = rb_ary_shift(queue->shift_waiters);
-    rb_funcall(async, ID_signal, 1, Qnil);
-  }
-
-  rb_ary_push(queue->items, value);
-  return self;
-}
-
-VALUE Gyro_Queue_shift(VALUE self) {
-  Gyro_Queue_t *queue;
-  GetGyro_Queue(self, queue);
-
-  if (RARRAY_LEN(queue->items) == 0) {
-    VALUE ret;
-    VALUE async = Fiber_auto_async(rb_fiber_current());
-    rb_ary_push(queue->shift_waiters, async);
-    ret = Gyro_Async_await_no_raise(async);
-    if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-      rb_ary_delete(queue->shift_waiters, async);
-      return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-    }
-    RB_GC_GUARD(ret);
-  }
-
-  return rb_ary_shift(queue->items);
-}
-
-VALUE Gyro_Queue_shift_no_wait(VALUE self) {
-  Gyro_Queue_t *queue;
-  GetGyro_Queue(self, queue);
-
-  return rb_ary_shift(queue->items);
-}
-
-VALUE Gyro_Queue_shift_each(VALUE self) {
-  Gyro_Queue_t *queue;
-  VALUE old_queue;
-  GetGyro_Queue(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 Gyro_Queue_clear(VALUE self) {
-  Gyro_Queue_t *queue;
-  GetGyro_Queue(self, queue);
-
-  rb_ary_clear(queue->items);
-  return self;
-}
-
-VALUE Gyro_Queue_empty_p(VALUE self) {
-  Gyro_Queue_t *queue;
-  GetGyro_Queue(self, queue);
-
-  return (RARRAY_LEN(queue->items) == 0) ? Qtrue : Qfalse;
-}
-
-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_no_wait", Gyro_Queue_shift_no_wait, 0);
-
-  rb_define_method(cGyro_Queue, "shift_each", Gyro_Queue_shift_each, 0);
-  rb_define_method(cGyro_Queue, "clear", Gyro_Queue_clear, 0);
-  rb_define_method(cGyro_Queue, "empty?", Gyro_Queue_empty_p, 0);
-}
-
-

data/ext/gyro/selector.c

@@ -1,205 +0,0 @@
-#include "gyro.h"
-
-struct Gyro_Selector {
-  struct  ev_loop *ev_loop;
-  long    run_no_wait_count;
-  int     ev_loop_running;
-  struct  ev_async async;
-  VALUE   active_watchers;
-};
-
-VALUE cGyro_Selector = Qnil;
-
-static void Gyro_Selector_mark(void *ptr) {
-  struct Gyro_Selector *selector = ptr;
-  rb_gc_mark(selector->active_watchers);
-}
-
-static void Gyro_Selector_free(void *ptr) {
-  struct Gyro_Selector *selector = ptr;
-  ev_async_stop(selector->ev_loop, &selector->async);
-  if (selector->ev_loop && !ev_is_default_loop(selector->ev_loop)) {
-    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, 0
-};
-
-static VALUE Gyro_Selector_allocate(VALUE klass) {
-  struct Gyro_Selector *selector = ALLOC(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;
-}
-
-inline ev_tstamp Gyro_Selector_now(VALUE self) {
-  struct Gyro_Selector *selector;
-  GetGyro_Selector(self, selector);
-
-  return ev_now(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);
-}
-
-void dummy_async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
-  // This callback does nothing, the selector's async is used solely for waking
-  // up the event loop.
-}
-
-inline void Gyro_Selector_run_ev_loop(struct Gyro_Selector *selector, int flags) {
-  selector->ev_loop_running = 1;
-  ev_run(selector->ev_loop, flags);
-  selector->ev_loop_running = 0;
-}
-
-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);
-  selector->run_no_wait_count = 0;
-
-  selector->active_watchers = rb_hash_new();
-
-  ev_async_init(&selector->async, dummy_async_callback);
-  ev_async_start(selector->ev_loop, &selector->async);
-  Gyro_Selector_run_ev_loop(selector, EVRUN_NOWAIT);
-  return Qnil;
-}
-
-inline void Gyro_Selector_add_active_watcher(VALUE self, VALUE watcher) {
-  struct Gyro_Selector *selector;
-  GetGyro_Selector(self, selector);
-
-  rb_hash_aset(selector->active_watchers, watcher, Qtrue);
-}
-
-inline void Gyro_Selector_remove_active_watcher(VALUE self, VALUE watcher) {
-  struct Gyro_Selector *selector;
-  GetGyro_Selector(self, selector);
-
-  rb_hash_delete(selector->active_watchers, watcher);
-}
-
-inline VALUE Gyro_Selector_run(VALUE self, VALUE current_fiber) {
-  struct Gyro_Selector *selector;
-  GetGyro_Selector(self, selector);
-  if (selector->ev_loop) {
-    selector->run_no_wait_count = 0;
-    FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
-    Gyro_Selector_run_ev_loop(selector, EVRUN_ONCE);
-    FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
-  }
-  return Qnil;
-}
-
-inline void Gyro_Selector_run_no_wait(VALUE self, VALUE current_fiber, long runnable_count) {
-  struct Gyro_Selector *selector;
-  GetGyro_Selector(self, selector);
-
-  selector->run_no_wait_count++;
-  if (selector->run_no_wait_count < runnable_count || selector->run_no_wait_count < 10) {
-    return;
-  }
-
-  selector->run_no_wait_count = 0;
-  FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
-  Gyro_Selector_run_ev_loop(selector, EVRUN_NOWAIT);
-  FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
-}
-
-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;
-}
-
-VALUE Gyro_Selector_post_fork(VALUE self) {
-  struct Gyro_Selector *selector;
-  GetGyro_Selector(self, selector);
-
-  ev_loop_fork(selector->ev_loop);
-  return self;
-}
-
-VALUE Gyro_Selector_break_out_of_ev_loop(VALUE self) {
-  struct Gyro_Selector *selector;
-  GetGyro_Selector(self, selector);
-
-  if (selector->ev_loop_running) {
-    // Since the loop will run until at least one event has occurred, we signal
-    // the selector's associated async watcher, which will cause the ev loop to
-    // return. In contrast to using `ev_break` to break out of the loop, which
-    // should be called from the same thread (from within the ev_loop), using an
-    // `ev_async` allows us to interrupt the event loop across threads.
-    ev_async_send(selector->ev_loop, &selector->async);
-    return Qtrue;
-  }
-
-  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);
-  VALUE ret = Gyro_Timer_await(watcher);
-  RB_GC_GUARD(watcher);
-  return ret;
-}
-
-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, 1);
-  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);
-  rb_define_method(cGyro_Selector, "break_out_of_ev_loop", Gyro_Selector_break_out_of_ev_loop, 0);
-}

data/ext/gyro/signal.c

@@ -1,99 +0,0 @@
-#include "gyro.h"
-
-struct Gyro_Signal {
-  GYRO_WATCHER_DECL(ev_signal);
-  int signum;
-};
-
-static VALUE cGyro_Signal = Qnil;
-
-static void Gyro_Signal_mark(void *ptr) {
-  struct Gyro_Signal *signal = ptr;
-  GYRO_WATCHER_MARK(signal);
-}
-
-static void Gyro_Signal_free(void *ptr) {
-  struct Gyro_Signal *signal = ptr;
-  GYRO_WATCHER_FREE(signal);
-}
-
-static size_t Gyro_Signal_size(const void *ptr) {
-  return sizeof(struct Gyro_Signal);
-}
-
-static const rb_data_type_t Gyro_Signal_type = {
-    "Gyro_Signal",
-    {Gyro_Signal_mark, Gyro_Signal_free, Gyro_Signal_size,},
-    0, 0, 0
-};
-
-static VALUE Gyro_Signal_allocate(VALUE klass) {
-  struct Gyro_Signal *signal = ALLOC(struct Gyro_Signal);
-  return TypedData_Wrap_Struct(klass, &Gyro_Signal_type, signal);
-}
-
-inline void signal_activate(struct Gyro_Signal *signal) {
-  if (signal->active) return;
-
-  signal->active = 1;
-  signal->fiber = rb_fiber_current();
-  signal->selector = Thread_current_event_selector();
-  signal->ev_loop = Gyro_Selector_ev_loop(signal->selector);
-  Gyro_Selector_add_active_watcher(signal->selector, signal->self);
-  ev_signal_start(signal->ev_loop, &signal->ev_signal);
-}
-
-inline void signal_deactivate(struct Gyro_Signal *signal) {
-  if (!signal->active) return;
-
-  ev_signal_stop(signal->ev_loop, &signal->ev_signal);
-  Gyro_Selector_remove_active_watcher(signal->selector, signal->self);
-  signal->active = 0;
-  signal->ev_loop = 0;
-  signal->selector = Qnil;
-  signal->fiber = 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;
-
-  Fiber_make_runnable(signal->fiber, INT2NUM(signal->signum));
-  signal_deactivate(signal);
-}
-
-#define GetGyro_Signal(obj, signal) \
-  TypedData_Get_Struct((obj), struct Gyro_Signal, &Gyro_Signal_type, (signal))
-
-static VALUE Gyro_Signal_initialize(VALUE self, VALUE sig) {
-  struct Gyro_Signal *signal;
-  VALUE signum = sig;
-
-  GetGyro_Signal(self, signal);
-  GYRO_WATCHER_INITIALIZE(signal, self);
-  signal->signum = NUM2INT(signum);
-  ev_signal_init(&signal->ev_signal, Gyro_Signal_callback, signal->signum);
-
-  return Qnil;
-}
-
-static VALUE Gyro_Signal_await(VALUE self) {
-  struct Gyro_Signal *signal;
-  VALUE ret;
-  GetGyro_Signal(self, signal);
-
-  signal_activate(signal);
-  ret = Gyro_switchpoint();
-  signal_deactivate(signal);
-
-  TEST_RESUME_EXCEPTION(ret);
-  RB_GC_GUARD(ret);
-  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);
-}