sleepy_penguin 3.2.0 → 3.3.0

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -6,7 +6,6 @@ include pkg.mk
 pkg_extra += ext/sleepy_penguin/git_version.h
 ifneq ($(VERSION),)
 release::
-	$(RAKE) raa_update VERSION=$(VERSION)
 	$(RAKE) publish_news VERSION=$(VERSION)
 endif
 .PHONY: .FORCE-GIT-VERSION-FILE doc test $(test_units) manifest

data/Rakefile

@@ -31,40 +31,3 @@ task :publish_news do
   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/ext/sleepy_penguin/epoll.c

@@ -1,8 +1,8 @@
 #include "sleepy_penguin.h"
 #ifdef HAVE_SYS_EPOLL_H
 #include <sys/epoll.h>
-#include <unistd.h>
 #include <time.h>
+#include "missing_clock_gettime.h"
 #include "missing_epoll.h"
 #include "missing_rb_thread_fd_close.h"
 #include "missing_rb_update_max_fd.h"
@@ -51,10 +51,8 @@ static int ep_fd_check(struct ep_per_thread *ept)
 
 static struct ep_per_thread *ept_get(VALUE self, int maxevents)
 {
-	static __thread struct ep_per_thread *ept;
+	struct ep_per_thread *ept;
 	size_t size;
-	int err;
-	void *ptr;
 
 	/* error check here to prevent OOM from posix_memalign */
 	if (maxevents <= 0) {
@@ -62,21 +60,11 @@ static struct ep_per_thread *ept_get(VALUE self, int maxevents)
 		rb_sys_fail("epoll_wait maxevents <= 0");
 	}
 
-	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 */
-	err = posix_memalign(&ptr, rb_sp_l1_cache_line_size, size);
-	if (err) {
-		errno = err;
-		rb_memerror();
-	}
-	ept = ptr;
+	ept = rb_sp_gettlsbuf(&size);
 	ept->capa = maxevents;
-out:
 	ept->maxevents = maxevents;
 	ept->io = self;
 	ept->fd = rb_sp_fileno(ept->io);

data/ext/sleepy_penguin/extconf.rb

@@ -1,8 +1,9 @@
 require 'mkmf'
 have_header('sys/epoll.h')
 dir_config('kqueue')
-have_library('kqueue')
-have_header('sys/event.h')
+if have_header('sys/event.h')
+  have_library('kqueue')
+end
 have_header('sys/mount.h')
 have_header('sys/eventfd.h')
 
@@ -13,6 +14,11 @@ have_header('sys/eventfd.h')
 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')
+unless have_macro('CLOCK_MONOTONIC', 'time.h')
+  have_func('CLOCK_MONOTONIC', 'time.h')
+end
+have_type('clockid_t', 'time.h')
+have_func('clock_gettime', 'time.h')
 have_func('epoll_create1', %w(sys/epoll.h))
 have_func('rb_thread_call_without_gvl')
 have_func('rb_thread_blocking_region')
@@ -20,4 +26,5 @@ have_func('rb_thread_io_blocking_region')
 have_func('rb_thread_fd_close')
 have_func('rb_update_max_fd')
 have_func('rb_fd_fix_cloexec')
+have_func('rb_io_get_io')
 create_makefile('sleepy_penguin_ext')

data/ext/sleepy_penguin/init.c

@@ -1,10 +1,20 @@
-#define _GNU_SOURCE
 #include <ruby.h>
+#ifndef _GNU_SOURCE
+#  define _GNU_SOURCE /* TODO: confirm this is needed */
+#endif
+
 #include <unistd.h>
+#include <pthread.h>
 #include <sys/types.h>
 #include "git_version.h"
+#include "sleepy_penguin.h"
 #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;
+struct rb_sp_tlsbuf {
+	size_t capa;
+	unsigned char ptr[FLEX_ARRAY];
+};
 
 #ifdef HAVE_SYS_EVENT_H
 void sleepy_penguin_init_kqueue(void);
@@ -53,9 +63,57 @@ static size_t l1_cache_line_size_detect(void)
 	return L1_CACHE_LINE_MAX;
 }
 
