ever 0.1

data/ext/ever/ever.h

@@ -0,0 +1,49 @@
+#ifndef EVER_H
+#define EVER_H
+
+#include <execinfo.h>
+#include "ruby.h"
+#include "../libev/ev.h"
+
+// debugging
+#define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
+#define INSPECT(str, obj) { printf(str); VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf(": %s\n", StringValueCStr(s)); }
+#define TRACE_CALLER() { VALUE c = rb_funcall(rb_mKernel, rb_intern("caller"), 0); INSPECT("caller: ", c); }
+#define TRACE_C_STACK() { \
+  void *entries[10]; \
+  size_t size = backtrace(entries, 10); \
+  char **strings = backtrace_symbols(entries, size); \
+  for (unsigned long i = 0; i < size; i++) printf("%s\n", strings[i]); \
+  free(strings); \
+}
+
+// exceptions
+#define TEST_EXCEPTION(ret) (rb_obj_is_kind_of(ret, rb_eException) == Qtrue)
+#define RAISE_EXCEPTION(e) rb_funcall(e, ID_invoke, 0);
+#define RAISE_IF_EXCEPTION(ret) if (rb_obj_is_kind_of(ret, rb_eException) == Qtrue) { RAISE_EXCEPTION(ret); }
+#define RAISE_IF_NOT_NIL(ret) if (ret != Qnil) { RAISE_EXCEPTION(ret); }
+
+extern VALUE mEver;
+extern VALUE cLoop;
+extern VALUE cWatcher;
+
+typedef struct Loop_t {
+  struct ev_loop *ev_loop;
+  struct ev_async break_async;
+
+  VALUE active_watchers;
+  VALUE free_watchers;
+  VALUE queued_events;
+  
+  int stop;
+  int in_ev_loop;
+} Loop_t;
+
+void loop_emit(Loop_t *loop, VALUE key);
+void loop_release_watcher(Loop_t *loop, VALUE key);
+
+void Watcher_setup_io(VALUE watcher, Loop_t *loop, VALUE key, int fd, int events, int oneshot);
+void Watcher_setup_timer(VALUE watcher, Loop_t *loop, VALUE key, double timeout, double interval);
+void Watcher_stop(VALUE watcher);
+
+#endif /* EVER_H */

data/ext/ever/ever_ext.c

@@ -0,0 +1,12 @@
+#include "ever.h"
+
+void Init_Loop();
+void Init_Watcher();
+
+VALUE mEver;
+
+void Init_ever_ext() {
+  mEver = rb_define_module("Ever");
+  Init_Loop();
+  Init_Watcher();
+}

data/ext/ever/extconf.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'mkmf'
+
+$defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
+$defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
+$defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')
+$defs << '-DEV_USE_EPOLL'        if have_header('sys/epoll.h')
+$defs << '-DEV_USE_KQUEUE'       if have_header('sys/event.h') && have_header('sys/queue.h')
+$defs << '-DEV_USE_PORT'         if have_type('port_event_t', 'port.h')
+$defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')  
+
+$CFLAGS << " -Wno-comment"
+$CFLAGS << " -Wno-unused-result"
+$CFLAGS << " -Wno-dangling-else"
+$CFLAGS << " -Wno-parentheses"
+
+CONFIG['optflags'] << ' -fno-strict-aliasing' unless RUBY_PLATFORM =~ /mswin/
+
+dir_config 'ever_ext'
+create_makefile 'ever_ext'

data/ext/ever/libev.c

@@ -0,0 +1,2 @@
+#include "libev.h"
+#include "../libev/ev.c"

data/ext/ever/libev.h

@@ -0,0 +1,11 @@
+#define EV_STANDALONE
+
+/* keeps ev from requiring config.h */
+
+#ifdef _WIN32
+#define EV_SELECT_IS_WINSOCKET 1
+#define EV_USE_MONOTONIC 0
+#define EV_USE_REALTIME 0
+#endif
+
+#include "../libev/ev.h"

data/ext/ever/loop.c

