sleepy_penguin 1.0.0

data/README

@@ -0,0 +1,62 @@
+= sleepy_penguin - Ruby I/O events for Linux
+
+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, and epoll interfaces are provided.
+
+== Features
+
+* Thread-safe blocking operations under both Ruby 1.8 and 1.9.
+
+* Mostly working under Rubinius
+
+* IO-like objects are backwards-compatible with IO.select.
+
+* Epoll interface is fork-safe
+
+* Unlike portable event frameworks, the Linux-only Epoll interface
+  allows using edge-triggered I/O for possibly improved performance
+
+== Install
+
+If you're using a packaged Ruby distribution, make sure you have a C
+compiler and the matching Ruby development libraries and headers.
+
+If you use RubyGems:
+
+    gem install sleepy_penguin
+
+Otherwise grab the latest tarball from:
+
+http://bogomips.org/sleepy_penguin/files/
+
+Unpack it, and run "ruby setup.rb"
+
+== Development
+
+You can get the latest source via git from the following locations:
+
+  git://git.bogomips.org/sleepy_penguin.git
+  git://repo.or.cz/sleepy_penguin.git (mirror)
+
+You may browse the code from the web and download the latest snapshot
+tarballs here:
+
+* http://git.bogomips.org/cgit/sleepy_penguin.git (cgit)
+* http://repo.or.cz/w/sleepy_penguin.git (gitweb)
+
+Inline patches (from "git format-patch") to the mailing list are
+preferred because they allow code review and comments in the reply to
+the patch.
+
+We will adhere to mostly the same conventions for patch submissions as
+git itself.  See the Documentation/SubmittingPatches document
+distributed with git on on patch submission guidelines to follow.  Just
+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
+
+* http://bogomips.org/sleepy_penguin/archives/

data/Rakefile

