polyphony 0.36 → 0.42

data/ext/gyro/thread.c

@@ -1,298 +0,0 @@
-#include "gyro.h"
-
-static VALUE cQueue;
-
-static ID ID_create_event_selector;
-static ID ID_empty;
-static ID ID_fiber_ref_count;
-static ID ID_ivar_event_selector_proc;
-static ID ID_ivar_event_selector;
-static ID ID_ivar_join_wait_queue;
-static ID ID_ivar_main_fiber;
-static ID ID_ivar_result;
-static ID ID_ivar_terminated;
-static ID ID_pop;
-static ID ID_push;
-static ID ID_run_queue;
-// static ID ID_run_queue_head;
-// static ID ID_run_queue_tail;
-static ID ID_runnable_next;
-static ID ID_stop;
-
-VALUE event_selector_factory_proc(RB_BLOCK_CALL_FUNC_ARGLIST(args, klass)) {
-  return rb_funcall(klass, ID_new, 1, rb_ary_entry(args, 0));
-}
-
-static VALUE Thread_event_selector_set_proc(VALUE self, VALUE proc) {
-  if (!rb_obj_is_proc(proc)) {
-    proc = rb_proc_new(event_selector_factory_proc, proc);
-  }
-  rb_ivar_set(self, ID_ivar_event_selector_proc, proc);
-  return self;
-}
-
-static VALUE Thread_create_event_selector(VALUE self, VALUE thread) {
-  VALUE selector_proc = rb_ivar_get(self, ID_ivar_event_selector_proc);
-  if (selector_proc == Qnil) {
-    rb_raise(rb_eRuntimeError, "No event_selector_proc defined");
-  }
-
-  return rb_funcall(selector_proc, ID_call, 1, thread);
-}
-
-static VALUE Thread_setup_fiber_scheduling(VALUE self) {
-  rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
-  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
-  VALUE queue = rb_ary_new();
-  rb_ivar_set(self, ID_run_queue, queue);
-  VALUE selector = rb_funcall(rb_cThread, ID_create_event_selector, 1, self);
-  rb_ivar_set(self, ID_ivar_event_selector, selector);
-
-  return self;
-}
-
-static VALUE Thread_stop_event_selector(VALUE self) {
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  if (selector != Qnil) {
-    rb_funcall(selector, ID_stop, 0);
-  }
-  // Nullify the selector in order to prevent running the
-  // selector after the thread is done running.
-  rb_ivar_set(self, ID_ivar_event_selector, Qnil);
-
-  return self;
-}
-
-VALUE Thread_ref(VALUE self) {
-  VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
-  int new_count = NUM2INT(count) + 1;
-  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(new_count));
-  return self;
-}
-
-VALUE Thread_unref(VALUE self) {
-  VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
-  int new_count = NUM2INT(count) - 1;
-  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(new_count));
-  return self;
-}
-
-int Thread_fiber_ref_count(VALUE self) {
-  VALUE count = rb_ivar_get(self, ID_fiber_ref_count);
-  return NUM2INT(count);
-}
-
-void Thread_fiber_reset_ref_count(VALUE self) {
-  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
-}
-
-static VALUE SYM_scheduled_fibers;
-static VALUE SYM_pending_watchers;
-
-static VALUE Thread_fiber_scheduling_stats(VALUE self) {
-  VALUE stats = rb_hash_new();
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  
-  long scheduled_count = RARRAY_LEN(queue);
-  rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
-
-  long pending_count = Gyro_Selector_pending_count(selector);
-  rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
-
-  return stats;
-}
-
-VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
-  if (rb_fiber_alive_p(fiber) != Qtrue) {
-    return self;
-  }
-
-  FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
-  // if fiber is already scheduled, just set the scheduled value, then return
-  rb_ivar_set(fiber, ID_runnable_value, value);
-  if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
-    return self;
-  }
-
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  rb_ary_push(queue, fiber);
-  rb_ivar_set(fiber, ID_runnable, Qtrue);
-
-  if (rb_thread_current() != self) {
-    // if the fiber scheduling is done across threads, we need to make sure the
-    // target thread is woken up in case it is in the middle of running its
-    // event selector. Otherwise it's gonna be stuck waiting for an event to
-    // happen, not knowing that it there's already a fiber ready to run in its
-    // run queue.
-    VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-    if (selector != Qnil) {
-      Gyro_Selector_break_out_of_ev_loop(selector);
-    }
-  }
-  return self;
-}
-
-VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value) {
-  if (rb_fiber_alive_p(fiber) != Qtrue) {
-    return self;
-  }
-  FIBER_TRACE(3, SYM_fiber_schedule, fiber, value);
-  rb_ivar_set(fiber, ID_runnable_value, value);
-
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-
-  // if fiber is already scheduled, remove it from the run queue
-  if (rb_ivar_get(fiber, ID_runnable) != Qnil) {
-    rb_ary_delete(queue, fiber);
-  } else {
-    rb_ivar_set(fiber, ID_runnable, Qtrue);
-  }
-
-  // the fiber is given priority by putting it at the front of the run queue
-  rb_ary_unshift(queue, fiber);
-
-  if (rb_thread_current() != self) {
-    // if the fiber scheduling is done across threads, we need to make sure the
-    // target thread is woken up in case it is in the middle of running its
-    // event selector. Otherwise it's gonna be stuck waiting for an event to
-    // happen, not knowing that it there's already a fiber ready to run in its
-    // run queue.
-    VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-    if (selector != Qnil) {
-      Gyro_Selector_break_out_of_ev_loop(selector);
-    }
-  }
-  return self;
-}
-
-VALUE Thread_switch_fiber(VALUE self) {
-  VALUE current_fiber = rb_fiber_current();
-  if (__tracing_enabled__) {
-    if (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse) {
-      rb_funcall(rb_cObject, ID_fiber_trace, 2, SYM_fiber_switchpoint, current_fiber);
-    }
-  }
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-
-  VALUE next_fiber;
-
-  while (1) {
-    next_fiber = rb_ary_shift(queue);
-    // if (break_flag != 0) {
-    //   return Qnil;
-    // }
-    int ref_count = Thread_fiber_ref_count(self);
-    if (next_fiber != Qnil) {
-      if (ref_count > 0) {
-        // this mechanism prevents event starvation in case the run queue never
-        // empties
-        Gyro_Selector_run_no_wait(selector, current_fiber, RARRAY_LEN(queue));
-      }
-      break;
-    }
-    if (ref_count == 0) {
-      break;
-    }
-
-    Gyro_Selector_run(selector, current_fiber);
-  }
-
-  if (next_fiber == Qnil) {
-    return Qnil;
-  }
-
-  // run next fiber
-  VALUE value = rb_ivar_get(next_fiber, ID_runnable_value);
-  FIBER_TRACE(3, SYM_fiber_run, next_fiber, value);
-
-  rb_ivar_set(next_fiber, ID_runnable, Qnil);
-  RB_GC_GUARD(next_fiber);
-  RB_GC_GUARD(value);
-  return rb_funcall(next_fiber, ID_transfer, 1, value);
-}
-
-VALUE Thread_reset_fiber_scheduling(VALUE self) {
-  VALUE queue = rb_ivar_get(self, ID_run_queue);
-  rb_ary_clear(queue);
-  Thread_fiber_reset_ref_count(self);
-  return self;
-}
-
-VALUE Thread_post_fork(VALUE self) {
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  Gyro_Selector_post_fork(selector);
-
-  return self;
-}
-
-VALUE Gyro_switchpoint() {
-  VALUE thread = rb_thread_current();
-  Thread_ref(thread);
-  VALUE ret = Thread_switch_fiber(thread);
-  Thread_unref(thread);
-  RB_GC_GUARD(ret);
-  return ret;
-}
-
-VALUE Thread_current_event_selector() {
-  return rb_ivar_get(rb_thread_current(), ID_ivar_event_selector);
-}
-
-VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE fiber, VALUE resume_obj) {
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  if (fiber != Qnil) {
-    Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
-  }
-
-  if (Gyro_Selector_break_out_of_ev_loop(selector) == Qnil) {
-    // we're not inside the ev_loop, so we just do a switchpoint
-    Thread_switch_fiber(self);
-  }
-
-  return self;
-}
-
-void Init_Thread() {
-  cQueue = rb_const_get(rb_cObject, rb_intern("Queue"));
-
-  rb_define_singleton_method(rb_cThread, "event_selector=", Thread_event_selector_set_proc, 1);
-  rb_define_singleton_method(rb_cThread, "create_event_selector", Thread_create_event_selector, 1);
-
-  rb_define_method(rb_cThread, "fiber_ref", Thread_ref, 0);
-  rb_define_method(rb_cThread, "fiber_unref", Thread_unref, 0);
-
-  rb_define_method(rb_cThread, "post_fork", Thread_post_fork, 0);
-
-  rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
-  rb_define_method(rb_cThread, "stop_event_selector", Thread_stop_event_selector, 0);
-  rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
-  rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
-  rb_define_method(rb_cThread, "break_out_of_ev_loop", Thread_fiber_break_out_of_ev_loop, 2);
-
-  rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 2);
-  rb_define_method(rb_cThread, "schedule_fiber_with_priority",
-    Thread_schedule_fiber_with_priority, 2);
-  rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
-
-  ID_create_event_selector    = rb_intern("create_event_selector");
-  ID_empty                    = rb_intern("empty?");
-  ID_fiber_ref_count          = rb_intern("fiber_ref_count");
-  ID_ivar_event_selector      = rb_intern("@event_selector");
-  ID_ivar_event_selector_proc = rb_intern("@event_selector_proc");
-  ID_ivar_join_wait_queue     = rb_intern("@join_wait_queue");
-  ID_ivar_main_fiber          = rb_intern("@main_fiber");
-  ID_ivar_result              = rb_intern("@result");
-  ID_ivar_terminated          = rb_intern("@terminated");
-  ID_pop                      = rb_intern("pop");
-  ID_push                     = rb_intern("push");
-  ID_run_queue                = rb_intern("run_queue");
-  ID_runnable_next            = rb_intern("runnable_next");
-  ID_stop                     = rb_intern("stop");
-
-  SYM_scheduled_fibers = ID2SYM(rb_intern("scheduled_fibers"));
-  SYM_pending_watchers = ID2SYM(rb_intern("pending_watchers"));
-  rb_global_variable(&SYM_scheduled_fibers);
-  rb_global_variable(&SYM_pending_watchers);
-}

