mwrap 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8559afec1946b7f545c944085aac5e205601deb82fa9f1529785dd3ef7526e5a
-  data.tar.gz: 34ea90410103ec59f367baa00e1e4df6424fe67af8608b5c7a3a0cb66fec2440
+  metadata.gz: 406933abeb7d63d1304c63f0f5aa7a2f4deb9ecb1820816886df8bfcf2d01601
+  data.tar.gz: 214975358778869db55691d8ddcac9e078cc16be6870e143094bb837d88551eb
 SHA512:
-  metadata.gz: ff91f6f250e7a18cb465a6dc04ddee374411a10a92cd1b3227e09a4ccd0be1b8597f475f71d5061bd5bc36e8c0418ce3bf6faa3a78b37aec5d21b0340f736031
-  data.tar.gz: 06311f2949ae4dae6bd2d0e95e6b0d147b44b6bae6cd4464e4c1d160fc1f5f3f99b2a6a3a3e711a10b8894da3bdb6220ccfeb72dfb18545170edbbc65dbad225
+  metadata.gz: a0a353c1ed720192b6dc63699d7d53661fc80c204429df3c93d4795b39cdec1d0e1b83c90e4250ddee11abd1911d578dd4f83516368a787a21fb1327de0ac32b
+  data.tar.gz: 28fd47f870ec74cd4c15570e6f6df0b9ee80ff30eb460185f841d2bc796836dd8aa6d82a7e3304bf811d22acc2dfb3e00fa4f92143a0cbb04dbd78e99ae7231e

data/.document

@@ -1,2 +1,3 @@
 ext/mwrap/mwrap.c
 lib/mwrap_rack.rb
+README

data/.gitignore

@@ -4,3 +4,6 @@
 /pkg
 /*.gem
 /doc
+/NEWS
+/NEWS.atom.xml
+/LATEST

data/.olddoc.yml

@@ -0,0 +1,10 @@
+---
+cgit_url: https://80x24.org/mwrap.git
+git_url: https://80x24.org/mwrap.git
+rdoc_url: https://80x24.org/mwrap/
+ml_url: https://80x24.org/mwrap-public/
+public_email: mwrap-public@80x24.org
+nntp_url:
+- nntps://news.public-inbox.org/inbox.comp.lang.ruby.mwrap
+imap_url:
+- imaps://;AUTH=ANONYMOUS@80x24.org/inbox.comp.lang.ruby.mwrap.0

data/MANIFEST

@@ -1,5 +1,6 @@
 .document
 .gitignore
+.olddoc.yml
 COPYING
 MANIFEST
 README

data/README

@@ -67,16 +67,18 @@ first two columns to find the hottest malloc locations.
 mwrap 2.0.0+ also supports a Rack application endpoint,
 it is documented at:
 
-	https://80x24.org/mwrap/MwrapRack.html
+https://80x24.org/mwrap/MwrapRack.html
 
 == Known problems
 
 * 32-bit machines are prone to overflow (WONTFIX)
 
-== Mail archives and list:
+== Public mail archives and contact info:
 
-	https://80x24.org/mwrap-public/
-	nntp://80x24.org/inbox.comp.lang.ruby.mwrap
+* https://80x24.org/mwrap-public/
+* nntps://80x24.org/inbox.comp.lang.ruby.mwrap
+* imaps://;AUTH=ANONYMOUS@80x24.org/inbox.comp.lang.ruby.mwrap.0
+* https://80x24.org/mwrap-public/_/text/help/#pop3
 
 No subscription will ever be required to post, but HTML mail
 will be rejected:
@@ -88,7 +90,7 @@ will be rejected:
 	git clone https://80x24.org/mwrap.git
 
 Send all patches and pull requests (use "git request-pull" to format) to
-the mailing list.  We do not use centralized or proprietary messaging
+mwrap-public@80x24.org.  We do not use centralized or proprietary messaging
 systems.
 
 == License

data/Rakefile

@@ -1,4 +1,4 @@
-# Copyright (C) 2018 mwrap hackers <mwrap-public@80x24.org>
+# Copyright (C) mwrap hackers <mwrap-public@80x24.org>
 # License: GPL-2.0+ <https://www.gnu.org/licenses/gpl-2.0.txt>
 require 'rake/testtask'
 begin
@@ -14,3 +14,31 @@ task :default => :compile
 
 c_files = File.readlines('MANIFEST').grep(%r{ext/.*\.[ch]$}).map!(&:chomp!)
 task 'compile:mwrap' => c_files
+
+olddoc = ENV['OLDDOC'] || 'olddoc'
+rdoc = ENV['RDOC'] || 'rdoc'
+task :rsync_docs do
+  require 'fileutils'
+  top = %w(README COPYING LATEST NEWS NEWS.atom.xml)
+  system("git", "set-file-times")
+  dest = ENV["RSYNC_DEST"] || "80x24.org:/srv/80x24/mwrap/"
+  FileUtils.rm_rf('doc')
+  sh "#{olddoc} prepare"
+  sh "#{rdoc} -f dark216" # dark216 requires olddoc 1.7+
+  File.unlink('doc/created.rid') rescue nil
+  File.unlink('doc/index.html') rescue nil
+  FileUtils.cp(top, 'doc')
+  sh "#{olddoc} merge"
+
+  Dir['doc/**/*'].each do |txt|
+    st = File.stat(txt)
+    if st.file?
+      gz = "#{txt}.gz"
+      tmp = "#{gz}.#$$"
+      sh("gzip --rsyncable -9 <#{txt} >#{tmp}")
+      File.utime(st.atime, st.mtime, tmp) # make nginx gzip_static happy
+      File.rename(tmp, gz)
+    end
+  end
+  sh("rsync --chmod=Fugo=r #{ENV['RSYNC_OPT']} -av doc/ #{dest}/")
+end

data/bin/mwrap

@@ -1,6 +1,6 @@
 #!/usr/bin/ruby
 # frozen_string_literal: true
-# Copyright (C) 2018 mwrap hackers <mwrap-public@80x24.org>
+# Copyright (C) mwrap hackers <mwrap-public@80x24.org>
 # License: GPL-2.0+ <https://www.gnu.org/licenses/gpl-2.0.txt>
 require 'mwrap'
 mwrap_so = $".grep(%r{/mwrap\.so\z})[0] or abort "mwrap.so not loaded"

