sleepy_penguin 3.0.1 → 3.1.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v3.0.1.GIT
+DEF_VER=v3.1.0.GIT
 
 LF='
 '

data/README

@@ -2,7 +2,7 @@
 
 sleepy_penguin provides access to newer, Linux-only system calls to wait
 on events from traditionally non-I/O sources.  Bindings to the eventfd,
-timerfd, inotify, signalfd and epoll interfaces are provided.
+timerfd, inotify, and epoll interfaces are provided.
 
 == Features
 
@@ -57,6 +57,6 @@ don't email the git mailing list or maintainer with sleepy_penguin patches.
 == Contact
 
 All feedback (bug reports, user/development discussion, patches, pull
-requests) go to the mailing list: mailto:sleepy.penguin@librelist.com
+requests) go to the mailing list: mailto:sleepy.penguin@librelist.org
 
 * http://bogomips.org/sleepy_penguin/archives/

data/ext/sleepy_penguin/epoll.c

@@ -9,8 +9,10 @@
 #  include <st.h>
 #endif
 #include "missing_rb_thread_fd_close.h"
+#include "missing_rb_update_max_fd.h"
 #define EP_RECREATE (-2)
 
+static pthread_key_t epoll_key;
 static st_table *active;
 static const int step = 64; /* unlikely to grow unless you're huge */
 static VALUE cEpoll_IO;
@@ -35,18 +37,60 @@ static VALUE unpack_event_data(struct epoll_event *event)
 	return (VALUE)event->data.ptr;
 }
 
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+# define FLEX_ARRAY
+#elif defined(__GNUC__)
+# if (__GNUC__ >= 3)
+#  define FLEX_ARRAY
+# else
+#  define FLEX_ARRAY 0
+# endif
+#endif
+
 struct rb_epoll {
 	int fd;
-	int timeout;
-	int maxevents;
-	int capa;
-	struct epoll_event *events;
 	VALUE io;
 	VALUE marks;
 	VALUE flag_cache;
 	int flags;
 };
 
+struct ep_per_thread {
+	struct rb_epoll *ep;
+	int timeout;
+	int maxevents;
+	int capa;
+	struct epoll_event events[FLEX_ARRAY];
+};
+
+static struct ep_per_thread *ept_get(int maxevents)
+{
+	struct ep_per_thread *ept = pthread_getspecific(epoll_key);
+	int err;
+	size_t size;
+
+	if (ept && ept->capa >= maxevents)
+		goto out;
+
+	size = sizeof(struct ep_per_thread) +
+	       sizeof(struct epoll_event) * maxevents;
+
+	free(ept); /* free(NULL) is POSIX and works on glibc */
+	ept = malloc(size);
+	if (ept == NULL)
+		rb_memerror();
+	err = pthread_setspecific(epoll_key, ept);
+	if (err != 0) {
+		errno = err;
+		rb_sys_fail("pthread_setspecific");
+	}
+	ept->capa = maxevents;
+out:
+	ept->maxevents = maxevents;
+
+	return ept;
+}
+
 static struct rb_epoll *ep_get(VALUE self)
 {
 	struct rb_epoll *ep;
@@ -69,7 +113,6 @@ static void gcfree(void *ptr)
 {
 	struct rb_epoll *ep = ptr;
 
-	xfree(ep->events);
 	if (ep->fd >= 0) {
 		st_data_t key = ep->fd;
 		st_delete(active, &key, NULL);
@@ -94,9 +137,7 @@ static VALUE alloc(VALUE klass)
 	ep->io = Qnil;
 	ep->marks = Qnil;
 	ep->flag_cache = Qnil;
-	ep->capa = step;
 	ep->flags = 0;
-	ep->events = xmalloc(sizeof(struct epoll_event) * ep->capa);
 
 	return self;
 }
@@ -113,6 +154,7 @@ static void my_epoll_create(struct rb_epoll *ep)
 		if (ep->fd == -1)
 			rb_sys_fail("epoll_create1");
 	}
+	rb_update_max_fd(ep->fd);
 	st_insert(active, (st_data_t)ep->fd, (st_data_t)ep);
 	ep->marks = rb_ary_new();
 	ep->flag_cache = rb_ary_new();
@@ -294,10 +336,10 @@ out:
 	return io;
 }
 
