sleepy_penguin 1.0.0

data/ext/sleepy_penguin/eventfd.c

@@ -0,0 +1,177 @@
+#ifdef HAVE_SYS_EVENTFD_H
+#include "sleepy_penguin.h"
+#include <sys/eventfd.h>
+#include "nonblock.h"
+static ID id_for_fd;
+
+static VALUE create(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE _initval, _flags;
+	unsigned initval;
+	int flags = 0;
+	int fd;
+
+	rb_scan_args(argc, argv, "11", &_initval, &_flags);
+	initval = NUM2UINT(_initval);
+	flags = NIL_P(_flags) ? 0 : NUM2INT(_flags);
+
+	fd = eventfd(initval, flags);
+	if (fd == -1) {
+		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
+			rb_gc();
+			fd = eventfd(initval, flags);
+		}
+		if (fd == -1)
+			rb_sys_fail("eventfd");
+	}
+
+	return rb_funcall(klass, id_for_fd, 1, INT2NUM(fd));
+}
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+struct efd_args {
+	int fd;
+	uint64_t val;
+};
+
+static VALUE efd_write(void *_args)
+{
+	struct efd_args *args = _args;
+	ssize_t w = write(args->fd, &args->buf, sizeof(uint64_t));
+
+	return (VALUE)w;
+}
+
+static VALUE efd_read(void *_args)
+{
+	struct efd_args *args = _args;
+	ssize_t r = read(args->fd, &args->buf, sizeof(uint64_t));
+
+	return (VALUE)r;
+}
+
+static VALUE incr(VALUE self, VALUE value)
+{
+	struct efd_args x;
+	ssize_t w;
+
+	x.fd = my_fileno(self);
+	x.val = (uint64_t)NUM2ULL(value);
+
+retry:
+	w = (ssize_t)rb_thread_blocking_region(efd_write, &x, RUBY_UBF_IO, 0);
+	if (w == -1) {
+		if (rb_io_wait_writable(x.fd))
+			goto retry;
+		rb_sys_fail("write(eventfd)");
+	}
+
+	return Qnil;
+}
+
+static VALUE getvalue(VALUE self)
+{
+	struct efd_args x;
+
+	x.fd = my_fileno(self);
+
+retry:
+	w = (ssize_t)rb_thread_blocking_region(efd_read, &x, RUBY_UBF_IO, 0);
+	if (w == -1) {
+		if (rb_io_wait_readable(x.fd))
+			goto retry;
+		rb_sys_fail("read(eventfd)");
+	}
+
+	return ULL2NUM(x.buf);
+}
+#else  /* !HAVE_RB_THREAD_BLOCKING_REGION */
+
+static VALUE incr(VALUE self, VALUE value)
+{
+	int fd = my_fileno(self);
+	uint64_t val = (uint64_t)NUM2ULL(value);
+	ssize_t w;
+
+	set_nonblock(fd);
+retry:
+	w = write(fd, &val, sizeof(uint64_t));
+	if (w == -1) {
+		if (rb_io_wait_writable(fd))
+			goto retry;
+		rb_sys_fail("write(eventfd)");
+	}
+
+	return Qnil;
+}
+
+static VALUE getvalue(VALUE self)
+{
+	int fd = my_fileno(self);
+	uint64_t val;
+	ssize_t r;
+
+	set_nonblock(fd);
+retry:
+	r = read(fd, &val, sizeof(uint64_t));
+	if (r == -1) {
+		if (rb_io_wait_readable(fd))
+			goto retry;
+		rb_sys_fail("read(eventfd)");
+	}
+
+	return ULL2NUM(val);
+}
+#endif /* !HAVE_RB_THREAD_BLOCKING_REGION */
+
+static VALUE getvalue_nonblock(VALUE self)
+{
+	int fd = my_fileno(self);
+	uint64_t val;
+	ssize_t r;
+
+	set_nonblock(fd);
+	r = read(fd, &val, sizeof(uint64_t));
+	if (r == -1)
+		rb_sys_fail("read(eventfd)");
+
+	return ULL2NUM(val);
+}
+
+static VALUE incr_nonblock(VALUE self, VALUE value)
+{
+	int fd = my_fileno(self);
+	uint64_t val = (uint64_t)NUM2ULL(value);
+	ssize_t w;
+
+	set_nonblock(fd);
+	w = write(fd, &val, sizeof(uint64_t));
+	if (w == -1)
+		rb_sys_fail("write(eventfd)");
+
+	return Qnil;
+}
+
+void sleepy_penguin_init_eventfd(void)
+{
+	VALUE mSleepyPenguin, cEventFD;
+
+	mSleepyPenguin = rb_const_get(rb_cObject, rb_intern("SleepyPenguin"));
+	cEventFD = rb_define_class_under(mSleepyPenguin, "EventFD", rb_cIO);
+	rb_define_singleton_method(cEventFD, "new", create, -1);
+#ifdef EFD_NONBLOCK
+	rb_define_const(cEventFD, "NONBLOCK", UINT2NUM(EFD_NONBLOCK));
+#endif
+#ifdef EFD_CLOEXEC
+	rb_define_const(cEventFD, "CLOEXEC", UINT2NUM(EFD_CLOEXEC));
+#endif
+#ifdef EFD_SEMAPHORE
+	rb_define_const(cEventFD, "SEMAPHORE", UINT2NUM(EFD_SEMAPHORE));
+#endif
+	rb_define_method(cEventFD, "value", getvalue, 0);
+	rb_define_method(cEventFD, "incr", incr, 1);
+	rb_define_method(cEventFD, "value_nonblock", getvalue_nonblock, 0);
+	rb_define_method(cEventFD, "incr_nonblock", incr_nonblock, 1);
+	id_for_fd = rb_intern("for_fd");
+}
+#endif /* HAVE_SYS_EVENTFD_H */

