sleepy_penguin 3.1.0 → 3.1.0.26.g7181

data/ext/sleepy_penguin/eventfd.c

@@ -27,15 +27,15 @@ static VALUE s_new(int argc, VALUE *argv, VALUE klass)
 
 	rb_scan_args(argc, argv, "11", &_initval, &_flags);
 	initval = NUM2UINT(_initval);
-	flags = rb_sp_get_flags(klass, _flags);
+	flags = rb_sp_get_flags(klass, _flags, RB_SP_CLOEXEC(EFD_CLOEXEC));
 
 	fd = eventfd(initval, flags);
-	if (fd == -1) {
+	if (fd < 0) {
 		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
 			rb_gc();
 			fd = eventfd(initval, flags);
 		}
-		if (fd == -1)
+		if (fd < 0)
 			rb_sys_fail("eventfd");
 	}
 
@@ -88,10 +88,10 @@ static VALUE incr(int argc, VALUE *argv, VALUE self)
 	x.val = (uint64_t)NUM2ULL(value);
 retry:
 	w = (ssize_t)rb_sp_fd_region(efd_write, &x, x.fd);
-	if (w == -1) {
+	if (w < 0) {
 		if (errno == EAGAIN && RTEST(nonblock))
 			return Qfalse;
-		if (rb_io_wait_writable(x.fd))
+		if (rb_sp_wait(rb_io_wait_writable, self, &x.fd))
 			goto retry;
 		rb_sys_fail("write(eventfd)");
 	}
@@ -124,10 +124,10 @@ static VALUE getvalue(int argc, VALUE *argv, VALUE self)
 	RTEST(nonblock) ? rb_sp_set_nonblock(x.fd) : blocking_io_prepare(x.fd);
 retry:
 	w = (ssize_t)rb_sp_fd_region(efd_read, &x, x.fd);
-	if (w == -1) {
+	if (w < 0) {
 		if (errno == EAGAIN && RTEST(nonblock))
 			return Qnil;
-		if (rb_io_wait_readable(x.fd = rb_sp_fileno(self)))
+		if (rb_sp_wait(rb_io_wait_readable, self, &x.fd))
 			goto retry;
 		rb_sys_fail("read(eventfd)");
 	}

data/ext/sleepy_penguin/extconf.rb

@@ -1,6 +1,5 @@
 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')
 
 # it's impossible to use signalfd reliably with Ruby since Ruby currently
@@ -11,9 +10,10 @@ have_header('sys/timerfd.h')
 have_header('sys/inotify.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_call_without_gvl')
 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')
+have_func('rb_fd_fix_cloexec')
 create_makefile('sleepy_penguin_ext')

data/ext/sleepy_penguin/init.c

@@ -1,3 +1,9 @@
+#define _GNU_SOURCE
+#include <unistd.h>
+#include <sys/types.h>
+#define L1_CACHE_LINE_MAX 128 /* largest I've seen (Pentium 4) */
+size_t rb_sp_l1_cache_line_size;
+
 void sleepy_penguin_init_epoll(void);
 
 #ifdef HAVE_SYS_TIMERFD_H
@@ -24,8 +30,21 @@ void sleepy_penguin_init_signalfd(void);
 #  define sleepy_penguin_init_signalfd() for(;0;)
 #endif
 
+static size_t l1_cache_line_size_detect(void)
+{
+#ifdef _SC_LEVEL1_DCACHE_LINESIZE
+	long tmp = sysconf(_SC_LEVEL1_DCACHE_LINESIZE);
+
+	if (tmp > 0 && tmp <= L1_CACHE_LINE_MAX)
+		return (size_t)tmp;
+#endif /* _SC_LEVEL1_DCACHE_LINESIZE */
+	return L1_CACHE_LINE_MAX;
+}
+
 void Init_sleepy_penguin_ext(void)
 {
+	rb_sp_l1_cache_line_size = l1_cache_line_size_detect();
+
 	sleepy_penguin_init_epoll();
 	sleepy_penguin_init_timerfd();
 	sleepy_penguin_init_eventfd();

data/ext/sleepy_penguin/inotify.c

@@ -4,7 +4,12 @@
 #include <sys/ioctl.h>
 #include "missing_inotify.h"
 
-static ID id_inotify_buf, id_inotify_tmp, id_mask;
+struct inbuf {
+	size_t capa;
+	void *ptr;
+};
+
+static ID id_inotify_tmp, id_mask;
 static VALUE cEvent, checks;
 
 /*
@@ -22,21 +27,20 @@ static VALUE s_new(int argc, VALUE *argv, VALUE klass)
 	int fd;
 
 	rb_scan_args(argc, argv, "01", &_flags);
-	flags = rb_sp_get_flags(klass, _flags);
+	flags = rb_sp_get_flags(klass, _flags, RB_SP_CLOEXEC(IN_CLOEXEC));
 
 	fd = inotify_init1(flags);
-	if (fd == -1) {
+	if (fd < 0) {
 		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
 			rb_gc();
 			fd = inotify_init1(flags);
 		}
-		if (fd == -1)
+		if (fd < 0)
 			rb_sys_fail("inotify_init1");
 	}
 
 	rv = INT2FIX(fd);
 	rv = rb_call_super(1, &rv);
-	rb_ivar_set(rv, id_inotify_buf, rb_str_new(0, 128));
 	rb_ivar_set(rv, id_inotify_tmp, rb_ary_new());
 
 	return rv;
@@ -89,14 +93,9 @@ static VALUE add_watch(VALUE self, VALUE path, VALUE vmask)
 	uint32_t mask = rb_sp_get_uflags(self, vmask);
 	int rc = inotify_add_watch(fd, pathname, mask);
 
-	if (rc == -1) {
-		if (errno == ENOMEM) {
-			rb_gc();
-			rc = inotify_add_watch(fd, pathname, mask);
-		}
-		if (rc == -1)
-			rb_sys_fail("inotify_add_watch");
-	}
+	if (rc < 0)
+		rb_sys_fail("inotify_add_watch");
+
 	return UINT2NUM((uint32_t)rc);
 }
 
@@ -113,7 +112,7 @@ static VALUE rm_watch(VALUE self, VALUE vwd)
 	int fd = rb_sp_fileno(self);
 	int rc = inotify_rm_watch(fd, wd);
 
-	if (rc == -1)
+	if (rc < 0)
 		rb_sys_fail("inotify_rm_watch");
 	return INT2NUM(rc);
 }
@@ -138,15 +137,50 @@ static VALUE event_new(struct inotify_event *e)
 
 struct inread_args {
 	int fd;
-	struct inotify_event *ptr;
-	long len;
+	struct inbuf *inbuf;
 };
 
 static VALUE inread(void *ptr)
 {
 	struct inread_args *args = ptr;
 
-	return (VALUE)read(args->fd, args->ptr, args->len);
+	return (VALUE)read(args->fd, args->inbuf->ptr, args->inbuf->capa);
+}
+
+static void inbuf_grow(struct inbuf *inbuf, size_t size)
+{
+	int err;
+
+	if (inbuf->capa >= size)
+		return;
+	free(inbuf->ptr);
+	err = posix_memalign(&inbuf->ptr, rb_sp_l1_cache_line_size, size);
+	if (err) {
+		errno = err;
+		rb_memerror();
+	}
+	inbuf->capa = size;
+}
+
+static void resize_internal_buffer(struct inread_args *args)
+{
+	int newlen;
+
+	if (args->inbuf->capa > 0x10000)
+		rb_raise(rb_eRuntimeError, "path too long");
+
+	if (ioctl(args->fd, FIONREAD, &newlen) != 0)
+		rb_sys_fail("ioctl(inotify,FIONREAD)");
+
+	if (newlen > 0)
+		inbuf_grow(args->inbuf, (size_t)newlen);
+
+	if (newlen == 0) /* race: some other thread grabbed the data */
+		return;
+
+	rb_raise(rb_eRuntimeError,
+		"ioctl(inotify,FIONREAD) returned negative length: %d",
+		newlen);
 }
 
 /*
@@ -158,8 +192,9 @@ static VALUE inread(void *ptr)
  */
 static VALUE take(int argc, VALUE *argv, VALUE self)
 {
+	static __thread struct inbuf inbuf;
+
 	struct inread_args args;
-	VALUE buf;
 	VALUE tmp = rb_ivar_get(self, id_inotify_tmp);
 	struct inotify_event *e, *end;
 	ssize_t r;
@@ -171,42 +206,31 @@ static VALUE take(int argc, VALUE *argv, VALUE self)
 
 	rb_scan_args(argc, argv, "01", &nonblock);
 
+	inbuf_grow(&inbuf, 128);
 	args.fd = rb_sp_fileno(self);
-	buf = rb_ivar_get(self, id_inotify_buf);
-	args.len = RSTRING_LEN(buf);
-	args.ptr = (struct inotify_event *)RSTRING_PTR(buf);
+	args.inbuf = &inbuf;
 
 	if (RTEST(nonblock))
 		rb_sp_set_nonblock(args.fd);
 	else
 		blocking_io_prepare(args.fd);
 	do {
-		r = rb_sp_fd_region(inread, &args, args.fd);
+		r = (ssize_t)rb_sp_fd_region(inread, &args, args.fd);
 		if (r == 0 /* Linux < 2.6.21 */
 		    ||
 		    (r < 0 && errno == EINVAL) /* Linux >= 2.6.21 */
 		   ) {
-			/* resize internal buffer */
-			int newlen;
-			if (args.len > 0x10000)
-				rb_raise(rb_eRuntimeError, "path too long");
-			if (ioctl(args.fd, FIONREAD, &newlen) != 0)
-				rb_sys_fail("ioctl(inotify,FIONREAD)");
-			rb_str_resize(buf, newlen);
-			args.ptr = (struct inotify_event *)RSTRING_PTR(buf);
-			args.len = newlen;
+			resize_internal_buffer(&args);
 		} else if (r < 0) {
-			if (errno == EAGAIN && RTEST(nonblock)) {
+			if (errno == EAGAIN && RTEST(nonblock))
 				return Qnil;
-			} else {
-				args.fd = rb_sp_fileno(self);
-				if (!rb_io_wait_readable(args.fd))
-					rb_sys_fail("read(inotify)");
-			}
+			if (!rb_sp_wait(rb_io_wait_readable, self, &args.fd))
+				rb_sys_fail("read(inotify)");
 		} else {
 			/* buffer in userspace to minimize read() calls */
-			end = (struct inotify_event *)((char *)args.ptr + r);
-			for (e = args.ptr; e < end; ) {
+			end = (struct inotify_event *)
+					((char *)args.inbuf->ptr + r);
+			for (e = args.inbuf->ptr; e < end; ) {
 				VALUE event = event_new(e);
 				if (NIL_P(rv))
 					rv = event;
@@ -247,22 +271,6 @@ static VALUE events(VALUE self)
 	return rv;
 }
 
-/*
- * call-seq:
- *	inotify.dup	-> another Inotify object
- *
- * Duplicates an Inotify object, allowing it to be used in a blocking
- * fashion in another thread.  Ensures duplicated Inotify objects do
- * not share read buffers, but do share the userspace Array buffer.
- */
-static VALUE init_copy(VALUE dest, VALUE orig)
-{
-	rb_call_super(1, &orig); /* copy all other ivars as-is */
-	rb_ivar_set(dest, id_inotify_buf, rb_str_new(0, 128));
-
-	return dest;
-}
-
 /*
  * call-seq:
  *	ino.each { |event| ... } -> ino
@@ -308,7 +316,6 @@ void sleepy_penguin_init_inotify(void)
 	cInotify = rb_define_class_under(mSleepyPenguin, "Inotify", rb_cIO);
 	rb_define_method(cInotify, "add_watch", add_watch, 2);
 	rb_define_method(cInotify, "rm_watch", rm_watch, 1);
-	rb_define_method(cInotify, "initialize_copy", init_copy, 1);
 	rb_define_method(cInotify, "take", take, -1);
 	rb_define_method(cInotify, "each", each, 0);
 
@@ -338,7 +345,6 @@ void sleepy_penguin_init_inotify(void)
 	cEvent = rb_define_class_under(cInotify, "Event", cEvent);
 	rb_define_method(cEvent, "events", events, 0);
 	rb_define_singleton_method(cInotify, "new", s_new, -1);
-	id_inotify_buf = rb_intern("@inotify_buf");
 	id_inotify_tmp = rb_intern("@inotify_tmp");
 	id_mask = rb_intern("mask");
 	checks = rb_ary_new();

data/ext/sleepy_penguin/missing_epoll.h

@@ -15,7 +15,7 @@ static int my_epoll_create1(int flags)
 	if (fd < 0 || flags == 0)
 		return fd;
 
-	if ((flags & EPOLL_CLOEXEC) && (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1))
+	if ((flags & EPOLL_CLOEXEC) && (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0))
 		goto err;
 	return fd;
 err:

data/ext/sleepy_penguin/missing_inotify.h

@@ -36,13 +36,13 @@ static int my_inotify_init1(int flags)
 
 	if (fd < 0)
 		return fd;
-	if ((flags & IN_CLOEXEC) && (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1))
+	if ((flags & IN_CLOEXEC) && (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0))
 		goto fcntl_err;
 	if (flags & IN_NONBLOCK) {
 		tmp = fcntl(fd, F_GETFL);
 		if (tmp == -1)
 			goto fcntl_err;
-		if ((fcntl(fd, F_SETFL, tmp | O_NONBLOCK) != 0))
+		if ((fcntl(fd, F_SETFL, tmp | O_NONBLOCK) < 0))
 			goto fcntl_err;
 	}
 

data/ext/sleepy_penguin/signalfd.c

@@ -92,11 +92,12 @@ static VALUE update_bang(int argc, VALUE *argv, VALUE self)
 	int rc;
 
 	rb_scan_args(argc, argv, "02", &vmask, &vflags);
-	flags = NIL_P(vflags) ? cur_flags(fd) : rb_sp_get_flags(self, vflags);
+	flags = NIL_P(vflags) ? cur_flags(fd)
+				: rb_sp_get_flags(self, vflags, 0);
 	value2sigset(&mask, vmask);
 
 	rc = signalfd(fd, &mask, flags);
-	if (rc == -1)
+	if (rc < 0)
 		rb_sys_fail("signalfd");
 	return self;
 }
@@ -128,16 +129,16 @@ static VALUE s_new(int argc, VALUE *argv, VALUE klass)
 	int fd;
 
 	rb_scan_args(argc, argv, "02", &vmask, &vflags);
-	flags = rb_sp_get_flags(klass, vflags);
+	flags = rb_sp_get_flags(klass, vflags, RB_SP_CLOEXEC(SFD_CLOEXEC));
 	value2sigset(&mask, vmask);
 
 	fd = signalfd(-1, &mask, flags);
-	if (fd == -1) {
+	if (fd < 0) {
 		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
 			rb_gc();
 			fd = signalfd(-1, &mask, flags);
 		}
-		if (fd == -1)
+		if (fd < 0)
 			rb_sys_fail("signalfd");
 	}
 
@@ -195,10 +196,10 @@ static VALUE sfd_take(int argc, VALUE *argv, VALUE self)
 retry:
 	ssi->ssi_fd = fd;
 	r = (ssize_t)rb_sp_fd_region(sfd_read, ssi, fd);
-	if (r == -1) {
+	if (r < 0) {
 		if (errno == EAGAIN && RTEST(nonblock))
 			return Qnil;
-		if (rb_io_wait_readable(fd = rb_sp_fileno(self)))
+		if (rb_sp_wait(rb_io_wait_readable, self, &fd))
 			goto retry;
 		rb_sys_fail("read(signalfd)");
 	}

data/ext/sleepy_penguin/sleepy_penguin.h

@@ -12,32 +12,69 @@
 #include <assert.h>
 #include <unistd.h>
 
+extern size_t rb_sp_l1_cache_line_size;
 unsigned rb_sp_get_uflags(VALUE klass, VALUE flags);
-int rb_sp_get_flags(VALUE klass, VALUE flags);
+int rb_sp_get_flags(VALUE klass, VALUE flags, int default_flags);
 int rb_sp_io_closed(VALUE io);
 int rb_sp_fileno(VALUE io);
 void rb_sp_set_nonblock(int fd);
 
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
-static inline VALUE rb_sp_io_region(rb_blocking_function_t *func, void *data)
-{
-	return rb_thread_blocking_region(func, data, RUBY_UBF_IO, 0);
-}
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || \
+    defined(HAVE_RB_THREAD_IO_BLOCKING_REGION) || \
+    defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+#  define RB_SP_GREEN_THREAD 0
 #  define blocking_io_prepare(fd) ((void)(fd))
 #else
-typedef VALUE rb_blocking_function_t(void *);
-VALUE rb_sp_io_region(rb_blocking_function_t *func, void *data);
+#  define RB_SP_GREEN_THREAD 1
 #  define blocking_io_prepare(fd) rb_sp_set_nonblock((fd))
 #endif
 
 #ifdef HAVE_RB_THREAD_IO_BLOCKING_REGION
+/* Ruby 1.9.3 and 2.0.0 */
 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))
+	rb_thread_io_blocking_region((fn),(data),(fd))
+#elif defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \
+	defined(HAVE_RUBY_THREAD_H) && HAVE_RUBY_THREAD_H
+/* in case Ruby 2.0+ ever drops rb_thread_io_blocking_region: */
+#  include <ruby/thread.h>
+#  define COMPAT_FN (void *(*)(void *))
+#  define rb_sp_fd_region(fn,data,fd) \
+	rb_thread_call_without_gvl(COMPAT_FN(fn),(data),RUBY_UBF_IO,NULL)
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
+/* Ruby 1.9.2 */
+#  define rb_sp_fd_region(fn,data,fd) \
+	rb_thread_blocking_region((fn),(data),RUBY_UBF_IO,NULL)
 #else
-#  define rb_sp_fd_region(fn,data,fd) rb_sp_io_region(fn,data)
+/*
+ * Ruby 1.8 does not have a GVL, we'll just enable signal interrupts
+ * here in case we make interruptible syscalls.
+ *
+ * Note: epoll_wait with timeout=0 was interruptible until Linux 2.6.39
+ */
+#  include <rubysig.h>
+static inline VALUE fake_blocking_region(VALUE (*fn)(void *), void *data)
+{
+	VALUE rv;
+
+	TRAP_BEG;
+	rv = fn(data);
+	TRAP_END;
+
+	return rv;
+}
+#  define rb_sp_fd_region(fn,data,fd) fake_blocking_region((fn),(data))
 #endif
 
 #define NODOC_CONST(klass,name,value) \
   rb_define_const((klass),(name),(value))
+
+#ifdef HAVE_RB_FD_FIX_CLOEXEC
+#  define RB_SP_CLOEXEC(flag) (flag)
+#else
+#  define RB_SP_CLOEXEC(flag) (0)
+#endif
+
+typedef int rb_sp_waitfn(int fd);
+int rb_sp_wait(rb_sp_waitfn waiter, VALUE obj, int *fd);
 #endif /* SLEEPY_PENGUIN_H */