-static VALUE epwait_result(struct rb_epoll *ep, int n)
+static VALUE epwait_result(struct ep_per_thread *ept, int n)
 {
 	int i;
-	struct epoll_event *epoll_event = ep->events;
+	struct epoll_event *epoll_event = ept->events;
 	VALUE obj_events, obj;
 
 	if (n == -1)
@@ -309,144 +351,47 @@ static VALUE epwait_result(struct rb_epoll *ep, int n)
 		rb_yield_values(2, obj_events, obj);
 	}
 
-	/* grow our event buffer for the next epoll_wait call */
-	if (n == ep->capa) {
-		xfree(ep->events);
-		ep->capa += step;
-		ep->events = xmalloc(sizeof(struct epoll_event) * ep->capa);
-	}
-
 	return INT2NUM(n);
 }
 
-static int epoll_resume_p(uint64_t expire_at, struct rb_epoll *ep)
+static int epoll_resume_p(uint64_t expire_at, struct ep_per_thread *ept)
 {
 	uint64_t now;
 
-	ep_fd_check(ep);
+	ep_fd_check(ept->ep);
 
 	if (errno != EINTR)
 		return 0;
-	if (ep->timeout < 0)
+	if (ept->timeout < 0)
 		return 1;
 	now = now_ms();
-	ep->timeout = now > expire_at ? 0 : (int)(expire_at - now);
+	ept->timeout = now > expire_at ? 0 : (int)(expire_at - now);
 	return 1;
 }
 
 #if defined(HAVE_RB_THREAD_BLOCKING_REGION)
 static VALUE nogvl_wait(void *args)
 {
-	struct rb_epoll *ep = args;
-	int n = epoll_wait(ep->fd, ep->events, ep->maxevents, ep->timeout);
+	struct ep_per_thread *ept = args;
+	int fd = ept->ep->fd;
+	int n = epoll_wait(fd, ept->events, ept->maxevents, ept->timeout);
 
 	return (VALUE)n;
 }
 
