allocation_sampler 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 268a796ca59b96cfcba16f0ee5778de979a9295adb7b7d32285d7749fabfb7e7
+  data.tar.gz: 76c4e4773f3ed799f461569db97a4541e873cdde5bad3ab1dbfe589c21991647
+SHA512:
+  metadata.gz: 7d25b1f773144e4c60dc0eb2ac8f38f9623de0c6e5e7177ccd871c58edb0d018d7505c400f62423d2dce7c921dc49b5e9f98fb8c87e6448b4225fe82f9c04303
+  data.tar.gz: da097230b8c5d24f9c1d8c85e1cc9bd0e11a2743232ee1cc936ccde713c773fcbf85ce6ef0a4a48a170f522ffc5480b18b4bdd4532041ca9cb677139dc62683a

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2018-08-06
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+ext/allocation_sampler/allocation_sampler.c
+ext/allocation_sampler/sort_r.h
+ext/allocation_sampler/extconf.rb
+lib/allocation_sampler.rb
+test/test_allocation_sampler.rb

data/README.md

@@ -0,0 +1,45 @@
+# allocation_sampler
+
+* https://github.com/tenderlove/allocation_sampler
+
+## DESCRIPTION:
+
+A sampling allocation profiler.  This keeps track of allocations, but only on
+specified intervals.  Useful for profiling allocations in programs where there
+is a time limit on completion of the program.
+
+## SYNOPSIS:
+
+```ruby
+as = ObjectSpace::AllocationSampler.new(interval: 1)
+as.enable
+10.times { Object.new }
+as.disable
+
+as.result # => {"Object"=>{"<compiled>"=>{1=>10}}}
+```
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2018 Aaron Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,26 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require 'rake/extensiontask'
+
+Hoe.plugin :minitest
+Hoe.plugin :gemspec # `gem install hoe-gemspec`
+Hoe.plugin :git     # `gem install hoe-git`
+
+HOE = Hoe.spec 'allocation_sampler' do
+  developer('Aaron Patterson', 'aaron@tenderlovemaking.com')
+  self.readme_file   = 'README.md'
+  self.history_file  = 'CHANGELOG.md'
+  self.extra_rdoc_files  = FileList['*.md']
+  self.license 'MIT'
+  self.spec_extras = {
+    :extensions => ["ext/allocation_sampler/extconf.rb"],
+  }
+end
+
+Rake::ExtensionTask.new("allocation_sampler", HOE.spec)
+
+task :default => [:compile, :test]
+
+# vim: syntax=ruby

data/ext/allocation_sampler/allocation_sampler.c

