polyphony 0.34 → 0.41

data/ext/gyro/queue.c

@@ -1,142 +0,0 @@
-#include "gyro.h"
-
-struct Gyro_Queue {
-  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->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);
-    rb_funcall(async, ID_signal_bang, 1, Qnil);
-  }
-  
-  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) {
-    VALUE async = rb_funcall(cGyro_Async, ID_new, 0);
-    rb_ary_push(queue->wait_queue, async);
-    VALUE ret = Gyro_Async_await_no_raise(async);
-    if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-      rb_ary_delete(queue->wait_queue, async);
-      return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-    }
-  }
-
-  return rb_ary_shift(queue->queue);
-}
-
-VALUE Gyro_Queue_shift_no_wait(VALUE self) {
-  struct Gyro_Queue *queue;
-  GetGyro_Queue(self, queue);
-
-  return rb_ary_shift(queue->queue);
-}
-
-VALUE Gyro_Queue_shift_each(VALUE self) {
-  struct Gyro_Queue *queue;
-  GetGyro_Queue(self, queue);
-
-  VALUE old_queue = queue->queue;
-  queue->queue = 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 {
-    return old_queue;
-  }
-}
-
-VALUE Gyro_Queue_clear(VALUE self) {
-  struct Gyro_Queue *queue;
-  GetGyro_Queue(self, queue);
-
-  rb_ary_clear(queue->queue);
-  return self;
-}
-
-VALUE Gyro_Queue_empty_p(VALUE self) {
-  struct Gyro_Queue *queue;
-  GetGyro_Queue(self, queue);
-
-  return (RARRAY_LEN(queue->queue) == 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,183 +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 cGyro_Selector = Qnil;
-
-static void Gyro_Selector_mark(void *ptr) {
-  // struct Gyro_Selector *selector = ptr;
-}
-
-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)) {
-    // printf("Selector garbage collected before being stopped!\n");
-    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,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-static VALUE Gyro_Selector_allocate(VALUE klass) {
-  struct Gyro_Selector *selector = (struct Gyro_Selector *)xmalloc(sizeof(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.
-}
-
-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;
-
-  ev_async_init(&selector->async, dummy_async_callback);
-  ev_async_start(selector->ev_loop, &selector->async);
-  ev_run(selector->ev_loop, EVRUN_NOWAIT);
-  return Qnil;
-}
-
-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);
-    selector->ev_loop_running = 1;
-    ev_run(selector->ev_loop, EVRUN_ONCE);
-    selector->ev_loop_running = 0;
-    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);
-  ev_run(selector->ev_loop, 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);
-  return Gyro_Timer_await(watcher);
-}
-
-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,108 +0,0 @@
-#include "gyro.h"
-
-struct Gyro_Signal {
-  struct  ev_signal ev_signal;
-  struct  ev_loop *ev_loop;
-  int     active;
-  int     signum;
-  VALUE   fiber;
-};
-
-static VALUE cGyro_Signal = Qnil;
-
-static void Gyro_Signal_mark(void *ptr) {
-  struct Gyro_Signal *signal = ptr;
-  if (signal->fiber != Qnil) {
-    rb_gc_mark(signal->fiber);
-  }
-}
-
-static void Gyro_Signal_free(void *ptr) {
-  struct Gyro_Signal *signal = ptr;
-  if (signal->active) {
-    printf("Signal watcher garbage collected while still active!\n");
-    // ev_signal_stop(signal->ev_loop, &signal->ev_signal);
-  }
-  xfree(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,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-static VALUE Gyro_Signal_allocate(VALUE klass) {
-  struct Gyro_Signal *signal = (struct Gyro_Signal *)xmalloc(sizeof(struct Gyro_Signal));
-  return TypedData_Wrap_Struct(klass, &Gyro_Signal_type, signal);
-}
-
-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;
-
-  if (signal->fiber != Qnil) {
-    VALUE fiber = signal->fiber;
-
-    ev_signal_stop(signal->ev_loop, ev_signal);
-    signal->active = 0;
-    signal->fiber = Qnil;
-    Gyro_schedule_fiber(fiber, INT2NUM(signal->signum));
-  }
-}
-
-#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);
-  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->fiber = rb_fiber_current();
-  signal->active = 1;
-  signal->ev_loop = Gyro_Selector_current_thread_ev_loop();
-  ev_signal_start(signal->ev_loop, &signal->ev_signal);
-
-  ret = Fiber_await();
-  RB_GC_GUARD(ret);
-
-  if (signal->active) {
-    signal->active = 0;
-    signal->fiber = Qnil;
-    ev_signal_stop(signal->ev_loop, &signal->ev_signal);
-  }
-
-  // fiber is resumed, check if resumed value is an exception
-  signal->fiber = Qnil;
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-  }
-  else
-    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);
-}

data/ext/gyro/timer.c

