rev 0.1.4 → 0.2.0

data/ext/libev/README

@@ -0,0 +1,130 @@
+libev is a high-performance event loop/event model with lots of features.
+(see benchmark at http://libev.schmorp.de/bench.html)
+
+   Homepage: http://software.schmorp.de/pkg/libev
+   E-Mail: libev@lists.schmorp.de
+   Library Documentation: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod
+
+   It is modelled (very losely) after libevent and the Event perl module,
+   but aims to be faster and more correct, and also more featureful. And
+   also smaller. Yay.
+
+ABOUT THIS DISTRIBUTION
+
+   If you downloaded the libevent+libev distribution of libev, you will
+   find it looks very much like libevent. In fact, the distributed libev
+   tarballs are indeed libevent tarballs patched up with the libev
+   event core, taking the evbuffer, evtag, evdns and evhttpd parts from
+   libevent (they use the libevent emulation inside libev). Configure and
+   Makefile stuff is also a more or less direct copy of libevent, and are
+   maintained by the libevent authors.
+
+   If you downloaded the libev distribution (without libevent), then
+   you only get the core parts of the library, meaning http and dns
+   client/server code and similar things are missing. Only the core event
+   loop is included.
+
+   If you are looking for an easily embeddable version, I recommend using
+   the libev standalone distribution or the CVS repository.
+
+   Examples of programs that embed libev: the EV perl module,
+   rxvt-unicode, gvpe (GNU Virtual Private Ethernet) and deliantra
+   (http://www.deliantra.net).
+
+DIFFERENCES AND COMPARISON TO LIBEVENT
+
+   The comparisons below are relative to libevent-1.3e.
+
+   - multiple watchers can wait for the same event without deregistering others,
+     both for file descriptors as well as signals.
+     (registering two read events on fd 10 and unregistering one will not
+     break the other).
+
+   - fork() is supported and can be handled
+     (there is no way to recover from a fork with libevent).
+
+   - timers are handled as a priority queue (important operations are O(1))
+     (libevent uses a much less efficient but more complex red-black tree).
+
+   - supports absolute (wallclock-based) timers in addition to relative ones,
+     i.e. can schedule timers to occur after n seconds, or at a specific time.
+
+   - timers can be repeating (both absolute and relative ones).
+
+   - absolute timers can have customised rescheduling hooks (suitable for cron-like
+     applications).
+
+   - detects time jumps and adjusts timers
+     (works for both forward and backward time jumps and also for absolute timers).
+
+   - race-free signal processing
+     (libevent may delay processing signals till after the next event).
+
+   - more efficient epoll backend
+     (stopping and starting an io watcher between two loop iterations will not
+     result in spurious epoll_ctl calls).
+
+   - usually less calls to gettimeofday and clock_gettime
+     (libevent calls it on every timer event change, libev twice per iteration).
+
+   - watchers use less memory
+     (libevent watcher on amd64: 152 bytes, libev native: <= 56 bytes, libevent emulation: 144 bytes).
+
+   - library uses less memory
+     (libevent allocates large data structures wether used or not, libev
+     scales all its data structures dynamically).
+
+   - no hardcoded arbitrary limits
+     (libevent contains an off-by-one bug and sometimes hardcodes limits).
+
+   - libev separates timer, signal and io watchers from each other
+     (libevent combines them, but with libev you can combine them yourself
+     by reusing the same callback and still save memory).
+
+   - simpler design, backends are potentially much simpler
+     (in libevent, backends have to deal with watchers, thus the problems with
+     wildly different semantics between diferent backends)
+     (epoll backend in libevent: 366 lines no caching, libev: 90 lines full caching).
+
+   - libev handles EBADF gracefully by removing the offending fds.
+
+   - libev communicates errors to the callback, libevent to the
+     event adder or not at all.
+
+   - doesn't rely on nonportable BSD header files.
+
+   - an event.h compatibility header exists, and can be used to run a wide
+     range of libevent programs unchanged (such as evdns.c).
+
+   - win32 compatibility for the core parts.
+     (the backend is fd-based as documented and on other platforms,
+     not handle-based like libevent, and can be used for both winscoket environments
+     and unix-like ones).
+
+   - libev can be embedded easily with or without autoconf support into
+     other programs, with no changes to the source code necessary.
+
+   - the event core library (ev and event layer) compiles and works both as
+     C and C++.
+
+   - a simple C++ wrapper that supports methods as callbacks exists.
+
+   - a full featured and widely used perl module is available.
+
+   whats missing?
+
+   - no event-like priority support at the moment (the ev priorities work
+     differently, but you can use idle watchers to get a similar effect).
+
+AUTHOR
+
+   libev was written and designed by Marc Lehmann and Emanuele Giaquinta.
+
+   The following people sent in patches or made other noteworthy
+   contributions to the design (if I forgot to include you, please shout
+   at me, it was an accident):
+
+   W.C.A. Wijngaards
+   Christopher Layne
+   Chris Brody
+

data/ext/libev/README.embed

@@ -0,0 +1,3 @@
+This file is now included in the main libev documentation, see
+
+   http://cvs.schmorp.de/libev/ev.html

data/ext/libev/update_ev_wrap

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+(
+   echo '#define VAR(name,decl) name'
+   echo '#define EV_GENWRAP 1'
+   cat ev_vars.h
+) | cc -E -o - - | perl -ne '
+   while (<>) {
+      push @syms, $1 if /(^\w+)/;
+   }
+   print "/* DO NOT EDIT, automatically generated by update_ev_wrap */\n",
+         "#ifndef EV_WRAP_H\n",
+         "#define EV_WRAP_H\n",
+         (map "#define $_ ((loop)->$_)\n", @syms),
+         "#else\n",
+         "#undef EV_WRAP_H\n",
+         (map "#undef $_\n", @syms),
+         "#endif\n";
+' >ev_wrap.h

data/ext/rev/extconf.rb

@@ -1,36 +1,49 @@
 require 'mkmf'
 
-flags = []
+cflags = []
+libs = []
 
-unless have_func('rb_thread_blocking_region') and have_macro('RB_UBF_DFL', 'ruby.h')
-  abort "Rev requires Ruby 1.9.0 or greater"
+if have_func('rb_thread_blocking_region')
+  cflags << '-DHAVE_RB_THREAD_BLOCKING_REGION'
 end
 
 if have_header('sys/select.h')
-  flags << '-DEV_USE_SELECT'
+  cflags << '-DEV_USE_SELECT'
 end
 
 if have_header('poll.h')
-  flags << '-DEV_USE_POLL'
+  cflags << '-DEV_USE_POLL'
 end
 
 if have_header('sys/epoll.h')
-  flags << '-DEV_USE_EPOLL'
+  cflags << '-DEV_USE_EPOLL'
 end
 
 if have_header('sys/event.h') and have_header('sys/queue.h')
-  flags << '-DEV_USE_KQUEUE'
+  cflags << '-DEV_USE_KQUEUE'
 end
 
 if have_header('port.h')
-  flags << '-DEV_USE_PORT'
+  cflags << '-DEV_USE_PORT'
 end
 
-if have_header('sys/inotify.h')
-  flags << '-DEV_USE_INOTIFY'
+if have_header('openssl/ssl.h')
+  cflags << '-DHAVE_OPENSSL_SSL_H'
+  libs << '-lssl -lcrypto'
 end
 
-$CFLAGS << ' ' << flags.join(' ')
+# ncpu detection specifics
+case RUBY_PLATFORM
+when /linux/
+  cflags << '-DHAVE_LINUX_PROCFS'
+else
+  if have_func('sysctlbyname', ['sys/param.h', 'sys/sysctl.h'])
+    cflags << '-DHAVE_SYSCTLBYNAME'
+  end
+end
+
+$CFLAGS << ' ' << cflags.join(' ')
+$LIBS << ' ' << libs.join(' ')
 
 dir_config('rev_ext')
 create_makefile('rev_ext')

data/ext/rev/rev.h

@@ -8,6 +8,13 @@
 #define REV_H
 
 #include "ruby.h"
+#include "rubyio.h"
+
+#if HAVE_RB_IO_T
+#define FPTR_TO_FD(fptr) fptr->fd
+#else
+#define FPTR_TO_FD(fptr) fileno(fptr->f)
+#endif
 
 struct Rev_Event
 {

data/ext/rev/rev_buffer.c

@@ -6,6 +6,12 @@
 
 #include "ruby.h"
 #include "rubyio.h"
+
+#define EV_STANDALONE 1
+#include "../libev/ev.h"
+
+#include "rev.h"
+
 #include <assert.h>
 
 #include <string.h>
@@ -37,16 +43,13 @@ struct buffer_node {
   unsigned char data[0];
 };
 
-/* Module and object handles */
 static VALUE mRev = Qnil;
 static VALUE cRev_Buffer = Qnil;
 
-/* Data allocators and deallocators */
 static VALUE Rev_Buffer_allocate(VALUE klass);
 static void Rev_Buffer_mark(struct buffer *);
 static void Rev_Buffer_free(struct buffer *);
 
-/* Method implementations */
 static VALUE Rev_Buffer_initialize(int argc, VALUE *argv, VALUE self);
 static VALUE Rev_Buffer_clear(VALUE self);
 static VALUE Rev_Buffer_size(VALUE self);
@@ -58,7 +61,6 @@ static VALUE Rev_Buffer_to_str(VALUE self);
 static VALUE Rev_Buffer_read_from(VALUE self, VALUE io);
 static VALUE Rev_Buffer_write_to(VALUE self, VALUE io);
 
-/* Prototypes for internal functions */
 static struct buffer *buffer_new(void);
 static void buffer_clear(struct buffer *buf);
 static void buffer_free(struct buffer *buf);
@@ -71,8 +73,7 @@ static int buffer_read_from(struct buffer *buf, int fd);
 static int buffer_write_to(struct buffer *buf, int fd);
 
 /* 
- * High speed buffering geared towards non-blocking I/O.  This was largely
- * written in response to String#slice! being incredibly slow in Ruby 1.9.
+ * High speed buffering geared towards non-blocking I/O.
  *
  * Data is stored in a byte queue implemented as a linked list of equal size
  * chunks.  Since every node in the list is the same size they are easily
@@ -287,13 +288,17 @@ static VALUE Rev_Buffer_to_str(VALUE self) {
  */
 static VALUE Rev_Buffer_read_from(VALUE self, VALUE io) {
 	struct buffer *buf;
+#if HAVE_RB_IO_T
   rb_io_t *fptr;
+#else
+  OpenFile *fptr;
+#endif
 
   Data_Get_Struct(self, struct buffer, buf);
   GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
   rb_io_set_nonblock(fptr);
 
-  return INT2NUM(buffer_read_from(buf, fptr->fd));
+  return INT2NUM(buffer_read_from(buf, FPTR_TO_FD(fptr)));
 }
 
 /**
@@ -306,13 +311,17 @@ static VALUE Rev_Buffer_read_from(VALUE self, VALUE io) {
  */
 static VALUE Rev_Buffer_write_to(VALUE self, VALUE io) {
   struct buffer *buf;
+#if HAVE_RB_IO_T 
   rb_io_t *fptr;
+#else
+  OpenFile *fptr;
+#endif
 
   Data_Get_Struct(self, struct buffer, buf);
   GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
   rb_io_set_nonblock(fptr);
 
-  return INT2NUM(buffer_write_to(buf, fptr->fd));
+  return INT2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
 }
 
 /*

data/ext/rev/rev_ext.c

@@ -16,10 +16,6 @@ static VALUE mRev = Qnil;
 void Init_rev_ext() 
 {
   ev_set_allocator((void *(*)(void *, long))xrealloc);
-  mRev = rb_define_module("Rev");
-
-  /* Make libev version available in Ruby */
-  rb_define_const(mRev, "LIBEV_VERSION", rb_sprintf("%d.%d", ev_version_major(), ev_version_minor()));
 
   /* Initializers for other modules */
   Init_rev_loop();
@@ -27,4 +23,9 @@ void Init_rev_ext()
   Init_rev_io_watcher();
   Init_rev_timer_watcher();
   Init_rev_buffer();
+  Init_rev_utils();
+  
+#ifdef HAVE_OPENSSL_SSL_H
+  Init_rev_ssl();
+#endif
 }

data/ext/rev/rev_io_watcher.c

@@ -13,13 +13,11 @@
 #include "rev.h"
 #include "rev_watcher.h"
 
-/* Module and object handles */
 static VALUE mRev = Qnil;
 static VALUE cRev_Watcher = Qnil;
 static VALUE cRev_Loop = Qnil;
 static VALUE cRev_IOWatcher = Qnil;
 
-/* Method implementations */
 static VALUE Rev_IOWatcher_initialize(int argc, VALUE *argv, VALUE self);
 static VALUE Rev_IOWatcher_attach(VALUE self, VALUE loop);
 static VALUE Rev_IOWatcher_detach(VALUE self);
@@ -28,7 +26,6 @@ static VALUE Rev_IOWatcher_disable(VALUE self);
 static VALUE Rev_IOWatcher_on_readable(VALUE self);
 static VALUE Rev_IOWatcher_on_writable(VALUE self);
 
-/* Callbacks */
 static void Rev_IOWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
 static void Rev_IOWatcher_dispatch_callback(VALUE self, int revents);
 
@@ -66,8 +63,12 @@ static VALUE Rev_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
   VALUE io, flags;
   char *flags_str;
   int events;
-  rb_io_t *fptr;
   struct Rev_Watcher *watcher_data;
+#if HAVE_RB_IO_T
+  rb_io_t *fptr;
+#else
+  OpenFile *fptr;
+#endif
 
   rb_scan_args(argc, argv, "11", &io, &flags);
 
@@ -85,11 +86,11 @@ static VALUE Rev_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
   else
     rb_raise(rb_eArgError, "invalid event type: '%s' (must be 'r', 'w', or 'rw')", flags_str);
 
-  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
   Data_Get_Struct(self, struct Rev_Watcher, watcher_data);
+  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
 
   watcher_data->dispatch_callback = Rev_IOWatcher_dispatch_callback;
-  ev_io_init(&watcher_data->event_types.ev_io, Rev_IOWatcher_libev_callback, fptr->fd, events);
+  ev_io_init(&watcher_data->event_types.ev_io, Rev_IOWatcher_libev_callback, FPTR_TO_FD(fptr), events);
   watcher_data->event_types.ev_io.data = (void *)self;
 
   return Qnil;

data/ext/rev/rev_loop.c

@@ -12,22 +12,19 @@
 
 #include "rev.h"
 
-/* Module and object handles */
 static VALUE mRev = Qnil;
 static VALUE cRev_Loop = Qnil;
 
-/* Data allocators and deallocators */
 static VALUE Rev_Loop_allocate(VALUE klass);
 static void Rev_Loop_mark(struct Rev_Loop *loop);
 static void Rev_Loop_free(struct Rev_Loop *loop);
 
-/* Method implementations */
 static VALUE Rev_Loop_initialize(VALUE self);
 static VALUE Rev_Loop_ev_loop_new(VALUE self, VALUE flags);
 static VALUE Rev_Loop_run_once(VALUE self);
-static VALUE Rev_Loop_run_once_blocking(void *ptr);
 static VALUE Rev_Loop_run_nonblock(VALUE self);
 
+static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data);
 static void Rev_Loop_dispatch_events(struct Rev_Loop *loop_data);
 
 #define DEFAULT_EVENTBUF_SIZE 32
@@ -184,15 +181,20 @@ static VALUE Rev_Loop_run_once(VALUE self)
   assert(loop_data->ev_loop && !loop_data->events_received);
 
   loop_data->running = 1;
-  rb_thread_blocking_region(Rev_Loop_run_once_blocking, loop_data->ev_loop, RB_UBF_DFL, 0);
+
+  Rev_Loop_ev_loop_oneshot(loop_data);
   Rev_Loop_dispatch_events(loop_data);
   loop_data->events_received = 0;
+
   loop_data->running = 0;
 
   return Qnil;
 }
 
