allocation_tracer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3ec726b2a738166d01a261edd355fe34d8a727af
+  data.tar.gz: 4bcfe98dad9c2e41621992b780a60c419f710b70
+SHA512:
+  metadata.gz: 0c2195f1424ca3220e939519b79130a4baad68993643fd895d1c26433d313876738372232cdd12df1a673b6d248af736647d11c0d35ed2018996ee49dad6927d
+  data.tar.gz: 6a28c18f2c5a943c28cbde895f020dfe7cc8e4542c83bdf3d8b05058d7210d7ee6f3ff8fffcd055ed65e374bd9e5f88b82fb980747a02b2b9c873cef91997dec

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in allocation_tracer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Koichi Sasada
+
+MIT License
+
+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/README.md

@@ -0,0 +1,149 @@
+# ObjectSpace::AllocationTracer
+
+This module allows to trace object allocation.
+
+This feature is similar to https://github.com/SamSaffron/memory_profiler 
+and https://github.com/srawlins/allocation_stats. But this feature 
+focused on `age' of objects.
+
+This gem was separated from gc_tracer.gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'allocation_tracer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install allocation_tracer
+
+## Usage
+
+### Allocation tracing
+
+You can trace allocation information and you can get aggregated information.
+
+```ruby
+require 'allocation_tracer'
+require 'pp'
+
+pp ObjectSpace::AllocationTracer.trace{
+  50_000.times{|i|
+    i.to_s
+    i.to_s
+    i.to_s
+  }
+}
+```
+
+will show
+
+```
+{["test.rb", 6]=>[50000, 44290, 0, 6],
+ ["test.rb", 7]=>[50000, 44289, 0, 5],
+ ["test.rb", 8]=>[50000, 44295, 0, 6]}
+```
+
+In this case, 50,000 objects are created at `test.rb:6'. 44,290 is total 
+age of objects created at this line. Average age of object created at 
+this line is 50000/44290 = 0.8858. 0 is minimum age and 6 is maximum age.
+
+You can also specify `type' in GC::Tracer.setup_allocation_tracing() to 
+specify what should be keys to aggregate like that.
+
+```ruby
+require 'allocation_tracer'
+require 'pp'
+
+ObjectSpace::AllocationTracer.setup(%i{path line type})
+
+result = ObjectSpace::AllocationTracer.trace do
+  50_000.times{|i|
+    a = [i.to_s]
+    b = {i.to_s => nil}
+    c = (i.to_s .. i.to_s)
+  }
+end
+
+pp result
+```
+
+and you will get:
+
+```
+{["test.rb", 8, :T_STRING]=>[50000, 49067, 0, 17],
+ ["test.rb", 8, :T_ARRAY]=>[50000, 49053, 0, 17],
+ ["test.rb", 9, :T_STRING]=>[100000, 98146, 0, 17],
+ ["test.rb", 9, :T_HASH]=>[50000, 49111, 0, 17],
+ ["test.rb", 10, :T_STRING]=>[100000, 98267, 0, 17],
+ ["test.rb", 10, :T_STRUCT]=>[50000, 49126, 0, 17]}
+```
+
+Interestingly, you can not see array creations in a middle of block:
+
+```ruby
+require 'allocation_tracer'
+require 'pp'
+
+ObjectSpace::AllocationTracer.setup(%i{path line type})
+
+result = ObjectSpace::AllocationTracer.trace do
+  50_000.times{|i|
+    [i.to_s]
+    nil
+  }
+end
+
+pp result
+```
+
+and it prints:
+
+```
+{["test.rb", 8, :T_STRING]=>[50000, 38322, 0, 2]}
+```
+
+There are only string creation. This is because unused array creation is 
+ommitted by optimizer.
+
+Simply you can require `allocation_tracer/trace' to start allocation 
+tracer and output the aggregated information into stdot at the end of 
+program.
+
+```ruby
+require 'allocation_tracer/trace'
+
+# Run your program here
+50_000.times{|i|
+  i.to_s
+  i.to_s
+  i.to_s
+}
+```
+
+and you will see:
+
+```
+path    line    count   total_age       max_age min_age
+.../lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb 55      18      23      1       6
+.../lib/allocation_tracer/trace.rb       6       2       12      6       6
+test.rb 0       1       0       0       0
+test.rb 5       50000   41645   0       4
+test.rb 6       50000   41648   0       5
+test.rb 7       50000   41650   0       5
+```
+
+(tab separated colums)
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/allocation_tracer/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+require 'rspec/core/rake_task'
+
+spec = Gem::Specification.load('allocation_tracer.gemspec')
+
+Rake::ExtensionTask.new("allocation_tracer", spec){|ext|
+  ext.lib_dir = "lib/allocation_tracer"
+}
+
+RSpec::Core::RakeTask.new('spec' => 'compile')
+
+task default: :spec
+
+task :run => 'compile' do
+  ruby %q{-I ./lib test.rb}
+end

