sleepy_penguin 3.4.1 → 3.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65ea0df5a538075f28711e1d2c220f4810eff81a
-  data.tar.gz: 5f1566a8d5ddaf86c955189d0c5b730c1f95ef31
+  metadata.gz: dff861d3873bfcd1a028f7cdc0ae46a1065d4092
+  data.tar.gz: 19244c89ef9f4a8719e31eaed7354ce88640ff5c
 SHA512:
-  metadata.gz: 58068d4e4f28ad4b5d02049dd3c87b1de8a9a4f20b6884fad942a020c45ebd97c6f96257a8060fa9b66b6a5c003446de832dad5e0e466c18ef52a5705a70ae2d
-  data.tar.gz: ba28da9192001381d99f4a8b1ae9823d76cebb0e97e7d2836ec1b9bbe4146da4da733cdaafc5cc440b6d4e15d501c3d406b6bb82b829a7ee261b6ebf7795d847
+  metadata.gz: 7a82315acdb00dead8609707ed1fe9c5d649c58997170b0fbd0d600a0531bc100f6d57b09fc1fe9ebe4e3f1b1d0e0a967dd0627b26e87e1928f4439aa17b454c
+  data.tar.gz: 48ff2a95beb3a28150504ddcf7d5e3f475a92b4379aad96db219dd8556872cd0e4351392f72e91ab5fd608cc597e80374134f4340227d31a4f6a5f5a6840eaae

data/.document

@@ -9,3 +9,4 @@ ext/sleepy_penguin/init.c
 ext/sleepy_penguin/inotify.c
 ext/sleepy_penguin/timerfd.c
 ext/sleepy_penguin/kqueue.c
+ext/sleepy_penguin/splice.c

data/.olddoc.yml

@@ -1,7 +1,6 @@
 ---
-cgit_url: http://bogomips.org/sleepy_penguin.git
+cgit_url: https://bogomips.org/sleepy_penguin.git
 git_url: git://bogomips.org/sleepy_penguin.git
-rdoc_url: http://bogomips.org/sleepy_penguin/
-ml_url: http://bogomips.org/sleepy-penguin/
-private_email: bofh@bogomips.org
+rdoc_url: https://bogomips.org/sleepy_penguin/
+ml_url: https://bogomips.org/sleepy-penguin/
 public_email: sleepy-penguin@bogomips.org

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v3.4.1
+DEF_VER=v3.5.0
 GVH=ext/sleepy_penguin/git_version.h
 
 LF='

data/LICENSE

@@ -3,8 +3,8 @@ logs in revision control for names and email addresses of all of them.
 
 You can redistribute it and/or modify it under the terms of the GNU
 Lesser General Public License (LGPL) as published by the Free Software
