sleepy_penguin 1.4.0 → 2.0.0

data/ext/sleepy_penguin/timerfd.c

@@ -4,15 +4,31 @@
 #include "value2timespec.h"
 static ID id_for_fd;
 
-static VALUE create(int argc, VALUE *argv, VALUE klass)
+/*
+ * call-seq:
+ *	TimerFD.new([clockid[, flags]]) -> TimerFD IO object
+ *
+ * Creates a new timer as an IO object.
+ *
+ * If set +clockid+ must be be one of the following:
+ * - :REALTIME - use the settable clock
+ * - :MONOTONIC - use the non-settable clock unaffected by manual changes
+ *
+ * +clockid+ defaults to :MONOTONIC if unspecified
+ * +flags+ may be any or none of the following:
+ *
+ * - :CLOEXEC - set the close-on-exec flag on the new object
+ * - :NONBLOCK - set the non-blocking I/O flag on the new object
+ */
+static VALUE s_new(int argc, VALUE *argv, VALUE klass)
 {
 	VALUE cid, fl;
-	int clockid, flags = 0;
+	int clockid, flags;
 	int fd;
 
 	rb_scan_args(argc, argv, "02", &cid, &fl);
-	clockid = NIL_P(cid) ? CLOCK_MONOTONIC : NUM2INT(cid);
-	flags = NIL_P(fl) ? 0 : NUM2INT(fl);
+	clockid = NIL_P(cid) ? CLOCK_MONOTONIC : rb_sp_get_flags(klass, cid);
+	flags = rb_sp_get_flags(klass, fl);
 
 	fd = timerfd_create(clockid, flags);
 	if (fd == -1) {
@@ -35,10 +51,22 @@ static VALUE itimerspec2ary(struct itimerspec *its)
 	return rb_ary_new3(2, interval, value);
 }
 
+/*
+ * call-seq:
+ *	tfd.settime(flags, interval, value) -> [ old_interval, old_value ]
+ *
+ * Arms (starts) or disarms (stops) the timer referred by the TimerFD object
+ * and returns the old value of the timer.
+ *
+ * +flags+ is either zero (or nil) to start a relative timer or :ABSTIME
+ * to start an absolute timer.  If the +interval+ is zero, the timer fires
+ * only once, otherwise the timer is fired every +interval+ seconds.
+ * +value+ is the time of the initial expiration in seconds.
+ */
 static VALUE settime(VALUE self, VALUE fl, VALUE interval, VALUE value)
 {
-	int fd = my_fileno(self);
-	int flags = NUM2INT(fl);
+	int fd = rb_sp_fileno(self);
+	int flags = rb_sp_get_flags(self, fl);
 	struct itimerspec old, new;
 
 	value2timespec(&new.it_interval, interval);
@@ -50,9 +78,15 @@ static VALUE settime(VALUE self, VALUE fl, VALUE interval, VALUE value)
 	return itimerspec2ary(&old);
 }
 
+/*
+ * call-seq:
+ *	tfd#gettime	-> [ interval, value ]
+ *
+ * Returns the current +interval+ and +value+ of the timer as an Array.
+ */
 static VALUE gettime(VALUE self)
 {
-	int fd = my_fileno(self);
+	int fd = rb_sp_fileno(self);
 	struct itimerspec curr;
 
 	if (timerfd_gettime(fd, &curr) == -1)
@@ -61,7 +95,6 @@ static VALUE gettime(VALUE self)
 	return itimerspec2ary(&curr);
 }
 
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
 static VALUE tfd_read(void *args)
 {
 	uint64_t *buf = args;
@@ -71,29 +104,31 @@ static VALUE tfd_read(void *args)
 	return (VALUE)r;
 }
 
-static VALUE expirations(VALUE self)
+/*
+ * call-seq:
+ *	tfd.expirations([nonblock])		-> Integer
+ *
+ * Returns the number of expirations that have occurred.  This will block
+ * if no expirations have occurred at the time of the call.  Returns +nil+
+ * if +nonblock+ is passed and is +true+
+ */
+static VALUE expirations(int argc, VALUE *argv, VALUE self)
 {
 	ssize_t r;
-	uint64_t buf = (int)my_fileno(self);
-
-	r = (VALUE)rb_thread_blocking_region(tfd_read, &buf, RUBY_UBF_IO, 0);
-	if (r == -1)
-		rb_sys_fail("read(timerfd)");
-
-	return ULL2NUM(buf);
-}
-#else /* ! HAVE_RB_THREAD_BLOCKING_REGION */
-#include "nonblock.h"
-static VALUE expirations(VALUE self)
-{
-	int fd = my_fileno(self);
-	uint64_t buf;
-	ssize_t r;
-
-	set_nonblock(fd);
+	int fd = rb_sp_fileno(self);
+	uint64_t buf = (uint64_t)fd;
+	VALUE nonblock;
+
+	rb_scan_args(argc, argv, "01", &nonblock);
+	if (RTEST(nonblock))
+		rb_sp_set_nonblock(fd);
+	else
+		blocking_io_prepare(fd);
 retry:
-	r = read(fd, &buf, sizeof(uint64_t));
+	r = (ssize_t)rb_sp_io_region(tfd_read, &buf);
 	if (r == -1) {
+		if (errno == EAGAIN && RTEST(nonblock))
+			return Qnil;
 		if (rb_io_wait_readable(fd))
 			goto retry;
 		rb_sys_fail("read(timerfd)");
@@ -101,28 +136,35 @@ retry:
 
 	return ULL2NUM(buf);
 }
-#endif
 
 void sleepy_penguin_init_timerfd(void)
 {
 	VALUE mSleepyPenguin, cTimerFD;
 
 	mSleepyPenguin = rb_define_module("SleepyPenguin");
+
+	/*
+	 * Document-class: SleepyPenguin::TimerFD
+	 *
+	 * TimerFD exposes kernel timers as IO objects that may be monitored
+	 * by IO.select or Epoll.  IO#close disarms the timers and returns
+	 * resources back to the kernel.
+	 */
 	cTimerFD = rb_define_class_under(mSleepyPenguin, "TimerFD", rb_cIO);
-	rb_define_singleton_method(cTimerFD, "create", create, -1);
-	rb_define_singleton_method(cTimerFD, "new", create, -1);
-	rb_define_const(cTimerFD, "REALTIME", UINT2NUM(CLOCK_REALTIME));
-	rb_define_const(cTimerFD, "MONOTONIC", UINT2NUM(CLOCK_MONOTONIC));
-	rb_define_const(cTimerFD, "ABSTIME", UINT2NUM(TFD_TIMER_ABSTIME));
+	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_NONBLOCK
-	rb_define_const(cTimerFD, "NONBLOCK", UINT2NUM(TFD_NONBLOCK));
+	NODOC_CONST(cTimerFD, "NONBLOCK", UINT2NUM(TFD_NONBLOCK));
 #endif
 #ifdef TFD_CLOEXEC
-	rb_define_const(cTimerFD, "CLOEXEC", UINT2NUM(TFD_CLOEXEC));
+	NODOC_CONST(cTimerFD, "CLOEXEC", UINT2NUM(TFD_CLOEXEC));
 #endif
 
 	rb_define_method(cTimerFD, "settime", settime, 3);
-	rb_define_method(cTimerFD, "expirations", expirations, 0);
+	rb_define_method(cTimerFD, "gettime", gettime, 0);
+	rb_define_method(cTimerFD, "expirations", expirations, -1);
 	id_for_fd = rb_intern("for_fd");
 }
 #endif /* HAVE_SYS_TIMERFD_H */

data/ext/sleepy_penguin/util.c

@@ -0,0 +1,149 @@
+#include "sleepy_penguin.h"
+
+static VALUE klass_for(VALUE klass)
+{
+	return (TYPE(klass) == T_CLASS) ? klass : CLASS_OF(klass);
+}
+
+int rb_sp_get_flags(VALUE klass, VALUE flags)
+{
+	switch (TYPE(flags)) {
+	case T_NIL: return 0;
+	case T_FIXNUM: return FIX2INT(flags);
+	case T_BIGNUM: return NUM2INT(flags);
+	case T_SYMBOL:
+		return NUM2INT(rb_const_get(klass_for(klass), SYM2ID(flags)));
+	case T_ARRAY: {
+		VALUE *ptr = RARRAY_PTR(flags);
+		long len = RARRAY_LEN(flags);
+		int rv = 0;
+
+		klass = klass_for(klass);
+		while (--len >= 0) {
+			VALUE tmp = *ptr++;
+
+			Check_Type(tmp, T_SYMBOL);
+			tmp = rb_const_get(klass, SYM2ID(tmp));
+			rv |= NUM2INT(tmp);
+		}
+		return rv;
+		}
+	}
+	rb_raise(rb_eTypeError, "invalid flags");
+	return 0;
+}
+
+unsigned rb_sp_get_uflags(VALUE klass, VALUE flags)
+{
+	switch (TYPE(flags)) {
+	case T_NIL: return 0;
+	case T_FIXNUM: return FIX2UINT(flags);
+	case T_BIGNUM: return NUM2UINT(flags);
+	case T_SYMBOL:
+		return NUM2UINT(rb_const_get(klass_for(klass), SYM2ID(flags)));
+	case T_ARRAY: {
+		VALUE *ptr = RARRAY_PTR(flags);
+		long len = RARRAY_LEN(flags);
+		unsigned rv = 0;
+
+		klass = klass_for(klass);
+		while (--len >= 0) {
+			VALUE tmp = *ptr++;
+
+			Check_Type(tmp, T_SYMBOL);
+			tmp = rb_const_get(klass, SYM2ID(tmp));
+			rv |= NUM2UINT(tmp);
+		}
+		return rv;
+		}
+	}
+	rb_raise(rb_eTypeError, "invalid flags");
+	return 0;
+}
+
+#if ! HAVE_RB_IO_T
+#  define rb_io_t OpenFile
+#endif
+
+#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
+#endif
+
+static int fixint_closed_p(VALUE io)
+{
+	return (fcntl(FIX2INT(io), F_GETFD) == -1 && errno == EBADF);
+}
+
+#if defined(RFILE) && defined(HAVE_ST_FD)
+static int my_rb_io_closed(VALUE io)
+{
+	return RFILE(io)->fptr->fd < 0;
+}
+#else
+static int my_rb_io_closed(VALUE io)
+{
+	return rb_funcall(io, rb_intern("closed?"), 0) == Qtrue;
+}
+#endif
+
+int rb_sp_io_closed(VALUE io)
+{
+	switch (TYPE(io)) {
+	case T_FIXNUM:
+		return fixint_closed_p(io);
+	case T_FILE:
+		break;
+	default:
+		io = rb_convert_type(io, T_FILE, "IO", "to_io");
+	}
+
+	return my_rb_io_closed(io);
+}
+
+int rb_sp_fileno(VALUE io)
+{
+	rb_io_t *fptr;
+
+	switch (TYPE(io)) {
+	case T_FIXNUM: return FIX2INT(io);
+	case T_FILE:
+		GetOpenFile(io, fptr);
+		return FPTR_TO_FD(fptr);
+	}
+	io = rb_convert_type(io, T_FILE, "IO", "to_io");
+	GetOpenFile(io, fptr);
+	return FPTR_TO_FD(fptr);
+}
+
+void rb_sp_set_nonblock(int fd)
+{
+	int flags = fcntl(fd, F_GETFL);
+
+	if (flags == -1)
+		rb_sys_fail("fcntl(F_GETFL)");
+	if ((flags & O_NONBLOCK) == O_NONBLOCK)
+		return;
+	flags = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+	if (flags == -1)
+		rb_sys_fail("fcntl(F_SETFL)");
+}
+
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+#include <rubysig.h>
+VALUE rb_sp_io_region(rb_blocking_function_t *func, void *data)
+{
+	VALUE rv;
+
+	TRAP_BEG;
+	rv = func(data);
+	TRAP_END;
+
+	return rv;
+}
+#endif

data/lib/sleepy_penguin.rb

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

data/lib/sleepy_penguin/signalfd/sig_info.rb

@@ -0,0 +1,20 @@
+# :stopdoc:
+class SleepyPenguin::SignalFD::SigInfo
+
+  def to_hash
+    Hash[*MEMBERS.inject([]) { |ary,k| ary << k << __send__(k) }]
+  end
+
+  def hash
+    to_hash.hash
+  end
+
+  def inspect
+    "#<#{self.class}:#{to_hash.inspect}>"
+  end
+
+  def ==(other)
+    other.kind_of?(self.class) && to_hash == other.to_hash
+  end
+end
+# :startdoc:

data/lib/sleepy_penguin/sp.rb

@@ -0,0 +1,4 @@
+# :stopdoc:
+require "sleepy_penguin"
+SP = SleepyPenguin
+# :startdoc:

data/pkg.mk

@@ -46,22 +46,23 @@ lib := $(lib):$(ext_pfx)/$(ext)
 build: $(ext_dl)
 endif
 
-pkg_extra := GIT-VERSION-FILE NEWS ChangeLog LATEST
+pkg_extra += GIT-VERSION-FILE NEWS ChangeLog LATEST
 ChangeLog: GIT-VERSION-FILE .wrongdoc.yml
 	$(WRONGDOC) prepare
+NEWS LATEST: ChangeLog
 
 manifest:
 	$(RM) .manifest
 	$(MAKE) .manifest
 
-.manifest: ChangeLog
+.manifest: $(pkg_extra)
 	(git ls-files && for i in $@ $(pkg_extra); do echo $$i; done) | \
 		LC_ALL=C sort > $@+
 	cmp $@+ $@ || mv $@+ $@
 	$(RM) $@+
 
-doc:: .document .wrongdoc.yml
-	find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
+doc:: .document .wrongdoc.yml $(pkg_extra)
+	-find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
 	-find ext -type f -name '*.rbc' -exec rm -f '{}' ';'
 	$(RM) -r doc
 	$(WRONGDOC) all

data/test/test_epoll.rb

@@ -14,6 +14,14 @@ class TestEpoll < Test::Unit::TestCase
     @ep = Epoll.new
   end
 
+  def test_constants
+    Epoll.constants.each do |const|
+      next if const.to_sym == :IO
+      nr = Epoll.const_get(const)
+      assert nr <= 0xffffffff, "#{const}=#{nr}"
+    end
+  end
+
   def test_cross_thread
     tmp = []
     Thread.new { sleep 0.100; @ep.add(@wr, Epoll::OUT) }
@@ -347,6 +355,27 @@ class TestEpoll < Test::Unit::TestCase
     assert_nil @ep.flags_for(@rd)
   end
 
+  def test_flags_for_sym
+    @ep.add @rd, :IN
+    assert_equal Epoll::IN, @ep.flags_for(@rd.fileno)
+    assert_equal Epoll::IN, @ep.flags_for(@rd)
+
+    @ep.del @rd
+    assert_nil @ep.flags_for(@rd.fileno)
+    assert_nil @ep.flags_for(@rd)
+  end
+
+  def test_flags_for_sym_ary
+    @ep.add @rd, [:IN, :ET]
+    expect = Epoll::IN | Epoll::ET
+    assert_equal expect, @ep.flags_for(@rd.fileno)
+    assert_equal expect, @ep.flags_for(@rd)
+
+    @ep.del @rd
+    assert_nil @ep.flags_for(@rd.fileno)
+    assert_nil @ep.flags_for(@rd)
+  end
+
   def test_include?
     assert ! @ep.include?(@rd)
     @ep.add @rd, Epoll::IN

data/test/test_epoll_gc.rb

@@ -44,4 +44,4 @@ class TestEpollGC < Test::Unit::TestCase
       end
     end while true
   end
-end
+end if ENV["GC_STRESS"].to_i != 0

data/test/test_epoll_optimizations.rb

@@ -1,5 +1,8 @@
 require 'test/unit'
-require 'strace'
+begin
+  require 'strace'
+rescue LoadError
+end
 $-w = true
 
 require 'sleepy_penguin'
@@ -148,4 +151,4 @@ class TestEpollOptimizations < Test::Unit::TestCase
     assert_equal 1, lines.grep(/^epoll_ctl/).size
     assert_equal 1, lines.grep(/EBADF/).size
   end
-end
+end if defined?(Strace)