data/ext/sleepy_penguin/extconf.rb

@@ -0,0 +1,13 @@
+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')
+have_header('sys/signalfd.h')
+have_header('sys/timerfd.h')
+have_func('rb_memerror')
+have_func('rb_io_close')
+have_func('epoll_create1', %w(sys/epoll.h))
+have_func('rb_thread_blocking_region')
+have_library('pthread')
+dir_config('sleepy_penguin')
+create_makefile('sleepy_penguin_ext')

data/ext/sleepy_penguin/init.c

@@ -0,0 +1,20 @@
+void sleepy_penguin_init_epoll(void);
+
+#ifdef HAVE_SYS_TIMERFD_H
+void sleepy_penguin_init_timerfd(void);
+#else
+#  define sleepy_penguin_init_timerfd() if(0)
+#endif
+
+#ifdef HAVE_SYS_EVENTFD_H
+void sleepy_penguin_init_eventfd(void);
+#else
+#  define sleepy_penguin_init_eventfd() if(0)
+#endif
+
+void Init_sleepy_penguin_ext(void)
+{
+	sleepy_penguin_init_epoll();
+	sleepy_penguin_init_timerfd();
+	sleepy_penguin_init_eventfd();
+}

data/ext/sleepy_penguin/nonblock.h

@@ -0,0 +1,19 @@
+#ifndef SLEEPY_PENGUIN_NONBLOCK_H
+#define SLEEPY_PENGUIN_NONBLOCK_H
+#include <unistd.h>
+#include <fcntl.h>
+#include <ruby.h>
+static void 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)");
+}
+
+#endif /* SLEEPY_PENGUIN_NONBLOCK_H */

data/ext/sleepy_penguin/sleepy_penguin.h