@@ -0,0 +1,167 @@
+# -*- encoding: binary -*-
+# most tasks are in the GNUmakefile which offers better parallelism
+def tags
+  timefmt = '%Y-%m-%dT%H:%M:%SZ'
+  @tags ||= `git tag -l`.split(/\n/).map do |tag|
+    if %r{\Av[\d\.]+\z} =~ tag
+      header, subject, body = `git cat-file tag #{tag}`.split(/\n\n/, 3)
+      header = header.split(/\n/)
+      tagger = header.grep(/\Atagger /).first
+      body ||= "initial"
+      {
+        :time => Time.at(tagger.split(/ /)[-2].to_i).utc.strftime(timefmt),
+        :tagger_name => %r{^tagger ([^<]+)}.match(tagger)[1].strip,
+        :tagger_email => %r{<([^>]+)>}.match(tagger)[1].strip,
+        :id => `git rev-parse refs/tags/#{tag}`.chomp!,
+        :tag => tag,
+        :subject => subject,
+        :body => body,
+      }
+    end
+  end.compact.sort { |a,b| b[:time] <=> a[:time] }
+end
+
+cgit_url = "http://git.bogomips.org/cgit/sleepy_penguin.git"
+git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/sleepy_penguin.git'
+web_url = "http://bogomips.org/sleepy_penguin"
+
+desc 'prints news as an Atom feed'
+task :news_atom do
+  require 'nokogiri'
+  new_tags = tags[0,10]
+  puts(Nokogiri::XML::Builder.new do
+    feed :xmlns => "http://www.w3.org/2005/Atom" do
+      id! "#{web_url}NEWS.atom.xml"
+      title "sleepy_penguin news"
+      subtitle "epoll"
+      link! :rel => "alternate", :type => "text/html",
+            :href => "#{web_url}NEWS.html"
+      updated(new_tags.empty? ? "1970-01-01T00:00:00Z" : new_tags.first[:time])
+      new_tags.each do |tag|
+        entry do
+          title tag[:subject]
+          updated tag[:time]
+          published tag[:time]
+          author {
+            name tag[:tagger_name]
+            email tag[:tagger_email]
+          }
+          url = "#{cgit_url}/tag/?id=#{tag[:tag]}"
+          link! :rel => "alternate", :type => "text/html", :href =>url
+          id! url
+          message_only = tag[:body].split(/\n.+\(\d+\):\n {6}/s).first.strip
+          content({:type =>:text}, message_only)
+          content(:type =>:xhtml) { pre tag[:body] }
+        end
+      end
+    end
+  end.to_xml)
+end
+
+desc 'prints RDoc-formatted news'
+task :news_rdoc do
+  tags.each do |tag|
+    time = tag[:time].tr!('T', ' ').gsub!(/:\d\dZ/, ' UTC')
+    puts "=== #{tag[:tag].sub(/^v/, '')} / #{time}"
+    puts ""
+
+    body = tag[:body]
+    puts tag[:body].gsub(/^/sm, "  ").gsub(/[ \t]+$/sm, "")
+    puts ""
+  end
+end
+
+desc "print release changelog for Rubyforge"
+task :release_changes do
+  version = ENV['VERSION'] or abort "VERSION= needed"
+  version = "v#{version}"
+  vtags = tags.map { |tag| tag[:tag] =~ /\Av/ and tag[:tag] }.sort
+  prev = vtags[vtags.index(version) - 1]
+  if prev
+    system('git', 'diff', '--stat', prev, version) or abort $?
+    puts ""
+    system('git', 'log', "#{prev}..#{version}") or abort $?
+  else
+    system('git', 'log', version) or abort $?
+  end
+end
+
+desc "print release notes for Rubyforge"
+task :release_notes do
+  spec = Gem::Specification.load('sleepy_penguin.gemspec')
+  puts spec.description.strip
+  puts ""
+  puts "* #{spec.homepage}"
+  puts "* #{spec.email}"
+  puts "* #{git_url}"
+
+  _, _, body = `git cat-file tag v#{spec.version}`.split(/\n\n/, 3)
+  print "\nChanges:\n\n"
+  puts body
+end
+
+desc "read news article from STDIN and post to rubyforge"
+task :publish_news do
+  require 'rubyforge'
+  spec = Gem::Specification.load('sleepy_penguin.gemspec')
+  tmp = Tempfile.new('rf-news')
+  _, subject, body = `git cat-file tag v#{spec.version}`.split(/\n\n/, 3)
+  tmp.puts subject
+  tmp.puts
+  tmp.puts spec.description.strip
+  tmp.puts ""
+  tmp.puts "* #{spec.homepage}"
+  tmp.puts "* #{spec.email}"
+  tmp.puts "* #{git_url}"
+  tmp.print "\nChanges:\n\n"
+  tmp.puts body
+  tmp.flush
+  system(ENV["VISUAL"], tmp.path) or abort "#{ENV["VISUAL"]} failed: #$?"
+  msg = File.readlines(tmp.path)
+  subject = msg.shift
+  blank = msg.shift
+  blank == "\n" or abort "no newline after subject!"
+  subject.strip!
+  body = msg.join("").strip!
+
+  rf = RubyForge.new.configure
+  rf.login
+  rf.post_news('rainbows', subject, body)
+end
+
+desc "post to RAA"
+task :raa_update do
+  require 'net/http'
+  require 'net/netrc'
+  rc = Net::Netrc.locate('sleepy_penguin-raa') or abort "~/.netrc not found"
+  password = rc.password
+
+  s = Gem::Specification.load('sleepy_penguin.gemspec')
+  desc = [ s.description.strip ]
+  desc << ""
+  desc << "* #{s.email}"
+  desc << "* #{git_url}"
+  desc << "* #{cgit_url}"
+  desc = desc.join("\n")
+  uri = URI.parse('http://raa.ruby-lang.org/regist.rhtml')
+  form = {
+    :name => s.name,
+    :short_description => s.summary,
+    :version => s.version.to_s,
+    :status => 'experimental',
+    :owner => s.authors.first,
+    :email => s.email,
+    :category_major => 'Library',
+    :category_minor => 'System',
+    :url => s.homepage,
+    :download => 'http://rubyforge.org/frs/?group_id=8977',
+    :license => "LGPL",
+    :description_style => 'Plain',
+    :description => desc,
+    :pass => password,
+    :submit => 'Update',
+  }
+  res = Net::HTTP.post_form(uri, form)
+  p res
+  puts res.body
+end

data/TODO

@@ -0,0 +1,3 @@
+* SignalFD interface
+
+* Inotify? Several libraries already support it, but it fits this project, too

data/ext/sleepy_penguin/epoll.c

