nio4r 0.1.0-java

data/ext/nio4r/nio4r.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+ * LICENSE.txt for further details.
+ */
+
+#ifndef NIO4R_H
+#define NIO4R_H
+
+#include "ruby.h"
+#include "rubyio.h"
+#include "libev.h"
+
+struct NIO_Selector
+{
+    struct ev_loop *ev_loop;
+    struct ev_timer timer; /* for timeouts */
+    struct ev_async wakeup;
+
+    int closed, selecting;
+    int ready_count;
+    int ready_buffer_size;
+    VALUE *ready_buffer;
+};
+
+struct NIO_callback_data
+{
+    VALUE *monitor;
+    struct NIO_Selector *selector;
+};
+
+struct NIO_Monitor
+{
+    VALUE self;
+    struct ev_io ev_io;
+    struct NIO_Selector *selector;
+};
+
+#ifdef GetReadFile
+# define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
+#else
+
+#if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
+# define FPTR_TO_FD(fptr) fileno(fptr->f)
+#else
+# define FPTR_TO_FD(fptr) fptr->fd
+#endif /* !HAVE_RB_IO_T */
+
+#endif /* GetReadFile */
+
+/* Thunk between libev callbacks in NIO::Monitors and NIO::Selectors */
+void NIO_Selector_handle_event(struct NIO_Selector *selector, VALUE monitor, int revents);
+
+#endif /* NIO4R_H */

data/ext/nio4r/nio4r_ext.c

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+ * LICENSE.txt for further details.
+ */
+
+#include "nio4r.h"
+#include "../libev/ev.c"
+
+void Init_NIO_Selector();
+void Init_NIO_Monitor();
+
+void Init_nio4r_ext()
+{
+    Init_NIO_Selector();
+    Init_NIO_Monitor();
+}