@@ -0,0 +1,44 @@
+#ifndef SLEEPY_PENGUIN_H
+#define SLEEPY_PENGUIN_H
+
+#include <ruby.h>
+#ifdef HAVE_RUBY_IO_H
+#  include <ruby/io.h>
+#else
+#  include <rubyio.h>
+#endif
+#include <errno.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <unistd.h>
+
+#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 my_fileno(VALUE io)
+{
+	rb_io_t *fptr;
+
+	switch (TYPE(io)) {
+	case T_FIXNUM: return NUM2INT(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);
+}
+
+#endif /* SLEEPY_PENGUIN_H */

data/ext/sleepy_penguin/timerfd.c

@@ -0,0 +1,128 @@
+#ifdef HAVE_SYS_TIMERFD_H
+#include "sleepy_penguin.h"
+#include <sys/timerfd.h>
+#include "value2timespec.h"
+static ID id_for_fd;
+
+static VALUE create(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE cid, fl;
+	int clockid, flags = 0;
+	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);
+
+	fd = timerfd_create(clockid, flags);
+	if (fd == -1) {
+		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
+			rb_gc();
+			fd = timerfd_create(clockid, flags);
+		}
+		if (fd == -1)
+			rb_sys_fail("timerfd_create");
+	}
+
+	return rb_funcall(klass, id_for_fd, 1, INT2NUM(fd));
+}
+
+static VALUE itimerspec2ary(struct itimerspec *its)
+{
+	VALUE interval = timespec2num(&its->it_interval);
+	VALUE value = timespec2num(&its->it_value);
+
+	return rb_ary_new3(2, interval, value);
+}
+
+static VALUE settime(VALUE self, VALUE fl, VALUE interval, VALUE value)
+{
+	int fd = my_fileno(self);
+	int flags = NUM2INT(fl);
+	struct itimerspec old, new;
+
+	value2timespec(&new.it_interval, interval);
+	value2timespec(&new.it_value, value);
+
+	if (timerfd_settime(fd, flags, &new, &old) == -1)
+		rb_sys_fail("timerfd_settime");
+
+	return itimerspec2ary(&old);
+}
+
+static VALUE gettime(VALUE self)
+{
+	int fd = my_fileno(self);
+	struct itimerspec curr;
+
+	if (timerfd_gettime(fd, &curr) == -1)
+		rb_sys_fail("timerfd_gettime");
+
+	return itimerspec2ary(&curr);
+}
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+static VALUE tfd_read(void *args)
+{
+	uint64_t *buf = args;
+	int fd = (int)(*buf);
+	ssize_t r = read(fd, buf, sizeof(uint64_t));
+
+	return (VALUE)r;
+}
+
+static VALUE expirations(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);
+retry:
+	r = read(fd, &buf, sizeof(uint64_t));
+	if (r == -1) {
+		if (rb_io_wait_readable(fd))
+			goto retry;
+		rb_sys_fail("read(timerfd)");
+	}
+
+	return ULL2NUM(buf);
+}
+#endif
+
+void sleepy_penguin_init_timerfd(void)
+{
+	VALUE mSleepyPenguin, cTimerFD;
+
+	mSleepyPenguin = rb_const_get(rb_cObject, rb_intern("SleepyPenguin"));
+	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));
+#ifdef TFD_NONBLOCK
+	rb_define_const(cTimerFD, "NONBLOCK", UINT2NUM(TFD_NONBLOCK));
+#endif
+#ifdef TFD_CLOEXEC
+	rb_define_const(cTimerFD, "CLOEXEC", UINT2NUM(TFD_CLOEXEC));
+#endif
+
+	rb_define_method(cTimerFD, "settime", settime, 3);
+	rb_define_method(cTimerFD, "expirations", expirations, 0);
+	id_for_fd = rb_intern("for_fd");
+}
+#endif /* HAVE_SYS_TIMERFD_H */

data/ext/sleepy_penguin/value2timespec.h

@@ -0,0 +1,64 @@
+#ifndef VALUE2TIMESPEC_H
+#define VALUE2TIMESPEC_H
+
+#include <ruby.h>
+#include <math.h>
+#include <time.h>
+
+#ifndef NUM2TIMET
+#  define NUM2TIMET(n) NUM2LONG(n)
+#endif
+
+#ifndef RFLOAT_VALUE
+#  define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+
+static struct timespec *value2timespec(struct timespec *ts, VALUE num)
+{
+	switch (TYPE(num)) {
+	case T_FIXNUM:
+	case T_BIGNUM:
+		ts->tv_sec = NUM2TIMET(num);
+		ts->tv_nsec = 0;
+		return ts;
+	case T_FLOAT: {
+		double orig = RFLOAT_VALUE(num);
+		double f, d;
+
+		d = modf(orig, &f);
+		if (d >= 0) {
+			ts->tv_nsec = (long)(d * 1e9 + 0.5);
+		} else {
+			ts->tv_nsec = (long)(-d * 1e9 + 0.5);
+			if (ts->tv_nsec > 0) {
+				ts->tv_nsec = (long)1e9 - ts->tv_nsec;
+				f -= 1;
+			}
+		}
+		ts->tv_sec = (time_t)f;
+		if (f != ts->tv_sec)
+			rb_raise(rb_eRangeError, "%f out of range", orig);
+		return ts;
+	}}
+	{
+		VALUE tmp = rb_inspect(num);
+		rb_raise(rb_eTypeError, "can't convert %s into timespec",
+			 StringValuePtr(tmp));
+	}
+	rb_bug("rb_raise() failed, timespec failed");
+	return NULL;
+}
+
+#ifndef TIMET2NUM
+#  define TIMET2NUM(n) LONG2NUM(n)
+#endif
+
+static VALUE timespec2num(struct timespec *ts)
+{
+	if (ts->tv_nsec == 0)
+		return TIMET2NUM(ts->tv_sec);
+
+	return rb_float_new(ts->tv_sec + ((double)ts->tv_nsec / 1e9));
+}
+
+#endif /* VALUE2TIMESPEC_H */