@@ -0,0 +1,532 @@
+#include <ruby/ruby.h>
+#include <ruby/debug.h>
+#include <stdlib.h>
+#include "sort_r.h"
+
+typedef struct {
+    char   frames;
+    size_t capa;
+    size_t next_free;
+    size_t prev_free;
+    size_t record_count;
+    union {
+	VALUE *frames;
+	int *lines;
+    } as;
+} sample_buffer_t;
+
+typedef struct {
+    size_t interval;
+    size_t allocation_count;
+    size_t overall_samples;
+    sample_buffer_t * stack_samples;
+    sample_buffer_t * lines_samples;
+    VALUE newobj_hook;
+} trace_stats_t;
+
+typedef struct {
+    sample_buffer_t * frames;
+    sample_buffer_t * lines;
+} compare_data_t;
+
+static void
+free_sample_buffer(sample_buffer_t *buffer)
+{
+    if (buffer->frames) {
+	xfree(buffer->as.lines);
+    } else {
+	xfree(buffer->as.frames);
+    }
+    xfree(buffer);
+}
+
+static sample_buffer_t *
+alloc_lines_buffer(size_t size)
+{
+    sample_buffer_t * samples = xcalloc(sizeof(sample_buffer_t), 1);
+    samples->as.lines = xcalloc(sizeof(int), size);
+    samples->capa = size;
+    samples->frames = 0;
+    return samples;
+}
+
+static sample_buffer_t *
+alloc_frames_buffer(size_t size)
+{
+    sample_buffer_t * samples = xcalloc(sizeof(sample_buffer_t), 1);
+    samples->as.frames = xcalloc(sizeof(VALUE), size);
+    samples->capa = size;
+    samples->frames = 1;
+    return samples;
+}
+
+static void
+ensure_sample_buffer_capa(sample_buffer_t * buffer, size_t size)
+{
+    /* If we can't fit all the samples in the buffer, double the buffer size. */
+    while (buffer->capa <= (buffer->next_free - 1) + (size + 2)) {
+	buffer->capa *= 2;
+	if (buffer->frames) {
+	    buffer->as.frames = xrealloc(buffer->as.frames, sizeof(VALUE) * buffer->capa);
+	} else {
+	    buffer->as.lines = xrealloc(buffer->as.lines, sizeof(int) * buffer->capa);
+	}
+    }
+}
+
+static void
+dealloc(void *ptr)
+{
+    trace_stats_t * stats = (trace_stats_t *)ptr;
+    sample_buffer_t * frames;
+    sample_buffer_t * lines;
+
+    frames = stats->stack_samples;
+    lines = stats->lines_samples;
+
+    if (frames && lines) {
+	free_sample_buffer(frames);
+	free_sample_buffer(lines);
+    }
+    xfree(stats);
+}
+
+static VALUE
+make_frame_info(VALUE *frames, int *lines)
+{
+    size_t count, i;
+    VALUE rb_frames;
+
+    count = *frames;
+    frames++;
+    lines++;
+
+    rb_frames = rb_ary_new_capa(count);
+
+    for(i = 0; i < count; i++, frames++, lines++) {
+	VALUE line = INT2NUM(*lines);
+	rb_ary_push(rb_frames, rb_ary_new3(2, rb_obj_id(*frames), line));
+    }
+
+    return rb_frames;
+}
+
+static int
+compare(const void* l, const void* r, void* ctx)
+{
+    compare_data_t *compare_data = (compare_data_t *)ctx;
+    sample_buffer_t *stacks = compare_data->frames;
+    sample_buffer_t *lines = compare_data->lines;
+
+    size_t left_offset = *(const size_t*)l;
+    size_t right_offset = *(const size_t*)r;
+
+    size_t lstack = *(stacks->as.frames + left_offset);
+    size_t rstack = *(stacks->as.frames + right_offset);
+
+    if (lstack == rstack) {
+	/* Compare the stack plus type info */
+	int stack_cmp = memcmp(stacks->as.frames + left_offset,
+		               stacks->as.frames + right_offset,
+			       (lstack + 3) * sizeof(VALUE *));
+
+	if (stack_cmp == 0) {
+	    /* If the stacks are the same, check the line numbers */
+	    int line_cmp = memcmp(lines->as.lines + left_offset + 1,
+		                  lines->as.lines + right_offset + 1,
+				  lstack * sizeof(int));
+
+	    return line_cmp;
+	} else {
+	    return stack_cmp;
+	}
+    } else {
+	if (lstack < rstack) {
+	    return -1;
+	} else {
+	    return 1;
+	}
+    }
+}
+
+static void
+mark(void * ptr)
+{
+    trace_stats_t * stats = (trace_stats_t *)ptr;
+    sample_buffer_t * stacks;
+
+    stacks = stats->stack_samples;
+
+    if (stacks) {
+	VALUE * frame = stacks->as.frames;
+
+	while(frame < stacks->as.frames + stacks->next_free) {
+	    size_t stack_size;
+	    VALUE * head;
+
+	    stack_size = *frame;
+	    frame++; /* First element is the stack size */
+	    head = frame;
+
+	    for(; frame < (head + stack_size); frame++) {
+		rb_gc_mark(*frame);
+	    }
+	    frame++; /* Frame info */
+	    rb_gc_mark(*frame);
+	    frame++; /* Next Head */
+	}
+    }
+
+    if (stats->newobj_hook) {
+	rb_gc_mark(stats->newobj_hook);
+    }
+}
+
+static const rb_data_type_t trace_stats_type = {
+    "ObjectSpace/AllocationSampler",
+    {mark, dealloc, 0,},
+    0, 0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+static VALUE
+user_class(VALUE klass, VALUE obj)
+{
+    if (RTEST(klass) && !(RB_TYPE_P(obj, T_IMEMO) || RB_TYPE_P(obj, T_NODE)) && BUILTIN_TYPE(klass) == T_CLASS) {
+	return rb_class_path_cached(rb_class_real(klass));
+    } else {
+	return Qnil;
+    }
+}
+
+#define BUF_SIZE 2048
+
+static void
+newobj(VALUE tpval, void *ptr)
+{
+    trace_stats_t * stats = (trace_stats_t *)ptr;
+
+    if (!(stats->allocation_count % stats->interval)) {
+	rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+	VALUE obj = rb_tracearg_object(tparg);
+	VALUE klass = RBASIC_CLASS(obj);
+	VALUE uc = user_class(klass, obj);
+
+	if (!NIL_P(uc)) {
+	    VALUE frames_buffer[BUF_SIZE];
+	    int lines_buffer[BUF_SIZE];
+
+	    VALUE path = rb_tracearg_path(tparg);
+
+	    if (RTEST(path)) {
+		sample_buffer_t * stack_samples;
+		sample_buffer_t * lines_samples;
+
+		int num = rb_profile_frames(0, sizeof(frames_buffer) / sizeof(VALUE), frames_buffer, lines_buffer);
+		if (!stats->stack_samples) {
+		    stats->stack_samples = alloc_frames_buffer(num * 100);
+		    stats->lines_samples = alloc_lines_buffer(num * 100);
+		}
+		stack_samples = stats->stack_samples;
+		lines_samples = stats->lines_samples;
+
+		ensure_sample_buffer_capa(stack_samples, num + 2);
+		ensure_sample_buffer_capa(lines_samples, num + 2);
+
+		stack_samples->prev_free = stack_samples->next_free;
+		lines_samples->prev_free = lines_samples->next_free;
+
+		stack_samples->as.frames[stack_samples->next_free] = (VALUE)num;
+		lines_samples->as.lines[lines_samples->next_free] = (VALUE)num;
+
+		memcpy(stack_samples->as.frames + stack_samples->next_free + 1, frames_buffer, num * sizeof(VALUE *));
+		memcpy(lines_samples->as.lines + lines_samples->next_free + 1, lines_buffer, num * sizeof(int));
+
+		/* We're not doing de-duping right now, so just set the stack count to 0xdeadbeef */
+		stack_samples->as.frames[stack_samples->next_free + num + 1] = 0xdeadbeef;
+		stack_samples->as.frames[stack_samples->next_free + num + 2] = uc;
+
+		lines_samples->as.lines[stack_samples->next_free + num + 1] = 0xdeadbeef;
+		lines_samples->as.lines[stack_samples->next_free + num + 2] = uc;
+
+		stack_samples->next_free += (num + 3);
+		lines_samples->next_free += (num + 3);
+
+		stack_samples->record_count++;
+		lines_samples->record_count++;
+
+		stats->overall_samples++;
+	    }
+	}
+    }
+    stats->allocation_count++;
+}
+
+static VALUE
+allocate(VALUE klass)
+{
+    trace_stats_t * stats;
+    stats = xcalloc(sizeof(trace_stats_t), 1);
+    stats->interval = 1;
+    stats->newobj_hook = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj, stats);
+
+    return TypedData_Wrap_Struct(klass, &trace_stats_type, stats);
+}
+
+VALUE rb_cAllocationSampler;
+
+static VALUE
+enable(VALUE self)
+{
+    trace_stats_t * stats;
+    TypedData_Get_Struct(self, trace_stats_t, &trace_stats_type, stats);
+    rb_tracepoint_enable(stats->newobj_hook);
+    return Qnil;
+}
+
+static VALUE
+disable(VALUE self)
+{
+    trace_stats_t * stats;
+    TypedData_Get_Struct(self, trace_stats_t, &trace_stats_type, stats);
+    rb_tracepoint_disable(stats->newobj_hook);
+    return Qnil;
+}
+
+static int
+sort_frames(const void *left, const void *right)
+{
+    const VALUE *vleft = (const VALUE *)left;
+    const VALUE *vright = (const VALUE *)right;
+    /* Sort so that 0 is always at the right */
+    if (*vleft == *vright) {
+	return 0;
+    } else {
+	if (*vleft == 0) {
+	    return 1;
+	} else if (*vright == 0) {
+	    return -1;
+	}
+    }
+    return *vleft - *vright;
+}
+
+static VALUE
+frames(VALUE self)
+{
+    trace_stats_t * stats;
+    sample_buffer_t * frame_buffer;
+    VALUE frames;
+    VALUE *samples;
+    VALUE *head;
+    VALUE rb_cFrame;
+
+    size_t buffer_size;
+
+    TypedData_Get_Struct(self, trace_stats_t, &trace_stats_type, stats);
+
+    frame_buffer = stats->stack_samples;
+
+    if (!frame_buffer) {
+	return Qnil;
+    }
+
+    buffer_size = frame_buffer->next_free;
+
+    samples = xcalloc(sizeof(VALUE), buffer_size);
+    memcpy(samples, frame_buffer->as.frames, buffer_size * sizeof(VALUE));
+
+    /* Clear anything that's not a frame */
+    for(head = samples; head < (samples + buffer_size - 1); head++) {
+	size_t frame_count;
+	frame_count = *head;
+
+	*head = 0;
+	head++;              /* Skip the count */
+	head += frame_count; /* Skip the stack */
+	*head = 0;           /* Set the de-dup count to 0 */
+	head++;
+	*head = 0;           /* Set the type to 0 */
+    }
+
+    qsort(samples, buffer_size, sizeof(VALUE *), sort_frames);
+
+    frames = rb_hash_new();
+
+    rb_cFrame = rb_const_get(rb_cAllocationSampler, rb_intern("Frame"));
+
+    for(head = samples; head < (samples + buffer_size); ) {
+	if (*head == 0)
+	    break;
+
+	VALUE file;
+	VALUE frame;
+
+	file = rb_profile_frame_absolute_path(*(VALUE *)head);
+	if (NIL_P(file))
+	    file = rb_profile_frame_path(*head);
+
+	VALUE args[3];
+
+	args[0] = rb_obj_id(*head);
+	args[1] = rb_profile_frame_full_label(*head);
+	args[2] = file;
+
+	frame = rb_class_new_instance(3, args, rb_cFrame);
+
+	rb_hash_aset(frames, rb_obj_id(*head), frame);
+
+	/* Skip duplicates */
+	VALUE *cmp;
+	for (cmp = head + 1; cmp < (samples + buffer_size); cmp++) {
+	    if (*cmp != *head) {
+		break;
+	    }
+	}
+	head = cmp;
+    }
+
+    xfree(samples);
+
+    return frames;
+}
+
+static VALUE
+samples(VALUE self)
+{
+    trace_stats_t * stats;
+    sample_buffer_t * frames;
+    sample_buffer_t * lines;
+    size_t *record_offsets;
+    VALUE result = Qnil;
+
+    TypedData_Get_Struct(self, trace_stats_t, &trace_stats_type, stats);
+
+    frames = stats->stack_samples;
+    lines = stats->lines_samples;
+
+    if (frames && lines) {
+	size_t i, j;
+	size_t * head;
+	VALUE * frame = frames->as.frames;
+	compare_data_t compare_ctx;
+	compare_ctx.frames = frames;
+	compare_ctx.lines = lines;
+
+	record_offsets = xcalloc(sizeof(size_t), frames->record_count);
+	head = record_offsets;
+
+	i = 0;
+	while(frame < frames->as.frames + frames->next_free) {
+	    *head = i;             /* Store the frame start offset */
+	    head++;                /* Move to the next entry in record_offsets */
+	    i     += (*frame + 3); /* Increase the offset */
+	    frame += (*frame + 3); /* Move to the next frame */
+	}
+
+	sort_r(record_offsets, frames->record_count, sizeof(size_t), compare, &compare_ctx);
+
+	VALUE unique_frames = rb_ary_new();
+
+	for(i = 0; i < frames->record_count; ) {
+	    size_t current = record_offsets[i];
+	    size_t count = 0;
+
+	    /* Count any duplicate stacks ahead of us in the array */
+	    for (j = i+1; j < frames->record_count; j++) {
+		size_t next = record_offsets[j];
+		int same = compare(&current, &next, &compare_ctx);
+
+		if (same == 0) {
+		    count++;
+		} else {
+		    break;
+		}
+	    }
+
+	    i = j;
+
+	    size_t stack_size = *(frames->as.frames + current);
+
+	    VALUE type = *(frames->as.frames + current + stack_size + 2);
+
+	    rb_ary_push(unique_frames,
+		    rb_ary_new3(3,
+			type,
+			INT2NUM(count + 1),
+			make_frame_info(frames->as.frames + current, lines->as.lines + current)));
+
+	}
+
+	xfree(record_offsets);
+
+	result = unique_frames;
+    }
+
+    return result;
+}
+
+static VALUE
+initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE opts;
+    trace_stats_t * stats;
+
+    TypedData_Get_Struct(self, trace_stats_t, &trace_stats_type, stats);
+    rb_scan_args(argc, argv, ":", &opts);
+    if (!NIL_P(opts)) {
+	ID ids[2];
+	VALUE args[2];
+	ids[0] = rb_intern("interval");
+	rb_get_kwargs(opts, ids, 0, 1, args);
+
+	if (args[0] != Qundef) {
+	    stats->interval = NUM2INT(args[0]);
+	}
+    }
+
+    return self;
+}
+
+static VALUE
+interval(VALUE self)
+{
+    trace_stats_t * stats;
+    TypedData_Get_Struct(self, trace_stats_t, &trace_stats_type, stats);
+    return INT2NUM(stats->interval);
+}
+
+static VALUE
+allocation_count(VALUE self)
+{
+    trace_stats_t * stats;
+    TypedData_Get_Struct(self, trace_stats_t, &trace_stats_type, stats);
+    return INT2NUM(stats->allocation_count);
+}
+
+static VALUE
+overall_samples(VALUE self)
+{
+    trace_stats_t * stats;
+    TypedData_Get_Struct(self, trace_stats_t, &trace_stats_type, stats);
+    return INT2NUM(stats->overall_samples);
+}
+
+void
+Init_allocation_sampler(void)
+{
+    VALUE rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+
+    rb_cAllocationSampler = rb_define_class_under(rb_mObjSpace, "AllocationSampler", rb_cObject);
+    rb_define_alloc_func(rb_cAllocationSampler, allocate);
+    rb_define_method(rb_cAllocationSampler, "initialize", initialize, -1);
+    rb_define_method(rb_cAllocationSampler, "enable", enable, 0);
+    rb_define_method(rb_cAllocationSampler, "disable", disable, 0);
+    rb_define_method(rb_cAllocationSampler, "frames", frames, 0);
+    rb_define_method(rb_cAllocationSampler, "samples", samples, 0);
+    rb_define_method(rb_cAllocationSampler, "interval", interval, 0);
+    rb_define_method(rb_cAllocationSampler, "allocation_count", allocation_count, 0);
+    rb_define_method(rb_cAllocationSampler, "overall_samples", overall_samples, 0);
+}

