raindrops 0.3.0 → 0.4.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v0.3.0.GIT
+DEF_VER=v0.4.0.GIT
 
 LF='
 '

data/GNUmakefile

@@ -53,7 +53,7 @@ NEWS: GIT-VERSION-FILE
 latest: NEWS
 	@awk 'BEGIN{RS="=== ";ORS=""}NR==2{sub(/\n$$/,"");print RS""$$0 }' $<
 
-SINCE = 0.2.1
+SINCE = 0.2.0
 ChangeLog: LOG_VERSION = \
   $(shell git rev-parse -q "$(GIT_VERSION)" >/dev/null 2>&1 && \
           echo $(GIT_VERSION) || git describe)

data/README

@@ -3,8 +3,7 @@
 Raindrops is a real time stats package to show statistics for Rack HTTP
 servers.  It is designed for preforking servers such as Rainbows! and
 Unicorn, but should support any Rack HTTP server under Ruby 1.9, 1.8 and
-possibly Rubinius (untested) on platforms supporting POSIX shared memory
-and compiled with GCC (for atomic builtins).
+possibly Rubinius (untested) on platforms supporting POSIX shared memory.
 
 Raindrops includes a Struct-like Raindrops::Struct class that may be used
 standalone to create atomic counters shared across any number of forked
@@ -35,9 +34,12 @@ processes under SMP.
 
 == Install
 
-raindrops requires GCC 4.x (or compatible) or later to support the
-atomic builtins (__sync_{add,sub}_and_fetch()).  Atomic operations on
-other compilers may be supported if there is demand.
+We recommend GCC 4+ (or compatible) to support the
+{atomic builtins}[http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html]
+(__sync_{add,sub}_and_fetch()).  For non-GCC 4+ users, we also support
+compilation with the
+{libatomic_ops}[http://www.hpl.hp.com/research/linux/atomic_ops/]
+package starting with Raindrops 0.4.0.
 
 If you're using a packaged Ruby distribution, make sure you have a C
 compiler and the matching Ruby development libraries and headers.
@@ -115,6 +117,12 @@ git itself.  See the Documentation/SubmittingPatches document
 distributed with git on on patch submission guidelines to follow.  Just
 don't email the git mailing list or maintainer with raindrops patches.
 
+raindrops is currently dual-licensed under the LGPLv2.1 and LGPLv3.  To
+allow for a transition to future versions of the LGPL, contributors are
+required to sign-off changes allowing allowing the project leader to
+relicense raindrops under newer versions of the LGPL (which should be
+similar in spirit to the existing LGPL).
+
 == Contact
 
 All feedback (bug reports, user/development discussion, patches, pull

data/Rakefile

@@ -25,7 +25,7 @@ end
 
 cgit_url = "http://git.bogomips.org/cgit/raindrops.git"
 git_url = ENV['GIT_URL'] || 'git://git.bogomips.org/raindrops.git'
-web_url = "http://rainbows.bogomips.org/"
+web_url = "http://raindrops.bogomips.org/"
 
 desc 'prints news as an Atom feed'
 task :news_atom do

data/TODO

@@ -1,2 +1 @@
-* more portable atomics for non-GCC systems (libatomicops?)
 * pure Ruby version for non-forking servers

data/ext/raindrops/extconf.rb

@@ -7,5 +7,31 @@ have_func('munmap', 'sys/mman.h') or abort 'munmap() not found'
 have_func("rb_struct_alloc_noinit")
 have_func('rb_thread_blocking_region')
 
+checking_for "GCC 4+ atomic builtins" do
+  src = <<SRC
+int main(int argc, char * const argv[]) {
+        volatile unsigned long i = 0;
+        __sync_add_and_fetch(&i, argc);
+        __sync_sub_and_fetch(&i, argc);
+        return 0;
+}
+SRC
+
+  if try_run(src)
+    $defs.push(format("-DHAVE_GCC_ATOMIC_BUILTINS"))
+    true
+  else
+    false
+  end
+end or have_header('atomic_ops.h') or abort <<-SRC
+
+libatomic_ops is required if GCC 4+ is not used.
+See http://www.hpl.hp.com/research/linux/atomic_ops/
+
+Users of Debian-based distros may run:
+
+  apt-get install libatomic-ops-dev
+SRC
+
 dir_config('raindrops')
 create_makefile('raindrops_ext')

data/ext/raindrops/linux_inet_diag.c

@@ -144,7 +144,7 @@ static VALUE diag(void *ptr)
 	} req;
 	struct msghdr msg;
 	const char *err = NULL;
-	unsigned seq = __sync_add_and_fetch(&g_seq, 1);
+	unsigned seq = ++g_seq; /* not atomic, rely on GVL for now */
 	int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_INET_DIAG);
 
 	if (fd < 0)