data/ext/mwrap/extconf.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# Copyright (C) 2018 mwrap hackers <mwrap-public@80x24.org>
+# Copyright (C) mwrap hackers <mwrap-public@80x24.org>
 # License: GPL-2.0+ <https://www.gnu.org/licenses/gpl-2.0.txt>
 require 'mkmf'
 
@@ -25,4 +25,11 @@ else
   abort 'missing __builtin_add_overflow'
 end
 
+begin
+  if n = GC::INTERNAL_CONSTANTS[:HEAP_PAGE_SIZE]
+    $defs << "-DHEAP_PAGE_SIZE=#{n}"
+  end
+rescue NameError
+end
+
 create_makefile 'mwrap'

data/ext/mwrap/mwrap.c

@@ -1,9 +1,9 @@
 /*
- * Copyright (C) 2018 mwrap hackers <mwrap-public@80x24.org>
+ * Copyright (C) mwrap hackers <mwrap-public@80x24.org>
  * License: GPL-2.0+ <https://www.gnu.org/licenses/gpl-2.0.txt>
  */
 #define _LGPL_SOURCE /* allows URCU to inline some stuff */
-#include <ruby/ruby.h>
+#include <ruby.h> /* defines HAVE_RUBY_RACTOR_H on 3.0+ */
 #include <ruby/thread.h>
 #include <ruby/io.h>
 #include <execinfo.h>
@@ -22,19 +22,48 @@
 #include <urcu/rculist.h>
 #include "jhash.h"
 
+#if __STDC_VERSION__ >= 201112
+#	define MWRAP_TSD _Thread_local
+#elif defined(__GNUC__)
+#	define MWRAP_TSD __thread
+#else
+#	error _Thread_local nor __thread supported
+#endif
+
 static ID id_uminus;
-static unsigned int track_memalign;
 const char *rb_source_location_cstr(int *line); /* requires 2.6.0dev */
 extern int __attribute__((weak)) ruby_thread_has_gvl_p(void);
+
+#ifdef HAVE_RUBY_RACTOR_H /* Ruby 3.0+ */
+extern MWRAP_TSD void * __attribute__((weak)) ruby_current_ec;
+#else /* Ruby 2.6-2.7 */
 extern void * __attribute__((weak)) ruby_current_execution_context_ptr;
+#	define ruby_current_ec ruby_current_execution_context_ptr
+#endif
 extern void * __attribute__((weak)) ruby_current_vm_ptr; /* for rb_gc_count */
 extern size_t __attribute__((weak)) rb_gc_count(void);
 extern VALUE __attribute__((weak)) rb_cObject;
+extern VALUE __attribute__((weak)) rb_eTypeError;
 extern VALUE __attribute__((weak)) rb_yield(VALUE);
 
+static size_t total_bytes_inc, total_bytes_dec;
+
 /* true for glibc/dlmalloc/ptmalloc, not sure about jemalloc */
 #define ASSUMED_MALLOC_ALIGNMENT (sizeof(void *) * 2)
 
+/* match values in Ruby gc.c */
+#define HEAP_PAGE_ALIGN_LOG 14
+enum {
+	HEAP_PAGE_ALIGN = (1UL << HEAP_PAGE_ALIGN_LOG)
+#ifndef HEAP_PAGE_SIZE /* Ruby 2.6-2.7 only */
+	,
+	REQUIRED_SIZE_BY_MALLOC = (sizeof(size_t) * 5),
+	HEAP_PAGE_SIZE = (HEAP_PAGE_ALIGN - REQUIRED_SIZE_BY_MALLOC)
+#endif
+};
+
+#define IS_HEAP_PAGE_BODY ((struct src_loc *)-1)
+
 int __attribute__((weak)) ruby_thread_has_gvl_p(void)
 {
 	return 0;
@@ -63,7 +92,7 @@ static int resolving_malloc;
 	} \
 } while (0)
 
-static __thread size_t locating;
+static MWRAP_TSD size_t locating;
 static size_t generation;
 static size_t page_size;
 static struct cds_lfht *totals;
@@ -94,7 +123,6 @@ lfht_new(void)
 __attribute__((constructor)) static void resolve_malloc(void)
 {
 	int err;
-	const char *opt;
 	++locating;
 
 #ifdef __FreeBSD__
@@ -128,8 +156,8 @@ __attribute__((constructor)) static void resolve_malloc(void)
 		_exit(1);
 	}
 #endif /* !FreeBSD */
-	totals = lfht_new();
-	if (!totals)
+	CMM_STORE_SHARED(totals, lfht_new());
+	if (!CMM_LOAD_SHARED(totals))
 		fprintf(stderr, "failed to allocate totals table\n");
 
 	err = pthread_atfork(call_rcu_before_fork,
@@ -138,19 +166,21 @@ __attribute__((constructor)) static void resolve_malloc(void)
 	if (err)
 		fprintf(stderr, "pthread_atfork failed: %s\n", strerror(err));
 	page_size = sysconf(_SC_PAGESIZE);
-	opt = getenv("MWRAP");
-	if (opt && (opt = strstr(opt, "memalign:"))) {
-		if (!sscanf(opt, "memalign:%u", &track_memalign))
-			fprintf(stderr, "not an unsigned int: %s\n", opt);
-	}
 	--locating;
 }
 
+#ifdef NDEBUG
+#define QUIET_CC_WARNING(var) (void)var;
+#else
+#define QUIET_CC_WARNING(var)
+#endif
+
 static void
 mutex_lock(pthread_mutex_t *m)
 {
 	int err = pthread_mutex_lock(m);
 	assert(err == 0);
+	QUIET_CC_WARNING(err)
 }
 
 static void
@@ -158,6 +188,7 @@ mutex_unlock(pthread_mutex_t *m)
 {
 	int err = pthread_mutex_unlock(m);
 	assert(err == 0);
+	QUIET_CC_WARNING(err)
 }
 
 #ifndef HAVE_MEMPCPY
@@ -208,9 +239,35 @@ static char *int2str(int num, char *dst, size_t * size)
 static int has_ec_p(void)
 {
 	return (ruby_thread_has_gvl_p() && ruby_current_vm_ptr &&
-		ruby_current_execution_context_ptr);
+		ruby_current_ec);
 }
 