-Foundation, version {2.1}[http://www.gnu.org/licenses/lgpl-2.1.txt] or
-(at your option) any later version.
+Foundation, version {2.1}[https://www.gnu.org/licenses/lgpl-2.1.txt]
+or (at your option) any later version.
 
 sleepy_penguin is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -12,4 +12,4 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
 General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public License
-along with this library; if not, see http://www.gnu.org/licenses/
+along with this library; if not, see https://www.gnu.org/licenses/

data/README

@@ -3,7 +3,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, and epoll interfaces are provided.  Experimental support
-for kqueue on FreeBSD (and likely OpenBSD/NetBSD) are also provided.
+for kqueue on FreeBSD (and likely OpenBSD/NetBSD) is also provided.
 
 == Features
 
@@ -31,7 +31,7 @@ If you use RubyGems:
 
 Otherwise grab the latest tarball from:
 
-http://bogomips.org/sleepy_penguin/files/
+https://bogomips.org/sleepy_penguin/files/
 
 Unpack it, and run "ruby setup.rb"
 
@@ -45,7 +45,7 @@ You can get the latest source via git from the following locations:
 You may browse the code from the web and download the latest snapshot
 tarballs here:
 
-* http://bogomips.org/sleepy_penguin.git (cgit)
+* https://bogomips.org/sleepy_penguin.git
 * http://repo.or.cz/w/sleepy_penguin.git (gitweb)
 
 Inline patches (from "git format-patch") to the mailing list are
@@ -62,4 +62,7 @@ don't email the git mailing list or maintainer with sleepy_penguin patches.
 All feedback (bug reports, user/development discussion, patches, pull
 requests) go to the mailing list: mailto:sleepy-penguin@bogomips.org
 
-* Mailing list archives: http://bogomips.org/sleepy-penguin/
+* Mailing list archives: https://bogomips.org/sleepy-penguin/
+
+* Also available over NNTP:
+  nntp://news.public-inbox.org/inbox.comp.lang.ruby.sleepy-penguin

data/TODO

@@ -1 +1,2 @@
 * FANotify interface
+* memfd interface (awaiting glibc support)

data/ext/sleepy_penguin/cfr.c

@@ -0,0 +1,62 @@
+#include "sleepy_penguin.h"
+#include "sp_copy.h"
+#include <unistd.h>
+
+#ifdef __NR_copy_file_range
+static ssize_t my_cfr(int fd_in, off_t *off_in, int fd_out, off_t *off_out,
+		       size_t len, unsigned int flags)
+{
+	long n = syscall(__NR_copy_file_range,
+			fd_in, off_in, fd_out, off_out, len, flags);
+
+	return (ssize_t)n;
+}
+#  define copy_file_range(fd_in,off_in,fd_out,off_out,len,flags) \
+		my_cfr((fd_in),(off_in),(fd_out),(off_out),(len),(flags))
+#endif
+
+#if defined(HAVE_COPY_FILE_RANGE) || \
+    (defined(__linux__) && defined(__NR_copy_file_range))
+static void *nogvl_cfr(void *ptr)
+{
+	struct copy_args *a = ptr;
+
+	return (void *)copy_file_range(a->fd_in, a->off_in,
+				a->fd_out, a->off_out, a->len, a->flags);
+}
+
+/* :nodoc: */
+static VALUE rb_sp_cfr(VALUE mod, VALUE io_in, VALUE off_in,
+			VALUE io_out, VALUE off_out,
+			VALUE len, VALUE flags)
+{
+	off_t i = 0, o = 0;
+	struct copy_args a;
+	ssize_t bytes;
+
+	a.off_in = NIL_P(off_in) ? NULL : (i = NUM2OFFT(off_in), &i);
+	a.off_out = NIL_P(off_out) ? NULL : (o = NUM2OFFT(off_out), &o);
+	a.len = NUM2SIZET(len);
+	a.flags = NUM2UINT(flags);
+
+	for (;;) {
+		a.fd_in = rb_sp_fileno(io_in);
+		a.fd_out = rb_sp_fileno(io_out);
+		bytes = (ssize_t)IO_RUN(nogvl_cfr, &a);
+		if (bytes < 0) {
+			switch (errno) {
+			case EINTR: continue;
+			default: rb_sys_fail("copy_file_range");
+			}
+		}
+		return SSIZET2NUM(bytes);
+	}
+}
+
+void sleepy_penguin_init_cfr(void)
+{
+	VALUE mod = rb_define_module("SleepyPenguin");
+
+	rb_define_singleton_method(mod, "__cfr", rb_sp_cfr, 6);
+}
+#endif /* !HAVE_COPY_FILE_RANGE */

data/ext/sleepy_penguin/epoll.c

@@ -49,7 +49,7 @@ static int ep_fd_check(struct ep_per_thread *ept)
 	return 1;
 }
 
-static struct ep_per_thread *ept_get(VALUE self, int maxevents)
+static struct ep_per_thread *ept_get(int maxevents)
 {
 	struct ep_per_thread *ept;
 	size_t size;
@@ -66,8 +66,6 @@ static struct ep_per_thread *ept_get(VALUE self, int maxevents)
 	ept = rb_sp_gettlsbuf(&size);
 	ept->capa = maxevents;
 	ept->maxevents = maxevents;
-	ept->io = self;
-	ept->fd = rb_sp_fileno(ept->io);
 
 	return ept;
 }
@@ -82,15 +80,13 @@ static struct ep_per_thread *ept_get(VALUE self, int maxevents)
 static VALUE s_new(VALUE klass, VALUE _flags)
 {
 	int default_flags = RB_SP_CLOEXEC(EPOLL_CLOEXEC);
-	int flags = rb_sp_get_flags(klass, _flags, default_flags);
+	int flags = rb_sp_get_flags(cEpoll, _flags, default_flags);
 	int fd = epoll_create1(flags);
 	VALUE rv;
 
 	if (fd < 0) {
-		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
-			rb_gc();
+		if (rb_sp_gc_for_fd(errno))
 			fd = epoll_create1(flags);
-		}
 		if (fd < 0)
 			rb_sys_fail("epoll_create1");
 	}
@@ -106,7 +102,7 @@ static VALUE s_new(VALUE klass, VALUE _flags)
  * Register, modify, or register a watch for a given +io+ for events.
  *
  * +op+ may be one of +EPOLL_CTL_ADD+, +EPOLL_CTL_MOD+, or +EPOLL_CTL_DEL+
- * +io+ is an IO object or one which proxies via the +to_io+ method.
+ * +io+ is an +IO+ object or one which proxies via the +to_io+ method.
  * +events+ is an integer mask of events to watch for.
  *
  * Returns nil on success.
@@ -179,6 +175,7 @@ static VALUE real_epwait(struct ep_per_thread *ept)
 	long n;
 	uint64_t expire_at = ept->timeout > 0 ? now_ms() + ept->timeout : 0;
 
+	ept->fd = rb_sp_fileno(ept->io);
 	do {
 		n = (long)rb_sp_fd_region(nogvl_wait, ept, ept->fd);
 	} while (n < 0 && epoll_resume_p(expire_at, ept));
@@ -190,7 +187,7 @@ static VALUE real_epwait(struct ep_per_thread *ept)
  * call-seq:
  *	ep_io.epoll_wait([maxevents[, timeout]]) { |events, io| ... }
  *
- * Calls epoll_wait(2) and yields Integer +events+ and IO objects watched
+ * Calls epoll_wait(2) and yields Integer +events+ and +IO+ objects watched
  * for.  +maxevents+ is the maximum number of events to process at once,
  * lower numbers may prevent starvation when used by epoll_wait in multiple
  * threads.  Larger +maxevents+ reduces syscall overhead for
@@ -202,14 +199,17 @@ static VALUE epwait(int argc, VALUE *argv, VALUE self)
 {
 	VALUE timeout, maxevents;
 	struct ep_per_thread *ept;
+	int t;
 
 	rb_need_block();
 	rb_scan_args(argc, argv, "02", &maxevents, &timeout);
+	t = NIL_P(timeout) ? -1 : NUM2INT(timeout);
 
-	ept = ept_get(self, NIL_P(maxevents) ? 64 : NUM2INT(maxevents));
-	ept->timeout = NIL_P(timeout) ? -1 : NUM2INT(timeout);
+	ept = ept_get(NIL_P(maxevents) ? 64 : NUM2INT(maxevents));
+	ept->timeout = t;
+	ept->io = self;
 
-	return real_epwait(ept);
+	return rb_ensure(real_epwait, (VALUE)ept, rb_sp_puttlsbuf, (VALUE)ept);
 }
 
 /* :nodoc: */
@@ -251,7 +251,7 @@ void sleepy_penguin_init_epoll(void)
 	 *
 	 * The Epoll class provides high-level access to epoll(7)
 	 * functionality in the Linux 2.6 and later kernels.  It provides
-	 * fork and GC-safety for Ruby objects stored within the IO object
+	 * fork and GC-safety for Ruby objects stored within the +IO+ object
 	 * and may be passed as an argument to IO.select.
 	 */
 	cEpoll = rb_define_class_under(mSleepyPenguin, "Epoll", rb_cObject);
@@ -260,7 +260,7 @@ void sleepy_penguin_init_epoll(void)
 	 * Document-class: SleepyPenguin::Epoll::IO
 	 *
 	 * Epoll::IO is a low-level class.  It does not provide fork nor
-	 * GC-safety, so Ruby IO objects added via epoll_ctl must be retained
+	 * GC-safety, so Ruby +IO+ objects added via epoll_ctl must be retained
 	 * by the application until IO#close is called.
 	 */
 	cEpoll_IO = rb_define_class_under(cEpoll, "IO", rb_cIO);
@@ -271,13 +271,13 @@ void sleepy_penguin_init_epoll(void)
 
 	rb_define_method(cEpoll, "__event_flags", event_flags, 1);
 
-	/* registers an IO object via epoll_ctl */
+	/* registers a target +IO+ object via epoll_ctl */
 	rb_define_const(cEpoll, "CTL_ADD", INT2NUM(EPOLL_CTL_ADD));
 
-	/* unregisters an IO object via epoll_ctl */
+	/* unregisters a target +IO+ object via epoll_ctl */
 	rb_define_const(cEpoll, "CTL_DEL", INT2NUM(EPOLL_CTL_DEL));
 
-	/* modifies the registration of an IO object via epoll_ctl */
+	/* modifies the registration of a target +IO+ object via epoll_ctl */
 	rb_define_const(cEpoll, "CTL_MOD", INT2NUM(EPOLL_CTL_MOD));
 
 	/* specifies whether close-on-exec flag is set for Epoll.new */
@@ -306,18 +306,29 @@ void sleepy_penguin_init_epoll(void)
 	rb_define_const(cEpoll, "WAKEUP", UINT2NUM(EPOLLWAKEUP));
 #endif
 
+#ifdef EPOLLEXCLUSIVE
+	/*
+	 * Sets an exclusive wakeup mode for the epoll object
+	 * that is being attached to the target +IO+.  This
+	 * avoids thundering herd scenarios when the same
+	 * target +IO+ is shared among multiple epoll objects.
+	 * Available since Linux 4.5
+	 */
+	rb_define_const(cEpoll, "EXCLUSIVE", UINT2NUM(EPOLLEXCLUSIVE));
+#endif
+
 	/* watch for urgent read(2) data */
 	rb_define_const(cEpoll, "PRI", UINT2NUM(EPOLLPRI));
 
 	/*
 	 * watch for errors, there is no need to specify this,
-	 * it is always monitored when an IO is watched
+	 * it is always monitored when an +IO+ is watched
 	 */
 	rb_define_const(cEpoll, "ERR", UINT2NUM(EPOLLERR));
 
 	/*
 	 * watch for hangups, there is no need to specify this,
-	 * it is always monitored when an IO is watched
+	 * it is always monitored when an +IO+ is watched
 	 */
 	rb_define_const(cEpoll, "HUP", UINT2NUM(EPOLLHUP));
 
@@ -329,10 +340,9 @@ void sleepy_penguin_init_epoll(void)
 
 	id_for_fd = rb_intern("for_fd");
 
-	if (RB_SP_GREEN_THREAD)
-		rb_require("sleepy_penguin/epoll/io");
-
-	/* the high-level interface is implemented in Ruby: */
-	rb_require("sleepy_penguin/epoll");
+	/*
+	 * the high-level interface is implemented in Ruby,
+	 * see lib/sleepy_penguin/epoll.rb
+	 */
 }
 #endif /* HAVE_SYS_EPOLL_H */

