raindrops 0.4.1 → 0.5.0

data/ext/raindrops/linux_tcp_info.c

@@ -0,0 +1,170 @@
+#include <ruby.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <linux/tcp.h>
+#ifdef TCP_INFO
+#include "my_fileno.h"
+
+#define TCPI_ATTR_READER(x) \
+static VALUE tcp_info_##x(VALUE self) \
+{ \
+	struct tcp_info *info = DATA_PTR(self); \
+	return UINT2NUM((uint32_t)info->tcpi_##x); \
+}
+
+TCPI_ATTR_READER(state)
+TCPI_ATTR_READER(ca_state)
+TCPI_ATTR_READER(retransmits)
+TCPI_ATTR_READER(probes)
+TCPI_ATTR_READER(backoff)
+TCPI_ATTR_READER(options)
+TCPI_ATTR_READER(snd_wscale)
+TCPI_ATTR_READER(rcv_wscale)
+TCPI_ATTR_READER(rto)
+TCPI_ATTR_READER(ato)
+TCPI_ATTR_READER(snd_mss)
+TCPI_ATTR_READER(rcv_mss)
+TCPI_ATTR_READER(unacked)
+TCPI_ATTR_READER(sacked)
+TCPI_ATTR_READER(lost)
+TCPI_ATTR_READER(retrans)
+TCPI_ATTR_READER(fackets)
+TCPI_ATTR_READER(last_data_sent)
+TCPI_ATTR_READER(last_ack_sent)
+TCPI_ATTR_READER(last_data_recv)
+TCPI_ATTR_READER(last_ack_recv)
+TCPI_ATTR_READER(pmtu)
+TCPI_ATTR_READER(rcv_ssthresh)
+TCPI_ATTR_READER(rtt)
+TCPI_ATTR_READER(rttvar)
+TCPI_ATTR_READER(snd_ssthresh)
+TCPI_ATTR_READER(snd_cwnd)
+TCPI_ATTR_READER(advmss)
+TCPI_ATTR_READER(reordering)
+TCPI_ATTR_READER(rcv_rtt)
+TCPI_ATTR_READER(rcv_space)
+TCPI_ATTR_READER(total_retrans)
+
+static VALUE alloc(VALUE klass)
+{
+	struct tcp_info *info = xmalloc(sizeof(struct tcp_info));
+
+	/* Data_Make_Struct has an extra memset 0 which is so wasteful */
+	return Data_Wrap_Struct(klass, NULL, -1, info);
+}
+
+/*
+ * call-seq:
+ *
+ *	Raindrops::TCP_Info.new(tcp_socket)	-> TCP_Info object
+ *
+ * Reads a TCP_Info object from any given +tcp_socket+.  See the tcp(7)
+ * manpage and /usr/include/linux/tcp.h for more details.
+ */
+static VALUE init(VALUE self, VALUE io)
+{
+	int fd = my_fileno(io);
+	struct tcp_info *info = DATA_PTR(self);
+	socklen_t len = (socklen_t)sizeof(struct tcp_info);
+	int rc = getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &len);
+
+	if (rc != 0)
+		rb_sys_fail("getsockopt");
+
+	return self;
+}
+
+void Init_raindrops_linux_tcp_info(void)
+{
+	VALUE cRaindrops = rb_const_get(rb_cObject, rb_intern("Raindrops"));
+	VALUE cTCP_Info;
+
+	/*
+	 * Document-class: Raindrops::TCP_Info
+	 *
+	 * This is used to wrap "struct tcp_info" as described in tcp(7)
+	 * and /usr/include/linux/tcp.h.  The following readers methods
+	 * are defined corresponding to the "tcpi_" fields in the
+	 * tcp_info struct.
+	 *
+	 * In particular, the +last_data_recv+ field is useful for measuring
+	 * the amount of time a client spent in the listen queue before
+	 * +accept()+, but only if +TCP_DEFER_ACCEPT+ is used with the
+	 * listen socket (it is on by default in Unicorn).
+	 *
+	 * - state
+	 * - ca_state
+	 * - retransmits
+	 * - probes
+	 * - backoff
+	 * - options
+	 * - snd_wscale
+	 * - rcv_wscale
+	 * - rto
+	 * - ato
+	 * - snd_mss
+	 * - rcv_mss
+	 * - unacked
+	 * - sacked
+	 * - lost
+	 * - retrans
+	 * - fackets
+	 * - last_data_sent
+	 * - last_ack_sent
+	 * - last_data_recv
+	 * - last_ack_recv
+	 * - pmtu
+	 * - rcv_ssthresh
+	 * - rtt
+	 * - rttvar
+	 * - snd_ssthresh
+	 * - snd_cwnd
+	 * - advmss
+	 * - reordering
+	 * - rcv_rtt
+	 * - rcv_space
+	 * - total_retrans
+	 *
+	 * http://kernel.org/doc/man-pages/online/pages/man7/tcp.7.html
+	 */
+	cTCP_Info = rb_define_class_under(cRaindrops, "TCP_Info", rb_cObject);
+	rb_define_alloc_func(cTCP_Info, alloc);
+	rb_define_private_method(cTCP_Info, "initialize", init, 1);
+
+#define TCPI_DEFINE_METHOD(x) \
+	rb_define_method(cTCP_Info, #x, tcp_info_##x, 0)
+
+	TCPI_DEFINE_METHOD(state);
+	TCPI_DEFINE_METHOD(ca_state);
+	TCPI_DEFINE_METHOD(retransmits);
+	TCPI_DEFINE_METHOD(probes);
+	TCPI_DEFINE_METHOD(backoff);
+	TCPI_DEFINE_METHOD(options);
+	TCPI_DEFINE_METHOD(snd_wscale);
+	TCPI_DEFINE_METHOD(rcv_wscale);
+	TCPI_DEFINE_METHOD(rto);
+	TCPI_DEFINE_METHOD(ato);
+	TCPI_DEFINE_METHOD(snd_mss);
+	TCPI_DEFINE_METHOD(rcv_mss);
+	TCPI_DEFINE_METHOD(unacked);
+	TCPI_DEFINE_METHOD(sacked);
+	TCPI_DEFINE_METHOD(lost);
+	TCPI_DEFINE_METHOD(retrans);
+	TCPI_DEFINE_METHOD(fackets);
+	TCPI_DEFINE_METHOD(last_data_sent);
+	TCPI_DEFINE_METHOD(last_ack_sent);
+	TCPI_DEFINE_METHOD(last_data_recv);
+	TCPI_DEFINE_METHOD(last_ack_recv);
+	TCPI_DEFINE_METHOD(pmtu);
+	TCPI_DEFINE_METHOD(rcv_ssthresh);
+	TCPI_DEFINE_METHOD(rtt);
+	TCPI_DEFINE_METHOD(rttvar);
+	TCPI_DEFINE_METHOD(snd_ssthresh);
+	TCPI_DEFINE_METHOD(snd_cwnd);
+	TCPI_DEFINE_METHOD(advmss);
+	TCPI_DEFINE_METHOD(reordering);
+	TCPI_DEFINE_METHOD(rcv_rtt);
+	TCPI_DEFINE_METHOD(rcv_space);
+	TCPI_DEFINE_METHOD(total_retrans);
+}
+#endif /* TCP_INFO */

data/ext/raindrops/my_fileno.h

@@ -0,0 +1,36 @@
+#include <ruby.h>
+#ifdef HAVE_RUBY_IO_H
+#  include <ruby/io.h>
+#else
+#  include <stdio.h>
+#  include <rubyio.h>
+#endif
+
+#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;
+	int fd;
+
+	if (TYPE(io) != T_FILE)
+		io = rb_convert_type(io, T_FILE, "IO", "to_io");
+	GetOpenFile(io, fptr);
+	fd = FPTR_TO_FD(fptr);
+
+	if (fd < 0)
+		rb_raise(rb_eIOError, "closed stream");
+	return fd;
+}