+struct acc {
+	uint64_t nr;
+	int64_t min;
+	int64_t max;
+	double m2;
+	double mean;
+};
+
+#define ACC_INIT(name) { .nr=0, .min=INT64_MAX, .max=-1, .m2=0, .mean=0 }
+
+/* for tracking 16K-aligned heap page bodies (protected by GVL) */
+struct {
+	pthread_mutex_t lock;
+	struct cds_list_head bodies;
+	struct cds_list_head freed;
+
+	struct acc alive;
+	struct acc reborn;
+} hpb_stats = {
+	.lock = PTHREAD_MUTEX_INITIALIZER,
+	.bodies = CDS_LIST_HEAD_INIT(hpb_stats.bodies),
+	.freed = CDS_LIST_HEAD_INIT(hpb_stats.freed),
+	.alive = ACC_INIT(hpb_stats.alive),
+	.reborn = ACC_INIT(hpb_stats.reborn)
+};
+
 /* allocated via real_malloc/real_free */
 struct src_loc {
 	pthread_mutex_t *mtx;
@@ -235,6 +292,9 @@ struct alloc_hdr {
 			struct src_loc *loc;
 		} live;
 		struct rcu_head dead;
+		struct {
+			size_t at; /* rb_gc_count() */
+		} hpb_freed;
 	} as;
 	void *real; /* what to call real_free on */
 	size_t size;
@@ -274,7 +334,65 @@ static int loc_eq(struct cds_lfht_node *node, const void *key)
 		memcmp(k->k, existing->k, loc_size(k)) == 0);
 }
 
-static struct src_loc *totals_add_rcu(struct src_loc *k)
+/* note: not atomic */
+static void
+acc_add(struct acc *acc, size_t val)
+{
+	double delta = val - acc->mean;
+	uint64_t nr = ++acc->nr;
+
+	/* just don't divide-by-zero if we ever hit this (unlikely :P) */
+	if (nr)
+		acc->mean += delta / nr;
+
+	acc->m2 += delta * (val - acc->mean);
+	if ((int64_t)val < acc->min)
+		acc->min = (int64_t)val;
+	if ((int64_t)val > acc->max)
+		acc->max = (int64_t)val;
+}
+
+#if SIZEOF_LONG == 8
+# define INT64toNUM(x) LONG2NUM((long)x)
+#elif defined(HAVE_LONG_LONG) && SIZEOF_LONG_LONG == 8
+# define INT64toNUM(x) LL2NUM((LONG_LONG)x)
+#endif
+
+static VALUE
+acc_max(const struct acc *acc)
+{
+	return INT64toNUM(acc->max);
+}
+
+static VALUE
+acc_min(const struct acc *acc)
+{
+	return acc->min == INT64_MAX ? INT2FIX(-1) : INT64toNUM(acc->min);
+}
+
+static VALUE
+acc_mean(const struct acc *acc)
+{
+	return DBL2NUM(acc->nr ? acc->mean : HUGE_VAL);
+}
+
+static double
+acc_stddev_dbl(const struct acc *acc)
+{
+	if (acc->nr > 1) {
+		double variance = acc->m2 / (acc->nr - 1);
+		return sqrt(variance);
+	}
+	return 0.0;
+}
+
+static VALUE
+acc_stddev(const struct acc *acc)
+{
+	return DBL2NUM(acc_stddev_dbl(acc));
+}
+
+static struct src_loc *totals_add_rcu(const struct src_loc *k)
 {
 	struct cds_lfht_iter iter;
 	struct cds_lfht_node *cur;
@@ -282,7 +400,7 @@ static struct src_loc *totals_add_rcu(struct src_loc *k)
 	struct cds_lfht *t;
 
 again:
-	t = rcu_dereference(totals);
+	t = CMM_LOAD_SHARED(totals);
 	if (!t) goto out_unlock;
 	cds_lfht_lookup(t, k->hval, loc_eq, k, &iter);
 	cur = cds_lfht_iter_get_node(&iter);
@@ -324,9 +442,11 @@ static struct src_loc *update_stats_rcu_lock(size_t size, uintptr_t caller)
 	static const size_t xlen = sizeof(caller);
 	char *dst;
 
-	if (caa_unlikely(!totals)) return 0;
+	if (caa_unlikely(!CMM_LOAD_SHARED(totals))) return 0;
 	if (locating++) goto out; /* do not recurse into another *alloc */
 
+	uatomic_add(&total_bytes_inc, size);
+
 	rcu_read_lock();
 	if (has_ec_p()) {
 		int line;
@@ -387,9 +507,10 @@ void free(void *p)
 		struct src_loc *l = h->as.live.loc;
 
 		if (!real_free) return; /* oh well, leak a little */
-		if (l) {
+		if (l && l != IS_HEAP_PAGE_BODY) {
 			size_t age = generation - h->as.live.gen;
 
+			uatomic_add(&total_bytes_dec, h->size);
 			uatomic_set(&h->size, 0);
 			uatomic_add(&l->frees, 1);
 			uatomic_add(&l->age_total, age);
@@ -401,8 +522,20 @@ void free(void *p)
 			mutex_unlock(l->mtx);
 
 			call_rcu(&h->as.dead, free_hdr_rcu);
-		}
-		else {
+		} else if (l == IS_HEAP_PAGE_BODY) {
+			size_t gen = generation;
+			size_t age = gen - h->as.live.gen;
+
+			h->as.hpb_freed.at = gen;
+
+			mutex_lock(&hpb_stats.lock);
+			acc_add(&hpb_stats.alive, age);
+
+			/* hpb_stats.bodies => hpb_stats.freed */
+			cds_list_move(&h->anode, &hpb_stats.freed);
+
+			mutex_unlock(&hpb_stats.lock);
+		} else {
 			real_free(h->real);
 		}
 	}
@@ -429,7 +562,7 @@ static size_t size_align(size_t size, size_t alignment)
 	return ((size + (alignment - 1)) & ~(alignment - 1));
 }
 
-static bool ptr_is_aligned(void *ptr, size_t alignment)
+static bool ptr_is_aligned(const void *ptr, size_t alignment)
 {
 	return ((uintptr_t)ptr & (alignment - 1)) == 0;
 }
@@ -468,18 +601,66 @@ internal_memalign(void **pp, size_t alignment, size_t size, uintptr_t caller)
 	    __builtin_add_overflow(asize, sizeof(struct alloc_hdr), &asize))
 		return ENOMEM;
 