data/ext/raindrops/raindrops.c

@@ -1,24 +1,25 @@
 #include <ruby.h>
+#include <unistd.h>
 #include <sys/mman.h>
 #include <assert.h>
 #include <errno.h>
 #include <stddef.h>
+#include "raindrops_atomic.h"
+
+#ifndef SIZET2NUM
+#  define SIZET2NUM(x) ULONG2NUM(x)
+#endif
 
 /*
  * most modern CPUs have a cache-line size of 64 or 128.
  * We choose a bigger one by default since our structure is not
  * heavily used
  */
-#ifndef CACHE_LINE_SIZE
-#  define CACHE_LINE_SIZE 128
-#endif
+static size_t raindrop_size = 128;
 
 /* each raindrop is a counter */
 struct raindrop {
-	union {
-		unsigned long counter;
-		unsigned char padding[CACHE_LINE_SIZE];
-	} as;
+	unsigned long counter;
 } __attribute__((packed));
 
 /* allow mmap-ed regions can store more than one raindrop */
@@ -33,7 +34,7 @@ static void evaporate(void *ptr)
 	struct raindrops *r = ptr;
 
 	if (r->drops) {
-		int rv = munmap(r->drops, sizeof(struct raindrop) * r->size);
+		int rv = munmap(r->drops, raindrop_size * r->size);
 		if (rv != 0)
 			rb_bug("munmap failed in gc: %s", strerror(errno));
 	}
@@ -72,9 +73,10 @@ static VALUE init(VALUE self, VALUE size)
 		rb_raise(rb_eArgError, "size must be >= 1");
 
 retry:
