mall 1.0.3

data/ext/mall/mall.c

@@ -0,0 +1,301 @@
+#include <ruby.h>
+#include <malloc.h>
+#include <stdio.h>
+
+
+
+static VALUE sym_arena;
+
+static VALUE sym_ordblks;
+
+static VALUE sym_smblks;
+
+static VALUE sym_hblks;
+
+static VALUE sym_hblkhd;
+
+static VALUE sym_usmblks;
+
+static VALUE sym_fsmblks;
+
+static VALUE sym_uordblks;
+
+static VALUE sym_fordblks;
+
+static VALUE sym_keepcost;
+
+
+/*
+ * call-seq:
+ *	Mall.info	-> hash
+ *
+ * Returns a hash with the following keys:
+ *
+ *  :arena      - bytes allocated via sbrk() (and not mmap())
+ *  :ordblks    - number of free (unused) chunks
+ *  :smblks     - number of fastbin blocks[1]
+ *  :hblks      - number of allocated mmap()-ed regions
+ *  :hblkhd     - bytes allocated in mmap()-ed regions
+ *  :usmblks    - maximum total allocated space[1]
+ *  :fsmblks    - space available in freed fastbin blocks[1]
+ *  :uordblks   - total allocated space in use
+ *  :fordblks   - total free space
+ *  :keepcost   - top-most, releasable (via malloc_trim) space
+ *
+ * All values are limited to 32-bit integers.  This uses the limited
+ * mallinfo(3) function, consider using Mall.xml and parsing its output
+ * if you are using glibc (2.10+) with malloc_info(3)
+ *
+ * See also:
+ * http:// gnu.org/software/libc/manual/html_node/Statistics-of-Malloc.html
+ *
+ * [1] - this key is unused by glibc (ptmalloc2)
+ */
+static VALUE info(VALUE klass)
+{
+	VALUE rv = rb_hash_new();
+	struct mallinfo stats = mallinfo(); /* whee aggregate returns :( */
+
+#define MALLINFO_SET(KEY) \
+	rb_hash_aset(rv, sym_##KEY, INT2FIX(stats.KEY))
+
+	MALLINFO_SET(arena);
+	MALLINFO_SET(ordblks);
+	MALLINFO_SET(smblks);
+	MALLINFO_SET(hblks);
+	MALLINFO_SET(hblkhd);
+	MALLINFO_SET(usmblks);
+	MALLINFO_SET(fsmblks);
+	MALLINFO_SET(uordblks);
+	MALLINFO_SET(fordblks);
+	MALLINFO_SET(keepcost);
+#undef MALLINFO_SET
+	return rv;
+}
+
+/*
+ * call-seq:
+ *	Mall.opt(Mall::MMAP_THRESHOLD, 128 * 1024)
+ *
+ * some malloc implementations may not like mallopt() being called after
+ * malloc has been initialized (first call to malloc()).  This is not
+ * the case with glibc malloc.
+ *
+ * See also:
+ * http://gnu.org/software/libc/manual/html_node/Malloc-Tunable-Parameters.html
+ */
+static VALUE opt(VALUE klass, VALUE param, VALUE value)
+{
+	int rv = mallopt(FIX2INT(param), FIX2INT(value));
+
+	return rv == 0 ? Qfalse : Qtrue;
+}
+
+#ifdef HAVE_MALLOC_TRIM
+/*
+ *  call-seq:
+ *	Mall.trim(pad) => true or false
+ *
+ *  Attempt to trim off the top of the heap and release it back to
+ *  the OS. +pad+ represents the amount of free space (in bytes) to
+ *  leave unreleased for future allocations.
+ *
+ *  Returns true if memory was released and false if not.
+ *
+ *  This method is glibc-specific.
+ */
+static VALUE trim(VALUE klass, VALUE pad)
+{
+	unsigned long tmp = NUM2ULONG(pad);
+	int rv = malloc_trim((size_t)tmp);
+
+	return rv == 1 ? Qtrue : Qfalse;
+	return Qfalse;
+}
+#endif /* HAVE_MALLOC_TRIM */
+
+#ifdef HAVE_MALLOC_STATS
+/*
+ * call-seq:
+ *	Mall.dump_stats
+ *
+ * Dump malloc stats to STDERR
+ *
+ * This calls malloc_stats() internally, a function that is glibc-specific
+ */
+static VALUE dump_stats(VALUE klass)
+{
+	fflush(stderr);
+	malloc_stats();
+	fflush(stderr);
+	return Qnil;
+}
+#endif /* HAVE_MALLOC_STATS */
+
+#ifdef HAVE_MALLOC_INFO
+static ID id_ltlt;
+#include <errno.h>
+static void xmlerr(FILE *fp, int err, const char *msg)
+{
+	fclose(fp);
+	errno = err ? err : EIO; /* gotta have something */
+	rb_sys_fail(msg);
+}
+
+/*
+ * call-seq:
+ *	Mall.xml -> XML string
+ *	Mall.xml(options = 0, io = $stderr) -> io
+ *
+ * Called with no arguments, this returns an XML string suitable for
+ * parsing with your favorite XML parser.
+ *
+ * If specified, +options+ must currently be +0+, but is reserved for
+ * future expansion.
+ *
+ * The second optional argument may be any object that responds to "<<"
+ * so it may be an IO, Array, StringIO, or String object among other
+ * things.
+ *
+ * This relies on malloc_info(3) which is only in glibc 2.10+
+ */
+static VALUE xml(int argc, VALUE *argv, VALUE self)
+{
+	int err;
+	long len;
+	VALUE options, out, buf;
+	int xoptions;
+	FILE *fp;
+
+	rb_scan_args(argc, argv, "02", &options, &out);
+	xoptions = NIL_P(options) ? 0 : NUM2INT(options);
+
+	fp = tmpfile();
+	if (fp == NULL)
+		rb_sys_fail("tmpfile");
+
+	err = malloc_info(xoptions, fp);
+	if (err != 0)
+		xmlerr(fp, err, "malloc_info");
+
+	len = ftell(fp);
+	if (len < 0)
+		xmlerr(fp, errno, "ftell");
+
+	rewind(fp);
+	buf = rb_str_new(0, len);
+	if (fread(RSTRING_PTR(buf), 1, len, fp) != (size_t)len)
+		xmlerr(fp, ferror(fp), "fread");
+	fclose(fp);
+
+	if (NIL_P(out))
+		return buf;
+	return rb_funcall(out, id_ltlt, 1, buf);
+}
+#endif /* HAVE_MALLOC_INFO */
+
+/*
+ * Mall is a single module with several singleton methods, most of which
+ * are glibc-specific.  All constants may be used as the first argument
+ * to Mall.opt.
+ */
+void Init_mall(void)
+{
+	VALUE mMall = rb_define_module("Mall");
+	rb_define_singleton_method(mMall, "opt", opt, 2);
+	rb_define_singleton_method(mMall, "info", info, 0);
+#ifdef HAVE_MALLOC_TRIM
+	rb_define_singleton_method(mMall, "trim", trim, 1);
+#endif /* HAVE_MALLOC_TRIM */
+#ifdef HAVE_MALLOC_STATS
+	rb_define_singleton_method(mMall, "dump_stats", dump_stats, 0);
+#endif /* HAVE_MALLOC_STATS */
+#ifdef HAVE_MALLOC_INFO
+	id_ltlt = rb_intern("<<");
+	rb_define_singleton_method(mMall, "xml", xml, -1);
+#endif /* HAVE_MALLOC_INFO*/
+
+
+	sym_arena = ID2SYM(rb_intern("arena"));
+
+	sym_ordblks = ID2SYM(rb_intern("ordblks"));
+
+	sym_smblks = ID2SYM(rb_intern("smblks"));
+
+	sym_hblks = ID2SYM(rb_intern("hblks"));
+
+	sym_hblkhd = ID2SYM(rb_intern("hblkhd"));
+
+	sym_usmblks = ID2SYM(rb_intern("usmblks"));
+
+	sym_fsmblks = ID2SYM(rb_intern("fsmblks"));
+
+	sym_uordblks = ID2SYM(rb_intern("uordblks"));
+
+	sym_fordblks = ID2SYM(rb_intern("fordblks"));
+
+	sym_keepcost = ID2SYM(rb_intern("keepcost"));
+
+
+
+#ifdef M_MXFAST
+	/* max request size for "fastbins" */
+	rb_define_const(mMall, "MXFAST", INT2FIX(M_MXFAST));
+#endif
+
+#ifdef M_NLBLKS
+	/* unused in glibc */
+	rb_define_const(mMall, "NLBLKS", INT2FIX(M_NLBLKS));
+#endif
+
+#ifdef M_GRAIN
+	/* unused in glibc */
+	rb_define_const(mMall, "GRAIN", INT2FIX(M_GRAIN));
+#endif
+
+#ifdef M_KEEP
+	/* unused in glibc */
+	rb_define_const(mMall, "KEEP", INT2FIX(M_KEEP));
+#endif
+
+#ifdef M_TRIM_THRESHOLD
+	/* maximum amount of unused memory at the top of the heapto keep before releasing it back to the kernel */
+	rb_define_const(mMall, "TRIM_THRESHOLD", INT2FIX(M_TRIM_THRESHOLD));
+#endif
+
+#ifdef M_TOP_PAD
+	/* amount of extra space to allocate when allocating from the heap */
+	rb_define_const(mMall, "TOP_PAD", INT2FIX(M_TOP_PAD));
+#endif
+
+#ifdef M_MMAP_THRESHOLD
+	/* the request size threshold for using mmap() (instead of sbrk()) */
+	rb_define_const(mMall, "MMAP_THRESHOLD", INT2FIX(M_MMAP_THRESHOLD));
+#endif
+
+#ifdef M_MMAP_MAX
+	/* the maximum number of active mmap() requests in use at once */
+	rb_define_const(mMall, "MMAP_MAX", INT2FIX(M_MMAP_MAX));
+#endif
+
+#ifdef M_CHECK_ACTION
+	/* bitmask value used for debug message output (glibc) */
+	rb_define_const(mMall, "CHECK_ACTION", INT2FIX(M_CHECK_ACTION));
+#endif
+
+#ifdef M_PERTURB
+	/* perturb memory allocations with a given byte (for debugging) (glibc) */
+	rb_define_const(mMall, "PERTURB", INT2FIX(M_PERTURB));
+#endif
+
+#ifdef M_ARENA_TEST
+	/* initial number of arenas to allocate (glibc 2.10+) */
+	rb_define_const(mMall, "ARENA_TEST", INT2FIX(M_ARENA_TEST));
+#endif
+
+#ifdef M_ARENA_MAX
+	/* maximum number of arenas to allocate (glibc 2.10+) */
+	rb_define_const(mMall, "ARENA_MAX", INT2FIX(M_ARENA_MAX));
+#endif
+
+}

data/ext/mall/mall.c.erb

@@ -0,0 +1,246 @@
+#include <ruby.h>
+#include <malloc.h>
+#include <stdio.h>
+<%
+mallinfo_keys = %w(
+arena
+ordblks
+smblks
+hblks
+hblkhd
+usmblks
+fsmblks
+uordblks
+fordblks
+keepcost
+) %>
+
+<% mallinfo_keys.each { |x| %>
+static VALUE sym_<%= x %>;
+<% } %>
+
+/*
+ * call-seq:
+ *	Mall.info	-> hash
+ *
+ * Returns a hash with the following keys:
+ *
+ *  :arena      - bytes allocated via sbrk() (and not mmap())
+ *  :ordblks    - number of free (unused) chunks
+ *  :smblks     - number of fastbin blocks[1]
+ *  :hblks      - number of allocated mmap()-ed regions
+ *  :hblkhd     - bytes allocated in mmap()-ed regions
+ *  :usmblks    - maximum total allocated space[1]
+ *  :fsmblks    - space available in freed fastbin blocks[1]
+ *  :uordblks   - total allocated space in use
+ *  :fordblks   - total free space
+ *  :keepcost   - top-most, releasable (via malloc_trim) space
+ *
+ * All values are limited to 32-bit integers.  This uses the limited
+ * mallinfo(3) function, consider using Mall.xml and parsing its output
+ * if you are using glibc (2.10+) with malloc_info(3)
+ *
+ * See also:
+ * http:// gnu.org/software/libc/manual/html_node/Statistics-of-Malloc.html
+ *
+ * [1] - this key is unused by glibc (ptmalloc2)
+ */
+static VALUE info(VALUE klass)
+{
+	VALUE rv = rb_hash_new();
+	struct mallinfo stats = mallinfo(); /* whee aggregate returns :( */
+
+#define MALLINFO_SET(KEY) \
+	rb_hash_aset(rv, sym_##KEY, INT2FIX(stats.KEY))
+
+	MALLINFO_SET(arena);
+	MALLINFO_SET(ordblks);
+	MALLINFO_SET(smblks);
+	MALLINFO_SET(hblks);
+	MALLINFO_SET(hblkhd);
+	MALLINFO_SET(usmblks);
+	MALLINFO_SET(fsmblks);
+	MALLINFO_SET(uordblks);
+	MALLINFO_SET(fordblks);
+	MALLINFO_SET(keepcost);
+#undef MALLINFO_SET
+	return rv;
+}
+
+/*
+ * call-seq:
+ *	Mall.opt(Mall::MMAP_THRESHOLD, 128 * 1024)
+ *
+ * some malloc implementations may not like mallopt() being called after
+ * malloc has been initialized (first call to malloc()).  This is not
+ * the case with glibc malloc.
+ *
+ * See also:
+ * http://gnu.org/software/libc/manual/html_node/Malloc-Tunable-Parameters.html
+ */
+static VALUE opt(VALUE klass, VALUE param, VALUE value)
+{
+	int rv = mallopt(FIX2INT(param), FIX2INT(value));
+
+	return rv == 0 ? Qfalse : Qtrue;
+}
+
+#ifdef HAVE_MALLOC_TRIM
+/*
+ *  call-seq:
+ *	Mall.trim(pad) => true or false
+ *
+ *  Attempt to trim off the top of the heap and release it back to
+ *  the OS. +pad+ represents the amount of free space (in bytes) to
+ *  leave unreleased for future allocations.
+ *
+ *  Returns true if memory was released and false if not.
+ *
+ *  This method is glibc-specific.
+ */
+static VALUE trim(VALUE klass, VALUE pad)
+{
+	unsigned long tmp = NUM2ULONG(pad);
+	int rv = malloc_trim((size_t)tmp);
+
+	return rv == 1 ? Qtrue : Qfalse;
+	return Qfalse;
+}
+#endif /* HAVE_MALLOC_TRIM */
+
+#ifdef HAVE_MALLOC_STATS
+/*
+ * call-seq:
+ *	Mall.dump_stats
+ *
+ * Dump malloc stats to STDERR
+ *
+ * This calls malloc_stats() internally, a function that is glibc-specific
+ */
+static VALUE dump_stats(VALUE klass)
+{
+	fflush(stderr);
+	malloc_stats();
+	fflush(stderr);
+	return Qnil;
+}
+#endif /* HAVE_MALLOC_STATS */
+
+#ifdef HAVE_MALLOC_INFO
+static ID id_ltlt;
+#include <errno.h>
+static void xmlerr(FILE *fp, int err, const char *msg)
+{
+	fclose(fp);
+	errno = err ? err : EIO; /* gotta have something */
+	rb_sys_fail(msg);
+}
+
+/*
+ * call-seq:
+ *	Mall.xml -> XML string
+ *	Mall.xml(options = 0, io = $stderr) -> io
+ *
+ * Called with no arguments, this returns an XML string suitable for
+ * parsing with your favorite XML parser.
+ *
+ * If specified, +options+ must currently be +0+, but is reserved for
+ * future expansion.
+ *
+ * The second optional argument may be any object that responds to "<<"
+ * so it may be an IO, Array, StringIO, or String object among other
+ * things.
+ *
+ * This relies on malloc_info(3) which is only in glibc 2.10+
+ */
+static VALUE xml(int argc, VALUE *argv, VALUE self)
+{
+	int err;
+	long len;
+	VALUE options, out, buf;
+	int xoptions;
+	FILE *fp;
+
+	rb_scan_args(argc, argv, "02", &options, &out);
+	xoptions = NIL_P(options) ? 0 : NUM2INT(options);
+
+	fp = tmpfile();
+	if (fp == NULL)
+		rb_sys_fail("tmpfile");
+
+	err = malloc_info(xoptions, fp);
+	if (err != 0)
+		xmlerr(fp, err, "malloc_info");
+
+	len = ftell(fp);
+	if (len < 0)
+		xmlerr(fp, errno, "ftell");
+
+	rewind(fp);
+	buf = rb_str_new(0, len);
+	if (fread(RSTRING_PTR(buf), 1, len, fp) != (size_t)len)
+		xmlerr(fp, ferror(fp), "fread");
+	fclose(fp);
+
+	if (NIL_P(out))
+		return buf;
+	return rb_funcall(out, id_ltlt, 1, buf);
+}
+#endif /* HAVE_MALLOC_INFO */
+
+/*
+ * Mall is a single module with several singleton methods, most of which
+ * are glibc-specific.  All constants may be used as the first argument
+ * to Mall.opt.
+ */
+void Init_mall(void)
+{
+	VALUE mMall = rb_define_module("Mall");
+	rb_define_singleton_method(mMall, "opt", opt, 2);
+	rb_define_singleton_method(mMall, "info", info, 0);
+#ifdef HAVE_MALLOC_TRIM
+	rb_define_singleton_method(mMall, "trim", trim, 1);
+#endif /* HAVE_MALLOC_TRIM */
+#ifdef HAVE_MALLOC_STATS
+	rb_define_singleton_method(mMall, "dump_stats", dump_stats, 0);
+#endif /* HAVE_MALLOC_STATS */
+#ifdef HAVE_MALLOC_INFO
+	id_ltlt = rb_intern("<<");
+	rb_define_singleton_method(mMall, "xml", xml, -1);
+#endif /* HAVE_MALLOC_INFO*/
+
+<% mallinfo_keys.each { |x| %>
+	sym_<%= x %> = ID2SYM(rb_intern("<%= x %>"));
+<% } %>
+
+<%
+{
+  :mxfast => 'max request size for "fastbins"',
+  :nlblks => 'unused in glibc',
+  :grain => 'unused in glibc',
+  :keep => 'unused in glibc',
+  :trim_threshold =>
+    'maximum amount of unused memory at the top of the heap' \
+    'to keep before releasing it back to the kernel',
+  :top_pad =>
+    'amount of extra space to allocate when allocating from the heap',
+  :mmap_threshold =>
+    'the request size threshold for using mmap() (instead of sbrk())',
+  :mmap_max =>
+    'the maximum number of active mmap() requests in use at once',
+  :check_action =>
+    'bitmask value used for debug message output (glibc)',
+  :perturb =>
+    'perturb memory allocations with a given byte (for debugging) (glibc)',
+  :arena_test => 'initial number of arenas to allocate (glibc 2.10+)',
+  :arena_max => 'maximum number of arenas to allocate (glibc 2.10+)',
+}.each { |opt, doc|
+  opt = opt.to_s.upcase!
+  m_opt = "M_#{opt}"
+%>
+#ifdef <%= m_opt %>
+	/* <%= doc %> */
+	rb_define_const(mMall, "<%= opt %>", INT2FIX(<%= m_opt %>));
+#endif
+<% } %>
+}

data/mall.gemspec

@@ -0,0 +1,21 @@
+manifest = File.exist?('.manifest') ?
+  IO.readlines('.manifest').map!(&:chomp!) : `git ls-files`.split("\n")
+
+Gem::Specification.new do |s|
+  s.name = %q{mall}
+  s.version = (ENV["VERSION"] || '1.0.3').dup
+  s.authors = ["#{s.name} hackers (mall@yhbt.net)", "Ivan Prisyazhnyy"]
+  s.description = File.read('README').split("\n\n")[1] + "\n\n" +
+    "1.0.3 fixes minor issues to be compatible with gem install and rake."
+  s.email = ["john.koepi@gmail.com", "mall@yhbt.net"]
+  s.extra_rdoc_files = IO.readlines('.document').map!(&:chomp!).keep_if do |f|
+    File.exist?(f)
+  end
+  s.require_paths = %w(ext)
+  s.files = manifest
+  s.homepage = 'https://github.com/sitano/mall'
+  s.summary =  'access malloc tuning/reporting functions + glibc extras. linux only.'
+  s.test_files = Dir["test/test_*.rb"]
+  s.extensions = %w(ext/mall/extconf.rb)
+  s.licenses = ["LGPL"]
+end

data/pkg.mk

@@ -0,0 +1,150 @@
+RUBY = ruby
+RAKE = rake
+RSYNC = rsync
+OLDDOC = olddoc
+RDOC = rdoc
+
+GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
+	@./GIT-VERSION-GEN
+-include GIT-VERSION-FILE
+-include local.mk
+DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts RbConfig::CONFIG["DLEXT"]')
+RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
+RUBY_ENGINE := $(shell $(RUBY) -e 'puts((RUBY_ENGINE rescue "ruby"))')
+lib := lib
+
+ext := $(firstword $(wildcard ext/*))
+ifneq ($(ext),)
+ext_pfx := tmp/ext/$(RUBY_ENGINE)-$(RUBY_VERSION)
+ext_h := $(wildcard $(ext)/*/*.h $(ext)/*.h)
+ext_src := $(wildcard $(ext)/*.c $(ext_h))
+ext_pfx_src := $(addprefix $(ext_pfx)/,$(ext_src))
+ext_d := $(ext_pfx)/$(ext)/.d
+$(ext)/extconf.rb: $(wildcard $(ext)/*.h)
+	@>> $@
+$(ext_d):
+	@mkdir -p $(@D)
+	@> $@
+$(ext_pfx)/$(ext)/%: $(ext)/% $(ext_d)
+	install -m 644 $< $@
+$(ext_pfx)/$(ext)/Makefile: $(ext)/extconf.rb $(ext_d) $(ext_h)
+	$(RM) -f $(@D)/*.o
+	cd $(@D) && $(RUBY) $(CURDIR)/$(ext)/extconf.rb $(EXTCONF_ARGS)
+ext_sfx := _ext.$(DLEXT)
+ext_dl := $(ext_pfx)/$(ext)/$(notdir $(ext)_ext.$(DLEXT))
+$(ext_dl): $(ext_src) $(ext_pfx_src) $(ext_pfx)/$(ext)/Makefile
+	@echo $^ == $@
+	$(MAKE) -C $(@D)
+lib := $(lib):$(ext_pfx)/$(ext)
+build: $(ext_dl)
+else
+build:
+endif
+
+pkg_extra += GIT-VERSION-FILE NEWS LATEST
+NEWS: GIT-VERSION-FILE .olddoc.yml
+	$(OLDDOC) prepare
+LATEST: NEWS
+
+manifest:
+	$(RM) .manifest
+	$(MAKE) .manifest
+
+.manifest: $(pkg_extra)
+	(git ls-files && for i in $@ $(pkg_extra); do echo $$i; done) | \
+		LC_ALL=C sort > $@+
+	cmp $@+ $@ || mv $@+ $@
+	$(RM) $@+
+
+doc:: .document .olddoc.yml $(pkg_extra) $(PLACEHOLDERS)
+	-find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
+	-find ext -type f -name '*.rbc' -exec rm -f '{}' ';'
+	$(RM) -r doc
+	$(RDOC) -f dark216
+	$(OLDDOC) merge
+	install -m644 COPYING doc/COPYING
+	install -m644 NEWS doc/NEWS
+	install -m644 NEWS.atom.xml doc/NEWS.atom.xml
+	install -m644 $(shell LC_ALL=C grep '^[A-Z]' .document) doc/
+
+ifneq ($(VERSION),)
+pkggem := pkg/$(rfpackage)-$(VERSION).gem
+pkgtgz := pkg/$(rfpackage)-$(VERSION).tgz
+
+# ensures we're actually on the tagged $(VERSION), only used for release
+verify:
+	test x"$(shell umask)" = x0022
+	git rev-parse --verify refs/tags/v$(VERSION)^{}
+	git diff-index --quiet HEAD^0
+	test $$(git rev-parse --verify HEAD^0) = \
+	     $$(git rev-parse --verify refs/tags/v$(VERSION)^{})
+
+fix-perms:
+	-git ls-tree -r HEAD | awk '/^100644 / {print $$NF}' | xargs chmod 644
+	-git ls-tree -r HEAD | awk '/^100755 / {print $$NF}' | xargs chmod 755
+
+gem: $(pkggem)
+
+install-gem: $(pkggem)
+	gem install --local $(CURDIR)/$<
+
+$(pkggem): manifest fix-perms
+	gem build $(rfpackage).gemspec
+	mkdir -p pkg
+	mv $(@F) $@
+
+$(pkgtgz): distdir = $(basename $@)
+$(pkgtgz): HEAD = v$(VERSION)
+$(pkgtgz): manifest fix-perms
+	@test -n "$(distdir)"
+	$(RM) -r $(distdir)
+	mkdir -p $(distdir)
+	tar cf - $$(cat .manifest) | (cd $(distdir) && tar xf -)
+	cd pkg && tar cf - $(basename $(@F)) | gzip -9 > $(@F)+
+	mv $@+ $@
+
+package: $(pkgtgz) $(pkggem)
+
+release:: verify package
+	# push gem to RubyGems.org
+	gem push $(pkggem)
+else
+gem install-gem: GIT-VERSION-FILE
+	$(MAKE) $@ VERSION=$(GIT_VERSION)
+endif
+
+all:: check
+test_units := $(wildcard test/test_*.rb)
+test: check
+check: test-unit
+test-unit: $(test_units)
+$(test_units): build
+	$(VALGRIND) $(RUBY) -w -I $(lib) $@ $(RUBY_TEST_OPTS)
+
+# this requires GNU coreutils variants
+ifneq ($(RSYNC_DEST),)
+publish_doc:
+	-git set-file-times
+	$(MAKE) doc
+	$(MAKE) doc_gz
+	$(RSYNC) -av doc/ $(RSYNC_DEST)/
+	git ls-files | xargs touch
+endif
+
+# Create gzip variants of the same timestamp as the original so nginx
+# "gzip_static on" can serve the gzipped versions directly.
+doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.gz$$')
+doc_gz:
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+check-warnings:
+	@(for i in $$(git ls-files '*.rb'| grep -v '^setup\.rb$$'); \
+	  do $(RUBY) -d -W2 -c $$i; done) | grep -v '^Syntax OK$$' || :
+
+ifneq ($(PLACEHOLDERS),)
+$(PLACEHOLDERS):
+	echo olddoc_placeholder > $@
+endif
+
+.PHONY: all .FORCE-GIT-VERSION-FILE doc check test $(test_units) manifest
+.PHONY: check-warnings