data/allocation_tracer.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'allocation_tracer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "allocation_tracer"
+  spec.version       = ObjectSpace::AllocationTracer::VERSION
+  spec.authors       = ["Koichi Sasada"]
+  spec.email         = ["ko1@atdot.net"]
+  spec.summary       = %q{allocation_tracer gem adds ObjectSpace::AllocationTracer module.}
+  spec.description   = %q{allocation_tracer gem adds ObjectSpace::AllocationTracer module.}
+  spec.homepage      = "https://github.com/ko1/allocation_tracer"
+  spec.license       = "MIT"
+
+  spec.extensions    = %w[ext/allocation_tracer/extconf.rb]
+  spec.required_ruby_version = '>= 2.1.0'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rspec"
+end

data/ext/allocation_tracer/allocation_tracer.c

@@ -0,0 +1,568 @@
+/*
+ * allocation tracer: adds GC::Tracer::start_allocation_tracing
+ *
+ * By Koichi Sasada
+ * created at Thu Apr 17 03:50:38 2014.
+ */
+
+#include "ruby/ruby.h"
+#include "ruby/debug.h"
+
+static VALUE rb_mAllocationTracer;
+
+struct allocation_info {
+    /* all of information don't need marking. */
+    int living;
+    VALUE flags;
+    VALUE klass;
+    const char *klass_path;
+    size_t generation;
+
+    /* allocation info */
+    const char *path;
+    unsigned long line;
+
+    struct allocation_info *next;
+};
+
+#define KEY_PATH    (1<<1)
+#define KEY_LINE    (1<<2)
+#define KEY_TYPE    (1<<3)
+#define KEY_CLASS   (1<<4)
+
+#define VAL_COUNT     (1<<1)
+#define VAL_TOTAL_AGE (1<<2)
+#define VAL_MAX_AGE   (1<<3)
+#define VAL_MIN_AGE   (1<<4)
+
+struct traceobj_arg {
+    int running;
+    int keys, vals;
+    st_table *aggregate_table;  /* user defined key -> [count, total_age, max_age, min_age] */
+    st_table *object_table;     /* obj (VALUE)      -> allocation_info */
+    st_table *str_table;        /* cstr             -> refcount */
+    struct allocation_info *freed_allocation_info;
+};
+
+static char *
+keep_unique_str(st_table *tbl, const char *str)
+{
+    st_data_t n;
+
+    if (str && st_lookup(tbl, (st_data_t)str, &n)) {
+	char *result;
+
+	st_insert(tbl, (st_data_t)str, n+1);
+	st_get_key(tbl, (st_data_t)str, (st_data_t *)&result);
+
+	return result;
+    }
+    else {
+	return NULL;
+    }
+}
+
+static const char *
+make_unique_str(st_table *tbl, const char *str, long len)
+{
+    if (!str) {
+	return NULL;
+    }
+    else {
+	char *result;
+
+	if ((result = keep_unique_str(tbl, str)) == NULL) {
+	    result = (char *)ruby_xmalloc(len+1);
+	    strncpy(result, str, len);
+	    result[len] = 0;
+	    st_add_direct(tbl, (st_data_t)result, 1);
+	}
+	return result;
+    }
+}
+
+static void
+delete_unique_str(st_table *tbl, const char *str)
+{
+    if (str) {
+	st_data_t n;
+
+	st_lookup(tbl, (st_data_t)str, &n);
+	if (n == 1) {
+	    st_delete(tbl, (st_data_t *)&str, 0);
+	    ruby_xfree((char *)str);
+	}
+	else {
+	    st_insert(tbl, (st_data_t)str, n-1);
+	}
+    }
+}
+
+/* file, line, type */
+#define MAX_KEY_DATA 4
+
+struct memcmp_key_data {
+    int n;
+    st_data_t data[4];
+};
+
+static int
+memcmp_hash_compare(st_data_t a, st_data_t b)
+{
+    struct memcmp_key_data *k1 = (struct memcmp_key_data *)a;
+    struct memcmp_key_data *k2 = (struct memcmp_key_data *)b;
+    return memcmp(&k1->data[0], &k2->data[0], k1->n * sizeof(st_data_t));
+}
+
+static st_index_t
+memcmp_hash_hash(st_data_t a)
+{
+    struct memcmp_key_data *k = (struct memcmp_key_data *)a;
+    return rb_memhash(k->data, sizeof(st_data_t) * k->n);
+}
+
+static const struct st_hash_type memcmp_hash_type = {
+    memcmp_hash_compare, memcmp_hash_hash
+};
+
+static struct traceobj_arg *tmp_trace_arg; /* TODO: Do not use global variables */
+
+static struct traceobj_arg *
+get_traceobj_arg(void)
+{
+    if (tmp_trace_arg == 0) {
+	tmp_trace_arg = ALLOC_N(struct traceobj_arg, 1);
+	tmp_trace_arg->running = 0;
+	tmp_trace_arg->keys = 0;
+	tmp_trace_arg->vals = VAL_COUNT | VAL_TOTAL_AGE | VAL_MAX_AGE | VAL_MIN_AGE;
+	tmp_trace_arg->aggregate_table = st_init_table(&memcmp_hash_type);
+	tmp_trace_arg->object_table = st_init_numtable();
+	tmp_trace_arg->str_table = st_init_strtable();
+	tmp_trace_arg->freed_allocation_info = NULL;
+    }
+    return tmp_trace_arg;
+}
+
+static int
+free_keys_i(st_data_t key, st_data_t value, void *data)
+{
+    ruby_xfree((void *)key);
+    return ST_CONTINUE;
+}
+
+static int
+free_values_i(st_data_t key, st_data_t value, void *data)
+{
+    ruby_xfree((void *)value);
+    return ST_CONTINUE;
+}
+
+static int
+free_key_values_i(st_data_t key, st_data_t value, void *data)
+{
+    ruby_xfree((void *)key);
+    ruby_xfree((void *)value);
+    return ST_CONTINUE;
+}
+
+static void
+clear_traceobj_arg(void)
+{
+    struct traceobj_arg * arg = get_traceobj_arg();
+
+    st_foreach(arg->aggregate_table, free_key_values_i, 0);
+    st_clear(arg->aggregate_table);
+    st_foreach(arg->object_table, free_values_i, 0);
+    st_clear(arg->object_table);
+    st_foreach(arg->str_table, free_keys_i, 0);
+    st_clear(arg->str_table);
+}
+
+static struct allocation_info *
+create_allocation_info(void)
+{
+    return (struct allocation_info *)ruby_xmalloc(sizeof(struct allocation_info));
+}
+
+static void
+free_allocation_info(struct traceobj_arg *arg, struct allocation_info *info)
+{
+    delete_unique_str(arg->str_table, info->path);
+    delete_unique_str(arg->str_table, info->klass_path);
+    ruby_xfree(info);
+}
+
+static void
+newobj_i(VALUE tpval, void *data)
+{
+    struct traceobj_arg *arg = (struct traceobj_arg *)data;
+    struct allocation_info *info;
+    rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+    VALUE obj = rb_tracearg_object(tparg);
+    VALUE klass = RBASIC_CLASS(obj);
+    VALUE path = rb_tracearg_path(tparg);
+    VALUE line = rb_tracearg_lineno(tparg);
+    VALUE klass_path = (RTEST(klass) && !OBJ_FROZEN(klass)) ? rb_class_path_cached(klass) : Qnil;
+    const char *path_cstr = RTEST(path) ? make_unique_str(arg->str_table, RSTRING_PTR(path), RSTRING_LEN(path)) : NULL;
+    const char *klass_path_cstr = RTEST(klass_path) ? make_unique_str(arg->str_table, RSTRING_PTR(klass_path), RSTRING_LEN(klass_path)) : NULL;
+
+    if (st_lookup(arg->object_table, (st_data_t)obj, (st_data_t *)&info)) {
+	if (info->living) {
+	    /* do nothing. there is possibility to keep living if FREEOBJ events while suppressing tracing */
+	}
+	/* reuse info */
+	delete_unique_str(arg->str_table, info->path);
+	delete_unique_str(arg->str_table, info->klass_path);
+    }
+    else {
+	info = create_allocation_info();
+    }
+
+    info->next = NULL;
+    info->living = 1;
+    info->flags = RBASIC(obj)->flags;
+    info->klass = klass;
+    info->klass_path = klass_path_cstr;
+    info->generation = rb_gc_count();
+
+    info->path = path_cstr;
+    info->line = NUM2INT(line);
+
+    st_insert(arg->object_table, (st_data_t)obj, (st_data_t)info);
+}
+
+/* file, line, type, klass */
+#define MAX_KEY_SIZE 4
+
+void
+aggregator_i(void *data)
+{
+    size_t gc_count = rb_gc_count();
+    struct traceobj_arg *arg = (struct traceobj_arg *)data;
+    struct allocation_info *info = arg->freed_allocation_info;
+
+    arg->freed_allocation_info = NULL;
+
+    while (info) {
+	struct allocation_info *next_info = info->next;
+	st_data_t key, val;
+	struct memcmp_key_data key_data;
+	int *val_buff;
+	int age = (int)(gc_count - info->generation);
+	int i;
+
+	i = 0;
+	if (arg->keys & KEY_PATH) {
+	    key_data.data[i++] = (st_data_t)info->path;
+	}
+	if (arg->keys & KEY_LINE) {
+	    key_data.data[i++] = (st_data_t)info->line;
+	}
+	if (arg->keys & KEY_TYPE) {
+	    key_data.data[i++] = (st_data_t)(info->flags & T_MASK);
+	}
+	if (arg->keys & KEY_CLASS) {
+	    key_data.data[i++] = (st_data_t)info->klass_path;
+	}
+	key_data.n = i;
+	key = (st_data_t)&key_data;
+
+	if (st_lookup(arg->aggregate_table, key, &val) == 0) {
+	    struct memcmp_key_data *key_buff = ruby_xmalloc(sizeof(int) + sizeof(st_data_t) * key_data.n);
+	    key_buff->n = key_data.n;
+
+	    for (i=0; i<key_data.n; i++) {
+		key_buff->data[i] = key_data.data[i];
+	    }
+	    key = (st_data_t)key_buff;
+
+	    /* count, total age, max age, min age */
+	    val_buff = ALLOC_N(int, 4);
+	    val_buff[0] = val_buff[1] = 0;
+	    val_buff[2] = val_buff[3] = age;
+
+	    if (arg->keys & KEY_PATH) keep_unique_str(arg->str_table, info->path);
+	    if (arg->keys & KEY_CLASS) keep_unique_str(arg->str_table, info->klass_path);
+
+	    st_insert(arg->aggregate_table, (st_data_t)key_buff, (st_data_t)val_buff);
+	}
+	else {
+	    val_buff = (int *)val;
+	}
+
+	val_buff[0] += 1;
+	val_buff[1] += age;
+	if (val_buff[2] > age) val_buff[2] = age;
+	if (val_buff[3] < age) val_buff[3] = age;
+
+	free_allocation_info(arg, info);
+	info = next_info;
+    }
+}
+
+static void
+move_to_freed_list(struct traceobj_arg *arg, VALUE obj, struct allocation_info *info)
+{
+    info->next = arg->freed_allocation_info;
+    arg->freed_allocation_info = info;
+    st_delete(arg->object_table, (st_data_t *)&obj, (st_data_t *)&info);
+}
+
+static void
+freeobj_i(VALUE tpval, void *data)
+{
+    struct traceobj_arg *arg = (struct traceobj_arg *)data;
+    rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+    VALUE obj = rb_tracearg_object(tparg);
+    struct allocation_info *info;
+
+    if (arg->freed_allocation_info == NULL) {
+	rb_postponed_job_register_one(0, aggregator_i, arg);
+    }
+
+    if (st_lookup(arg->object_table, (st_data_t)obj, (st_data_t *)&info)) {
+	move_to_freed_list(arg, obj, info);
+    }
+}
+
+static void
+start_alloc_hooks(VALUE mod)
+{
+    VALUE newobj_hook, freeobj_hook;
+    struct traceobj_arg *arg = get_traceobj_arg();
+
+    if ((newobj_hook = rb_ivar_get(rb_mAllocationTracer, rb_intern("newobj_hook"))) == Qnil) {
+	rb_ivar_set(rb_mAllocationTracer, rb_intern("newobj_hook"), newobj_hook = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, arg));
+	rb_ivar_set(rb_mAllocationTracer, rb_intern("freeobj_hook"), freeobj_hook = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, arg));
+    }
+    else {
+	freeobj_hook = rb_ivar_get(rb_mAllocationTracer, rb_intern("freeobj_hook"));
+    }
+
+    rb_tracepoint_enable(newobj_hook);
+    rb_tracepoint_enable(freeobj_hook);
+}
+
+static const char *
+type_name(int type)
+{
+    switch (type) {
+#define TYPE_NAME(t) case (t): return #t;
+	TYPE_NAME(T_NONE);
+	TYPE_NAME(T_OBJECT);
+	TYPE_NAME(T_CLASS);
+	TYPE_NAME(T_MODULE);
+	TYPE_NAME(T_FLOAT);
+	TYPE_NAME(T_STRING);
+	TYPE_NAME(T_REGEXP);
+	TYPE_NAME(T_ARRAY);
+	TYPE_NAME(T_HASH);
+	TYPE_NAME(T_STRUCT);
+	TYPE_NAME(T_BIGNUM);
+	TYPE_NAME(T_FILE);
+	TYPE_NAME(T_MATCH);
+	TYPE_NAME(T_COMPLEX);
+	TYPE_NAME(T_RATIONAL);
+	TYPE_NAME(T_NIL);
+	TYPE_NAME(T_TRUE);
+	TYPE_NAME(T_FALSE);
+	TYPE_NAME(T_SYMBOL);
+	TYPE_NAME(T_FIXNUM);
+	TYPE_NAME(T_UNDEF);
+	TYPE_NAME(T_NODE);
+	TYPE_NAME(T_ICLASS);
+	TYPE_NAME(T_ZOMBIE);
+	TYPE_NAME(T_DATA);
+#undef TYPE_NAME
+    }
+    return "unknown";
+}
+
+struct arg_and_result {
+    struct traceobj_arg *arg;
+    VALUE result;
+};
+
+static int
+aggregate_result_i(st_data_t key, st_data_t val, void *data)
+{
+    struct arg_and_result *aar = (struct arg_and_result *)data;
+    struct traceobj_arg *arg = aar->arg;
+    VALUE result = aar->result;
+
+    int *val_buff = (int *)val;
+    struct memcmp_key_data *key_buff = (struct memcmp_key_data *)key;
+    VALUE v = rb_ary_new3(4, INT2FIX(val_buff[0]), INT2FIX(val_buff[1]), INT2FIX(val_buff[2]), INT2FIX(val_buff[3]));
+    VALUE k = rb_ary_new();
+    int i = 0;
+    static VALUE type_symbols[T_MASK] = {0};
+
+    if (type_symbols[0] == 0) {
+	int i;
+	for (i=0; i<T_MASK; i++) {
+	    type_symbols[i] = ID2SYM(rb_intern(type_name(i)));
+	}
+    }
+
+    i = 0;
+    if (arg->keys & KEY_PATH) {
+	const char *path = (const char *)key_buff->data[i++];
+	if (path) {
+	    rb_ary_push(k, rb_str_new2(path));
+	    delete_unique_str(arg->str_table, path);
+	}
+	else {
+	    rb_ary_push(k, Qnil);
+	}
+    }
+    if (arg->keys & KEY_LINE) {
+	rb_ary_push(k, INT2FIX((int)key_buff->data[i++]));
+    }
+    if (arg->keys & KEY_TYPE) {
+	rb_ary_push(k, type_symbols[key_buff->data[i++]]);
+    }
+    if (arg->keys & KEY_CLASS) {
+	const char *klass_path = (const char *)key_buff->data[i++];
+	if (klass_path) {
+	    
+	    delete_unique_str(arg->str_table, klass_path);
+	}
+	else {
+	    rb_ary_push(k, Qnil);
+	}
+    }
+
+    rb_hash_aset(result, k, v);
+
+    return ST_CONTINUE;
+}
+
+static int
+aggregate_rest_object_i(st_data_t key, st_data_t val, void *data)
+{
+    struct traceobj_arg *arg = (struct traceobj_arg *)data;
+    struct allocation_info *info = (struct allocation_info *)val;
+    move_to_freed_list(arg, (VALUE)key, info);
+    return ST_CONTINUE;
+}
+
+static VALUE
+aggregate_result(struct traceobj_arg *arg)
+{
+    struct arg_and_result aar;
+    aar.result = rb_hash_new();
+    aar.arg = arg;
+
+    st_foreach(arg->object_table, aggregate_rest_object_i, (st_data_t)arg);
+    aggregator_i(arg);
+    st_foreach(arg->aggregate_table, aggregate_result_i, (st_data_t)&aar);
+    clear_traceobj_arg();
+    return aar.result;
+}
+
+static VALUE
+stop_allocation_tracing(VALUE self)
+{
+    struct traceobj_arg * arg = get_traceobj_arg();
+
+    if (arg->running) {
+	VALUE newobj_hook = rb_ivar_get(rb_mAllocationTracer, rb_intern("newobj_hook"));
+	VALUE freeobj_hook = rb_ivar_get(rb_mAllocationTracer, rb_intern("freeobj_hook"));
+	rb_tracepoint_disable(newobj_hook);
+	rb_tracepoint_disable(freeobj_hook);
+
+	arg->running = 0;
+    }
+    else {
+	rb_raise(rb_eRuntimeError, "not started yet.");
+    }
+
+    return Qnil;
+}
+
+static VALUE
+allocation_tracer_stop(VALUE self)
+{
+    stop_allocation_tracing(self);
+    return aggregate_result(get_traceobj_arg());
+}
+
+static VALUE
+allocation_tracer_trace(VALUE self)
+{
+    struct traceobj_arg * arg = get_traceobj_arg();
+
+    if (arg->running) {
+	rb_raise(rb_eRuntimeError, "can't run recursivly");
+    }
+    else {
+	arg->running = 1;
+	if (arg->keys == 0) arg->keys = KEY_PATH | KEY_LINE;
+	start_alloc_hooks(rb_mAllocationTracer);
+
+	if (rb_block_given_p()) {
+	    rb_ensure(rb_yield, Qnil, stop_allocation_tracing, Qnil);
+	    return aggregate_result(get_traceobj_arg());
+	}
+    }
+
+    return Qnil;
+}
+
+static VALUE
+allocation_tracer_setup(int argc, VALUE *argv, VALUE self)
+{
+    struct traceobj_arg * arg = get_traceobj_arg();
+
+    if (arg->running) {
+	rb_raise(rb_eRuntimeError, "can't change configuration during running");
+    }
+    else {
+	int i;
+	VALUE ary = rb_check_array_type(argv[0]);
+
+	for (i=0; i<(int)RARRAY_LEN(ary); i++) {
+	         if (RARRAY_AREF(ary, i) == ID2SYM(rb_intern("path"))) arg->keys |= KEY_PATH;
+	    else if (RARRAY_AREF(ary, i) == ID2SYM(rb_intern("line"))) arg->keys |= KEY_LINE;
+	    else if (RARRAY_AREF(ary, i) == ID2SYM(rb_intern("type"))) arg->keys |= KEY_TYPE;
+	    else if (RARRAY_AREF(ary, i) == ID2SYM(rb_intern("class"))) arg->keys |= KEY_CLASS;
+	    else {
+		rb_raise(rb_eArgError, "not supported key type");
+	    }
+	}
+    }
+
+    return Qnil;
+}
+
+VALUE
+allocation_tracer_header(VALUE self)
+{
+    VALUE ary = rb_ary_new();
+    struct traceobj_arg * arg = get_traceobj_arg();
+
+    if (arg->keys & KEY_PATH) rb_ary_push(ary, ID2SYM(rb_intern("path")));
+    if (arg->keys & KEY_LINE) rb_ary_push(ary, ID2SYM(rb_intern("line")));
+    if (arg->keys & KEY_TYPE) rb_ary_push(ary, ID2SYM(rb_intern("type")));
+    if (arg->keys & KEY_CLASS) rb_ary_push(ary, ID2SYM(rb_intern("class")));
+
+    if (arg->vals & VAL_COUNT) rb_ary_push(ary, ID2SYM(rb_intern("count")));
+    if (arg->vals & VAL_TOTAL_AGE) rb_ary_push(ary, ID2SYM(rb_intern("total_age")));
+    if (arg->vals & VAL_MAX_AGE) rb_ary_push(ary, ID2SYM(rb_intern("max_age")));
+    if (arg->vals & VAL_MIN_AGE) rb_ary_push(ary, ID2SYM(rb_intern("min_age")));
+
+    return ary;
+}
+
+void
+Init_allocation_tracer(void)
+{
+    VALUE rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+    VALUE mod = rb_mAllocationTracer = rb_define_module_under(rb_mObjSpace, "AllocationTracer");
+
+    /* allocation tracer methods */
+    rb_define_module_function(mod, "trace", allocation_tracer_trace, 0);
+    rb_define_module_function(mod, "stop", allocation_tracer_stop, 0);
+    rb_define_module_function(mod, "setup", allocation_tracer_setup, -1);
+    rb_define_module_function(mod, "header", allocation_tracer_header, 0);
+}