data/ext/allocation_sampler/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS << " -Wno-declaration-after-statement"
+create_makefile('allocation_sampler')

data/ext/allocation_sampler/sort_r.h

@@ -0,0 +1,226 @@
+/* Obtained from https://github.com/noporpoise/sort_r on 2018-09-19 */
+/* Isaac Turner 29 April 2014 Public Domain */
+#ifndef SORT_R_H_
+#define SORT_R_H_
+
+#include <stdlib.h>
+#include <string.h>
+
+/*
+
+sort_r function to be exported.
+
+Parameters:
+  base is the array to be sorted
+  nel is the number of elements in the array
+  width is the size in bytes of each element of the array
+  compar is the comparison function
+  arg is a pointer to be passed to the comparison function
+
+void sort_r(void *base, size_t nel, size_t width,
+            int (*compar)(const void *_a, const void *_b, void *_arg),
+            void *arg);
+
+*/
+
+#define _SORT_R_INLINE inline
+
+#if (defined __APPLE__ || defined __MACH__ || defined __DARWIN__ || \
+     defined __FreeBSD__ || defined __DragonFly__)
+#  define _SORT_R_BSD
+#elif (defined _GNU_SOURCE || defined __gnu_hurd__ || defined __GNU__ || \
+       defined __linux__ || defined __MINGW32__ || defined __GLIBC__)
+#  define _SORT_R_LINUX
+#elif (defined _WIN32 || defined _WIN64 || defined __WINDOWS__)
+#  define _SORT_R_WINDOWS
+#  undef _SORT_R_INLINE
+#  define _SORT_R_INLINE __inline
+#else
+  /* Using our own recursive quicksort sort_r_simple() */
+#endif
+
+#if (defined NESTED_QSORT && NESTED_QSORT == 0)
+#  undef NESTED_QSORT
+#endif
+
+/* swap a, b iff a>b */
+/* __restrict is same as restrict but better support on old machines */
+static _SORT_R_INLINE int sort_r_cmpswap(char *__restrict a, char *__restrict b, size_t w,
+                                         int (*compar)(const void *_a, const void *_b,
+                                                       void *_arg),
+                                         void *arg)
+{
+  char tmp, *end = a+w;
+  if(compar(a, b, arg) > 0) {
+    for(; a < end; a++, b++) { tmp = *a; *a = *b; *b = tmp; }
+    return 1;
+  }
+  return 0;
+}
+
+/* Implement recursive quicksort ourselves */
+/* Note: quicksort is not stable, equivalent values may be swapped */
+static _SORT_R_INLINE void sort_r_simple(void *base, size_t nel, size_t w,
+                                         int (*compar)(const void *_a, const void *_b,
+                                                       void *_arg),
+                                         void *arg)
+{
+  char *b = (char *)base, *end = b + nel*w;
+  if(nel < 7) {
+    /* Insertion sort for arbitrarily small inputs */
+    char *pi, *pj;
+    for(pi = b+w; pi < end; pi += w) {
+      for(pj = pi; pj > b && sort_r_cmpswap(pj-w,pj,w,compar,arg); pj -= w) {}
+    }
+  }
+  else
+  {
+    /* nel > 6; Quicksort */
+
+    /* Use median of first, middle and last items as pivot */
+    char *x, *y, *xend, ch;
+    char *pl, *pr;
+    char *last = b+w*(nel-1), *tmp;
+    char *l[3];
+    l[0] = b;
+    l[1] = b+w*(nel/2);
+    l[2] = last;
+
+    if(compar(l[0],l[1],arg) > 0) { tmp=l[0]; l[0]=l[1]; l[1]=tmp; }
+    if(compar(l[1],l[2],arg) > 0) {
+      tmp=l[1]; l[1]=l[2]; l[2]=tmp; /* swap(l[1],l[2]) */
+      if(compar(l[0],l[1],arg) > 0) { tmp=l[0]; l[0]=l[1]; l[1]=tmp; }
+    }
+
+    /* swap l[id], l[2] to put pivot as last element */
+    for(x = l[1], y = last, xend = x+w; x<xend; x++, y++) {
+      ch = *x; *x = *y; *y = ch;
+    }
+
+    pl = b;
+    pr = last;
+
+    while(pl < pr) {
+      for(; pl < pr; pl += w) {
+        if(sort_r_cmpswap(pl, pr, w, compar, arg)) {
+          pr -= w; /* pivot now at pl */
+          break;
+        }
+      }
+      for(; pl < pr; pr -= w) {
+        if(sort_r_cmpswap(pl, pr, w, compar, arg)) {
+          pl += w; /* pivot now at pr */
+          break;
+        }
+      }
+    }
+
+    sort_r_simple(b, (pl-b)/w, w, compar, arg);
+    sort_r_simple(pl+w, (end-(pl+w))/w, w, compar, arg);
+  }
+}
+
+
+#if defined NESTED_QSORT
+
+  static _SORT_R_INLINE void sort_r(void *base, size_t nel, size_t width,
+                                    int (*compar)(const void *_a, const void *_b,
+                                                  void *aarg),
+                                    void *arg)
+  {
+    int nested_cmp(const void *a, const void *b)
+    {
+      return compar(a, b, arg);
+    }
+
+    qsort(base, nel, width, nested_cmp);
+  }
+
+#else /* !NESTED_QSORT */
+
+  /* Declare structs and functions */
+
+  #if defined _SORT_R_BSD
+
+    /* Ensure qsort_r is defined */
+    extern void qsort_r(void *base, size_t nel, size_t width, void *thunk,
+                        int (*compar)(void *_thunk, const void *_a, const void *_b));
+
+  #endif
+
+  #if defined _SORT_R_BSD || defined _SORT_R_WINDOWS
+
+    /* BSD (qsort_r), Windows (qsort_s) require argument swap */
+
+    struct sort_r_data
+    {
+      void *arg;
+      int (*compar)(const void *_a, const void *_b, void *_arg);
+    };
+
+    static _SORT_R_INLINE int sort_r_arg_swap(void *s, const void *a, const void *b)
+    {
+      struct sort_r_data *ss = (struct sort_r_data*)s;
+      return (ss->compar)(a, b, ss->arg);
+    }
+
+  #endif
+
+  #if defined _SORT_R_LINUX
+
+    typedef int(* __compar_d_fn_t)(const void *, const void *, void *);
+    extern void qsort_r(void *base, size_t nel, size_t width,
+                        __compar_d_fn_t __compar, void *arg)
+      __attribute__((nonnull (1, 4)));
+
+  #endif
+
+  /* implementation */
+
+  static _SORT_R_INLINE void sort_r(void *base, size_t nel, size_t width,
+                                    int (*compar)(const void *_a, const void *_b, void *_arg),
+                                    void *arg)
+  {
+    #if defined _SORT_R_LINUX
+
+      #if defined __GLIBC__ && ((__GLIBC__ < 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 8))
+
+        /* no qsort_r in glibc before 2.8, need to use nested qsort */
+        sort_r_simple(base, nel, width, compar, arg);
+
+      #else
+
+        qsort_r(base, nel, width, compar, arg);
+
+      #endif
+
+    #elif defined _SORT_R_BSD
+
+      struct sort_r_data tmp;
+      tmp.arg = arg;
+      tmp.compar = compar;
+      qsort_r(base, nel, width, &tmp, sort_r_arg_swap);
+
+    #elif defined _SORT_R_WINDOWS
+
+      struct sort_r_data tmp;
+      tmp.arg = arg;
+      tmp.compar = compar;
+      qsort_s(base, nel, width, sort_r_arg_swap, &tmp);
+
+    #else
+
+      /* Fall back to our own quicksort implementation */
+      sort_r_simple(base, nel, width, compar, arg);
+
+    #endif
+  }
+
+#endif /* !NESTED_QSORT */
+
+#undef _SORT_R_INLINE
+#undef _SORT_R_WINDOWS
+#undef _SORT_R_LINUX
+#undef _SORT_R_BSD
+
+#endif /* SORT_R_H_ */