data/ext/sleepy_penguin/eventfd.c

@@ -31,10 +31,8 @@ static VALUE s_new(int argc, VALUE *argv, VALUE klass)
 
 	fd = eventfd(initval, flags);
 	if (fd < 0) {
-		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
-			rb_gc();
+		if (rb_sp_gc_for_fd(errno))
 			fd = eventfd(initval, flags);
-		}
 		if (fd < 0)
 			rb_sys_fail("eventfd");
 	}
@@ -84,7 +82,9 @@ static VALUE incr(int argc, VALUE *argv, VALUE self)
 
 	rb_scan_args(argc, argv, "11", &value, &nonblock);
 	x.fd = rb_sp_fileno(self);
-	RTEST(nonblock) ? rb_sp_set_nonblock(x.fd) : blocking_io_prepare(x.fd);
+	if (RTEST(nonblock))
+		rb_sp_set_nonblock(x.fd);
+
 	x.val = (uint64_t)NUM2ULL(value);
 retry:
 	w = (ssize_t)rb_sp_fd_region(efd_write, &x, x.fd);
@@ -121,7 +121,8 @@ static VALUE getvalue(int argc, VALUE *argv, VALUE self)
 
 	rb_scan_args(argc, argv, "01", &nonblock);
 	x.fd = rb_sp_fileno(self);