@@ -0,0 +1,257 @@
+#include "ever.h"
+#include "ruby/io.h"
+
+VALUE cLoop;
+VALUE SYM_stop;
+ID ID_ivar_io;
+
+////////////////////////////////////////////////////////////////////////////////
+
+static inline void loop_run_ev_loop(Loop_t *loop) {
+  loop->in_ev_loop = 1;
+  ev_run(loop->ev_loop, EVRUN_ONCE);
+  loop->in_ev_loop = 0;
+}
+
+static inline void loop_yield_queued_events(Loop_t *loop) {
+  int len = RARRAY_LEN(loop->queued_events);
+  if (!len) return;
+
+  VALUE events = loop->queued_events;
+  loop->queued_events = rb_ary_new();
+  for (int i = 0; i < len; i++) {
+    rb_yield(RARRAY_AREF(events, i));
+  }
+  RB_GC_GUARD(events);
+}
+
+inline void loop_emit(Loop_t *loop, VALUE key) {
+  rb_ary_push(loop->queued_events, key);
+}
+
+static inline void loop_signal(Loop_t *loop) {
+  if (loop->in_ev_loop) {
+    // 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(loop->ev_loop, &loop->break_async);
+  }
+}
+
+static inline VALUE loop_get_free_watcher(Loop_t *loop) {
+  VALUE watcher = rb_ary_pop(loop->free_watchers);
+  if (watcher != Qnil) return watcher;
+
+  return rb_class_new_instance(0, 0, cWatcher);
+}
+
+static inline void loop_watch_fd(Loop_t *loop, VALUE key, int fd, int events, int oneshot) {
+  VALUE watcher = loop_get_free_watcher(loop);
+  Watcher_setup_io(watcher, loop, key, fd, events, oneshot);
+  rb_hash_aset(loop->active_watchers, key, watcher);
+}
+
+static inline void loop_watch_timer(Loop_t *loop, VALUE key, double timeout, double interval) {
+  VALUE watcher = loop_get_free_watcher(loop);
+  Watcher_setup_timer(watcher, loop, key, timeout, interval);
+  rb_hash_aset(loop->active_watchers, key, watcher);
+}
+
+static inline int sym_to_events(VALUE rw) {
+  return RTEST(rw) ? EV_WRITE : EV_READ;
+}
+
+static inline int fd_from_io(VALUE io) {
+  rb_io_t *fptr;
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+  GetOpenFile(io, fptr);
+  return fptr->fd;
+}
+
+inline void loop_release_watcher(Loop_t *loop, VALUE key) {
+  VALUE watcher = rb_hash_delete(loop->active_watchers, key);
+  if (watcher != Qnil)
+    rb_ary_push(loop->free_watchers, watcher);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+static void Loop_mark(void *ptr) {
+  Loop_t *loop = ptr;
+  rb_gc_mark(loop->active_watchers);
+  rb_gc_mark(loop->free_watchers);
+  rb_gc_mark(loop->queued_events);
+}
+
+static void Loop_free(void *ptr) {
+  Loop_t *loop = ptr;
+
+  ev_async_stop(loop->ev_loop, &loop->break_async);
+  ev_loop_destroy(loop->ev_loop);
+}
+
+static size_t Loop_size(const void *ptr) {
+  return sizeof(Loop_t);
+}
+
+static const rb_data_type_t Loop_type = {
+    "Ever::Loop",
+    {Loop_mark, Loop_free, Loop_size,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Loop_allocate(VALUE klass) {
+  Loop_t *loop = ALLOC(Loop_t);
+  return TypedData_Wrap_Struct(klass, &Loop_type, loop);
+}
+
+#define GetLoop(obj, loop) \
+  TypedData_Get_Struct((obj), Loop_t, &Loop_type, (loop))
+
+void break_async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
+  // This callback does nothing, the break async is used solely for breaking out
+  // of a *blocking* event loop (waking it up) in a thread-safe, signal-safe manner
+}
+
+static VALUE Loop_initialize(VALUE self) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  loop->ev_loop = ev_loop_new(EVFLAG_NOSIGMASK);
+  // start async watcher used for breaking a poll op (from another thread)
+  ev_async_init(&loop->break_async, break_async_callback);
+  ev_async_start(loop->ev_loop, &loop->break_async);
+  // the break_async watcher is unreferenced, in order for Loop_poll to not
+  // block when no other watcher is active
+  ev_unref(loop->ev_loop);
+
+  loop->active_watchers = rb_hash_new();
+  loop->free_watchers = rb_ary_new();
+  loop->queued_events = rb_ary_new();
+
+  loop->stop = 0;
+  loop->in_ev_loop = 0;
+
+  return Qnil;
+}
+
+VALUE Loop_each(VALUE self) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  loop->stop = 0;
+  while (!loop->stop) {
+    if (RARRAY_LEN(loop->queued_events) == 0) loop_run_ev_loop(loop);
+    loop_yield_queued_events(loop);
+  }
+  return self;
+}
+
+VALUE Loop_next_event(VALUE self) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  if (RARRAY_LEN(loop->queued_events) == 0) loop_run_ev_loop(loop);
+  return rb_ary_shift(loop->queued_events);
+}
+
+VALUE Loop_emit(VALUE self, VALUE key) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  if (key == SYM_stop)
+    loop->stop = 1;
+  else
+    rb_ary_push(loop->queued_events, key);
+
+  loop_signal(loop);
+  return key;
+}
+
+VALUE Loop_signal(VALUE self) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  loop_signal(loop);
+  return self;
+}
+
+VALUE Loop_stop(VALUE self) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  loop->stop = 1;
+  loop_signal(loop);
+  return self;
+}
+
+VALUE Loop_watch_fd(VALUE self, VALUE key, VALUE fd, VALUE rw, VALUE oneshot) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  if (rb_hash_aref(loop->active_watchers, key) != Qnil)
+    rb_raise(rb_eRuntimeError, "Duplicate event key detected, event key must be unique");
+
+  loop_watch_fd(loop, key, NUM2INT(fd), sym_to_events(rw), RTEST(oneshot));
+  return self;
+}
+
+VALUE Loop_watch_io(VALUE self, VALUE key, VALUE io, VALUE rw, VALUE oneshot) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  if (rb_hash_aref(loop->active_watchers, key) != Qnil)
+    rb_raise(rb_eRuntimeError, "Duplicate event key detected, event key must be unique");
+
+  loop_watch_fd(loop, key, fd_from_io(io), sym_to_events(rw), RTEST(oneshot));
+  return self;
+}
+
+VALUE Loop_watch_timer(VALUE self, VALUE key, VALUE timeout, VALUE interval) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  if (rb_hash_aref(loop->active_watchers, key) != Qnil)
+    rb_raise(rb_eRuntimeError, "Duplicate event key detected, event key must be unique");
+
+  loop_watch_timer(loop, key, NUM2DBL(timeout), NUM2DBL(interval));
+  return self;  
+}
+
+VALUE Loop_unwatch(VALUE self, VALUE key) {
+  Loop_t *loop;
+  GetLoop(self, loop);
+
+  VALUE watcher = rb_hash_delete(loop->active_watchers, key);
+  if (watcher == Qnil) return self;
+
+  Watcher_stop(watcher);
+  rb_ary_push(loop->free_watchers, watcher);
+
+  return self;
+}
+
+void Init_Loop() {
+  ev_set_allocator(xrealloc);
+
+  cLoop = rb_define_class_under(mEver, "Loop", rb_cObject);
+  rb_define_alloc_func(cLoop, Loop_allocate);
+
+  rb_define_method(cLoop, "initialize", Loop_initialize, 0);
+  
+  rb_define_method(cLoop, "each", Loop_each, 0);
+  rb_define_method(cLoop, "next_event", Loop_next_event, 0);
+  rb_define_method(cLoop, "emit", Loop_emit, 1);
+  rb_define_method(cLoop, "signal", Loop_signal, 0);
+  rb_define_method(cLoop, "stop", Loop_stop, 0);
+  rb_define_method(cLoop, "watch_fd", Loop_watch_fd, 4);
+  rb_define_method(cLoop, "watch_io", Loop_watch_io, 4);
+  rb_define_method(cLoop, "watch_timer", Loop_watch_timer, 3);
+  rb_define_method(cLoop, "unwatch", Loop_unwatch, 1);
+
+  SYM_stop = ID2SYM(rb_intern("stop"));
+  ID_ivar_io = rb_intern("@io");
+}