-static VALUE real_epwait(struct rb_epoll *ep)
-{
-	int n;
-	uint64_t expire_at = ep->timeout > 0 ? now_ms() + ep->timeout : 0;
-
-	do
-		n = (int)rb_sp_fd_region(nogvl_wait, ep, ep->fd);
-	while (n == -1 && epoll_resume_p(expire_at, ep));
-
-	return epwait_result(ep, n);
-}
-#else /* 1.8 Green thread compatible code */
-/*
- * we have to worry about green threads and always pass zero
- * as the timeout for epoll_wait :(
- */
-# include <rubysig.h>
-# include <sys/time.h>
-
-/* in case _BSD_SOURCE doesn't give us this macro */
-#ifndef timersub
-#  define timersub(a, b, result) \
-do { \
-	(result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
-	(result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
-	if ((result)->tv_usec < 0) { \
-		--(result)->tv_sec; \
-		(result)->tv_usec += 1000000; \
-	} \
-} while (0)
-#endif
-
-static int safe_epoll_wait(struct rb_epoll *ep)
-{
-	int n;
-
-	do {
-		TRAP_BEG;
-		n = epoll_wait(ep->fd, ep->events, ep->maxevents, 0);
-		TRAP_END;
-	} while (n == -1 && errno == EINTR && ep_fd_check(ep));
-
-	return n;
-}
-
-static int epwait_forever(struct rb_epoll *ep)
+static VALUE real_epwait(struct ep_per_thread *ept)
 {
 	int n;
+	uint64_t expire_at = ept->timeout > 0 ? now_ms() + ept->timeout : 0;
 
 	do {
-		(void)rb_io_wait_readable(ep->fd);
-		n = safe_epoll_wait(ep);
-	} while (n == 0);
-
-	return n;
-}
-
-static int epwait_timed(struct rb_epoll *ep)
-{
-	struct timeval tv;
-
-	tv.tv_sec = ep->timeout / 1000;
-	tv.tv_usec = (ep->timeout % 1000) * 1000;
-
-	for (;;) {
-		struct timeval t0, now, diff;
-		int n;
-		fd_set rfds;
-
-		FD_ZERO(&rfds);
-		FD_SET(ep->fd, &rfds);
+		n = (int)rb_sp_fd_region(nogvl_wait, ept, ept->ep->fd);
+	} while (n == -1 && epoll_resume_p(expire_at, ept));
 
-		gettimeofday(&t0, NULL);
-		(void)rb_thread_select(ep->fd + 1, &rfds, NULL, NULL, &tv);
-		n = safe_epoll_wait(ep);
-		if (n != 0)
-			return n;
-
-		/* XXX use CLOCK_MONOTONIC if people care about 1.8... */
-		gettimeofday(&now, NULL);
-		timersub(&now, &t0, &diff);
-		timersub(&tv, &diff, &tv);
-
-		if (tv.tv_usec < 0 || tv.tv_sec < 0)
-			return (n == -1) ? 0 : n;
-	}
-
-	assert("should never get here (epwait_timed)");
-	return -1;
-}
-
-static VALUE real_epwait(struct rb_epoll *ep)
-{
-	int n;
-
-	if (ep->timeout == -1)
-		n = epwait_forever(ep);
-	else if (ep->timeout == 0)
-		n = safe_epoll_wait(ep);
-	else
-		n = epwait_timed(ep);
-
-	return epwait_result(ep, n);
+	return epwait_result(ept, n);
 }
+#else /* 1.8 Green thread compatible code */
+#  include "epoll_green.h"
 #endif /* 1.8 Green thread compatibility code */
 
 /*
@@ -463,20 +408,16 @@ static VALUE epwait(int argc, VALUE *argv, VALUE self)
 {
 	VALUE timeout, maxevents;
 	struct rb_epoll *ep = ep_get(self);
+	struct ep_per_thread *ept;
 
 	ep_check(ep);
 	rb_need_block();
 	rb_scan_args(argc, argv, "02", &maxevents, &timeout);
-	ep->timeout = NIL_P(timeout) ? -1 : NUM2INT(timeout);
-	ep->maxevents = NIL_P(maxevents) ? ep->capa : NUM2INT(maxevents);
-
-	if (ep->maxevents > ep->capa) {
-		xfree(ep->events);
-		ep->capa = ep->maxevents;
-		ep->events = xmalloc(sizeof(struct epoll_event) * ep->capa);
-	}
+	ept = ept_get(NIL_P(maxevents) ? 64 : NUM2INT(maxevents));
+	ept->timeout = NIL_P(timeout) ? -1 : NUM2INT(timeout);
+	ept->ep = ep;
 
-	return real_epwait(ep);
+	return real_epwait(ept);
 }
 
 /*
@@ -615,8 +556,7 @@ static VALUE init_copy(VALUE copy, VALUE orig)
 	struct rb_epoll *a = ep_get(orig);
 	struct rb_epoll *b = ep_get(copy);
 
-	assert(a->events && b->events && a->events != b->events &&
-	       NIL_P(b->io) && "Ruby broken?");
+	assert(NIL_P(b->io) && "Ruby broken?");
 
 	ep_check(a);
 	assert(NIL_P(b->marks) && "mark array not nil");
@@ -721,9 +661,34 @@ static void atfork_child(void)
 	st_free_table(old);
 }
 
+static void epoll_once(void)
+{
+	int err = pthread_key_create(&epoll_key, free);
+
+	if (err) {
+		errno = err;
+		rb_sys_fail("pthread_key_create");
+	}
+
+	active = st_init_numtable();
+
+	if (pthread_atfork(NULL, NULL, atfork_child) != 0) {
+		rb_gc();
+		if (pthread_atfork(NULL, NULL, atfork_child) != 0)
+			rb_memerror();
+	}
+}
+
 void sleepy_penguin_init_epoll(void)
 {
 	VALUE mSleepyPenguin, cEpoll;
+	pthread_once_t once = PTHREAD_ONCE_INIT;
+	int err = pthread_once(&once, epoll_once);
+
+	if (err) {
+		errno = err;
+		rb_sys_fail("pthread_once(.., epoll_once)");
+	}
 
 	/*
 	 * Document-module: SleepyPenguin
@@ -731,7 +696,7 @@ void sleepy_penguin_init_epoll(void)
 	 *	require "sleepy_penguin"
 	 *	include SleepyPenguin
 	 *
-	 * The SleepyPenguin namespace includes the Epoll, Inotify, SignalFD,
+	 * The SleepyPenguin namespace includes the Epoll, Inotify,
 	 * TimerFD, EventFD classes in its top level and no other constants.
 	 *
 	 * If you are uncomfortable including SleepyPenguin, you may also
@@ -744,7 +709,6 @@ void sleepy_penguin_init_epoll(void)
 	 * - SP::Epoll
 	 * - SP::EventFD
 	 * - SP::Inotify
-	 * - SP::SignalFD
 	 * - SP::TimerFD
 	 */
 	mSleepyPenguin = rb_define_module("SleepyPenguin");
@@ -822,11 +786,4 @@ void sleepy_penguin_init_epoll(void)
 	rb_define_const(cEpoll, "ONESHOT", UINT2NUM(EPOLLONESHOT));
 
 	id_for_fd = rb_intern("for_fd");
-	active = st_init_numtable();
-
-	if (pthread_atfork(NULL, NULL, atfork_child) != 0) {
-		rb_gc();
-		if (pthread_atfork(NULL, NULL, atfork_child) != 0)
-			rb_memerror();
-	}
 }