-	RTEST(nonblock) ? rb_sp_set_nonblock(x.fd) : blocking_io_prepare(x.fd);
+	if (RTEST(nonblock))
+		rb_sp_set_nonblock(x.fd);
 retry:
 	w = (ssize_t)rb_sp_fd_region(efd_read, &x, x.fd);
 	if (w < 0) {

data/ext/sleepy_penguin/extconf.rb

@@ -6,6 +6,7 @@ if have_header('sys/event.h')
 end
 have_header('sys/mount.h')
 have_header('sys/eventfd.h')
+have_header('sys/sendfile.h')
 
 # it's impossible to use signalfd reliably with Ruby since Ruby currently
 # manages # (and overrides) all signal handling
@@ -19,8 +20,13 @@ unless have_macro('CLOCK_MONOTONIC', 'time.h')
 end
 have_type('clockid_t', 'time.h')
 have_func('clock_gettime', 'time.h')
+have_func('copy_file_range')
 have_func('epoll_create1', %w(sys/epoll.h))
 have_func('inotify_init1', %w(sys/inotify.h))
+have_func('splice', %w(fcntl.h))
+have_func('tee', %w(fcntl.h))
+have_macro('F_GETPIPE_SZ', %w(fcntl.h))
+have_macro('F_SETPIPE_SZ', %w(fcntl.h))
 have_func('rb_thread_call_without_gvl')
 have_func('rb_thread_blocking_region')
 have_func('rb_thread_io_blocking_region')

data/ext/sleepy_penguin/init.c

@@ -11,8 +11,15 @@
 #define L1_CACHE_LINE_MAX 128 /* largest I've seen (Pentium 4) */
 size_t rb_sp_l1_cache_line_size;
 static pthread_key_t rb_sp_key;
+enum rb_sp_tls_buf_type {
+	RB_SP_TLS_INUSE = -1,
+	RB_SP_TLS_READY = 0,
+	RB_SP_TLS_MALLOCED = 1
+};
+
 struct rb_sp_tlsbuf {
-	size_t capa;
+	uint32_t capa;
+	enum rb_sp_tls_buf_type buf_type;
 	unsigned char ptr[FLEX_ARRAY];
 };
 
@@ -52,6 +59,22 @@ void sleepy_penguin_init_signalfd(void);
 #  define sleepy_penguin_init_signalfd() for(;0;)
 #endif
 
+#ifdef HAVE_SPLICE
+void sleepy_penguin_init_splice(void);
+#else
+#  define sleepy_penguin_init_splice() for(;0;)
+#endif
+
+#if defined(HAVE_COPY_FILE_RANGE) || \
+    (defined(__linux__) && defined(__NR_copy_file_range))
+void sleepy_penguin_init_cfr(void);
+#else
+#  define sleepy_penguin_init_cfr() for (;0;)
+#endif
+
+/* everyone */
+void sleepy_penguin_init_sendfile(void);
+
 static size_t l1_cache_line_size_detect(void)
 {
 #ifdef _SC_LEVEL1_DCACHE_LINESIZE
@@ -73,12 +96,36 @@ static void sp_once(void)
 	}
 }
 