data/ext/nio4r/selector.c

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+ * LICENSE.txt for further details.
+ */
+
+#include "nio4r.h"
+#include "rubysig.h"
+
+static VALUE mNIO = Qnil;
+static VALUE cNIO_Channel  = Qnil;
+static VALUE cNIO_Monitor  = Qnil;
+static VALUE cNIO_Selector = Qnil;
+
+/* Allocator/deallocator */
+static VALUE NIO_Selector_allocate(VALUE klass);
+static void NIO_Selector_mark(struct NIO_Selector *loop);
+static void NIO_Selector_shutdown(struct NIO_Selector *selector);
+static void NIO_Selector_free(struct NIO_Selector *loop);
+
+/* Methods */
+static VALUE NIO_Selector_initialize(VALUE self);
+static VALUE NIO_Selector_register(VALUE self, VALUE selectable, VALUE interest);
+static VALUE NIO_Selector_deregister(VALUE self, VALUE io);
+static VALUE NIO_Selector_is_registered(VALUE self, VALUE io);
+static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self);
+static VALUE NIO_Selector_wakeup(VALUE self);
+static VALUE NIO_Selector_close(VALUE self);
+static VALUE NIO_Selector_closed(VALUE self);
+
+/* Internal functions */
+static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args);
+static VALUE NIO_Selector_unlock(VALUE lock);
+static VALUE NIO_Selector_register_synchronized(VALUE *args);
+static VALUE NIO_Selector_deregister_synchronized(VALUE *args);
+static VALUE NIO_Selector_select_synchronized(VALUE *args);
+static VALUE NIO_Selector_run_evloop(void *ptr);
+static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
+static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_async *async, int revents);
+
+/* Default number of slots in the buffer for selected monitors */
+#define INITIAL_READY_BUFFER 32
+
+/* Ruby 1.8 needs us to busy wait and run the green threads scheduler every 10ms */
+#define BUSYWAIT_INTERVAL 0.01
+
+/* Selectors wait for events */
+void Init_NIO_Selector()
+{
+    mNIO = rb_define_module("NIO");
+    cNIO_Channel  = rb_define_class_under(mNIO, "Channel",  rb_cObject);
+    cNIO_Monitor  = rb_define_class_under(mNIO, "Monitor",  rb_cObject);
+    cNIO_Selector = rb_define_class_under(mNIO, "Selector", rb_cObject);
+    rb_define_alloc_func(cNIO_Selector, NIO_Selector_allocate);
+
+    rb_define_method(cNIO_Selector, "initialize", NIO_Selector_initialize, 0);
+    rb_define_method(cNIO_Selector, "register", NIO_Selector_register, 2);
+    rb_define_method(cNIO_Selector, "deregister", NIO_Selector_deregister, 1);
+    rb_define_method(cNIO_Selector, "registered?", NIO_Selector_is_registered, 1);
+    rb_define_method(cNIO_Selector, "select", NIO_Selector_select, -1);
+    rb_define_method(cNIO_Selector, "wakeup", NIO_Selector_wakeup, 0);
+    rb_define_method(cNIO_Selector, "close", NIO_Selector_close, 0);
+    rb_define_method(cNIO_Selector, "closed?", NIO_Selector_closed, 0);
+}
+
+/* Create the libev event loop and incoming event buffer */
+static VALUE NIO_Selector_allocate(VALUE klass)
+{
+    struct NIO_Selector *selector = (struct NIO_Selector *)xmalloc(sizeof(struct NIO_Selector));
+
+    selector->ev_loop = ev_loop_new(0);
+    ev_init(&selector->timer, NIO_Selector_timeout_callback);
+
+    ev_async_init(&selector->wakeup, NIO_Selector_wakeup_callback);
+    selector->wakeup.data = (void *)selector;
+
+    ev_async_start(selector->ev_loop, &selector->wakeup);
+
+    selector->closed = selector->selecting = selector->ready_count = 0;
+    selector->ready_buffer_size = INITIAL_READY_BUFFER;
+    selector->ready_buffer = (VALUE *)xmalloc(sizeof(VALUE) * INITIAL_READY_BUFFER);
+
+    return Data_Wrap_Struct(klass, NIO_Selector_mark, NIO_Selector_free, selector);
+}
+
+/* NIO selectors store all Ruby objects in instance variables so mark is a stub */
+static void NIO_Selector_mark(struct NIO_Selector *selector)
+{
+}
+
+/* Free a Selector's system resources.
+   Called by both NIO::Selector#close and the finalizer below */
+static void NIO_Selector_shutdown(struct NIO_Selector *selector)
+{
+    if(selector->ev_loop) {
+        ev_loop_destroy(selector->ev_loop);
+        selector->ev_loop = 0;
+    }
+
+    if(selector->closed) {
+        return;
+    }
+
+    selector->closed = 1;
+}
+
+/* Ruby finalizer for selector objects */
+static void NIO_Selector_free(struct NIO_Selector *selector)
+{
+    NIO_Selector_shutdown(selector);
+
+    xfree(selector->ready_buffer);
+    xfree(selector);
+}
+
+/* Create a new selector. This is more or less the pure Ruby version
+   translated into an MRI cext */
+static VALUE NIO_Selector_initialize(VALUE self)
+{
+    VALUE lock;
+
+    rb_ivar_set(self, rb_intern("selectables"), rb_hash_new());
+
+    lock = rb_class_new_instance(0, 0, rb_const_get(rb_cObject, rb_intern("Mutex")));
+    rb_ivar_set(self, rb_intern("lock"), lock);
+
+    return Qnil;
+}
+
+/* Synchronize the given function with the selector mutex */
+static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args)
+{
+    VALUE lock;
+
+    lock = rb_ivar_get(self, rb_intern("lock"));
+    rb_funcall(lock, rb_intern("lock"), 0, 0);
+    return rb_ensure(func, (VALUE)args, NIO_Selector_unlock, lock);
+}
+
+/* Unlock the selector mutex */
+static VALUE NIO_Selector_unlock(VALUE lock)
+{
+    rb_funcall(lock, rb_intern("unlock"), 0, 0);
+}
+
+/* Register an IO object with the selector for the given interests */
+static VALUE NIO_Selector_register(VALUE self, VALUE io, VALUE interests)
+{
+    VALUE args[3] = {self, io, interests};
+    return NIO_Selector_synchronize(self, NIO_Selector_register_synchronized, args);
+}
+
+/* Internal implementation of register after acquiring mutex */
+static VALUE NIO_Selector_register_synchronized(VALUE *args)
+{
+    VALUE self, io, interests, selectables, monitor;
+    VALUE monitor_args[3];
+
+    self = args[0];
+    io = args[1];
+    interests = args[2];
+
+    selectables = rb_ivar_get(self, rb_intern("selectables"));
+    monitor = rb_hash_lookup(selectables, io);
+
+    if(monitor != Qnil)
+        rb_raise(rb_eArgError, "this IO is already registered with selector");
+
+    /* Create a new NIO::Monitor */
+    monitor_args[0] = self;
+    monitor_args[1] = io;
+    monitor_args[2] = interests;
+
+    monitor = rb_class_new_instance(3, monitor_args, cNIO_Monitor);
+    rb_hash_aset(selectables, io, monitor);
+
+    return monitor;
+}
+
+/* Deregister an IO object from the selector */
+static VALUE NIO_Selector_deregister(VALUE self, VALUE io)
+{
+    VALUE args[2] = {self, io};
+    return NIO_Selector_synchronize(self, NIO_Selector_deregister_synchronized, args);
+}
+
+/* Internal implementation of register after acquiring mutex */
+static VALUE NIO_Selector_deregister_synchronized(VALUE *args)
+{
+    VALUE self, io, interests, selectables, monitor;
+    VALUE monitor_args[3];
+
+    self = args[0];
+    io = args[1];
+
+    selectables = rb_ivar_get(self, rb_intern("selectables"));
+    monitor = rb_hash_delete(selectables, io);
+
+    if(monitor != Qnil) {
+        rb_funcall(monitor, rb_intern("close"), 0, 0);
+    }
+
+    return monitor;
+}
+
+/* Is the given IO object registered with the selector */
+static VALUE NIO_Selector_is_registered(VALUE self, VALUE io)
+{
+    VALUE selectables = rb_ivar_get(self, rb_intern("selectables"));
+
+    /* Perhaps this should be holding the mutex? */
+    return rb_funcall(selectables, rb_intern("has_key?"), 1, io);
+}
+
+/* Select from all registered IO objects */
+static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
+{
+    VALUE timeout, array;
+    VALUE args[2];
+
+    rb_scan_args(argc, argv, "01", &timeout);
+
+    args[0] = self;
+    args[1] = timeout;
+
+    return NIO_Selector_synchronize(self, NIO_Selector_select_synchronized, args);
+}
+
+/* Internal implementation of select with the selector lock held */
+static VALUE NIO_Selector_select_synchronized(VALUE *args)
+{
+    VALUE self, timeout, result;
+    struct NIO_Selector *selector;
+
+    self = args[0];
+    timeout = args[1];
+
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+    selector->selecting = 1;
+
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_ALONE)
+    /* Implement the optional timeout (if any) as a ev_timer */
+    if(timeout != Qnil) {
+        selector->timer.repeat = NUM2DBL(timeout);
+        ev_timer_again(selector->ev_loop, &selector->timer);
+    } else {
+        ev_timer_stop(selector->ev_loop, &selector->timer);
+    }
+#else
+    /* Store when we started the loop so we can calculate the timeout */
+    ev_tstamp started_at = ev_now(selector->ev_loop);
+#endif
+
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+    /* Ruby 1.9 lets us release the GIL and make a blocking I/O call */
+    rb_thread_blocking_region(NIO_Selector_run_evloop, selector, RUBY_UBF_IO, 0);
+#elif defined(HAVE_RB_THREAD_ALONE)
+    /* If we're the only thread we can make a blocking system call */
+    if(rb_thread_alone()) {
+#else
+    /* If we don't have rb_thread_alone() we can't block */
+    if(0) {
+#endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
+
+#if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
+        TRAP_BEG;
+        NIO_Selector_run_evloop(selector);
+        TRAP_END;
+    } else {
+        /* We need to busy wait as not to stall the green thread scheduler
+           Ruby 1.8: just say no! :( */
+        ev_timer_init(&selector->timer, NIO_Selector_timeout_callback, BUSYWAIT_INTERVAL, BUSYWAIT_INTERVAL);
+        ev_timer_start(selector->ev_loop, &selector->timer);
+
+        /* Loop until we receive events */
+        while(selector->selecting && !selector->ready_count) {
+            TRAP_BEG;
+            NIO_Selector_run_evloop(selector);
+            TRAP_END;
+
+            /* Run the next green thread */
+            rb_thread_schedule();
+
+            /* Break if the timeout has elapsed */
+            if(timeout != Qnil && ev_now(selector->ev_loop) - started_at >= NUM2DBL(timeout))
+                break;
+        }
+
+        ev_timer_stop(selector->ev_loop, &selector->timer);
+    }
+#endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
+
+    if(!selector->ready_count) {
+        return Qnil;
+    }
+
+    result = rb_ary_new4(selector->ready_count, selector->ready_buffer);
+    selector->selecting = selector->ready_count = 0;
+
+    return result;
+}
+
+/* Run the libev event loop */
+static VALUE NIO_Selector_run_evloop(void *ptr)
+{
+    struct NIO_Selector *selector = (struct NIO_Selector *)ptr;
+
+    ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
+
+    return Qnil;
+}
+
+/* Wake the selector up from another thread */
+static VALUE NIO_Selector_wakeup(VALUE self)
+{
+    struct NIO_Selector *selector;
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    ev_async_send(selector->ev_loop, &selector->wakeup);
+
+    return Qnil;
+}
+
+/* Close the selector and free system resources */
+static VALUE NIO_Selector_close(VALUE self)
+{
+    struct NIO_Selector *selector;
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    NIO_Selector_shutdown(selector);
+
+    return Qnil;
+}
+
+/* Is the selector closed? */
+static VALUE NIO_Selector_closed(VALUE self)
+{
+    struct NIO_Selector *selector;
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    return selector->closed ? Qtrue : Qfalse;
+}
+
+/* Called whenever a timeout fires on the event loop */
+static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
+{
+    /* We don't actually need to do anything here, the mere firing of the
+       timer is sufficient to interrupt the selector. However, libev still wants a callback */
+}
+
+/* Called whenever a wakeup request is sent to a selector */
+static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_async *async, int revents)
+{
+    struct NIO_Selector *selector = (struct NIO_Selector *)async->data;
+    selector->selecting = 0;
+}
+
+/* This gets called from individual monitors. We must be careful here because
+   the GIL isn't held, so we must rely only on standard C and can't touch
+   anything Ruby-related */
+void NIO_Selector_handle_event(struct NIO_Selector *selector, VALUE monitor, int revents)
+{
+    /* Grow the ready buffer if it's too small */
+    if(selector->ready_count >= selector->ready_buffer_size) {
+      selector->ready_buffer_size *= 2;
+      selector->ready_buffer = (VALUE *)xrealloc(selector->ready_buffer, sizeof(VALUE) * selector->ready_buffer_size);
+    }
+
+    selector->ready_buffer[selector->ready_count] = monitor;
+    selector->ready_count++;
+}