data/lib/allocation_sampler.rb

@@ -0,0 +1,210 @@
+require 'allocation_sampler.so'
+require 'delegate'
+require 'set'
+require 'cgi/escape'
+
+module ObjectSpace
+  class AllocationSampler
+    VERSION = '1.0.0'
+
+    class Frame
+      attr_reader :id, :name, :path, :children
+
+      def initialize id, name, path
+        @id       = id
+        @name     = name
+        @path     = path
+      end
+    end
+
+    class Result
+      class Frame < DelegateClass(AllocationSampler::Frame)
+        attr_reader :line, :children
+        attr_accessor :samples, :total_samples
+
+        include Enumerable
+
+        def initialize frame, line, samples
+          super(frame)
+          @line = line
+          @samples = samples
+          @total_samples = 0
+          @children = Set.new
+        end
+
+        def each
+          seen = {}
+          stack = [self]
+
+          while node = stack.pop
+            next if seen[node]
+            seen[node] = true
+            yield node
+            stack.concat node.children.to_a
+          end
+        end
+
+        def to_dot
+          seen = {}
+          "digraph allocations {\n" +
+            "  node[shape=record];\n" + print_edges(self, seen, total_samples) + "}\n"
+        end
+
+        private
+
+        def print_edges node, seen, total_samples
+          return '' if seen[node.id]
+          seen[node.id] = node
+          "  #{node.id} [label=\"#{CGI.escapeHTML node.name}\"];\n" +
+            node.children.map { |child|
+            ratio = child.total_samples / total_samples.to_f
+            width = (1 * ratio) + 1
+            "  #{node.id} -> #{child.id} [penwidth=#{width}];\n" + print_edges(child, seen, total_samples)
+          }.join
+        end
+      end
+
+      attr_reader :samples, :frames
+
+      def initialize samples, frames
+        @samples = samples.sort_by! { |s| s[1] }.reverse!
+        @frames = frames
+      end
+
+      def allocations_by_type
+        @samples.each_with_object(Hash.new(0)) do |(type, count, _), h|
+          h[type] += count
+        end
+      end
+
+      def allocations_with_top_frame
+        @samples.each_with_object({}) do |(type, count, stack), h|
+          top_frame_id, line = stack.first
+          frame = @frames[top_frame_id]
+          ((h[type] ||= {})[frame.path] ||= {})[line] = count
+        end
+      end
+
+      def calltree
+        frame_delegates = {}
+        @samples.map { |type, count, stack|
+          build_tree(stack, count, frame_delegates)
+        }.uniq.first
+      end
+
+      def by_type_with_call_tree
+        types_with_stacks = @samples.group_by(&:first)
+        types_with_stacks.transform_values do |stacks|
+          frame_delegates = {}
+          stacks.map { |_, count, stack|
+            build_tree(stack, count, frame_delegates)
+          }.uniq.first
+        end
+      end
+
+      private
+
+      def build_tree stack, count, frame_delegates
+        top_down = stack.reverse
+        last_caller = nil
+        seen = Set.new
+        root = nil
+        top_frame_id, top_line = stack.first
+        top = frame_delegates[top_frame_id] ||= build_frame(top_frame_id, top_line, 0)
+        top.samples += count
+        top_down.each do |frame_id, line|
+          frame = frame_delegates[frame_id] ||= build_frame(frame_id, line, 0)
+          root ||= frame
+          if last_caller
+            last_caller.children << frame
+          end
+          last_caller = frame
+          last_caller.total_samples += count unless seen.include?(frame_id)
+          seen << frame_id
+        end
+        root
+      end
+
+      def build_frame id, line, samples
+        Frame.new @frames[id], line, samples
+      end
+    end
+
+    def result
+      Result.new samples, frames
+    end
+
+    module Display
+      class Stack < DelegateClass(IO)
+        attr_reader :max_depth
+
+        def initialize output: $stdout
+          super(output)
+        end
+
+        def show frames
+          max_width = max_width(frames, 0, {})
+          display(frames, 0, frames.total_samples, [], {}, max_width)
+        end
+
+        private
+
+        def max_width frame, depth, seen
+          if seen.key? frame
+            return 0
+          end
+
+          seen[frame] = true
+
+          my_length = (depth * 4) + frame.name.length
+
+          frame.children.each do |caller|
+            child_len = max_width caller, depth + 1, seen
+            my_length = child_len if my_length < child_len
+          end
+
+          my_length
+        end
+
+        def display frame, depth, total_samples, last_stack, seen, max_width
+          seen[frame] = true
+
+
+          buffer = max_width - ((depth * 4) + frame.name.length)
+
+          self_samples = frame.samples
+          last_stack.each_with_index do |last, i|
+            if i == last_stack.length - 1
+              if last
+                printf "`-- "
+              else
+                printf "|-- "
+              end
+            else
+              if last
+                printf "    "
+              else
+                printf "|   "
+              end
+            end
+          end
+
+
+          printf frame.name
+          printf " " * buffer
+          printf "% d % 8s", self_samples, "(%2.1f%%)" % (self_samples*100.0/total_samples)
+          puts
+
+          children = (frame.children || []).sort_by { |ie|
+            -ie.total_samples
+          }.reject { |f| seen[f] }
+
+          children.each_with_index do |child, i|
+            s = last_stack + [i == children.length - 1]
+            display child, depth + 1, total_samples, s, seen, max_width
+          end
+        end
+      end
+    end
+  end
+end