-	r->drops = mmap(NULL, sizeof(struct raindrop) * r->size,
+	r->drops = mmap(NULL, raindrop_size * r->size,
 	                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;
@@ -92,7 +94,7 @@ static VALUE init_copy(VALUE dest, VALUE source)
 	struct raindrops *src = get(source);
 
 	init(dest, LONG2NUM(src->size));
-	memcpy(dst->drops, src->drops, sizeof(struct raindrop) * src->size);
+	memcpy(dst->drops, src->drops, raindrop_size * src->size);
 
 	return dest;
 }
@@ -100,9 +102,9 @@ static VALUE init_copy(VALUE dest, VALUE source)
 static unsigned long *addr_of(VALUE self, VALUE index)
 {
 	struct raindrops *r = get(self);
-	unsigned long off = FIX2ULONG(index) * sizeof(struct raindrop);
+	unsigned long off = FIX2ULONG(index) * raindrop_size;
 
-	if (off >= sizeof(struct raindrop) * r->size)
+	if (off >= raindrop_size * r->size)
 		rb_raise(rb_eArgError, "offset overrun");
 
 	return (unsigned long *)((unsigned long)r->drops + off);
@@ -143,7 +145,7 @@ static VALUE to_ary(VALUE self)
 
 	for (i = 0; i < r->size; i++) {
 		rb_ary_push(rv, ULONG2NUM(*((unsigned long *)base)));
-		base += sizeof(struct raindrop);
+		base += raindrop_size;
 	}
 
 	return rv;
@@ -172,9 +174,34 @@ static VALUE aref(VALUE self, VALUE index)
 void Init_raindrops_linux_inet_diag(void);
 #endif
 
+#ifndef _SC_NPROCESSORS_ONLN
+#  ifdef _SC_NPROC_ONLN
+#    define _SC_NPROCESSORS_ONLN _SC_NPROC_ONLN
+#  elif defined _SC_CRAY_NCPU
+#    define _SC_NPROCESSORS_ONLN _SC_CRAY_NCPU
+#  endif
+#endif
+
 void Init_raindrops_ext(void)
 {
 	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
+	long tmp = 2;
+
+#ifdef _SC_NPROCESSORS_ONLN
+	tmp = sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+	/* no point in padding on single CPU machines */
+	if (tmp == 1)
+		raindrop_size = sizeof(unsigned long);
+#ifdef _SC_LEVEL1_DCACHE_LINESIZE
+	if (tmp != 1) {
+		tmp = sysconf(_SC_LEVEL1_DCACHE_LINESIZE);
+		if (tmp > 0)
+			raindrop_size = (size_t)tmp;
+	}
+#endif
+	rb_define_const(cRaindrops, "SIZE", SIZET2NUM(raindrop_size));
+
 	rb_define_alloc_func(cRaindrops, alloc);
 
 	rb_define_method(cRaindrops, "initialize", init, 1);

data/ext/raindrops/raindrops_atomic.h

@@ -0,0 +1,23 @@
+/*
+ * use wrappers around libatomic-ops for folks that don't have GCC
+ * or a new enough version of GCC
+ */
+#ifndef HAVE_GCC_ATOMIC_BUILTINS
+#include <atomic_ops.h>
+
+static inline unsigned long
+__sync_add_and_fetch(unsigned long *dst, unsigned long incr)
+{
+        AO_t tmp = AO_fetch_and_add((AO_t *)dst, (AO_t)incr);
+
+        return (unsigned long)tmp + incr;
+}
+
+static inline unsigned long
+__sync_sub_and_fetch(unsigned long *dst, unsigned long incr)
+{
+        AO_t tmp = AO_fetch_and_add((AO_t *)dst, (AO_t)(-(long)incr));
+
+        return (unsigned long)tmp - incr;
+}
+#endif /* HAVE_GCC_ATOMIC_BUILTINS */

data/lib/raindrops.rb

@@ -1,8 +1,8 @@
 # -*- encoding: binary -*-
 class Raindrops
 
-  # Raindrops is currently at version 0.3.0
-  VERSION = '0.3.0'
+  # Raindrops is currently at version 0.4.0
+  VERSION = '0.4.0'
 
   # Used to represent the number of +active+ and +queued+ sockets for
   # a single listen socket across all threads and processes on a

data/test/test_raindrops.rb

@@ -4,6 +4,12 @@ require 'raindrops'
 
 class TestRaindrops < Test::Unit::TestCase
 
+  def test_raindrop_size
+    assert_kind_of Integer, Raindrops::SIZE
+    assert Raindrops::SIZE > 0
+    puts "Raindrops::SIZE = #{Raindrops::SIZE}"
+  end
+
   def test_size
     rd = Raindrops.new(4)
     assert_equal 4, rd.size

data/test/test_raindrops_gc.rb

@@ -4,9 +4,12 @@ require 'raindrops'
 
 class TestRaindropsGc < Test::Unit::TestCase
 
+  # we may need to create more garbage as GC may be less aggressive
+  # about expiring things.  This is completely unrealistic code,
+  # though...
   def test_gc
     assert_nothing_raised do
-      1000000.times { Raindrops.new(24) }
+      1000000.times { |i| Raindrops.new(24); [] }
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: raindrops
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 3
+  - 4
   - 0
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - raindrops hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-10 00:00:00 +00:00
+date: 2010-09-21 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -23,8 +23,7 @@ description: |-
   Raindrops is a real time stats package to show statistics for Rack HTTP
   servers.  It is designed for preforking servers such as Rainbows! and
   Unicorn, but should support any Rack HTTP server under Ruby 1.9, 1.8 and
-  possibly Rubinius (untested) on platforms supporting POSIX shared memory
-  and compiled with GCC (for atomic builtins).
+  possibly Rubinius (untested) on platforms supporting POSIX shared memory.
 email: raindrops@librelist.com
 executables: []
 
@@ -59,6 +58,7 @@ files:
 - ext/raindrops/extconf.rb
 - ext/raindrops/linux_inet_diag.c
 - ext/raindrops/raindrops.c
+- ext/raindrops/raindrops_atomic.h
 - lib/raindrops.rb
 - lib/raindrops/linux.rb
 - lib/raindrops/middleware.rb