data/lib/nio/jruby/monitor.rb

@@ -0,0 +1,26 @@
+module NIO
+  # Monitors watch Channels for specific events
+  class Monitor
+    attr_accessor :value
+
+    # :nodoc
+    def initialize(io, selection_key)
+      @io, @key = io, selection_key
+      selection_key.attach self
+      @closed = false
+    end
+
+    # Obtain the interests for this monitor
+    def interests
+      Selector.iops2sym @key.interestOps
+    end
+
+    # Is this monitor closed?
+    def closed?; @closed; end
+
+    # Deactivate this monitor
+    def close
+      @closed = true
+    end
+  end
+end

data/lib/nio/jruby/selector.rb

@@ -0,0 +1,110 @@
+module NIO
+  # Selectors monitor IO objects for events of interest
+  class Selector
+    java_import "java.nio.channels.Selector"
+    java_import "java.nio.channels.SelectionKey"
+
+    # Convert nio4r interest symbols to Java NIO interest ops
+    def self.sym2iops(interest)
+      case interest
+      when :r
+        interest = SelectionKey::OP_READ
+      when :w
+        interest = SelectionKey::OP_WRITE
+      when :rw
+        interest = SelectionKey::OP_READ | SelectionKey::OP_WRITE
+      else raise ArgumentError, "invalid interest type: #{interest}"
+      end
+    end
+
+    # Convert Java NIO interest ops to the corresponding Ruby symbols
+    def self.iops2sym(interest_ops)
+      case interest_ops
+      when SelectionKey::OP_READ
+        :r
+      when SelectionKey::OP_WRITE
+        :w
+      when SelectionKey::OP_READ | SelectionKey::OP_WRITE
+        :rw
+      else raise ArgumentError, "unknown interest op combination: 0x#{interest_ops.to_s(16)}"
+      end
+    end
+
+    # Create a new NIO::Selector
+    def initialize
+      @java_selector = Selector.open
+      @select_lock = Mutex.new
+    end
+
+    # Register interest in an IO object with the selector for the given types
+    # of events. Valid event types for interest are:
+    # * :r - is the IO readable?
+    # * :w - is the IO writeable?
+    # * :rw - is the IO either readable or writeable?
+    def register(io, interest)
+      java_channel = io.to_channel
+      java_channel.configureBlocking(false)
+
+      interest_ops = self.class.sym2iops(interest)
+
+      begin
+        selector_key = java_channel.register @java_selector, interest_ops
+      rescue NativeException => ex
+        case ex.cause
+        when java.lang.IllegalArgumentException
+          raise ArgumentError, "invalid interest type for #{channel}: #{interest}"
+        else raise
+        end
+      end
+
+      NIO::Monitor.new(io, selector_key)
+    end
+
+    # Deregister the given IO object from the selector
+    def deregister(io)
+      key = io.to_channel.keyFor(@java_selector)
+      return unless key
+
+      monitor = key.attachment
+      monitor.close
+      monitor
+    end
+
+    # Is the given IO object registered with the selector?
+    def registered?(io)
+      key = io.to_channel.keyFor(@java_selector)
+      return unless key
+      !key.attachment.closed?
+    end
+
+    # Select which monitors are ready
+    def select(timeout = nil)
+      @select_lock.synchronize do
+        if timeout
+          ready = @java_selector.select(timeout * 1000)
+        else
+          ready = @java_selector.select
+        end
+
+        return unless ready > 0 # timeout or wakeup
+        @java_selector.selectedKeys.map { |key| key.attachment }
+      end
+    end
+
+    # Wake up the other thread that's currently blocking on this selector
+    def wakeup
+      @java_selector.wakeup
+      nil
+    end
+
+    # Close this selector
+    def close
+      @java_selector.close
+    end
+
+    # Is this selector closed?
+    def closed?
+      !@java_selector.isOpen
+    end
+  end
+end