+static struct rb_sp_tlsbuf *alloc_tlsbuf(size_t size)
+{
+	size_t bytes = size + sizeof(struct rb_sp_tlsbuf);
+	struct rb_sp_tlsbuf *buf;
+	void *ptr;
+	int err = posix_memalign(&ptr, rb_sp_l1_cache_line_size, bytes);
+
+	if (err) {
+		errno = err;
+		rb_memerror(); /* fatal */
+	}
+
+	buf = ptr;
+	buf->capa = size;
+
+	return buf;
+}
+
 void *rb_sp_gettlsbuf(size_t *size)
 {
 	struct rb_sp_tlsbuf *buf = pthread_getspecific(rb_sp_key);
-	void *ptr;
 	int err;
-	size_t bytes;
+
+	assert(buf ? buf->buf_type != RB_SP_TLS_MALLOCED : 1);
+
+	if (buf && buf->buf_type != RB_SP_TLS_READY) {
+		buf = alloc_tlsbuf(*size);
+		buf->buf_type = RB_SP_TLS_MALLOCED;
+		return buf->ptr;
+	}
 
 	if (buf && buf->capa >= *size) {
 		*size = buf->capa;
@@ -86,24 +133,45 @@ void *rb_sp_gettlsbuf(size_t *size)
 	}
 
 	free(buf);
-	bytes = *size + sizeof(struct rb_sp_tlsbuf);
-	err = posix_memalign(&ptr, rb_sp_l1_cache_line_size, bytes);
-	if (err) {
-		errno = err;
-		rb_memerror(); /* fatal */
-	}
-
-	buf = ptr;
-	buf->capa = *size;
+	buf = alloc_tlsbuf(*size);
 	err = pthread_setspecific(rb_sp_key, buf);
 	if (err != 0) {
+		free(buf);
 		errno = err;
 		rb_sys_fail("BUG: pthread_setspecific");
 	}
 out:
+	buf->buf_type = RB_SP_TLS_INUSE;
 	return buf->ptr;
 }
 