-static VALUE Rev_Loop_run_once_blocking(void *ptr) 
+/* Ruby 1.9 supports blocking system calls through rb_thread_blocking_region() */
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#define HAVE_EV_LOOP_ONESHOT
+static VALUE Rev_Loop_ev_loop_oneshot_blocking(void *ptr) 
 {
   /* The libev loop has now escaped through the Global VM Lock unscathed! */
   struct ev_loop *loop = (struct ev_loop *)ptr;
@@ -201,6 +203,46 @@ static VALUE Rev_Loop_run_once_blocking(void *ptr)
   return Qnil;
 }
 
+static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
+{
+  /* Use Ruby 1.9's rb_thread_blocking_region call to make a blocking system call */
+  rb_thread_blocking_region(Rev_Loop_ev_loop_oneshot_blocking, loop_data->ev_loop, RB_UBF_DFL, 0);
+}
+#endif
+
+/* Ruby 1.8 requires us to periodically run the event loop then defer back to
+ * the green threads scheduler */
+#ifndef HAVE_EV_LOOP_ONESHOT
+#define BLOCKING_INTERVAL 0.01 /* Block for 10ms at a time */
+
+/* Stub callback */
+static void timer_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
+{
+}
+
+static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
+{
+  struct ev_timer timer;
+  struct timeval tv;
+
+  /* Set up an ev_timer to unblock the loop every 10ms */
+  ev_timer_init(&timer, timer_callback, BLOCKING_INTERVAL, BLOCKING_INTERVAL);
+  ev_timer_start(loop_data->ev_loop, &timer);
+
+  do {
+    /* Since blocking calls would hang the Ruby 1.8 thread scheduler, don't block */
+    ev_loop(loop_data->ev_loop, EVLOOP_ONESHOT);
+
+    /* Call rb_thread_select to resume the Ruby scheduler */
+    tv.tv_sec = 0;
+    tv.tv_usec = 0;
+    rb_thread_select(0, NULL, NULL, NULL, &tv);
+  } while(!loop_data->events_received);
+
+  ev_timer_stop(loop_data->ev_loop, &timer);
+}
+#endif
+
 /**
  *  call-seq:
  *    Rev::Loop.run_once -> nil