@@ -0,0 +1,563 @@
+#include "sleepy_penguin.h"
+#include <sys/epoll.h>
+#include <pthread.h>
+#ifdef HAVE_RUBY_ST_H
+#  include <ruby/st.h>
+#else
+#  include <st.h>
+#endif
+
+#ifndef EPOLL_CLOEXEC
+#  define EPOLL_CLOEXEC (int)(02000000)
+#endif
+
+#define EP_RECREATE (-2)
+
+#ifndef HAVE_RB_MEMERROR
+static void rb_memerror(void)
+{
+	static const char e[] = "[FATAL] failed to allocate memory\n";
+	write(2, e, sizeof(e) - 1);
+	abort();
+}
+#endif
+#ifndef HAVE_RB_IO_CLOSE
+static VALUE rb_io_close(VALUE io)
+{
+	return rb_funcall(io, rb_intern("close"), 0);
+}
+#endif
+
+static st_table *active;
+static const int step = 64; /* unlikely to grow unless you're huge */
+static VALUE cEpoll_IO;
+static ID id_for_fd;
+
+static void pack_event_data(struct epoll_event *event, VALUE obj)
+{
+	event->data.ptr = (void *)obj;
+}
+
+static VALUE unpack_event_data(struct epoll_event *event)
+{
+	return (VALUE)event->data.ptr;
+}
+
+struct rb_epoll {
+	int fd;
+	int timeout;
+	int maxevents;
+	int capa;
+	struct epoll_event *events;
+	VALUE io;
+	int flags;
+};
+
+static struct rb_epoll *ep_get(VALUE self)
+{
+	struct rb_epoll *ep;
+
+	Data_Get_Struct(self, struct rb_epoll, ep);
+
+	return ep;
+}
+
+#ifndef HAVE_EPOLL_CREATE1
+/*
+ * fake epoll_create1() since some systems don't have it.
+ * Don't worry about thread-safety since current Ruby 1.9 won't
+ * call this without GVL.
+ */
+static int epoll_create1(int flags)
+{
+	int fd = epoll_create(1024); /* size ignored since 2.6.8 */
+
+	if (fd < 0 || flags == 0)
+		return fd;
+
+	if ((flags & EPOLL_CLOEXEC) && (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1))
+		goto err;
+	return fd;
+err:
+	{
+		int saved_errno = errno;
+		close(fd);
+		errno = saved_errno;
+		return -1;
+	}
+}
+#endif
+
+static void gcmark(void *ptr)
+{
+	struct rb_epoll *ep = ptr;
+
+	rb_gc_mark(ep->io);
+}
+
+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);
+	}
+	if (NIL_P(ep->io) && ep->fd >= 0) {
+		/* can't raise during GC */
+		(void)close(ep->fd);
+		errno = 0;
+	}
+	/* let GC take care of the underlying IO object if there is one */
+
+	xfree(ep);
+}
+
+static VALUE alloc(VALUE klass)
+{
+	struct rb_epoll *ep;
+	VALUE self;
+
+	self = Data_Make_Struct(klass, struct rb_epoll, gcmark, gcfree, ep);
+	ep->fd = -1;
+	ep->io = Qnil;
+	ep->capa = step;
+	ep->flags = EPOLL_CLOEXEC;
+	ep->events = xmalloc(sizeof(struct epoll_event) * ep->capa);
+
+	return self;
+}
+
+static void my_epoll_create(struct rb_epoll *ep)
+{
+	ep->fd = epoll_create1(ep->flags);
+
+	if (ep->fd == -1) {
+		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
+			rb_gc();
+			ep->fd = epoll_create1(ep->flags);
+		}
+		if (ep->fd == -1)
+			rb_sys_fail("epoll_create1");
+	}
+	st_insert(active, (st_data_t)ep->fd, (st_data_t)ep);
+}
+
+static void ep_check(struct rb_epoll *ep)
+{
+	if (ep->fd == EP_RECREATE)
+		my_epoll_create(ep);
+	if (ep->fd == -1)
+		rb_raise(rb_eIOError, "closed");
+}
+
+/*
+ * creates a new Epoll object with an optional +flags+ argument.
+ * +flags+ may currently be +Epoll::CLOEXEC+ or 0 (or nil)
+ */
+static VALUE init(int argc, VALUE *argv, VALUE self)
+{
+	int flags;
+	struct rb_epoll *ep = ep_get(self);
+	VALUE fl;
+
+	rb_scan_args(argc, argv, "01", &fl);
+	if (NIL_P(fl)) {
+		flags = EPOLL_CLOEXEC;
+	} else {
+		switch (TYPE(fl)) {
+		case T_FIXNUM:
+		case T_BIGNUM:
+			flags = NUM2INT(fl);
+			break;
+		default:
+			rb_raise(rb_eArgError, "flags must be an integer");
+		}
+	}
+	ep->flags = flags;
+	my_epoll_create(ep);
+
+	return self;
+}
+
+static VALUE ctl(VALUE self, VALUE io, VALUE flags, int op)
+{
+	struct epoll_event event;
+	struct rb_epoll *ep = ep_get(self);
+	int fd = my_fileno(io);
+	int rv;
+
+	ep_check(ep);
+	event.events = NUM2UINT(flags);
+	pack_event_data(&event, io);
+
+	rv = epoll_ctl(ep->fd, op, fd, &event);
+	if (rv == -1) {
+		if (errno == ENOMEM) {
+			rb_gc();
+			rv = epoll_ctl(ep->fd, op, fd, &event);
+		}
+		if (rv == -1)
+			rb_sys_fail("epoll_ctl");
+	}
+
+	return INT2NUM(rv);
+}
+
+/*
+ */
+static VALUE set(VALUE self, VALUE io, VALUE flags)
+{
+	struct epoll_event event;
+	struct rb_epoll *ep = ep_get(self);
+	int fd = my_fileno(io);
+	int rv;
+
+	ep_check(ep);
+	event.events = NUM2UINT(flags);
+	pack_event_data(&event, io);
+
+	rv = epoll_ctl(ep->fd, EPOLL_CTL_MOD, fd, &event);
+	if (rv == -1) {
+		if (errno == ENOENT) {
+			rv = epoll_ctl(ep->fd, EPOLL_CTL_ADD, fd, &event);
+			if (rv == -1)
+				rb_sys_fail("epoll_ctl - add");
+			return INT2NUM(rv);
+		}
+		rb_sys_fail("epoll_ctl - mod");
+	}
+
+	return INT2NUM(rv);
+}
+
+static VALUE epwait_result(struct rb_epoll *ep, int n)
+{
+	int i;
+	struct epoll_event *epoll_event = ep->events;
+	VALUE obj_events, obj;
+
+	if (n == -1)
+		rb_sys_fail("epoll_wait");
+
+	for (i = n; --i >= 0; epoll_event++) {
+		obj_events = UINT2NUM(epoll_event->events);
+		obj = unpack_event_data(epoll_event);
+		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);
+}
+
+#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);
+
+	return (VALUE)n;
+}
+
+static VALUE real_epwait(struct rb_epoll *ep)
+{
+	int n;
+
+	do {
+		n = (int)rb_thread_blocking_region(nogvl_wait, ep,
+		                                   RUBY_UBF_IO, 0);
+	} while (n == -1 && errno == EINTR);
+
+	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;
+
+	TRAP_BEG;
+	n = epoll_wait(ep->fd, ep->events, ep->maxevents, 0);
+	TRAP_END;
+
+	return n;
+}
+
+static int epwait_forever(struct rb_epoll *ep)
+{
+	int n;
+
+	do {
+		(void)rb_io_wait_readable(ep->fd);
+		n = safe_epoll_wait(ep);
+	} while (n == 0 || (n == -1 && errno == EINTR));
+
+	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);
+
+		gettimeofday(&t0, NULL);
+		(void)rb_thread_select(ep->fd + 1, &rfds, NULL, NULL, &tv);
+		n = safe_epoll_wait(ep);
+
+		/*
+		 * if we got EINTR from epoll_wait /and/ timed out
+		 * just consider it a timeout and don't raise an error
+		 */
+
+		if (n > 0 || (n == -1 && errno != EINTR))
+			return n;
+
+		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);
+}
+#endif /* 1.8 Green thread compatibility code */
+
+static VALUE epwait(int argc, VALUE *argv, VALUE self)
+{
+	VALUE timeout, maxevents;
+	struct rb_epoll *ep = ep_get(self);
+
+	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);
+	}
+
+	return real_epwait(ep);
+}
+
+/* adds +io+ object the +self+ with +flags+ */
+static VALUE add(VALUE self, VALUE io, VALUE flags)
+{
+	return ctl(self, io, flags, EPOLL_CTL_ADD);
+}
+
+/* adds +io+ object the +self+ with +flags+ */
+static VALUE del(VALUE self, VALUE io)
+{
+	return ctl(self, io, INT2NUM(0), EPOLL_CTL_DEL);
+}
+
+static VALUE mod(VALUE self, VALUE io, VALUE flags)
+{
+	return ctl(self, io, flags, EPOLL_CTL_MOD);
+}
+
+static VALUE to_io(VALUE self)
+{
+	struct rb_epoll *ep = ep_get(self);
+
+	ep_check(ep);
+
+	if (NIL_P(ep->io))
+		ep->io = rb_funcall(cEpoll_IO, id_for_fd, 1, INT2NUM(ep->fd));
+
+	return ep->io;
+}
+
+static VALUE epclose(VALUE self)
+{
+	struct rb_epoll *ep = ep_get(self);
+
+	if (ep->fd >= 0) {
+		st_data_t key = ep->fd;
+		st_delete(active, &key, NULL);
+	}
+
+	if (NIL_P(ep->io)) {
+		if (ep->fd == EP_RECREATE) {
+			ep->fd = -1;
+		} else if (ep->fd == -1) {
+			rb_raise(rb_eIOError, "closed");
+		} else {
+			int e = close(ep->fd);
+
+			ep->fd = -1;
+			if (e == -1)
+				rb_sys_fail("close");
+		}
+	} else {
+		ep->fd = -1;
+		rb_io_close(ep->io);
+	}
+
+	return Qnil;
+}
+
+static VALUE epclosed(VALUE self)
+{
+	struct rb_epoll *ep = ep_get(self);
+
+	return ep->fd == -1 ? Qtrue : Qfalse;
+}
+
+static int cloexec_dup(struct rb_epoll *ep)
+{
+#ifdef F_DUPFD_CLOEXEC
+	int flags = ep->flags & EPOLL_CLOEXEC ? F_DUPFD_CLOEXEC : F_DUPFD;
+	int fd = fcntl(ep->fd, flags, 0);
+#else
+	int fd = dup(ep->fd);
+	if (fd >= 0)
+		(void)fcntl(fd, F_SETFD, FD_CLOEXEC);
+#endif
+	return fd;
+}
+
+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?");
+
+	ep_check(a);
+	b->flags = a->flags;
+	b->fd = cloexec_dup(a);
+	if (b->fd == -1) {
+		if (errno == ENFILE || errno == EMFILE) {
+			rb_gc();
+			b->fd = cloexec_dup(a);
+		}
+		if (b->fd == -1)
+			rb_sys_fail("dup");
+	}
+	st_insert(active, (st_data_t)b->fd, (st_data_t)b);
+
+	return copy;
+}
+
+/*
+ * we close (or lose to GC) epoll descriptors at fork to avoid leakage
+ * and invalid objects being referenced later in the child
+ */
+static int ep_atfork(st_data_t key, st_data_t value, void *ignored)
+{
+	struct rb_epoll *ep = (struct rb_epoll *)value;
+
+	if (NIL_P(ep->io)) {
+		if (ep->fd >= 0)
+			(void)close(ep->fd);
+	} else {
+		ep->io = Qnil; /* must let GC take care of it later :< */
+	}
+	ep->fd = EP_RECREATE;
+
+	return ST_CONTINUE;
+}
+
+static void atfork_child(void)
+{
+	st_table *old = active;
+
+	active = st_init_numtable();
+	st_foreach(old, ep_atfork, (st_data_t)NULL);
+	st_free_table(old);
+}
+
+void sleepy_penguin_init_epoll(void)
+{
+	VALUE mSleepyPenguin, cEpoll;
+
+	mSleepyPenguin = rb_const_get(rb_cObject, rb_intern("SleepyPenguin"));
+	cEpoll = rb_define_class_under(mSleepyPenguin, "Epoll", rb_cObject);
+	cEpoll_IO = rb_define_class_under(cEpoll, "IO", rb_cIO);
+	rb_define_method(cEpoll, "initialize", init, -1);
+	rb_define_method(cEpoll, "initialize_copy", init_copy, 1);
+	rb_define_alloc_func(cEpoll, alloc);
+	rb_define_method(cEpoll, "to_io", to_io, 0);
+	rb_define_method(cEpoll, "close", epclose, 0);
+	rb_define_method(cEpoll, "closed?", epclosed, 0);
+	rb_define_method(cEpoll, "add", add, 2);
+	rb_define_method(cEpoll, "mod", mod, 2);
+	rb_define_method(cEpoll, "del", del, 1);
+	rb_define_method(cEpoll, "set", set, 2);
+	rb_define_method(cEpoll, "wait", epwait, -1);
+	rb_define_const(cEpoll, "CLOEXEC", INT2NUM(EPOLL_CLOEXEC));
+	rb_define_const(cEpoll, "IN", INT2NUM(EPOLLIN));
+	rb_define_const(cEpoll, "OUT", INT2NUM(EPOLLOUT));
+	rb_define_const(cEpoll, "RDHUP", INT2NUM(EPOLLRDHUP));
+	rb_define_const(cEpoll, "PRI", INT2NUM(EPOLLPRI));
+	rb_define_const(cEpoll, "ERR", INT2NUM(EPOLLERR));
+	rb_define_const(cEpoll, "HUP", INT2NUM(EPOLLHUP));
+	rb_define_const(cEpoll, "ET", INT2NUM(EPOLLET));
+	rb_define_const(cEpoll, "ONESHOT", INT2NUM(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();
+	}
+}