data/test/test_allocation_sampler.rb

@@ -0,0 +1,170 @@
+require 'minitest/autorun'
+require 'allocation_sampler'
+
+class TestAllocationSampler < Minitest::Test
+  def test_initialize
+    assert ObjectSpace::AllocationSampler.new
+  end
+
+  def test_init_with_params
+    as = ObjectSpace::AllocationSampler.new(interval: 10)
+    assert_equal 10, as.interval
+  end
+
+  def test_init_with_location
+    iseq = RubyVM::InstructionSequence.new <<-eoruby
+    Object.new
+    Object.new
+    eoruby
+    as = ObjectSpace::AllocationSampler.new(interval: 1)
+    as.enable
+    iseq.eval
+    as.disable
+
+    assert_equal({"Object"=>{"<compiled>"=>{1=>1, 2=>1}}}, filter(as.result))
+  end
+
+  def test_location_same_line
+    iseq = RubyVM::InstructionSequence.new <<-eoruby
+    10.times { Object.new }
+    eoruby
+    as = ObjectSpace::AllocationSampler.new(interval: 1)
+    as.enable
+    iseq.eval
+    as.disable
+
+    assert_equal({"Object"=>{"<compiled>"=>{1=>10}}}, filter(as.result))
+  end
+
+  def test_location_mixed
+    iseq = RubyVM::InstructionSequence.new <<-eoruby
+    10.times { Object.new }
+    Object.new
+    eoruby
+    as = ObjectSpace::AllocationSampler.new(interval: 1)
+    as.enable
+    iseq.eval
+    as.disable
+
+    assert_equal({"Object"=>{"<compiled>"=>{1=>10, 2=>1}}}, filter(as.result))
+  end
+
+  def test_location_from_method
+    iseq = RubyVM::InstructionSequence.new <<-eoruby
+    def foo
+      10.times { Object.new }
+      Object.new
+    end
+    foo
+    eoruby
+    as = ObjectSpace::AllocationSampler.new(interval: 1)
+    as.enable
+    iseq.eval
+    as.disable
+
+    assert_equal({"Object"=>{"<compiled>"=>{2=>10, 3=>1}}}, filter(as.result))
+  end
+
+  def test_location_larger_interval
+    iseq = RubyVM::InstructionSequence.new <<-eom
+    100.times { Object.new }
+    100.times { Object.new }
+    eom
+    as = ObjectSpace::AllocationSampler.new(interval: 10)
+    as.enable
+    iseq.eval
+    as.disable
+
+    assert_equal({"Object"=>{"<compiled>"=>{1=>10, 2=>10}}}, filter(as.result))
+    assert_equal 201, as.allocation_count
+  end
+
+  def test_interval_default
+    as = ObjectSpace::AllocationSampler.new
+    assert_equal 1, as.interval
+  end
+
+  def test_two_with_same_type
+    as = ObjectSpace::AllocationSampler.new
+    as.enable
+    Object.new
+    Object.new
+    as.disable
+
+    assert_equal(2, filter(as.result)[Object.name].values.flat_map(&:values).inject(:+))
+  end
+
+  def test_two_with_same_type_same_line
+    as = ObjectSpace::AllocationSampler.new
+    as.enable
+    Object.new; Object.new
+    Object.new; Object.new
+    as.disable
+
+    assert_equal 4, as.result.allocations_by_type[Object.name]
+  end
+
+  class X
+  end
+
+  def test_expands
+    as = ObjectSpace::AllocationSampler.new
+    as.enable
+    500.times do
+      Object.new
+      X.new
+    end
+    Object.new
+    as.disable
+
+    result = as.result
+    assert_equal 501, result.allocations_by_type[Object.name]
+    assert_equal 500, result.allocations_by_type[TestAllocationSampler::X.name]
+  end
+
+  def d
+    Object.new
+  end
+  def c;  5.times { d }; end
+  def b;  5.times { c }; end
+  def a;  5.times { b }; end
+
+  def test_stack_trace
+    as = ObjectSpace::AllocationSampler.new
+    buffer = StringIO.new
+    stack_printer = ObjectSpace::AllocationSampler::Display::Stack.new(
+      output: buffer
+    )
+    as.enable
+    a
+    as.disable
+
+    as.result.by_type_with_call_tree.each do |class_name, tree|
+      assert_equal Object.name, class_name
+      root = tree.find { |node| node.name.include? __method__.to_s }
+      stack_printer.show root
+    end
+    assert_equal <<-eoout, buffer.string
+TestAllocationSampler#test_stack_trace  0   (0.0%)
+`-- TestAllocationSampler#a             0   (0.0%)
+    `-- TestAllocationSampler#b         0   (0.0%)
+        `-- TestAllocationSampler#c     0   (0.0%)
+            `-- TestAllocationSampler#d 125 (100.0%)
+    eoout
+  end
+
+  def test_dot
+    as = ObjectSpace::AllocationSampler.new
+    as.enable
+    a
+    as.disable
+
+    File.write 'out.dot', as.result.calltree.to_dot
+  end
+
+  private
+
+  def filter result
+    result.allocations_with_top_frame
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: allocation_sampler
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aaron Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+description: |-
+  A sampling allocation profiler.  This keeps track of allocations, but only on
+  specified intervals.  Useful for profiling allocations in programs where there
+  is a time limit on completion of the program.
+email:
+- aaron@tenderlovemaking.com
+executables: []
+extensions:
+- ext/allocation_sampler/extconf.rb
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- ext/allocation_sampler/allocation_sampler.c
+- ext/allocation_sampler/extconf.rb
+- ext/allocation_sampler/sort_r.h
+- lib/allocation_sampler.rb
+- test/test_allocation_sampler.rb
+homepage: https://github.com/tenderlove/allocation_sampler
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: A sampling allocation profiler
+test_files: []