-	/* assert(asize == (alignment + size + sizeof(struct alloc_hdr))); */
-	l = track_memalign ? update_stats_rcu_lock(size, caller) : 0;
-	real = real_malloc(asize);
-	if (real) {
-		void *p = hdr2ptr(real);
-		if (!ptr_is_aligned(p, alignment))
-			p = ptr_align(p, alignment);
-		h = ptr2hdr(p);
-		alloc_insert_rcu(l, h, size, real);
+
+	if (alignment == HEAP_PAGE_ALIGN && size == HEAP_PAGE_SIZE) {
+		if (has_ec_p()) generation = rb_gc_count();
+		l = IS_HEAP_PAGE_BODY;
+	} else {
+		l = update_stats_rcu_lock(size, caller);
+	}
+
+	if (l == IS_HEAP_PAGE_BODY) {
+		void *p;
+		size_t gen = generation;
+
+		mutex_lock(&hpb_stats.lock);
+
+		/* reuse existing entry */
+		if (!cds_list_empty(&hpb_stats.freed)) {
+			size_t deathspan;
+
+			h = cds_list_first_entry(&hpb_stats.freed,
+						 struct alloc_hdr, anode);
+			/* hpb_stats.freed => hpb_stats.bodies */
+			cds_list_move(&h->anode, &hpb_stats.bodies);
+			assert(h->size == size);
+			assert(h->real);
+			real = h->real;
+			p = hdr2ptr(h);
+			assert(ptr_is_aligned(p, alignment));
+
+			deathspan = gen - h->as.hpb_freed.at;
+			acc_add(&hpb_stats.reborn, deathspan);
+		}
+		else {
+			real = real_malloc(asize);
+			if (!real) return ENOMEM;
+
+			p = hdr2ptr(real);
+			if (!ptr_is_aligned(p, alignment))
+				p = ptr_align(p, alignment);
+			h = ptr2hdr(p);
+			h->size = size;
+			h->real = real;
+			cds_list_add(&h->anode, &hpb_stats.bodies);
+		}
+		mutex_unlock(&hpb_stats.lock);
+		h->as.live.loc = l;
+		h->as.live.gen = gen;
 		*pp = p;
 	}
-	update_stats_rcu_unlock(l);
+	else {
+		real = real_malloc(asize);
+		if (real) {
+			void *p = hdr2ptr(real);
+			if (!ptr_is_aligned(p, alignment))
+				p = ptr_align(p, alignment);
+			h = ptr2hdr(p);
+			alloc_insert_rcu(l, h, size, real);
+			*pp = p;
+		}
+		update_stats_rcu_unlock(l);
+	}
 
 	return real ? 0 : ENOMEM;
 }
@@ -487,16 +668,14 @@ internal_memalign(void **pp, size_t alignment, size_t size, uintptr_t caller)
 static void *
 memalign_result(int err, void *p)
 {
-	if (caa_unlikely(err)) {
+	if (caa_unlikely(err))
 		errno = err;
-		return 0;
-	}
 	return p;
 }
 
 void *memalign(size_t alignment, size_t size)
 {
-	void *p;
+	void *p = NULL;
 	int err = internal_memalign(&p, alignment, size, RETURN_ADDRESS(0));
 	return memalign_result(err, p);
 }
@@ -511,7 +690,7 @@ void cfree(void *) __attribute__((alias("free")));
 
 void *valloc(size_t size)
 {
-	void *p;
+	void *p = NULL;
 	int err = internal_memalign(&p, page_size, size, RETURN_ADDRESS(0));
 	return memalign_result(err, p);
 }