data/ext/sleepy_penguin/epoll_green.h

@@ -0,0 +1,95 @@
+/* this file is only used by Matz Ruby 1.8 which used green threads */
+
+/*
+ * we have to worry about green threads and always pass zero
+ * as the timeout for epoll_wait :(
+ */
+#include <rubysig.h>
+#include <sys/time.h>
+
+/* in case _BSD_SOURCE doesn't give us this macro */
+#ifndef timersub
+#  define timersub(a, b, result) \
+do { \
+	(result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
+	(result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
+	if ((result)->tv_usec < 0) { \
+		--(result)->tv_sec; \
+		(result)->tv_usec += 1000000; \
+	} \
+} while (0)
+#endif
+
+static int safe_epoll_wait(struct ep_per_thread *ept)
+{
+	int n;
+
+	do {
+		TRAP_BEG;
+		n = epoll_wait(ept->ep->fd, ept->events, ept->maxevents, 0);
+		TRAP_END;
+	} while (n == -1 && errno == EINTR && ep_fd_check(ept->ep));
+
+	return n;
+}
+
+static int epwait_forever(struct ep_per_thread *ept)
+{
+	int n;
+
+	do {
+		(void)rb_io_wait_readable(ept->ep->fd);
+		n = safe_epoll_wait(ept);
+	} while (n == 0);
+
+	return n;
+}
+
+static int epwait_timed(struct ep_per_thread *ept)
+{
+	struct timeval tv;
+
+	tv.tv_sec = ept->timeout / 1000;
+	tv.tv_usec = (ept->timeout % 1000) * 1000;
+
+	for (;;) {
+		struct timeval t0, now, diff;
+		int n;
+		int fd = ept->ep->fd;
+		fd_set rfds;
+
+		FD_ZERO(&rfds);
+		FD_SET(fd, &rfds);
+
+		gettimeofday(&t0, NULL);
+		(void)rb_thread_select(fd + 1, &rfds, NULL, NULL, &tv);
+		n = safe_epoll_wait(ept);
+		if (n != 0)
+			return n;
+
+		/* XXX use CLOCK_MONOTONIC if people care about 1.8... */
+		gettimeofday(&now, NULL);
+		timersub(&now, &t0, &diff);
+		timersub(&tv, &diff, &tv);
+
+		if (tv.tv_usec < 0 || tv.tv_sec < 0)
+			return (n == -1) ? 0 : n;
+	}
+
+	assert("should never get here (epwait_timed)");
+	return -1;
+}
+
+static VALUE real_epwait(struct ep_per_thread *ept)
+{
+	int n;
+
+	if (ept->timeout == -1)
+		n = epwait_forever(ept);
+	else if (ept->timeout == 0)
+		n = safe_epoll_wait(ept);
+	else
+		n = epwait_timed(ept);
+
+	return epwait_result(ept, n);
+}

data/ext/sleepy_penguin/extconf.rb

@@ -2,14 +2,18 @@ require 'mkmf'
 have_header('sys/epoll.h') or abort 'sys/epoll.h not found'
 have_header("pthread.h") or abort 'pthread.h not found'
 have_header('sys/eventfd.h')
-have_header('sys/signalfd.h')
+
+# it's impossible to use signalfd reliably with Ruby since Ruby currently
+# manages # (and overrides) all signal handling
+# have_header('sys/signalfd.h')
+
 have_header('sys/timerfd.h')
 have_header('sys/inotify.h')
-have_header('sys/signalfd.h')
 have_header('ruby/io.h') and have_struct_member('rb_io_t', 'fd', 'ruby/io.h')
 have_func('epoll_create1', %w(sys/epoll.h))
 have_func('rb_thread_blocking_region')
 have_func('rb_thread_io_blocking_region')
 have_func('rb_thread_fd_close')
+have_func('rb_update_max_fd')
 have_library('pthread')
 create_makefile('sleepy_penguin_ext')

data/ext/sleepy_penguin/inotify.c

@@ -232,7 +232,6 @@ static VALUE events(VALUE self)
 {
 	long len = RARRAY_LEN(checks);
 	VALUE *ptr = RARRAY_PTR(checks);
-	VALUE pair;
 	VALUE sym;
 	VALUE rv = rb_ary_new();
 	uint32_t mask;

data/ext/sleepy_penguin/missing_rb_update_max_fd.h

@@ -0,0 +1,3 @@
+#ifndef HAVE_RB_UPDATE_MAX_FD
+#  define rb_update_max_fd(fd) for (;0;)
+#endif

data/ext/sleepy_penguin/signalfd.c

@@ -2,7 +2,6 @@
 #include "sleepy_penguin.h"
 #include <signal.h>
 #include <sys/signalfd.h>
-static ID id_list;
 static VALUE ssi_members;
 static VALUE cSigInfo;
 
@@ -243,6 +242,9 @@ void sleepy_penguin_init_signalfd(void)
 	 * Use of this class is NOT recommended.  Ruby itself has a great
 	 * signal handling API and its implementation conflicts with this.
 	 *
+	 * This class is currently disabled and the documentation is only
+	 * provided to describe what it would look like.
+	 *
 	 * A SignalFD is an IO object for accepting signals.  It provides
 	 * an alternative to Signal.trap that may be monitored using
 	 * IO.select or Epoll.
@@ -252,7 +254,7 @@ void sleepy_penguin_init_signalfd(void)
 	 * decent signal handling interface anyways, this class is less useful
 	 * than signalfd() in a C-only environment.
 	 *
-	 * It is not supported at all under (Matz) Ruby 1.8.
+	 * It is not supported at all.
 	 */
 	cSignalFD = rb_define_class_under(mSleepyPenguin, "SignalFD", rb_cIO);
 

data/ext/sleepy_penguin/sleepy_penguin.h

@@ -31,6 +31,7 @@ VALUE rb_sp_io_region(rb_blocking_function_t *func, void *data);
 #endif
 
 #ifdef HAVE_RB_THREAD_IO_BLOCKING_REGION
+VALUE rb_thread_io_blocking_region(rb_blocking_function_t *, void *, int);
 #  define rb_sp_fd_region(fn,data,fd) \
           rb_thread_io_blocking_region((fn),(data),(fd))
 #else

data/ext/sleepy_penguin/timerfd.c

@@ -152,9 +152,15 @@ void sleepy_penguin_init_timerfd(void)
 	 */
 	cTimerFD = rb_define_class_under(mSleepyPenguin, "TimerFD", rb_cIO);
 	rb_define_singleton_method(cTimerFD, "new", s_new, -1);
+
 	NODOC_CONST(cTimerFD, "REALTIME", UINT2NUM(CLOCK_REALTIME));
 	NODOC_CONST(cTimerFD, "MONOTONIC", UINT2NUM(CLOCK_MONOTONIC));
 	NODOC_CONST(cTimerFD, "ABSTIME", UINT2NUM(TFD_TIMER_ABSTIME));
+#ifdef TFD_TIMER_CANCEL_ON_SET
+	NODOC_CONST(cTimerFD, "CANCEL_ON_SET",
+	            UINT2NUM(TFD_TIMER_CANCEL_ON_SET));
+#endif
+
 #ifdef TFD_NONBLOCK
 	NODOC_CONST(cTimerFD, "NONBLOCK", UINT2NUM(TFD_NONBLOCK));
 #endif

data/lib/sleepy_penguin.rb

@@ -1 +1,7 @@
+# -*- encoding: binary -*-
+module SleepyPenguin
+
+  # the version of sleepy_penguin, currently 3.1.0
+  SLEEPY_PENGUIN_VERSION = '3.1.0'
+end
 require 'sleepy_penguin_ext'

data/sleepy_penguin.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.authors = ["#{name} hackers"]
   s.date = Time.now.utc.strftime('%Y-%m-%d')
   s.description = readme_description
-  s.email = %q{sleepy.penguin@librelist.com}
+  s.email = %q{sleepy.penguin@librelist.org}
   s.extra_rdoc_files = extra_rdoc_files(manifest)
   s.files = manifest
   s.rdoc_options = rdoc_options

data/test/test_epoll.rb

@@ -1,7 +1,9 @@
 require 'test/unit'
 require 'fcntl'
 require 'socket'
+require 'thread'
 $-w = true
+Thread.abort_on_exception = true
 
 require 'sleepy_penguin'
 
@@ -93,6 +95,19 @@ class TestEpoll < Test::Unit::TestCase
     assert_equal [ [Epoll::OUT,  sock] ], tmp
   end
 
+  def test_edge_accept
+    host = '127.0.0.1'
+    srv = TCPServer.new(host, 0)
+    port = srv.addr[1]
+    sock = TCPSocket.new(host, port)
+    asock = srv.accept
+    assert_equal 3, asock.syswrite("HI\n")
+    @ep.add(asock, Epoll::OUT| Epoll::ET | Epoll::ONESHOT)
+    tmp = []
+    @ep.wait(1) { |flags, obj| tmp << [ flags, obj ] }
+    assert_equal [ [Epoll::OUT,  asock] ], tmp
+  end
+
   def teardown
     assert_nothing_raised do
       @rd.close unless @rd.closed?
@@ -399,10 +414,34 @@ class TestEpoll < Test::Unit::TestCase
     assert_nil thr.value
   end if RUBY_VERSION == "1.9.3"
 
+  def test_epoll_level_trigger
+    @ep.add(@wr, Epoll::OUT)
+
+    tmp = nil
+    @ep.wait { |flags, obj| tmp = obj }
+    assert_equal @wr, tmp
+
+    tmp = nil
+    @ep.wait { |flags, obj| tmp = obj }
+    assert_equal @wr, tmp
+
+    buf = '.' * 16384
+    begin
+      @wr.write_nonblock(buf)
+    rescue Errno::EAGAIN
+      break
+    end while true
+    @rd.read(16384)
+
+    tmp = nil
+    @ep.wait { |flags, obj| tmp = obj }
+    assert_equal @wr, tmp
+  end
+
   def test_epoll_wait_signal_torture
     usr1 = 0
     empty = 0
-    nr = 1000
+    nr = 100
     @ep.add(@rd, Epoll::IN)
     tmp = []
     trap(:USR1) { usr1 += 1 }
@@ -423,5 +462,66 @@ class TestEpoll < Test::Unit::TestCase
     assert usr1 > 0, "usr1: #{usr1}"
     ensure
       trap(:USR1, "DEFAULT")
+  end if ENV["STRESS"].to_i != 0
+
+  def test_wait_one_event_per_thread
+    thr = []
+    pipes = {}
+    lock = Mutex.new
+    maxevents = 1
+    ok = []
+    nr = 10
+    nr.times do
+      r, w = IO.pipe
+      pipes[r] = w
+      @ep.add(r, Epoll::IN | Epoll::ET | Epoll::ONESHOT)
+
+      t = Thread.new do
+        sleep 2
+        events = 0
+        @ep.wait(maxevents) do |_,obj|
+          assert pipes.include?(obj), "#{obj.inspect} is unknown"
+          lock.synchronize { ok << obj }
+          events += 1
+        end
+        events
+      end
+      thr << t
+    end
+    pipes.each_value { |w| w.syswrite '.' }
+    thr.each do |t|
+      begin
+        t.run
+      rescue ThreadError
+      end
+    end
+
+    thr.each { |t| assert_equal 1, t.value }
+    assert_equal nr, ok.size, ok.inspect
+    assert_equal ok.size, ok.uniq.size, ok.inspect
+    assert_equal ok.map { |io| io.fileno }.sort,
+                 pipes.keys.map { |io| io.fileno }.sort
+  ensure
+    pipes.each do |r,w|
+      r.close
+      w.close
+    end
+  end
+
+  def test_epoll_as_queue
+    fl = Epoll::OUT | Epoll::ET
+    first = nil
+    500.times do
+      r, w = IO.pipe
+      @ep.add(w, fl)
+      first ||= begin
+        @ep.add(r, Epoll::IN | Epoll::ET)
+        [ r, w ]
+      end
+    end
+    500.times do |i|
+      @ep.wait(1) { |flags, io| first[1].write('.') if i == 0 }
+    end
+    @ep.wait(1) { |flags, io| assert_equal(first[0], io) }
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sleepy_penguin
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 3
   prerelease: 
   segments: 
   - 3
-  - 0
   - 1
-  version: 3.0.1
+  - 0
+  version: 3.1.0
 platform: ruby
 authors: 
 - sleepy_penguin hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-21 00:00:00 Z
+date: 2012-05-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: wrongdoc
@@ -50,8 +50,8 @@ dependencies:
 description: |-
   sleepy_penguin provides access to newer, Linux-only system calls to wait
   on events from traditionally non-I/O sources.  Bindings to the eventfd,
-  timerfd, inotify, signalfd and epoll interfaces are provided.
-email: sleepy.penguin@librelist.com
+  timerfd, inotify, and epoll interfaces are provided.
+email: sleepy.penguin@librelist.org
 executables: []
 
 extensions: 
@@ -88,6 +88,7 @@ files:
 - Rakefile
 - TODO
 - ext/sleepy_penguin/epoll.c
+- ext/sleepy_penguin/epoll_green.h
 - ext/sleepy_penguin/eventfd.c
 - ext/sleepy_penguin/extconf.rb
 - ext/sleepy_penguin/init.c
@@ -95,6 +96,7 @@ files:
 - ext/sleepy_penguin/missing_epoll.h
 - ext/sleepy_penguin/missing_inotify.h
 - ext/sleepy_penguin/missing_rb_thread_fd_close.h
+- ext/sleepy_penguin/missing_rb_update_max_fd.h
 - ext/sleepy_penguin/signalfd.c
 - ext/sleepy_penguin/sleepy_penguin.h
 - ext/sleepy_penguin/timerfd.c
@@ -147,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rainbows
-rubygems_version: 1.8.2
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Linux I/O events for Ruby