@@ -1,154 +0,0 @@
-#include "gyro.h"
-
-struct Gyro_Timer {
-  struct  ev_timer ev_timer;
-  struct  ev_loop *ev_loop;
-  int     active;
-  double  after;
-  double  repeat;
-  int     should_free;
-  VALUE   self;
-  VALUE   fiber;
-  VALUE   selector;
-};
-
-VALUE cGyro_Timer = Qnil;
-
-static void Gyro_Timer_mark(void *ptr) {
-  struct Gyro_Timer *timer = ptr;
-  if (timer->fiber != Qnil) {
-    rb_gc_mark(timer->fiber);
-  }
-  if (timer->selector != Qnil) {
-    rb_gc_mark(timer->selector);
-  }
-}
-
-static void Gyro_Timer_free(void *ptr) {
-  struct Gyro_Timer *timer = ptr;
-  if (timer->active) {
-    printf("Timer watcher garbage collected while still active (%g, %g)!\n", timer->after, timer->repeat);
-    timer->should_free = 1;
-  } else {
-    xfree(timer);
-  }
-}
-
-static size_t Gyro_Timer_size(const void *ptr) {
-  return sizeof(struct Gyro_Timer);
-}
-
-static const rb_data_type_t Gyro_Timer_type = {
-    "Gyro_Timer",
-    {Gyro_Timer_mark, Gyro_Timer_free, Gyro_Timer_size,},
-    0, 0,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-};
-
-static VALUE Gyro_Timer_allocate(VALUE klass) {
-  struct Gyro_Timer *timer = (struct Gyro_Timer *)xmalloc(sizeof(struct Gyro_Timer));
-  return TypedData_Wrap_Struct(klass, &Gyro_Timer_type, timer);
-}
-#define GetGyro_Timer(obj, timer) \
-  TypedData_Get_Struct((obj), struct Gyro_Timer, &Gyro_Timer_type, (timer))
-
-void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int revents) {
-  struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
-
-  if (timer->should_free) {
-    ev_timer_stop(timer->ev_loop, ev_timer);
-    xfree(timer);
-    return;
-  }
-
-  if (!timer->repeat) {
-    timer->active = 0;
-    timer->selector = Qnil;
-  }
-
-  if (timer->fiber != Qnil) {
-    Gyro_schedule_fiber(timer->fiber, DBL2NUM(timer->after));
-  }
-}
-
-static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
-  struct Gyro_Timer *timer;
-
-  GetGyro_Timer(self, timer);
-
-  timer->self     = self;
-  timer->fiber    = Qnil;
-  timer->after    = NUM2DBL(after);
-  timer->repeat   = NUM2DBL(repeat);
-  timer->active   = 0;
-
-  timer->should_free    = 0;
-
-  ev_timer_init(&timer->ev_timer, Gyro_Timer_callback, timer->after, timer->repeat);
-  timer->ev_loop = 0;
-  timer->selector = Qnil;
-
-  return Qnil;
-}
-
-VALUE Gyro_Timer_stop(VALUE self) {
-  struct Gyro_Timer *timer;
-  GetGyro_Timer(self, timer);
-
-  if (timer->active) {
-    timer->active = 0;
-    timer->fiber = Qnil;
-    timer->selector = Qnil;
-    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-    timer->ev_loop = 0;
-  }
-
-  return self;
-}
-
-VALUE Gyro_Timer_await(VALUE self) {
-  struct Gyro_Timer *timer;
-  VALUE ret;
-  
-  GetGyro_Timer(self, timer);
-
-  timer->fiber = rb_fiber_current();
-  timer->selector = Thread_current_event_selector();
-  timer->ev_loop = Gyro_Selector_ev_loop(timer->selector);
-
-  if (timer->active != 1) {
-    timer->active = 1;
-    ev_timer_start(timer->ev_loop, &timer->ev_timer);
-  }
-
-  ret = Fiber_await();
-  RB_GC_GUARD(ret);
-
-  if (timer->active && (timer->repeat == .0)) {
-    timer->active = 0;
-    timer->fiber = Qnil;
-    timer->selector = Qnil;
-    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-    timer->ev_loop = 0;
-  }
-
-  // fiber is resumed, check if resumed value is an exception
-  timer->fiber = Qnil;
-  timer->selector = Qnil;
-
-  RB_GC_GUARD(self);
-  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
-    return rb_funcall(rb_mKernel, ID_raise, 1, ret);
-  }
-  else
-    return ret;
-}
-
-void Init_Gyro_Timer() {
-  cGyro_Timer = rb_define_class_under(mGyro, "Timer", rb_cData);
-  rb_define_alloc_func(cGyro_Timer, Gyro_Timer_allocate);
-
-  rb_define_method(cGyro_Timer, "initialize", Gyro_Timer_initialize, 2);
-  rb_define_method(cGyro_Timer, "stop", Gyro_Timer_stop, 0);
-  rb_define_method(cGyro_Timer, "await", Gyro_Timer_await, 0);
-}