data/ext/ever/watcher.c

@@ -0,0 +1,137 @@
+#include "ever.h"
+#include "../libev/ev.h"
+
+VALUE cWatcher;
+
+enum watcher_type {
+  WATCHER_IO,
+  WATCHER_TIMER
+};
+
+
+typedef struct Watcher_t {
+  union {
+    struct ev_io io;
+    struct ev_timer timer;
+  };
+
+  Loop_t *loop;
+  enum watcher_type type;
+  VALUE key;
+  int oneshot;
+} Watcher_t;
+
+////////////////////////////////////////////////////////////////////////////////
+
+static void Watcher_mark(void *ptr) {
+  Watcher_t *watcher = ptr;
+  rb_gc_mark(watcher->key);
+}
+
+static void Watcher_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t Watcher_size(const void *ptr) {
+  return sizeof(Watcher_t);
+}
+
+static const rb_data_type_t Watcher_type = {
+    "Ever::Watcher",
+    {Watcher_mark, Watcher_free, Watcher_size,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Watcher_allocate(VALUE klass) {
+  Watcher_t *watcher = ALLOC(Watcher_t);
+  return TypedData_Wrap_Struct(klass, &Watcher_type, watcher);
+}
+
+#define GetWatcher(obj, watcher) \
+  TypedData_Get_Struct((obj), Watcher_t, &Watcher_type, (watcher))
+
+VALUE Watcher_initialize(VALUE self) {
+  return self;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline void watcher_stop(Watcher_t *watcher) {
+  switch (watcher->type) {
+    case WATCHER_IO:
+      ev_io_stop(watcher->loop->ev_loop, &watcher->io);
+      return;
+    case WATCHER_TIMER:
+      ev_timer_stop(watcher->loop->ev_loop, &watcher->timer);
+      return;
+  }
+}
+
+void watcher_io_callback(EV_P_ ev_io *w, int revents)
+{
+  Watcher_t *watcher = (Watcher_t *)w;
+  loop_emit(watcher->loop, watcher->key);
+  if (watcher->oneshot) {
+    watcher_stop(watcher);
+    loop_release_watcher(watcher->loop, watcher->key);
+  }
+}
+
+void watcher_timer_callback(EV_P_ ev_timer *w, int revents)
+{
+  Watcher_t *watcher = (Watcher_t *)w;
+  loop_emit(watcher->loop, watcher->key);
+  if (watcher->oneshot) {
+    watcher_stop(watcher);
+    loop_release_watcher(watcher->loop, watcher->key);
+  }
+}
+
+static inline void watcher_setup_io(Watcher_t *watcher, Loop_t *loop, VALUE key, int fd, int events, int oneshot) {
+  watcher->type = WATCHER_IO;
+  watcher->loop = loop;
+  watcher->key = key;
+  watcher->oneshot = oneshot;
+
+  ev_io_init(&watcher->io, watcher_io_callback, fd, events);
+  ev_io_start(loop->ev_loop, &watcher->io);
+}
+
+static inline void watcher_setup_timer(Watcher_t *watcher, Loop_t *loop, VALUE key, double timeout, double interval) {
+  watcher->type = WATCHER_TIMER;
+  watcher->loop = loop;
+  watcher->key = key;
+  watcher->oneshot = interval == 0.;
+
+  ev_timer_init(&watcher->timer, watcher_timer_callback, timeout, interval);
+  ev_timer_start(loop->ev_loop, &watcher->timer);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline void Watcher_setup_io(VALUE self, Loop_t *loop, VALUE key, int fd, int events, int oneshot) {
+  Watcher_t *watcher;
+  GetWatcher(self, watcher);
+
+  watcher_setup_io(watcher, loop, key, fd, events, oneshot);
+}
+
+inline void Watcher_setup_timer(VALUE self, Loop_t *loop, VALUE key, double timeout, double interval) {
+  Watcher_t *watcher;
+  GetWatcher(self, watcher);
+
+  watcher_setup_timer(watcher, loop, key, timeout, interval);
+}
+
+inline void Watcher_stop(VALUE self) {
+  Watcher_t *watcher;
+  GetWatcher(self, watcher);
+
+  watcher_stop(watcher);
+}
+
+void Init_Watcher() {
+  cWatcher = rb_define_class_under(mEver, "Watcher", rb_cObject);
+  rb_define_alloc_func(cWatcher, Watcher_allocate);
+  rb_define_method(cWatcher, "initialize", Watcher_initialize, 0);
+}