data/ext/allocation_tracer/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('allocation_tracer/allocation_tracer')

data/lib/allocation_tracer.rb

@@ -0,0 +1,6 @@
+require "allocation_tracer/version"
+require "allocation_tracer/allocation_tracer"
+
+module ObjectSpace::AllocationTracer
+  # Your code goes here...
+end

data/lib/allocation_tracer/trace.rb

@@ -0,0 +1,15 @@
+require 'allocation_tracer'
+
+# ObjectSpace::AllocationTracer.setup(%i{path line})
+ObjectSpace::AllocationTracer.trace
+
+at_exit{
+  results = ObjectSpace::AllocationTracer.stop
+
+  puts ObjectSpace::AllocationTracer.header.join("\t")
+  results.sort_by{|k, v| k}.each{|k, v|
+    puts (k+v).join("\t")
+  }
+}
+
+

data/lib/allocation_tracer/version.rb

@@ -0,0 +1,3 @@
+module ObjectSpace::AllocationTracer
+  VERSION = "0.0.1"
+end

data/spec/allocation_tracer_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+
+describe ObjectSpace::AllocationTracer do
+  describe 'ObjectSpace::AllocationTracer.trace' do
+    it 'should includes allocation information' do
+      line = __LINE__ + 2
+      result = ObjectSpace::AllocationTracer.trace do
+        Object.new
+      end
+
+      expect(result.length).to be >= 1
+      expect(result[[__FILE__, line]]).to eq [1, 0, 0, 0]
+    end
+
+    it 'should run twice' do
+      line = __LINE__ + 2
+      result = ObjectSpace::AllocationTracer.trace do
+        Object.new
+      end
+
+      expect(result.length).to be >= 1
+      expect(result[[__FILE__, line]]).to eq [1, 0, 0, 0]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'allocation_tracer'
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: allocation_tracer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Koichi Sasada
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: allocation_tracer gem adds ObjectSpace::AllocationTracer module.
+email:
+- ko1@atdot.net
+executables: []
+extensions:
+- ext/allocation_tracer/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- allocation_tracer.gemspec
+- ext/allocation_tracer/allocation_tracer.c
+- ext/allocation_tracer/extconf.rb
+- lib/allocation_tracer.rb
+- lib/allocation_tracer/allocation_tracer.so
+- lib/allocation_tracer/trace.rb
+- lib/allocation_tracer/version.rb
+- spec/allocation_tracer_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ko1/allocation_tracer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: allocation_tracer gem adds ObjectSpace::AllocationTracer module.
+test_files:
+- spec/allocation_tracer_spec.rb
+- spec/spec_helper.rb
+has_rdoc: