libev_scheduler 0.1

data/ext/libev/test_libev_win32.c

@@ -0,0 +1,123 @@
+  // a single header file is required
+  #include <ev.h>
+   #include <stdio.h>
+   #include <io.h>
+
+   // every watcher type has its own typedef'd struct
+   // with the name ev_TYPE
+   ev_io stdin_watcher;
+   ev_timer timeout_watcher;
+
+   // all watcher callbacks have a similar signature
+   // this callback is called when data is readable on stdin
+   static void
+   stdin_cb (EV_P_ ev_io *w, int revents)
+   {
+     puts ("stdin ready or done or something");
+     // for one-shot events, one must manually stop the watcher
+     // with its corresponding stop function.
+     //ev_io_stop (EV_A_ w);
+
+     // this causes all nested ev_loop's to stop iterating
+     //ev_unloop (EV_A_ EVUNLOOP_ALL);
+   }
+
+   // another callback, this time for a time-out
+   static void
+   timeout_cb (EV_P_ ev_timer *w, int revents)
+   {
+     puts ("timeout");
+     // this causes the innermost ev_loop to stop iterating
+     ev_unloop (EV_A_ EVUNLOOP_ONE);
+   }
+
+
+
+   #include <winsock.h>
+
+#include <stdlib.h>
+#include <iostream>
+   int get_server_fd()
+   {
+
+  //----------------------
+  // Initialize Winsock.
+  WSADATA wsaData;
+  int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
+  if (iResult != NO_ERROR) {
+    printf("Error at WSAStartup()\n");
+    return 1;
+  }
+
+  //----------------------
+  // Create a SOCKET for listening for
+  // incoming connection requests.
+  SOCKET ListenSocket;
+  ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (ListenSocket == INVALID_SOCKET) {
+    printf("Error at socket(): %ld\n", WSAGetLastError());
+    WSACleanup();
+    return 1;
+  }
+  printf("socket returned %d\n", ListenSocket);
+
+  //----------------------
+  // The sockaddr_in structure specifies the address family,
+  // IP address, and port for the socket that is being bound.
+  sockaddr_in service;
+  service.sin_family = AF_INET;
+  service.sin_addr.s_addr = inet_addr("127.0.0.1");
+  service.sin_port = htons(4444);
+
+  if (bind( ListenSocket,
+    (SOCKADDR*) &service,
+    sizeof(service)) == SOCKET_ERROR) {
+    printf("bind() failed.\n");
+    closesocket(ListenSocket);
+    WSACleanup();
+    return 1;
+  }
+
+  //----------------------
+  // Listen for incoming connection requests.
+  // on the created socket
+  if (listen( ListenSocket, 1 ) == SOCKET_ERROR) {
+    printf("Error listening on socket.\n");
+    closesocket(ListenSocket);
+    WSACleanup();
+    return 1;
+  }
+
+
+  printf("sock and osf handle are %d %d, error is \n", ListenSocket, _get_osfhandle (ListenSocket)); // -1 is invalid file handle: http://msdn.microsoft.com/en-us/library/ks2530z6.aspx
+  printf("err was %d\n",  WSAGetLastError());
+  //----------------------
+  return ListenSocket;
+   }
+
+
+   int
+   main (void)
+   {
+     struct ev_loop *loopy = ev_default_loop(0);
+     int fd = get_server_fd();
+     int fd_real =  _open_osfhandle(fd, NULL);
+     int conv = _get_osfhandle(fd_real);
+     printf("got server fd %d, loop %d, fd_real %d, that converted %d\n", fd, loopy, fd_real, conv);
+    // accept(fd, NULL, NULL);
+     // initialise an io watcher, then start it
+     // this one will watch for stdin to become readable
+     ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ conv, EV_READ);
+     ev_io_start (loopy, &stdin_watcher);
+
+     // initialise a timer watcher, then start it
+     // simple non-repeating 5.5 second timeout
+     //ev_timer_init (&timeout_watcher, timeout_cb, 15.5, 0.);
+     //ev_timer_start (loopy, &timeout_watcher);
+    printf("starting loop\n");
+     // now wait for events to arrive
+     ev_loop (loopy, 0);
+
+     // unloop was called, so exit
+     return 0;
+   }