data/ext/raindrops/raindrops.c

@@ -9,6 +9,9 @@
 #ifndef SIZET2NUM
 #  define SIZET2NUM(x) ULONG2NUM(x)
 #endif
+#ifndef NUM2SIZET
+#  define NUM2SIZET(x) NUM2ULONG(x)
+#endif
 
 /*
  * most modern CPUs have a cache-line size of 64 or 128.
@@ -16,25 +19,31 @@
  * heavily used
  */
 static size_t raindrop_size = 128;
+static size_t rd_page_size;
+
+#define PAGE_MASK               (~(rd_page_size - 1))
+#define PAGE_ALIGN(addr)        (((addr) + rd_page_size - 1) & PAGE_MASK)
 
 /* each raindrop is a counter */
 struct raindrop {
 	unsigned long counter;
 } __attribute__((packed));
 
-/* allow mmap-ed regions can store more than one raindrop */
+/* allow mmap-ed regions to store more than one raindrop */
 struct raindrops {
-	long size;
+	size_t size;
+	size_t capa;
+	pid_t pid;
 	struct raindrop *drops;
 };
 
 /* called by GC */
-static void evaporate(void *ptr)
+static void gcfree(void *ptr)
 {
 	struct raindrops *r = ptr;
 
-	if (r->drops) {
-		int rv = munmap(r->drops, raindrop_size * r->size);
+	if (r->drops != MAP_FAILED) {
+		int rv = munmap(r->drops, raindrop_size * r->capa);
 		if (rv != 0)
 			rb_bug("munmap failed in gc: %s", strerror(errno));
 	}
@@ -46,8 +55,10 @@ static void evaporate(void *ptr)
 static VALUE alloc(VALUE klass)
 {
 	struct raindrops *r;
+	VALUE rv = Data_Make_Struct(klass, struct raindrops, NULL, gcfree, r);
 
-	return Data_Make_Struct(klass, struct raindrops, NULL, evaporate, r);
+	r->drops = MAP_FAILED;
+	return rv;
 }
 
 static struct raindrops *get(VALUE self)
@@ -56,44 +67,147 @@ static struct raindrops *get(VALUE self)
 
 	Data_Get_Struct(self, struct raindrops, r);
 
+	if (r->drops == MAP_FAILED)
+		rb_raise(rb_eStandardError, "invalid or freed Raindrops");
+
 	return r;
 }
 
-/* initializes a Raindrops object to hold +size+ elements */
+/*
+ * call-seq:
+ *	Raindrops.new(size)	-> raindrops object
+ *
+ * Initializes a Raindrops object to hold +size+ counters.  +size+ is
+ * only a hint and the actual number of counters the object has is
+ * dependent on the CPU model, number of cores, and page size of
+ * the machine.  The actual size of the object will always be equal
+ * or greater than the specified +size+.
+ */
 static VALUE init(VALUE self, VALUE size)
 {
-	struct raindrops *r = get(self);
+	struct raindrops *r = DATA_PTR(self);
 	int tries = 1;
+	size_t tmp;
 
-	if (r->drops)
+	if (r->drops != MAP_FAILED)
 		rb_raise(rb_eRuntimeError, "already initialized");
 
-	r->size = NUM2LONG(size);
+	r->size = NUM2SIZET(size);
 	if (r->size < 1)
 		rb_raise(rb_eArgError, "size must be >= 1");
 
+	tmp = PAGE_ALIGN(raindrop_size * r->size);
+	r->capa = tmp / raindrop_size;
+	assert(PAGE_ALIGN(raindrop_size * r->capa) == tmp && "not aligned");
+
 retry:
-	r->drops = mmap(NULL, raindrop_size * r->size,
+	r->drops = mmap(NULL, tmp,
 	                PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
 	if (r->drops == MAP_FAILED) {
-		r->drops = NULL;
 		if ((errno == EAGAIN || errno == ENOMEM) && tries-- > 0) {
 			rb_gc();
 			goto retry;
 		}
 		rb_sys_fail("mmap");
 	}
+	r->pid = getpid();
 
 	return self;
 }
 
-/* :nodoc */
+/*
+ * mremap() is currently broken with MAP_SHARED
+ * https://bugzilla.kernel.org/show_bug.cgi?id=8691
+ */
+#if defined(HAVE_MREMAP) && !defined(MREMAP_WORKS_WITH_MAP_SHARED)
+#  undef HAVE_MREMAP
+#endif
+
+#ifdef HAVE_MREMAP
+#ifndef MREMAP_MAYMOVE
+#  warn MREMAP_MAYMOVE undefined
+#  define MREMAP_MAYMOVE 0
+#endif
+static void resize(struct raindrops *r, size_t new_rd_size)
+{
+	size_t old_size = raindrop_size * r->capa;
+	size_t new_size = PAGE_ALIGN(raindrop_size * new_rd_size);
+	void *old_address = r->drops;
+	void *rv;
+
+	if (r->pid != getpid())
+		rb_raise(rb_eRuntimeError, "cannot mremap() from child");
+
+	rv = mremap(old_address, old_size, new_size, MREMAP_MAYMOVE);
+	if (rv == MAP_FAILED) {
+		if (errno == EAGAIN || errno == ENOMEM) {
+			rb_gc();
+			rv = mremap(old_address, old_size, new_size, 0);
+		}
+		if (rv == MAP_FAILED)
+			rb_sys_fail("mremap");
+	}
+	r->drops = rv;
+	r->size = new_rd_size;
+	r->capa = new_size / raindrop_size;
+	assert(r->capa >= r->size && "bad sizing");
+}
+#else /* ! HAVE_MREMAP */
+/*
+ * we cannot use munmap + mmap to reallocate the buffer since it may
+ * already be shared by other processes, so we just fail
+ */
+static void resize(struct raindrops *r, size_t new_rd_size)
+{
+	rb_raise(rb_eRangeError, "mremap(2) is not available");
+}
+#endif /* ! HAVE_MREMAP */
+
+/*
+ * call-seq:
+ *	rd.size = new_size
+ *
+ * Increases or decreases the current capacity of our Raindrop.
+ * Raises RangeError if +new_size+ is too big or small for the
+ * current backing store
+ */
+static VALUE setsize(VALUE self, VALUE new_size)
+{
+	size_t new_rd_size = NUM2SIZET(new_size);
+	struct raindrops *r = get(self);
+
+	if (new_rd_size <= r->capa)
+		r->size = new_rd_size;
+	else
+		resize(r, new_rd_size);
+
+	return new_size;
+}
+
+/*
+ * call-seq:
+ *	rd.capa		-> Integer
+ *
+ * Returns the number of slots allocated (but not necessarily used) by
+ * the Raindrops object.
+ */
+static VALUE capa(VALUE self)
+{
+	return SIZET2NUM(get(self)->capa);
+}
+
+/*
+ * call-seq:
+ *	rd.dup		-> rd_copy
+ *
+ * Duplicates and snapshots the current state of a Raindrops object.
+ */
 static VALUE init_copy(VALUE dest, VALUE source)
 {
-	struct raindrops *dst = get(dest);
+	struct raindrops *dst = DATA_PTR(dest);
 	struct raindrops *src = get(source);
 
-	init(dest, LONG2NUM(src->size));
+	init(dest, SIZET2NUM(src->size));
 	memcpy(dst->drops, src->drops, raindrop_size * src->size);
 
 	return dest;
@@ -119,7 +233,13 @@ static unsigned long incr_decr_arg(int argc, const VALUE *argv)
 	return argc == 2 ? NUM2ULONG(argv[1]) : 1;
 }
 
-/* increments the value referred to by the +index+ constant by 1 */
+/*
+ * call-seq:
+ *	rd.incr(index[, number])	-> result
+ *
+ * Increments the value referred to by the +index+ by +number+.
+ * +number+ defaults to +1+ if unspecified.
+ */
 static VALUE incr(int argc, VALUE *argv, VALUE self)
 {
 	unsigned long nr = incr_decr_arg(argc, argv);
@@ -127,7 +247,13 @@ static VALUE incr(int argc, VALUE *argv, VALUE self)
 	return ULONG2NUM(__sync_add_and_fetch(addr_of(self, argv[0]), nr));
 }
 
-/* decrements the value referred to by the +index+ constant by 1 */
+/*
+ * call-seq:
+ *	rd.decr(index[, number])	-> result
+ *
+ * Decrements the value referred to by the +index+ by +number+.
+ * +number+ defaults to +1+ if unspecified.
+ */
 static VALUE decr(int argc, VALUE *argv, VALUE self)
 {
 	unsigned long nr = incr_decr_arg(argc, argv);
@@ -135,12 +261,17 @@ static VALUE decr(int argc, VALUE *argv, VALUE self)
 	return ULONG2NUM(__sync_sub_and_fetch(addr_of(self, argv[0]), nr));
 }
 
-/* converts the raindrops structure to an Array */
+/*
+ * call-seq:
+ *	rd.to_ary	-> Array
+ *
+ * converts the Raindrops structure to an Array
+ */
 static VALUE to_ary(VALUE self)
 {
 	struct raindrops *r = get(self);
 	VALUE rv = rb_ary_new2(r->size);
-	long i;
+	size_t i;
 	unsigned long base = (unsigned long)r->drops;
 
 	for (i = 0; i < r->size; i++) {
@@ -151,11 +282,25 @@ static VALUE to_ary(VALUE self)
 	return rv;
 }
 
+/*
+ * call-seq:
+ *	rd.size		-> Integer
+ *
+ * Returns the number of counters a Raindrops object can hold.  Due to
+ * page alignment, this is always equal or greater than the number of
+ * requested slots passed to Raindrops.new
+ */
 static VALUE size(VALUE self)
 {
-	return LONG2NUM(get(self)->size);
+	return SIZET2NUM(get(self)->size);
 }
 
+/*
+ * call-seq:
+ *	rd[index] = value
+ *
+ * Assigns +value+ to the slot designated by +index+
+ */
 static VALUE aset(VALUE self, VALUE index, VALUE value)
 {
 	unsigned long *addr = addr_of(self, index);
@@ -165,6 +310,12 @@ static VALUE aset(VALUE self, VALUE index, VALUE value)
 	return value;
 }
 
+/*
+ * call-seq:
+ *	rd[index]	-> value
+ *
+ * Returns the value of the slot designated by +index+
+ */
 static VALUE aref(VALUE self, VALUE index)
 {
 	return  ULONG2NUM(*addr_of(self, index));
@@ -172,6 +323,7 @@ static VALUE aref(VALUE self, VALUE index)
 
 #ifdef __linux__
 void Init_raindrops_linux_inet_diag(void);
+void Init_raindrops_linux_tcp_info(void);
 #endif
 
 #ifndef _SC_NPROCESSORS_ONLN
@@ -182,6 +334,26 @@ void Init_raindrops_linux_inet_diag(void);
 #  endif
 #endif
 
+/*
+ * call-seq:
+ *	rd.evaporate!	-> nil
+ *
+ * Releases mmap()-ed memory allocated for the Raindrops object back
+ * to the OS.  The Ruby garbage collector will also release memory
+ * automatically when it is not needed, but this forces release
+ * under high memory pressure.
+ */
+static VALUE evaporate_bang(VALUE self)
+{
+	struct raindrops *r = get(self);
+	void *addr = r->drops;
+
+	r->drops = MAP_FAILED;
+	if (munmap(addr, raindrop_size * r->capa) != 0)
+		rb_sys_fail("munmap");
+	return Qnil;
+}
+
 void Init_raindrops_ext(void)
 {
 	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
@@ -200,8 +372,44 @@ void Init_raindrops_ext(void)
 			raindrop_size = (size_t)tmp;
 	}
 #endif
+#if defined(_SC_PAGE_SIZE)
+	rd_page_size = (size_t)sysconf(_SC_PAGE_SIZE);
+#elif defined(_SC_PAGESIZE)
+	rd_page_size = (size_t)sysconf(_SC_PAGESIZE);
+#elif defined(HAVE_GETPAGESIZE)
+	rd_page_size = (size_t)getpagesize();
+#elif defined(PAGE_SIZE)
+	rd_page_size = (size_t)PAGE_SIZE;
+#elif defined(PAGESIZE)
+	rd_page_size = (size_t)PAGESIZE;
+#else
+#  error unable to detect page size for mmap()
+#endif
+	if ((rd_page_size == (size_t)-1) || (rd_page_size < raindrop_size))
+		rb_raise(rb_eRuntimeError,
+			 "system page size invalid: %llu",
+			 (unsigned long long)rd_page_size);
+
+	/*
+	 * The size of one page of memory for a mmap()-ed Raindrops region.
+	 * Typically 4096 bytes under Linux.
+	 */
+	rb_define_const(cRaindrops, "PAGE_SIZE", SIZET2NUM(rd_page_size));
+
+	/*
+	 * The size (in bytes) of a slot in a Raindrops object.
+	 * This is the size of a word on single CPU systems and
+	 * the size of the L1 cache line size if detectable.
+	 *
+	 * Defaults to 128 bytes if undetectable.
+	 */
 	rb_define_const(cRaindrops, "SIZE", SIZET2NUM(raindrop_size));
 
+	/*
+	 * The maximum value a raindrop counter can hold
+	 */
+	rb_define_const(cRaindrops, "MAX", ULONG2NUM((unsigned long)-1));
+
 	rb_define_alloc_func(cRaindrops, alloc);
 
 	rb_define_method(cRaindrops, "initialize", init, 1);
@@ -211,9 +419,13 @@ void Init_raindrops_ext(void)
 	rb_define_method(cRaindrops, "[]", aref, 1);
 	rb_define_method(cRaindrops, "[]=", aset, 2);
 	rb_define_method(cRaindrops, "size", size, 0);
+	rb_define_method(cRaindrops, "size=", setsize, 1);
+	rb_define_method(cRaindrops, "capa", capa, 0);
 	rb_define_method(cRaindrops, "initialize_copy", init_copy, 1);
+	rb_define_method(cRaindrops, "evaporate!", evaporate_bang, 0);
 
 #ifdef __linux__
 	Init_raindrops_linux_inet_diag();
+	Init_raindrops_linux_tcp_info();
 #endif
 }