+static void sp_once(void)
+{
+	int err = pthread_key_create(&rb_sp_key, free);
+
+	if (err) {
+		errno = err;
+		rb_sys_fail( "pthread_key_create");
+	}
+}
+
+void *rb_sp_gettlsbuf(size_t *size)
+{
+	struct rb_sp_tlsbuf *buf = pthread_getspecific(rb_sp_key);
+	void *ptr;
+	int err;
+	size_t bytes;
+
+	if (buf && buf->capa >= *size) {
+		*size = buf->capa;
+		goto out;
+	}
+
+	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;
+	err = pthread_setspecific(rb_sp_key, buf);
+	if (err != 0) {
+		errno = err;
+		rb_sys_fail("BUG: pthread_setspecific");
+	}
+out:
+	return buf->ptr;
+}
+
 void Init_sleepy_penguin_ext(void)
 {
 	VALUE mSleepyPenguin;
+	static pthread_once_t once = PTHREAD_ONCE_INIT;
+	int err = pthread_once(&once, sp_once);
+
+	if (err) {
+		errno = err;
+		rb_sys_fail("pthread_once");
+	}
 
 	rb_sp_l1_cache_line_size = l1_cache_line_size_detect();
 

data/ext/sleepy_penguin/inotify.c

@@ -4,11 +4,6 @@
 #include <sys/ioctl.h>
 #include "missing_inotify.h"
 
-struct inbuf {
-	size_t capa;
-	void *ptr;
-};
-
 static ID id_inotify_tmp, id_mask;
 static VALUE cEvent, checks;
 
@@ -137,43 +132,31 @@ static VALUE event_new(struct inotify_event *e)
 
 struct inread_args {
 	int fd;
-	struct inbuf *inbuf;
+	size_t size;
+	void *buf;
 };
 
 static VALUE inread(void *ptr)
 {
 	struct inread_args *args = ptr;
 
-	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;
+	return (VALUE)read(args->fd, args->buf, args->size);
 }
 
 static void resize_internal_buffer(struct inread_args *args)
 {
 	int newlen;
 
-	if (args->inbuf->capa > 0x10000)
+	if (args->size > 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) {
+		args->size = (size_t)newlen;
+		args->buf = rb_sp_gettlsbuf(&args->size);
+	}
 
 	if (newlen == 0) /* race: some other thread grabbed the data */
 		return;
@@ -192,8 +175,6 @@ static void resize_internal_buffer(struct inread_args *args)
  */
 static VALUE take(int argc, VALUE *argv, VALUE self)
 {
-	static __thread struct inbuf inbuf;
-
 	struct inread_args args;
 	VALUE tmp = rb_ivar_get(self, id_inotify_tmp);
 	struct inotify_event *e, *end;
@@ -206,9 +187,9 @@ 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);
-	args.inbuf = &inbuf;
+	args.size = 128;
+	args.buf = rb_sp_gettlsbuf(&args.size);
 
 	if (RTEST(nonblock))
 		rb_sp_set_nonblock(args.fd);
@@ -228,9 +209,8 @@ static VALUE take(int argc, VALUE *argv, VALUE self)
 				rb_sys_fail("read(inotify)");
 		} else {
 			/* buffer in userspace to minimize read() calls */
-			end = (struct inotify_event *)
-					((char *)args.inbuf->ptr + r);
-			for (e = args.inbuf->ptr; e < end; ) {
+			end = (struct inotify_event *)((char *)args.buf + r);
+			for (e = args.buf; e < end; ) {
 				VALUE event = event_new(e);
 				if (NIL_P(rv))
 					rv = event;
@@ -255,15 +235,15 @@ static VALUE take(int argc, VALUE *argv, VALUE self)
 static VALUE events(VALUE self)
 {
 	long len = RARRAY_LEN(checks);
-	VALUE *ptr = RARRAY_PTR(checks);
+	long i;
 	VALUE sym;
 	VALUE rv = rb_ary_new();
 	uint32_t mask;
 	uint32_t event_mask = NUM2UINT(rb_funcall(self, id_mask, 0));
 
-	for (; (len -= 2) >= 0;) {
-		sym = *ptr++;
-		mask = NUM2UINT(*ptr++);
+	for (i = 0; i < len; ) {
+		sym = rb_ary_entry(checks, i++);
+		mask = NUM2UINT(rb_ary_entry(checks, i++));
 		if ((event_mask & mask) == mask)
 			rb_ary_push(rv, sym);
 	}

data/ext/sleepy_penguin/kqueue.c

@@ -5,6 +5,7 @@
 #include <sys/time.h>
 #include <unistd.h>
 #include <time.h>
+#include "missing_clock_gettime.h"
 #include "missing_rb_thread_fd_close.h"
 #include "missing_rb_update_max_fd.h"
 #include "value2timespec.h"
@@ -73,10 +74,8 @@ static int kq_fd_check(struct kq_per_thread *kpt)
 
 static struct kq_per_thread *kpt_get(VALUE self, int nchanges, int nevents)
 {
-	static __thread struct kq_per_thread *kpt;
+	struct kq_per_thread *kpt;
 	size_t size;
-	void *ptr;
-	int err;
 	int max = nchanges > nevents ? nchanges : nevents;
 
 	/* error check here to prevent OOM from posix_memalign */
@@ -85,20 +84,9 @@ static struct kq_per_thread *kpt_get(VALUE self, int nchanges, int nevents)
 		rb_sys_fail("kevent got negative events < 0");
 	}
 
-	if (kpt && kpt->capa >= max)
-		goto out;
-
 	size = sizeof(struct kq_per_thread) + sizeof(struct kevent) * max;
-
-	free(kpt); /* free(NULL) is POSIX */
-	err = posix_memalign(&ptr, rb_sp_l1_cache_line_size, size);
-	if (err) {
-		errno = err;
-		rb_memerror();
-	}
-	kpt = ptr;
+	kpt = rb_sp_gettlsbuf(&size);
 	kpt->capa = max;
-out:
 	kpt->nchanges = nchanges;
 	kpt->nevents = nevents;
 	kpt->io = self;

data/ext/sleepy_penguin/missing_clock_gettime.h

@@ -0,0 +1,36 @@
+/*
+ * this header includes functions to support broken systems
+ * without clock_gettime() or CLOCK_MONOTONIC
+ */
+
+#ifndef HAVE_TYPE_CLOCKID_T
+typedef int clockid_t;
+#endif
+
+#ifndef HAVE_CLOCK_GETTIME
+#  ifndef CLOCK_REALTIME
+#    define CLOCK_REALTIME 0 /* whatever */
+#  endif
+static int fake_clock_gettime(clockid_t clk_id, struct timespec *res)
+{
+	struct timeval tv;
+	int r = gettimeofday(&tv, NULL);
+
+	assert(0 == r && "gettimeofday() broke!?");
+	res->tv_sec = tv.tv_sec;
+	res->tv_nsec = tv.tv_usec * 1000;
+
+	return r;
+}
+#  define clock_gettime fake_clock_gettime
+#endif /* broken systems w/o clock_gettime() */
+
+/*
+ * UGH
+ * CLOCK_MONOTONIC is not guaranteed to be a macro, either
+ */
+#ifndef CLOCK_MONOTONIC
+#  if (!defined(_POSIX_MONOTONIC_CLOCK) || !defined(HAVE_CLOCK_MONOTONIC))
+#    define CLOCK_MONOTONIC CLOCK_REALTIME
+#  endif
+#endif

data/ext/sleepy_penguin/sleepy_penguin.h

@@ -77,6 +77,7 @@ static inline VALUE fake_blocking_region(VALUE (*fn)(void *), void *data)
 
 typedef int rb_sp_waitfn(int fd);
 int rb_sp_wait(rb_sp_waitfn waiter, VALUE obj, int *fd);
+void *rb_sp_gettlsbuf(size_t *size);
 
 /* Flexible array elements are standard in C99 */
 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)

data/ext/sleepy_penguin/util.c

@@ -1,5 +1,13 @@
 #include "sleepy_penguin.h"
 
+#ifndef HAVE_RB_IO_GET_IO
+static VALUE my_io_get_io(VALUE io)
+{
+	return rb_convert_type(io, T_FILE, "IO", "to_io");
+}
+#  define rb_io_get_io(io) my_io_get_io((io))
+#endif /* HAVE_RB_IO_GET_IO */
+
 static VALUE klass_for(VALUE klass)
 {
 	return (TYPE(klass) == T_CLASS) ? klass : CLASS_OF(klass);
@@ -14,13 +22,13 @@ int rb_sp_get_flags(VALUE klass, VALUE flags, int default_flags)
 	case T_SYMBOL:
 		return NUM2INT(rb_const_get(klass_for(klass), SYM2ID(flags)));
 	case T_ARRAY: {
-		VALUE *ptr = RARRAY_PTR(flags);
+		long i;
 		long len = RARRAY_LEN(flags);
 		int rv = 0;
 
 		klass = klass_for(klass);
-		while (--len >= 0) {
-			VALUE tmp = *ptr++;
+		for (i = 0; i < len; i++) {
+			VALUE tmp = rb_ary_entry(flags, i);
 
 			Check_Type(tmp, T_SYMBOL);
 			tmp = rb_const_get(klass, SYM2ID(tmp));
@@ -42,13 +50,13 @@ unsigned rb_sp_get_uflags(VALUE klass, VALUE flags)
 	case T_SYMBOL:
 		return NUM2UINT(rb_const_get(klass_for(klass), SYM2ID(flags)));
 	case T_ARRAY: {
-		VALUE *ptr = RARRAY_PTR(flags);
+		long i;
 		long len = RARRAY_LEN(flags);
 		unsigned rv = 0;
 
 		klass = klass_for(klass);
-		while (--len >= 0) {
-			VALUE tmp = *ptr++;
+		for (i = 0; i < len; i++) {
+			VALUE tmp = rb_ary_entry(flags, i);
 
 			Check_Type(tmp, T_SYMBOL);
 			tmp = rb_const_get(klass, SYM2ID(tmp));
@@ -100,7 +108,7 @@ int rb_sp_io_closed(VALUE io)
 	case T_FILE:
 		break;
 	default:
-		io = rb_convert_type(io, T_FILE, "IO", "to_io");
+		io = rb_io_get_io(io);
 	}
 
 	return my_rb_io_closed(io);
@@ -110,7 +118,7 @@ int rb_sp_fileno(VALUE io)
 {
 	rb_io_t *fptr;
 
-	io = rb_convert_type(io, T_FILE, "IO", "to_io");
+	io = rb_io_get_io(io);
 	GetOpenFile(io, fptr);
 	return FPTR_TO_FD(fptr);
 }