data/ext/gyro/timer.c

@@ -1,134 +0,0 @@
-#include "gyro.h"
-
-struct Gyro_Timer {
-  struct  ev_timer ev_timer;
-  struct  ev_loop *ev_loop;
-  int     active;
-  double  after;
-  double  repeat;
-  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) {
-    ev_clear_pending(timer->ev_loop, &timer->ev_timer);
-    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-  }
-  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, 0
-};
-
-static VALUE Gyro_Timer_allocate(VALUE klass) {
-  struct Gyro_Timer *timer = ALLOC(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))
-
-inline void Gyro_Timer_activate(struct Gyro_Timer *timer) {
-  timer->fiber = rb_fiber_current();
-  timer->selector = Thread_current_event_selector();
-  timer->ev_loop = Gyro_Selector_ev_loop(timer->selector);
-
-  if (timer->active) return;
-
-  timer->active = 1;
-  Gyro_Selector_add_active_watcher(timer->selector, timer->self);
-  ev_timer_start(timer->ev_loop, &timer->ev_timer);
-}
-
-inline void Gyro_Timer_deactivate(struct Gyro_Timer *timer, int non_recurring_only) {
-  if (!timer->active) return;
-
-  if (!timer->repeat || !non_recurring_only) {
-    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-    if (RTEST(timer->selector)) {
-      Gyro_Selector_remove_active_watcher(timer->selector, timer->self);
-      timer->selector = Qnil;
-    }
-    timer->ev_loop = 0;
-    timer->active = 0;
-  }
-
-  timer->fiber = Qnil;
-}
-
-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;
-
-  Fiber_make_runnable(timer->fiber, DBL2NUM(timer->after));
-  Gyro_Timer_deactivate(timer, 1);
-}
-
-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->selector = Qnil;
-  timer->after    = NUM2DBL(after);
-  timer->repeat   = NUM2DBL(repeat);
-  timer->active   = 0;
-  timer->ev_loop  = 0;
-
-  ev_timer_init(&timer->ev_timer, Gyro_Timer_callback, timer->after, timer->repeat);
-
-  return Qnil;
-}
-
-VALUE Gyro_Timer_stop(VALUE self) {
-  struct Gyro_Timer *timer;
-  GetGyro_Timer(self, timer);
-
-  Gyro_Timer_deactivate(timer, 0);
-  return self;
-}
-
-VALUE Gyro_Timer_await(VALUE self) {
-  struct Gyro_Timer *timer;
-  GetGyro_Timer(self, timer);
-
-  Gyro_Timer_activate(timer);
-  VALUE ret = Gyro_switchpoint();
-  Gyro_Timer_deactivate(timer, 1);
-
-  TEST_RESUME_EXCEPTION(ret);
-  RB_GC_GUARD(ret);
-  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);
-}

data/test/test_timer.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TimerTest < MiniTest::Test
-  def test_that_one_shot_timer_works
-    count = 0
-    t = Gyro::Timer.new(0.01, 0)
-    spin {
-      t.await
-      count += 1
-    }
-    suspend
-    assert_equal 1, count
-  end
-
-  def test_that_repeating_timer_works
-    count = 0
-    t = Gyro::Timer.new(0.001, 0.001)
-    spin {
-      loop {
-        t.await
-        count += 1
-        break if count >= 3
-      }
-    }
-    suspend
-    assert_equal 3, count
-  ensure
-    t.stop
-  end
-
-  def test_that_repeating_timer_compensates_for_drift
-    count = 0
-    t = Gyro::Timer.new(0.1, 0.1)
-    deltas = []
-    last = nil
-    spin {
-      last = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-      loop {
-        t.await
-        now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        elapsed = (now - last)
-        deltas << elapsed
-        last = now
-        count += 1
-        sleep 0.05
-        break if count >= 3
-      }
-    }
-    suspend
-    assert_equal 0, deltas[1..-1].filter { |d| (d - 0.1).abs >= 0.05 }.size
-  ensure
-    t.stop
-  end
-end