+#define container_of(ptr, type, member) \
+	(type *)((uintptr_t)(ptr) - offsetof(type, member))
+
+VALUE rb_sp_puttlsbuf(VALUE p)
+{
+	struct rb_sp_tlsbuf *tls = pthread_getspecific(rb_sp_key);
+	void *ptr = (void *)p;
+	struct rb_sp_tlsbuf *buf;
+
+	if (!ptr)
+		return Qfalse;
+
+	buf = container_of(ptr, struct rb_sp_tlsbuf, ptr);
+
+	switch (buf->buf_type) {
+	case RB_SP_TLS_INUSE:
+		assert(tls == buf && "rb_sp_puttlsbuf mismatch");
+		buf->buf_type = RB_SP_TLS_READY;
+		break;
+	case RB_SP_TLS_READY:
+		assert(0 && "rb_sp_gettlsbuf not called");
+	case RB_SP_TLS_MALLOCED:
+		free(buf);
+	}
+	return Qfalse;
+}
+
 void Init_sleepy_penguin_ext(void)
 {
 	VALUE mSleepyPenguin;
@@ -127,4 +195,7 @@ void Init_sleepy_penguin_ext(void)
 	sleepy_penguin_init_eventfd();
 	sleepy_penguin_init_inotify();
 	sleepy_penguin_init_signalfd();
+	sleepy_penguin_init_splice();
+	sleepy_penguin_init_cfr();
+	sleepy_penguin_init_sendfile();
 }