@@ -529,7 +708,7 @@ void *valloc(size_t size)
 void *pvalloc(size_t size)
 {
 	size_t alignment = page_size;
-	void *p;
+	void *p = NULL;
 	int err;
 
 	if (add_overflow_p(size, alignment)) {
@@ -652,7 +831,7 @@ static void *dump_to_file(void *x)
 
 	++locating;
 	rcu_read_lock();
-	t = rcu_dereference(totals);
+	t = CMM_LOAD_SHARED(totals);
 	if (!t)
 		goto out_unlock;
 	cds_lfht_for_each_entry(t, &iter, l, hnode) {
@@ -710,14 +889,18 @@ static VALUE mwrap_dump(int argc, VALUE * argv, VALUE mod)
 	return Qnil;
 }
 
+/* The whole operation is not remotely atomic... */
 static void *totals_reset(void *ign)
 {
 	struct cds_lfht *t;
 	struct cds_lfht_iter iter;
 	struct src_loc *l;
 
+	uatomic_set(&total_bytes_inc, 0);
+	uatomic_set(&total_bytes_dec, 0);
+
 	rcu_read_lock();
-	t = rcu_dereference(totals);
+	t = CMM_LOAD_SHARED(totals);
 	cds_lfht_for_each_entry(t, &iter, l, hnode) {
 		uatomic_set(&l->total, 0);
 		uatomic_set(&l->allocations, 0);
@@ -785,7 +968,7 @@ static VALUE dump_each_rcu(VALUE x)
 	struct cds_lfht_iter iter;
 	struct src_loc *l;
 
-	t = rcu_dereference(totals);
+	t = CMM_LOAD_SHARED(totals);
 	cds_lfht_for_each_entry(t, &iter, l, hnode) {
 		VALUE v[6];
 		if (l->total <= a->min) continue;
@@ -889,9 +1072,9 @@ static VALUE mwrap_aref(VALUE mod, VALUE loc)
 
 	if (!k) return val;
 
+	t = CMM_LOAD_SHARED(totals);
+	if (!t) return val;
 	rcu_read_lock();
-	t = rcu_dereference(totals);
-	if (!t) goto out_unlock;
 
 	cds_lfht_lookup(t, k->hval, loc_eq, k, &iter);
 	cur = cds_lfht_iter_get_node(&iter);
@@ -899,7 +1082,6 @@ static VALUE mwrap_aref(VALUE mod, VALUE loc)
 		l = caa_container_of(cur, struct src_loc, hnode);
 		val = TypedData_Wrap_Struct(cSrcLoc, &src_loc_type, l);
 	}
-out_unlock:
 	rcu_read_unlock();
 	return val;
 }
@@ -1033,6 +1215,89 @@ static VALUE mwrap_quiet(VALUE mod)
 	return rb_ensure(rb_yield, SIZET2NUM(cur), reset_locating, 0);
 }
 
+/*
+ * total bytes allocated as tracked by mwrap
+ */
+static VALUE total_inc(VALUE mod)
+{
+	return SIZET2NUM(total_bytes_inc);
+}
+
+/*
+ * total bytes freed as tracked by mwrap
+ */
+static VALUE total_dec(VALUE mod)
+{
+	return SIZET2NUM(total_bytes_dec);
+}
+
+static VALUE hpb_each_yield(VALUE ignore)
+{
+	struct alloc_hdr *h, *next;
+
+	cds_list_for_each_entry_safe(h, next, &hpb_stats.bodies, anode) {
+		VALUE v[2]; /* [ generation, address ] */
+		void *addr = hdr2ptr(h);
+		assert(ptr_is_aligned(addr, HEAP_PAGE_ALIGN));
+		v[0] = LONG2NUM((long)addr);
+		v[1] = SIZET2NUM(h->as.live.gen);
+		rb_yield_values2(2, v);
+	}
+	return Qnil;
+}
+
+/*
+ * call-seq:
+ *
+ *     Mwrap::HeapPageBody.each { |gen, addr| } -> Integer
+ *
+ * Yields the generation (GC.count) the heap page body was created
+ * and address of the heap page body as an Integer.  Returns the
+ * number of allocated pages as an Integer.  This return value should
+ * match the result of GC.stat(:heap_allocated_pages)
+ */
+static VALUE hpb_each(VALUE mod)
+{
+	++locating;
+	return rb_ensure(hpb_each_yield, Qfalse, reset_locating, 0);
+}
+
+/*
+ * call-seq:
+ *
+ *	Mwrap::HeapPageBody.stat -> Hash
+ *	Mwrap::HeapPageBody.stat(hash) -> hash
+ *
+ * The maximum lifespan of a heap page body in the Ruby VM.
+ * This may be Infinity if no heap page bodies were ever freed.
+ */
+static VALUE hpb_stat(int argc, VALUE *argv, VALUE hpb)
+{
+	VALUE h;
+
+	rb_scan_args(argc, argv, "01", &h);
+	if (NIL_P(h))
+		h = rb_hash_new();
+	else if (!RB_TYPE_P(h, T_HASH))
+		rb_raise(rb_eTypeError, "not a hash %+"PRIsVALUE, h);
+
+	++locating;
+#define S(x) ID2SYM(rb_intern(#x))
+	rb_hash_aset(h, S(lifespan_max), acc_max(&hpb_stats.alive));
+	rb_hash_aset(h, S(lifespan_min), acc_min(&hpb_stats.alive));
+	rb_hash_aset(h, S(lifespan_mean), acc_mean(&hpb_stats.alive));
+	rb_hash_aset(h, S(lifespan_stddev), acc_stddev(&hpb_stats.alive));
+	rb_hash_aset(h, S(deathspan_max), acc_max(&hpb_stats.reborn));
+	rb_hash_aset(h, S(deathspan_min), acc_min(&hpb_stats.reborn));
+	rb_hash_aset(h, S(deathspan_mean), acc_mean(&hpb_stats.reborn));
+	rb_hash_aset(h, S(deathspan_stddev), acc_stddev(&hpb_stats.reborn));
+	rb_hash_aset(h, S(resurrects), SIZET2NUM(hpb_stats.reborn.nr));
+#undef S
+	--locating;
+
+	return h;
+}
+
 /*
  * Document-module: Mwrap
  *
@@ -1051,20 +1316,19 @@ static VALUE mwrap_quiet(VALUE mod)
  * * dump_fd: a writable FD to dump to
  * * dump_path: a path to dump to, the file is opened in O_APPEND mode
  * * dump_min: the minimum allocation size (total) to dump
- * * memalign: use `1' to enable tracking the memalign family
+ * * dump_heap: mask of heap_page_body statistics to dump
  *
  * If both `dump_fd' and `dump_path' are specified, dump_path takes
  * precedence.
  *
- * Tracking the memalign family of functions is misleading for Ruby
- * applications, as heap page allocations can happen anywhere a
- * Ruby object is allocated, even in the coldest code paths.
- * Furthermore, it is rarely-used outside of the Ruby object allocator.
- * Thus tracking memalign functions is disabled by default.
+ * dump_heap bitmask
+ * * 0x01 - summary stats (same info as HeapPageBody.stat)
+ * * 0x02 - all live heaps (similar to HeapPageBody.each)
+ * * 0x04 - skip non-heap_page_body-related output
  */
 void Init_mwrap(void)
 {
-	VALUE mod;
+	VALUE mod, hpb;
 
 	++locating;
 	mod = rb_define_module("Mwrap");
@@ -1084,6 +1348,10 @@ void Init_mwrap(void)
 	rb_define_singleton_method(mod, "each", mwrap_each, -1);
 	rb_define_singleton_method(mod, "[]", mwrap_aref, 1);
 	rb_define_singleton_method(mod, "quiet", mwrap_quiet, 0);
+	rb_define_singleton_method(mod, "total_bytes_allocated", total_inc, 0);
+	rb_define_singleton_method(mod, "total_bytes_freed", total_dec, 0);
+
+
 	rb_define_method(cSrcLoc, "each", src_loc_each, 0);
 	rb_define_method(cSrcLoc, "frees", src_loc_frees, 0);
 	rb_define_method(cSrcLoc, "allocations", src_loc_allocations, 0);
@@ -1091,9 +1359,68 @@ void Init_mwrap(void)
 	rb_define_method(cSrcLoc, "mean_lifespan", src_loc_mean_lifespan, 0);
 	rb_define_method(cSrcLoc, "max_lifespan", src_loc_max_lifespan, 0);
 	rb_define_method(cSrcLoc, "name", src_loc_name, 0);
+
+	/*
+	 * Information about "struct heap_page_body" allocations from
+	 * Ruby gc.c.  This can be useful for tracking fragmentation
+	 * from posix_memalign(3) use in mainline Ruby:
+	 *
+	 *   https://sourceware.org/bugzilla/show_bug.cgi?id=14581
+	 *
+	 * These statistics are never reset by Mwrap.reset or
+	 * any other method.  They only make sense in the context
+	 * of an entire program lifetime.
+	 */
+	hpb = rb_define_class_under(mod, "HeapPageBody", rb_cObject);
+	rb_define_singleton_method(hpb, "stat", hpb_stat, -1);
+	rb_define_singleton_method(hpb, "each", hpb_each, 0);
+
 	--locating;
 }
 
+enum {
+	DUMP_HPB_STATS = 0x1,
+	DUMP_HPB_EACH = 0x2,
+	DUMP_HPB_EXCL = 0x4,
+};
+
+static void dump_hpb(FILE *fp, unsigned flags)
+{
+	if (flags & DUMP_HPB_STATS) {
+		fprintf(fp,
+			"lifespan_max: %"PRId64"\n"
+			"lifespan_min:%s%"PRId64"\n"
+			"lifespan_mean: %0.3f\n"
+			"lifespan_stddev: %0.3f\n"
+			"deathspan_max: %"PRId64"\n"
+			"deathspan_min:%s%"PRId64"\n"
+			"deathspan_mean: %0.3f\n"
+			"deathspan_stddev: %0.3f\n"
+			"gc_count: %zu\n",
+			hpb_stats.alive.max,
+			hpb_stats.alive.min == INT64_MAX ? " -" : " ",
+			hpb_stats.alive.min,
+			hpb_stats.alive.mean,
+			acc_stddev_dbl(&hpb_stats.alive),
+			hpb_stats.reborn.max,
+			hpb_stats.reborn.min == INT64_MAX ? " -" : " ",
+			hpb_stats.reborn.min,
+			hpb_stats.reborn.mean,
+			acc_stddev_dbl(&hpb_stats.reborn),
+			/* n.b.: unsafe to call rb_gc_count() in destructor */
+			generation);
+	}
+	if (flags & DUMP_HPB_EACH) {
+		struct alloc_hdr *h;
+
+		cds_list_for_each_entry(h, &hpb_stats.bodies, anode) {
+			void *addr = hdr2ptr(h);
+
+			fprintf(fp, "%p\t%zu\n", addr, h->as.live.gen);
+		}
+	}
+}
+
 /* rb_cloexec_open isn't usable by non-Ruby processes */
 #ifndef O_CLOEXEC
 #  define O_CLOEXEC 0
@@ -1104,10 +1431,12 @@ static void mwrap_dump_destructor(void)
 {
 	const char *opt = getenv("MWRAP");
 	const char *modes[] = { "a", "a+", "w", "w+", "r+" };
-	struct dump_arg a;
+	struct dump_arg a = { .min = 0 };
 	size_t i;
 	int dump_fd;
+	unsigned dump_heap = 0;
 	char *dump_path;
+	char *s;
 
 	if (!opt)
 		return;
@@ -1134,8 +1463,11 @@ static void mwrap_dump_destructor(void)
 	else if (!sscanf(opt, "dump_fd:%d", &dump_fd))
 		goto out;
 
-	if (!sscanf(opt, "dump_min:%zu", &a.min))
-		a.min = 0;
+	if ((s = strstr(opt, "dump_min:")))
+		sscanf(s, "dump_min:%zu", &a.min);
+
+	if ((s = strstr(opt, "dump_heap:")))
+		sscanf(s, "dump_heap:%u", &dump_heap);
 
 	switch (dump_fd) {
 	case 0: goto out;
@@ -1156,7 +1488,9 @@ static void mwrap_dump_destructor(void)
 		}
 		/* we'll leak some memory here, but this is a destructor */
 	}
-	dump_to_file(&a);
+	if ((dump_heap & DUMP_HPB_EXCL) == 0)
+		dump_to_file(&a);
+	dump_hpb(a.fp, dump_heap);
 out:
 	--locating;
 }

data/lib/mwrap_rack.rb

@@ -0,0 +1,170 @@
+# Copyright (C) all contributors <mwrap-public@80x24.org>
+# License: GPL-2.0+ <https://www.gnu.org/licenses/gpl-2.0.txt>
+# frozen_string_literal: true
+require 'mwrap'
+require 'rack'
+require 'cgi'
+
+# MwrapRack is a standalone Rack application which can be
+# mounted to run within your application process.
+#
+# Using the Rack::Builder API in config.ru, you can map it to
+# the "/MWRAP/" endpoint.  As with the rest of the Mwrap API,
+# your Rack server needs to be spawned with the mwrap(1)
+# wrapper to enable the LD_PRELOAD.
+#
+#     require 'mwrap_rack'
+#     map('/MWRAP') { run(MwrapRack.new) }
+#     map('/') { run(your_normal_app) }
+#
+# This module is only available in mwrap 2.0.0+
+class MwrapRack
+  module HtmlResponse # :nodoc:
+    def response
+      [ 200, {
+          'Expires' => 'Fri, 01 Jan 1980 00:00:00 GMT',
+          'Pragma' => 'no-cache',
+          'Cache-Control' => 'no-cache, max-age=0, must-revalidate',
+          'Content-Type' => 'text/html; charset=UTF-8',
+        }, self ]
+    end
+  end
+
+  class Each < Struct.new(:script_name, :min, :sort) # :nodoc:
+    include HtmlResponse
+    HEADER = '<tr><th>' + %w(total allocations frees mean_life max_life
+                location).join('</th><th>') + '</th></tr>'
+    FIELDS = %w(total allocations frees mean_life max_life location)
+    def each
+      Mwrap.quiet do
+        t = -"Mwrap.each(#{min})"
+        sn = script_name
+        all = []
+        f = FIELDS.dup
+        sc = FIELDS.index(sort || 'total') || 0
+        f[sc] = -"<b>#{f[sc]}</b>"
+        f.map! do |hdr|
+          if hdr.start_with?('<b>')
+            hdr
+          else
+            -%Q(<a\nhref="#{sn}/each/#{min}?sort=#{hdr}">#{hdr}</a>)
+          end
+        end
+        Mwrap.each(min) do |loc, total, allocations, frees, age_sum, max_life|
+          mean_life = frees == 0 ? Float::INFINITY : age_sum/frees.to_f
+          all << [total,allocations,frees,mean_life,max_life,loc]
+        end
+        all.sort_by! { |cols| -cols[sc] }
+
+        yield(-"<html><head><title>#{t}</title></head>" \
+               "<body><h1>#{t}</h1>\n" \
+               "<h2>Current generation: #{GC.count}</h2>\n<table>\n" \
+               "<tr><th>#{f.join('</th><th>')}</th></tr>\n")
+        all.each do |cols|
+          loc = cols.pop
+          cols[3] = sprintf('%0.3f', cols[3]) # mean_life
+          href = -(+"#{sn}/at/#{CGI.escape(loc)}").encode!(xml: :attr)
+          yield(%Q(<tr><td>#{cols.join('</td><td>')}<td><a\nhref=#{
+                  href}>#{-loc.encode(xml: :text)}</a></td></tr>\n))
+          cols.clear
+        end.clear
+        yield "</table></body></html>\n"
+      end
+    end
+  end
+
+  class EachAt < Struct.new(:loc) # :nodoc:
+    include HtmlResponse
+    HEADER = '<tr><th>size</th><th>generation</th></tr>'
+
+    def each
+      t = loc.name.encode(xml: :text)
+      yield(-"<html><head><title>#{t}</title></head>" \
+             "<body><h1>live allocations at #{t}</h1>" \
+             "<h2>Current generation: #{GC.count}</h2>\n<table>#{HEADER}")
+      loc.each do |size, generation|
+        yield("<tr><td>#{size}</td><td>#{generation}</td></tr>\n")
+      end
+      yield "</table></body></html>\n"
+    end
+  end
+
+  class HeapPages # :nodoc:
+    include HtmlResponse
+    HEADER = '<tr><th>address</th><th>generation</th></tr>'
+
+    def hpb_rows
+      Mwrap::HeapPageBody.stat(stat = Thread.current[:mwrap_hpb_stat] ||= {})
+      %i(lifespan_max lifespan_min lifespan_mean lifespan_stddev
+         deathspan_max deathspan_min deathspan_mean deathspan_stddev
+         resurrects
+        ).map! do |k|
+         "<tr><td>#{k}</td><td>#{stat[k]}</td></tr>\n"
+      end.join
+    end
+
+    def gc_stat_rows
+      GC.stat(stat = Thread.current[:mwrap_gc_stat] ||= {})
+      %i(count heap_allocated_pages heap_eden_pages heap_tomb_pages
+          total_allocated_pages total_freed_pages).map do |k|
+         "<tr><td>GC.stat(:#{k})</td><td>#{stat[k]}</td></tr>\n"
+      end.join
+    end
+
+    GC_STAT_URL = 'https://docs.ruby-lang.org/en/trunk/GC.html#method-c-stat'
+    GC_STAT_HELP = <<~EOM
+      <p>Non-Infinity lifespans can indicate fragmentation.
+      <p>See <a
+      href="#{GC_STAT_URL}">#{GC_STAT_URL}</a> for info on GC.stat values.
+    EOM
+
+    def each
+      Mwrap.quiet do
+        yield("<html><head><title>heap pages</title></head>" \
+              "<body><h1>heap pages</h1>" \
+              "<table><tr><th>stat</th><th>value</th></tr>\n" \
+              "#{hpb_rows}" \
+              "#{gc_stat_rows}" \
+              "</table>\n" \
+              "#{GC_STAT_HELP}" \
+              "<table>#{HEADER}")
+        Mwrap::HeapPageBody.each do |addr, generation|
+          addr = -sprintf('0x%x', addr)
+          yield(-"<tr><td>#{addr}</td><td>#{generation}</td></tr>\n")
+        end
+        yield "</table></body></html>\n"
+      end
+    end
+  end
+
+  def r404 # :nodoc:
+    [404,{'Content-Type'=>'text/plain'},["Not found\n"]]
+  end
+
+  # The standard Rack application endpoint for MwrapRack
+  def call(env)
+    case env['PATH_INFO']
+    when %r{\A/each/(\d+)\z}
+      min = $1.to_i
+      m = env['QUERY_STRING'].match(/\bsort=(\w+)/)
+      Each.new(env['SCRIPT_NAME'], min, m ? m[1] : nil).response
+    when %r{\A/at/(.*)\z}
+      loc = -CGI.unescape($1)
+      loc = Mwrap[loc] or return r404
+      EachAt.new(loc).response
+    when '/heap_pages'
+      HeapPages.new.response
+    when '/'
+      n = 2000
+      u = 'https://80x24.org/mwrap/README.html'
+      b = -('<html><head><title>Mwrap demo</title></head>' \
+          "<body><p><a href=\"each/#{n}\">allocations &gt;#{n} bytes</a>" \
+          "<p><a href=\"#{u}\">#{u}</a>" \
+          "<p><a href=\"heap_pages\">heap pages</a>" \
+          "</body></html>\n")
+      [ 200, {'Content-Type'=>'text/html','Content-Length'=>-b.size.to_s},[b]]
+    else
+      r404
+    end
+  end
+end

data/mwrap.gemspec

@@ -8,11 +8,13 @@ if git_manifest[0] && manifest != git_manifest
   system('git add MANIFEST')
 end
 
+desc = `git describe --abbrev=4 HEAD`.strip.tr('-', '.').delete_prefix('v')
+
 Gem::Specification.new do |s|
   s.name = 'mwrap'
-  s.version = '2.0.0'
+  s.version = desc.empty? ? '2.2.0' : desc
   s.homepage = 'https://80x24.org/mwrap/'
-  s.authors = ["Ruby hackers"]
+  s.authors = ["mwrap hackers"]
   s.summary = 'LD_PRELOAD malloc wrapper for Ruby'
   s.executables = %w(mwrap)
   s.files = manifest

data/test/test_mwrap.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# Copyright (C) 2018 mwrap hackers <mwrap-public@80x24.org>
+# Copyright (C) mwrap hackers <mwrap-public@80x24.org>
 # License: GPL-2.0+ <https://www.gnu.org/licenses/gpl-2.0.txt>
 require 'test/unit'
 require 'mwrap'
@@ -29,7 +29,8 @@ class TestMwrap < Test::Unit::TestCase
       tmp.rewind
       lines = tmp.readlines
       line_1 = lines.grep(/\s-e:1\b/)[0].strip
-      assert_equal '10001', line_1.split(/\s+/)[0]
+      bytes = line_1.split(/\s+/)[0].to_i
+      assert_operator bytes, :>=, 10001
     end
   end
 
@@ -42,7 +43,7 @@ class TestMwrap < Test::Unit::TestCase
       res = system(env, *cmd, { 5 => tmp })
       assert res, $?.inspect
       tmp.rewind
-      assert_match(/\b10001\s+1\s+-e:1$/, tmp.read)
+      assert_match(/\b1\d{4}\s+[1-9]\d*\s+-e:1$/, tmp.read)
 
       env['MWRAP'] = 'dump_fd:1,dump_min:10000'
       tmp.rewind
@@ -50,14 +51,21 @@ class TestMwrap < Test::Unit::TestCase
       res = system(env, *cmd, { 1 => tmp })
       assert res, $?.inspect
       tmp.rewind
-      assert_match(/\b10001\s+1\s+-e:1$/, tmp.read)
+      assert_match(/\b1\d{4}\s+[1-9]\d*\s+-e:1$/, tmp.read)
 
       tmp.rewind
       tmp.truncate(0)
       env['MWRAP'] = "dump_path:#{tmp.path},dump_min:10000"
       res = system(env, *cmd)
       assert res, $?.inspect
-      assert_match(/\b10001\s+1\s+-e:1$/, tmp.read)
+      assert_match(/\b1\d{4}\s+[1-9]\d*\s+-e:1$/, tmp.read)
+
+      tmp.rewind
+      tmp.truncate(0)
+      env['MWRAP'] = "dump_path:#{tmp.path},dump_heap:5"
+      res = system(env, *cmd)
+      assert res, $?.inspect
+      assert_match %r{lifespan_stddev}, tmp.read
     end
   end
 
@@ -91,7 +99,7 @@ class TestMwrap < Test::Unit::TestCase
       tmp.rewind
       buf = tmp.read
       assert_not_match(/\s+-e:1$/, buf)
-      assert_match(/\b20001\s+1\s+-e:3$/, buf)
+      assert_match(/\b2\d{4}\s+[0-9]\d*\s+-e:3$/, buf)
     end
   end
 
@@ -169,8 +177,8 @@ class TestMwrap < Test::Unit::TestCase
       -e GC.disable
       -e keep=("0"*10000)
       -e loc=Mwrap["-e:3"]
-      -e loc.each{|size,gen|p([size,gen,count])}
-    )
+      -e
+    ) + [ 'loc.each{|size,gen|p([size,gen,count]) if size > 10000}' ]
     buf = IO.popen(@@env, cmd, &:read)
     assert_predicate $?, :success?
     assert_match(/\A\[\s*\d+,\s*\d+,\s*\d+\]\s*\z/s, buf)
@@ -223,7 +231,8 @@ class TestMwrap < Test::Unit::TestCase
       loc.name == k or abort 'SourceLocation#name broken'
       loc.total >= 10000 or abort 'SourceLocation#total broken'
       loc.frees == 0 or abort 'SourceLocation#frees broken'
-      loc.allocations == 1 or abort 'SourceLocation#allocations broken'
+      loc.allocations >= 1 or
+        abort "SourceLocation#allocations broken: #{loc.allocations}"
       seen = false
       loc.each do |*x| seen = x end
       seen[1] == loc.total or 'SourceLocation#each broken'
@@ -233,7 +242,9 @@ class TestMwrap < Test::Unit::TestCase
       freed = false
       until freed
         freed = true
-        loc.each do freed = false end
+        loc.each do |size, gen|
+          freed = false if size >= 10000
+        end
       end
       loc.frees == 1 or abort 'SourceLocation#frees broken (after free)'
       Float === loc.mean_lifespan or abort 'mean_lifespan broken'
@@ -257,8 +268,9 @@ class TestMwrap < Test::Unit::TestCase
     assert_separately(+"#{<<~"begin;"}\n#{<<~'end;'}")
     begin;
       require 'mwrap'
-      before = __LINE__
+      before = nil
       res = Mwrap.quiet do |depth|
+        before = __LINE__
         depth == 1 or abort 'depth is not 1'
         ('a' * 10000).clear
         Mwrap.quiet { |d| d == 2 or abort 'depth is not 2' }
@@ -272,4 +284,46 @@ class TestMwrap < Test::Unit::TestCase
       res == :foo or abort 'Mwrap.quiet did not return block result'
     end;
   end
+
+  def test_total_bytes
+    assert_separately(+"#{<<~"begin;"}\n#{<<~'end;'}")
+    begin;
+      require 'mwrap'
+      Mwrap.total_bytes_allocated > 0 or abort 'nothing allocated'
+      Mwrap.total_bytes_freed > 0 or abort 'nothing freed'
+      Mwrap.total_bytes_allocated > Mwrap.total_bytes_freed or
+        abort 'freed more than allocated'
+    end;
+  end
+
+  def test_heap_page_body
+    assert_separately(+"#{<<~"begin;"}\n#{<<~'end;'}")
+    begin;
+      require 'mwrap'
+      require 'rubygems' # use up some memory
+      ap = GC.stat(:heap_allocated_pages)
+      h = {}
+      nr = 0
+      Mwrap::HeapPageBody.each do |addr, gen|
+        nr += 1
+        gen <= GC.count && gen >= 0 or abort "bad generation: #{gen}"
+        (0 == (addr & 16383)) or abort "addr not aligned: #{'%x' % addr}"
+      end
+      if RUBY_VERSION.to_f < 3.1 # 3.1+ uses mmap on platforms we care about
+        nr == ap or abort "HeapPageBody.each missed page #{nr} != #{ap}"
+      end
+      10.times { (1..20000).to_a.map(&:to_s) }
+      3.times { GC.start }
+      Mwrap::HeapPageBody.stat(h)
+      Integer === h[:lifespan_max] or abort 'lifespan_max not recorded'
+      Integer === h[:lifespan_min] or abort 'lifespan_min not recorded'
+      Float === h[:lifespan_mean] or abort 'lifespan_mean not recorded'
+      3.times { GC.start }
+      10.times { (1..20000).to_a.map(&:to_s) }
+      Mwrap::HeapPageBody.stat(h)
+      h[:deathspan_min] <= h[:deathspan_max] or
+        abort 'wrong min/max deathtime'
+      Float === h[:deathspan_mean] or abort 'deathspan_mean not recorded'
+    end;
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mwrap
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
-- Ruby hackers
+- mwrap hackers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-20 00:00:00.000000000 Z
+date: 2022-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -50,6 +50,7 @@ extra_rdoc_files: []
 files:
 - ".document"
 - ".gitignore"
+- ".olddoc.yml"
 - COPYING
 - MANIFEST
 - README
@@ -58,6 +59,7 @@ files:
 - ext/mwrap/extconf.rb
 - ext/mwrap/jhash.h
 - ext/mwrap/mwrap.c
+- lib/mwrap_rack.rb
 - mwrap.gemspec
 - test/test_mwrap.rb
 homepage: https://80x24.org/mwrap/
@@ -79,8 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: LD_PRELOAD malloc wrapper for Ruby