data/ext/libev_scheduler/extconf.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'mkmf'
+
+$defs << "-DPOLYPHONY_BACKEND_LIBEV"
+$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 'libev_scheduler_ext'
+create_makefile 'libev_scheduler_ext'

data/ext/libev_scheduler/libev.c

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

data/ext/libev_scheduler/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/libev_scheduler/libev_scheduler_ext.c

@@ -0,0 +1,5 @@
+void Init_Scheduler();
+
+void Init_libev_scheduler_ext() {
+  Init_Scheduler();
+}

data/ext/libev_scheduler/scheduler.c

@@ -0,0 +1,330 @@
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <stdnoreturn.h>
+
+#include "../libev/ev.h"
+#include "ruby.h"
+#include "ruby/io.h"
+#include "../libev/ev.h"
+
+#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); }
+
+
+ID ID_ivar_is_nonblocking;
+ID ID_ivar_io;
+
+int event_readable;
+int event_writable;
+
+// VALUE SYM_libev;
+
+typedef struct Scheduler_t {
+  struct ev_loop *ev_loop;
+  struct ev_async break_async;
+
+  unsigned int pending_count;
+  unsigned int currently_polling;
+  VALUE ready; // holds ready fibers (used only while polling)
+} Scheduler_t;
+
+static size_t Scheduler_size(const void *ptr) {
+  return sizeof(Scheduler_t);
+}
+
+static void Scheduler_mark(void *ptr) {
+  Scheduler_t *scheduler = ptr;
+  rb_gc_mark(scheduler->ready);
+}
+
+static const rb_data_type_t Scheduler_type = {
+    "LibevScheduler",
+    {Scheduler_mark, 0, Scheduler_size,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE Scheduler_allocate(VALUE klass) {
+  Scheduler_t *scheduler = ALLOC(Scheduler_t);
+
+  return TypedData_Wrap_Struct(klass, &Scheduler_type, scheduler);
+}
+
+#define GetScheduler(obj, scheduler) \
+  TypedData_Get_Struct((obj), Scheduler_t, &Scheduler_type, (scheduler))
+
+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 Scheduler_initialize(VALUE self) {
+  Scheduler_t *scheduler;
+  VALUE thread = rb_thread_current();
+  int is_main_thread = (thread == rb_thread_main());
+
+  GetScheduler(self, scheduler);
+  scheduler->ev_loop = is_main_thread ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
+
+  ev_async_init(&scheduler->break_async, break_async_callback);
+  ev_async_start(scheduler->ev_loop, &scheduler->break_async);
+  ev_unref(scheduler->ev_loop); // don't count the break_async watcher
+
+  scheduler->pending_count = 0;
+  scheduler->currently_polling = 0;
+  scheduler->ready = rb_ary_new();
+
+  return Qnil;
+}
+
+VALUE Scheduler_poll(VALUE self);
+
+VALUE Scheduler_run(VALUE self) {
+  Scheduler_t *scheduler;
+  GetScheduler(self, scheduler);
+
+  while (scheduler->pending_count > 0 || RARRAY_LEN(scheduler->ready) > 0) {
+    Scheduler_poll(self);
+  }
+
+  return self;
+}
+
+VALUE Scheduler_close(VALUE self) {
+  Scheduler_t *scheduler;
+  GetScheduler(self, scheduler);
+
+  Scheduler_run(self);
+
+  ev_async_stop(scheduler->ev_loop, &scheduler->break_async);
+  if (!ev_is_default_loop(scheduler->ev_loop)) ev_loop_destroy(scheduler->ev_loop);
+  return self;
+}
+
+struct libev_timer {
+  struct ev_timer timer;
+  Scheduler_t *scheduler;
+  VALUE fiber;
+};
+
+void Scheduler_timer_callback(EV_P_ ev_timer *w, int revents)
+{
+  struct libev_timer *watcher = (struct libev_timer *)w;
+  rb_ary_push(watcher->scheduler->ready, watcher->fiber);
+}
+
+VALUE Scheduler_sleep(VALUE self, VALUE duration) {
+  Scheduler_t *scheduler;
+  struct libev_timer watcher;
+  GetScheduler(self, scheduler);
+
+  watcher.scheduler = scheduler;
+  watcher.fiber = rb_fiber_current();
+  ev_timer_init(&watcher.timer, Scheduler_timer_callback, NUM2DBL(duration), 0.);
+  ev_timer_start(scheduler->ev_loop, &watcher.timer);
+  VALUE nil = Qnil;
+  scheduler->pending_count++;
+  VALUE ret = rb_fiber_yield(1, &nil);
+  scheduler->pending_count--;
+  ev_timer_stop(scheduler->ev_loop, &watcher.timer);
+  return ret;
+}
+
+VALUE Scheduler_pause(VALUE self) {
+  Scheduler_t *scheduler;
+  GetScheduler(self, scheduler);
+
+  ev_ref(scheduler->ev_loop);
+  VALUE nil = Qnil;
+  scheduler->pending_count++;
+  VALUE ret = rb_fiber_yield(1, &nil);
+  scheduler->pending_count--;
+  ev_unref(scheduler->ev_loop);
+  return ret;
+}
+
+VALUE Scheduler_block(int argc, VALUE *argv, VALUE self) {
+  VALUE timeout = (argc == 2) ? argv[1] : Qnil;
+
+  if (timeout != Qnil)
+    Scheduler_sleep(self, timeout);
+  else
+    Scheduler_pause(self);
+  
+  return Qtrue;
+}
+
+VALUE Scheduler_unblock(VALUE self, VALUE blocker, VALUE fiber) {
+  Scheduler_t *scheduler;
+  GetScheduler(self, scheduler);
+
+  rb_ary_push(scheduler->ready, fiber);
+
+  if (scheduler->currently_polling)
+    ev_async_send(scheduler->ev_loop, &scheduler->break_async);
+
+  return self;
+}
+
+struct libev_io {
+  struct ev_io io;
+  Scheduler_t *scheduler;
+  VALUE fiber;
+};
+
+void Scheduler_io_callback(EV_P_ ev_io *w, int revents)
+{
+  struct libev_io *watcher = (struct libev_io *)w;
+  rb_ary_push(watcher->scheduler->ready, watcher->fiber);
+}
+
+int io_event_mask(VALUE events) {
+  int interest = NUM2INT(events);
+  int mask = 0;
+  if (interest & event_readable) mask |= EV_READ;
+  if (interest & event_writable) mask |= EV_WRITE;
+  return mask;
+}
+
+VALUE Scheduler_io_wait(VALUE self, VALUE io, VALUE events, VALUE timeout) {
+  Scheduler_t *scheduler;
+  struct libev_io io_watcher;
+  struct libev_timer timeout_watcher;
+  GetScheduler(self, scheduler);
+
+  rb_io_t *fptr;
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+  GetOpenFile(io, fptr);
+
+  io_watcher.scheduler = scheduler;
+  io_watcher.fiber = rb_fiber_current();
+  ev_io_init(&io_watcher.io, Scheduler_io_callback, fptr->fd, io_event_mask(events));
+
+  int use_timeout = timeout != Qnil;
+  if (use_timeout) {
+    timeout_watcher.scheduler = scheduler;
+    timeout_watcher.fiber = rb_fiber_current();
+    ev_timer_init(&timeout_watcher.timer, Scheduler_timer_callback, NUM2DBL(timeout), 0.);
+    ev_timer_start(scheduler->ev_loop, &timeout_watcher.timer);
+  }
+
+  ev_io_start(scheduler->ev_loop, &io_watcher.io);
+  VALUE nil = Qnil;
+  scheduler->pending_count++;
+  rb_fiber_yield(1, &nil);
+  scheduler->pending_count--;
+  ev_io_stop(scheduler->ev_loop, &io_watcher.io);
+  if (use_timeout)
+    ev_timer_stop(scheduler->ev_loop, &timeout_watcher.timer);
+  
+  return self;
+}
+
+struct libev_child {
+  struct ev_child child;
+  Scheduler_t *scheduler;
+  VALUE fiber;
+  VALUE status;
+};
+
+void Scheduler_child_callback(EV_P_ ev_child *w, int revents)
+{
+  printf("Scheduler_child_callback\n");
+  struct libev_child *watcher = (struct libev_child *)w;
+  int exit_status = WEXITSTATUS(w->rstatus);
+  watcher->status = rb_ary_new_from_args(2, INT2NUM(w->rpid), INT2NUM(exit_status));
+  rb_ary_push(watcher->scheduler->ready, watcher->fiber);
+}
+
+VALUE Scheduler_process_wait(VALUE self, VALUE pid, VALUE flags) {
+  Scheduler_t *scheduler;
+  struct libev_child watcher;
+  VALUE result = Qnil;
+  GetScheduler(self, scheduler);
+
+  watcher.scheduler = scheduler;
+  watcher.fiber = rb_fiber_current();
+  watcher.status = Qnil;
+  ev_child_init(&watcher.child, Scheduler_child_callback, NUM2INT(pid), 0);
+  ev_child_start(scheduler->ev_loop, &watcher.child);
+  VALUE nil = Qnil;
+  scheduler->pending_count++;
+  rb_fiber_yield(1, &nil);
+  scheduler->pending_count--;
+  ev_child_stop(scheduler->ev_loop, &watcher.child);
+  RB_GC_GUARD(watcher.status);
+  RB_GC_GUARD(result);
+  return result;
+}
+
+void Scheduler_resume_ready(Scheduler_t *scheduler) {
+  VALUE nil = Qnil;
+  VALUE ready = Qnil;
+
+  unsigned int ready_count = RARRAY_LEN(scheduler->ready);
+  while (ready_count > 0) {
+    ready = scheduler->ready;
+    scheduler->ready = rb_ary_new();
+
+    for (unsigned int i = 0; i < ready_count; i++) {
+      VALUE fiber = RARRAY_AREF(ready, i);
+      rb_fiber_resume(fiber, 1, &nil);
+    }
+
+    ready_count = RARRAY_LEN(scheduler->ready);
+  }
+
+  RB_GC_GUARD(ready);
+}
+
+VALUE Scheduler_poll(VALUE self) {
+  Scheduler_t *scheduler;
+  GetScheduler(self, scheduler);
+
+  scheduler->currently_polling = 1;
+  ev_run(scheduler->ev_loop, EVRUN_ONCE);
+  scheduler->currently_polling = 0;
+
+  Scheduler_resume_ready(scheduler);
+
+  return self;
+}
+
+VALUE Scheduler_pending_count(VALUE self) {
+  Scheduler_t *scheduler;
+  GetScheduler(self, scheduler);
+
+  return INT2NUM(scheduler->pending_count);
+}
+
+void Init_Scheduler() {
+  ev_set_allocator(xrealloc);
+
+  VALUE mLibev = rb_define_module("Libev");
+  VALUE cScheduler = rb_define_class_under(mLibev, "Scheduler", rb_cObject);
+  rb_define_alloc_func(cScheduler, Scheduler_allocate);
+
+  rb_define_method(cScheduler, "initialize", Scheduler_initialize, 0);
+
+  // fiber scheduler interface
+  rb_define_method(cScheduler, "close", Scheduler_close, 0);
+  rb_define_method(cScheduler, "io_wait", Scheduler_io_wait, 3);
+  rb_define_method(cScheduler, "process_wait", Scheduler_process_wait, 2);
+  rb_define_method(cScheduler, "block", Scheduler_block, -1);
+  rb_define_method(cScheduler, "unblock", Scheduler_unblock, 2);
+
+  rb_define_method(cScheduler, "run", Scheduler_run, 0);
+  rb_define_method(cScheduler, "pending_count", Scheduler_pending_count, 0);
+
+  ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
+  ID_ivar_io             = rb_intern("@io");
+
+  event_readable = NUM2INT(rb_const_get(rb_cIO, rb_intern("READABLE")));
+  event_writable = NUM2INT(rb_const_get(rb_cIO, rb_intern("WRITABLE")));
+  // SYM_libev = ID2SYM(rb_intern("libev"));
+}