data/lib/nio/monitor.rb

@@ -0,0 +1,21 @@
+module NIO
+  # Monitors watch IO objects for specific events
+  class Monitor
+    attr_reader :io, :interests
+    attr_accessor :value
+
+    # :nodoc
+    def initialize(io, interests)
+      @io, @interests = io, interests
+      @closed = false
+    end
+
+    # Is this monitor closed?
+    def closed?; @closed; end
+
+    # Deactivate this monitor
+    def close
+      @closed = true
+    end
+  end
+end

data/lib/nio/selector.rb

@@ -0,0 +1,101 @@
+module NIO
+  # Selectors monitor IO objects for events of interest
+  class Selector
+    # Create a new NIO::Selector
+    def initialize
+      @selectables = {}
+      @lock = Mutex.new
+
+      # Other threads can wake up a selector
+      @wakeup, @waker = IO.pipe
+      @closed = false
+    end
+
+    # Register interest in an IO object with the selector for the given types
+    # of events. Valid event types for interest are:
+    # * :r - is the IO readable?
+    # * :w - is the IO writeable?
+    # * :rw - is the IO either readable or writeable?
+    def register(io, interest)
+      @lock.synchronize do
+        raise ArgumentError, "this IO is already registered with the selector" if @selectables[io]
+
+        monitor = Monitor.new(io, interest)
+        @selectables[io] = monitor
+
+        monitor
+      end
+    end
+
+    # Deregister the given IO object from the selector
+    def deregister(io)
+      @lock.synchronize do
+        monitor = @selectables.delete io
+        monitor.close if monitor
+        monitor
+      end
+    end
+
+    # Is the given IO object registered with the selector?
+    def registered?(io)
+      @lock.synchronize { @selectables.has_key? io }
+    end
+
+    # Select which monitors are ready
+    def select(timeout = nil)
+      @lock.synchronize do
+        readers, writers = [@wakeup], []
+
+        @selectables.each do |io, monitor|
+          readers << io if monitor.interests == :r || monitor.interests == :rw
+          writers << io if monitor.interests == :w || monitor.interests == :rw
+        end
+
+        ready_readers, ready_writers = Kernel.select readers, writers, [], timeout
+        return unless ready_readers # timeout or wakeup
+
+        results = ready_readers
+        results.concat ready_writers if ready_writers
+
+        results.map! do |io|
+          if io == @wakeup
+            # Clear all wakeup signals we've received by reading them
+            # Wakeups should have level triggered behavior
+            begin
+              @wakeup.read_nonblock(1024)
+
+              # Loop until we've drained all incoming events
+              redo
+            rescue Errno::EWOULDBLOCK
+            end
+
+            return
+          else
+            @selectables[io]
+          end
+        end
+      end
+    end
+
+    # Wake up other threads waiting on this selector
+    def wakeup
+      # Send the selector a signal in the form of writing data to a pipe
+      @waker << "\0"
+      nil
+    end
+
+    # Close this selector and free its resources
+    def close
+      @lock.synchronize do
+        return if @closed
+
+        @wakeup.close rescue nil
+        @waker.close rescue nil
+        @closed = true
+      end
+    end
+
+    # Is this selector closed?
+    def closed?; @closed end
+  end
+end

data/lib/nio/version.rb

@@ -0,0 +1,3 @@
+module NIO
+  VERSION = "0.1.0"
+end