polyphony 0.40 → 0.43.2

data/ext/polyphony/libev_queue.c

@@ -0,0 +1,217 @@
+#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;
+  GetQueue(self, queue);
+  if (queue->shift_queue.count > 0) {
+    struct async_watcher *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 libev_agent_await(VALUE self);
+
+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 = libev_agent_await(agent);
+    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,17 +1,14 @@
-#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;
 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;
@@ -25,7 +22,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 +33,7 @@ VALUE Gyro_snooze(VALUE self) {
   return ret;
 }
 
-static VALUE Gyro_ref(VALUE self) {
-  return Thread_ref(rb_thread_current());
-}
-
-static VALUE Gyro_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,38 +41,28 @@ 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, "trace", Polyphony_trace, 1);
 
-  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");
   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");
@@ -91,8 +70,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(obj) { VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf("%s\n", StringValueCStr(s));}
+#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 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 LibevAgent_ref(VALUE self);
+VALUE LibevAgent_unref(VALUE self);
+int LibevAgent_ref_count(VALUE self);
+void LibevAgent_reset_ref_count(VALUE self);
+
+VALUE Polyphony_snooze(VALUE self);
+
+VALUE Polyphony_Queue_push(VALUE self, VALUE value);
+
+VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
+VALUE Thread_switch_fiber(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,21 @@
+#include "polyphony.h"
+
+void Init_Fiber();
+void Init_Polyphony();
+void Init_LibevAgent();
+void Init_LibevQueue();
+void Init_Thread();
+void Init_Tracing();
+
+void Init_polyphony_ext() {
+  ev_set_allocator(xrealloc);
+
+  Init_Polyphony();
+  Init_LibevAgent();
+  Init_LibevQueue();
+
+  Init_Fiber();
+  Init_Thread();
+
+  Init_Tracing();
+}

data/ext/{gyro → polyphony}/thread.c

@@ -1,115 +1,48 @@
-#include "gyro.h"
-
-static VALUE cQueue;
-
-static ID ID_create_event_selector;
-static ID ID_deactivate_all_watchers_post_fork;
-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_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);
-}
+#include "polyphony.h"
+
+ID ID_deactivate_all_watchers_post_fork;
+ID ID_ivar_agent;
+ID ID_ivar_join_wait_queue;
+ID ID_ivar_main_fiber;
+ID ID_ivar_result;
+ID ID_ivar_terminated;
+ID ID_run_queue;
+ID ID_runnable_next;
+ID ID_stop;
 
 static VALUE Thread_setup_fiber_scheduling(VALUE self) {
   VALUE queue;
-  VALUE selector;
   
   rb_ivar_set(self, ID_ivar_main_fiber, rb_fiber_current());
-  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
   queue = rb_ary_new();
   rb_ivar_set(self, ID_run_queue, queue);
-  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;
-}
-
-static VALUE Thread_deactivate_all_watchers_post_fork(VALUE self) {
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  if (selector != Qnil) {
-    rb_funcall(selector, ID_deactivate_all_watchers_post_fork, 0);
-  }
-
-  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);
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  return NUM2INT(LibevAgent_ref_count(agent));
 }
 
-void Thread_fiber_reset_ref_count(VALUE self) {
-  rb_ivar_set(self, ID_fiber_ref_count, INT2NUM(0));
+inline void Thread_fiber_reset_ref_count(VALUE self) {
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+  LibevAgent_reset_ref_count(agent);
 }
 
 static VALUE SYM_scheduled_fibers;
 static VALUE SYM_pending_watchers;
 
 static VALUE Thread_fiber_scheduling_stats(VALUE self) {
+  VALUE agent = rb_ivar_get(self,ID_ivar_agent);
   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 pending_count;
 
   long scheduled_count = RARRAY_LEN(queue);
   rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
 
-  pending_count = Gyro_Selector_pending_count(selector);
+  pending_count = LibevAgent_pending_count(agent);
   rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
 
   return stats;
@@ -137,10 +70,8 @@ VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
     // 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);
-    }
+    VALUE agent = rb_ivar_get(self,ID_ivar_agent);
+    LibevAgent_break(agent);
   }
   return self;
 }
@@ -168,13 +99,11 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
   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
+    // event loop. 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);
-    }
+    VALUE agent = rb_ivar_get(self, ID_ivar_agent);
+    LibevAgent_break(agent);
   }
   return self;
 }
@@ -182,9 +111,9 @@ VALUE Thread_schedule_fiber_with_priority(VALUE self, VALUE fiber, VALUE value)
 VALUE Thread_switch_fiber(VALUE self) {
   VALUE current_fiber = rb_fiber_current();
   VALUE queue = rb_ivar_get(self, ID_run_queue);
-  VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
   VALUE next_fiber;
   VALUE value;
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
   int ref_count;
 
   if (__tracing_enabled__) {
@@ -193,31 +122,23 @@ VALUE Thread_switch_fiber(VALUE self) {
     }
   }
 
-
+  ref_count = LibevAgent_ref_count(agent);
   while (1) {
     next_fiber = rb_ary_shift(queue);
-    // if (break_flag != 0) {
-    //   return Qnil;
-    // }
-    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));
+        LibevAgent_poll(agent, Qtrue, current_fiber, queue);
       }
       break;
     }
-    if (ref_count == 0) {
-      break;
-    }
+    if (ref_count == 0) break;
 
-    Gyro_Selector_run(selector, current_fiber);
+    LibevAgent_poll(agent, Qnil, current_fiber, queue);
   }
 
-  if (next_fiber == Qnil) {
-    return Qnil;
-  }
+  if (next_fiber == Qnil) return Qnil;
 
   // run next fiber
   value = rb_ivar_get(next_fiber, ID_runnable_value);
@@ -226,7 +147,8 @@ VALUE Thread_switch_fiber(VALUE self) {
   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);
+  return (next_fiber == current_fiber) ? 
+    value : rb_funcall(next_fiber, ID_transfer, 1, value);
 }
 
 VALUE Thread_reset_fiber_scheduling(VALUE self) {
@@ -236,34 +158,13 @@ VALUE Thread_reset_fiber_scheduling(VALUE 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 ret;
-  VALUE thread = rb_thread_current();
-  Thread_ref(thread);
-  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);
+  VALUE agent = rb_ivar_get(self, ID_ivar_agent);
   if (fiber != Qnil) {
     Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
   }
 
-  if (Gyro_Selector_break_out_of_ev_loop(selector) == Qnil) {
+  if (LibevAgent_break(agent) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
@@ -272,19 +173,7 @@ VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE fiber, VALUE resume_ob
 }
 
 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, "deactivate_all_watchers_post_fork", Thread_deactivate_all_watchers_post_fork, 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);
@@ -294,18 +183,12 @@ void Init_Thread() {
     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_deactivate_all_watchers_post_fork = rb_intern("deactivate_all_watchers_post_fork");
-  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_agent               = rb_intern("@agent");
   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");