gc_tracer 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe62a5d40bec9e63a7f686a912ad5b7025de0baa
-  data.tar.gz: 8103c971df3779bb9d2aa3a57b98208540be98ef
+  metadata.gz: f02605c54bfd6ac29179037b21d3af38c7c8e0bd
+  data.tar.gz: a7a328f0b154d4952bf7ca57f669303d53b341a3
 SHA512:
-  metadata.gz: 5901c6798b9f33b90e584db043ad102feba487c4206bc1b67b9d7d6570353bb08cf39980130bb767ec89fa22debb3c5ed9543ef531db2a8137bf7ee6e9a128b1
-  data.tar.gz: 5ce7a8796a30b4e3f05284a7108043ea942b52878904ec6925cf5def9ad1f4dc114cfee9dec0466f39fb7f5df0f5f82da34123ea511c404d33f4bc785e1e124c
+  metadata.gz: 7e8bef62c7648c00b1a25dcfd0370ad53f8ee1b6dd9f210535f723982a60fcb05e8a75cfaaedd74f40c6d8d449248f1abce5a0ab2cb4e1ee07b1dfffa1264f9c
+  data.tar.gz: 76228e7ed79f5e94f45a732e0b7ca8fb26f69bcf36bac5dd058a78561cdcf883e4f9474c749b9efe31582e09a10fbbd108b99513a984cf373bd205ac4d6b2557

data/README.md

@@ -23,7 +23,6 @@ Or install it yourself as:
 gc_tracer gem adds GC::Tracer module. GC::Tracer module has the following features.
 
 - Logging GC statistics information
-- Allocation tracing information
 - ObjectSpace recorder
 
 ### Logging
@@ -60,127 +59,6 @@ at each events, there are one of:
 
 For one GC, you can get all three lines.
 
-### Allocation tracing
-
-You can trace allocation information and you can get aggregated information.
-
-```ruby
-require 'gc_tracer'
-require 'pp'
-
-pp GC::Tracer.start_allocation_tracing{
-  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 'gc_tracer'
-require 'pp'
-
-GC::Tracer.setup_allocation_tracing(%i{path line type})
-
-result = GC::Tracer.start_allocation_tracing 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 'gc_tracer'
-require 'pp'
-
-GC::Tracer.setup_allocation_tracing(%i{path line type})
-
-result = GC::Tracer.start_allocation_tracing 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 `gc_tracer/allocation_trace' to start allocation 
-tracer and output the aggregated information into stdot at the end of 
-program.
-
-```ruby
-require 'gc_tracer/allocation_trace'
-
-# Run your program here
-50_000.times{|i|
-  i.to_s
-  i.to_s
-  i.to_s
-}
-```
-
-and you will see:
-
-```
-file    line    count   total_age       max_age min_age
-.../lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb 55      18      23      1       6
-.../gc_tracer/lib/gc_tracer/allocation_trace.rb    5       2       12      6       6
-.../gc_tracer/lib/gc_tracer/allocation_trace.rb    6       2       0       0       0
-test.rb 0       1       0       0       0
-test.rb 5       50000   41574   0       5
-test.rb 6       50000   41566   0       4
-test.rb 7       50000   41574   0       5
-```
-
-(tab separated colums)
-
-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.
-
 ### ObjectSpace recorder
 
 You can records objspace snapshots on each events.  Snapshots are stored 

data/ext/gc_tracer/gc_tracer.c

@@ -781,13 +781,6 @@ gc_tracer_start_objspace_recording(int argc, VALUE *argv, VALUE self)
 
 #endif /* HAVE_RB_OBJSPACE_EACH_OBJECTS_WITHOUT_SETUP */
 
-VALUE gc_tracer_start_allocation_tracing(VALUE self);
-VALUE gc_tracer_stop_allocation_tracing(VALUE self);
-VALUE gc_tracer_setup_allocation_tracing(int argc, VALUE *argv, VALUE self);
-VALUE gc_tracer_header_of_allocation_tracing(VALUE self);
-
-VALUE rb_mGCTracer;
-
 /**
  * GC::Tracer traces GC/ObjectSpace behavior.
  *
@@ -808,7 +801,7 @@ VALUE rb_mGCTracer;
 void
 Init_gc_tracer(void)
 {
-    VALUE mod = rb_mGCTracer = rb_define_module_under(rb_mGC, "Tracer");
+    VALUE mod = rb_define_module_under(rb_mGC, "Tracer");
 
     /* logging methods */
     rb_define_module_function(mod, "start_logging", gc_tracer_start_logging, -1);
@@ -821,12 +814,6 @@ Init_gc_tracer(void)
     rb_define_module_function(mod, "stop_objspace_recording", gc_tracer_stop_objspace_recording, 0);
 #endif
 
-    /* allocation tracer methods */
-    rb_define_module_function(mod, "start_allocation_tracing", gc_tracer_start_allocation_tracing, 0);
-    rb_define_module_function(mod, "stop_allocation_tracing", gc_tracer_stop_allocation_tracing, 0);
-    rb_define_module_function(mod, "setup_allocation_tracing", gc_tracer_setup_allocation_tracing, -1);
-    rb_define_module_function(mod, "header_of_allocation_tracing", gc_tracer_header_of_allocation_tracing, 0);
-
     /* setup default banners */
     setup_gc_trace_symbols();
     start_tick = tick();

data/lib/gc_tracer/version.rb

@@ -1,3 +1,3 @@
 module GC::Tracer
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/spec/gc_tracer_spec.rb

@@ -56,26 +56,4 @@ describe GC::Tracer do
     let(:count){2}
     it_behaves_like "objspace_recorder_test"
   end
-
-  describe 'GC::Tracer.start_allocation_tracing' do
-    it 'should includes allocation information' do
-      line = __LINE__ + 2
-      result = GC::Tracer.start_allocation_tracing 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 = GC::Tracer.start_allocation_tracing do
-        Object.new
-      end
-
-      expect(result.length).to be >= 1
-      expect(result[[__FILE__, line]]).to eq [1, 0, 0, 0]
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gc_tracer
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Koichi Sasada
@@ -81,7 +81,6 @@ files:
 - README.md
 - Rakefile
 - bin/objspace_recorder_convert.rb
-- ext/gc_tracer/allocation_tracer.c
 - ext/gc_tracer/extconf.rb
 - ext/gc_tracer/gc_tracer.c
 - gc_tracer.gemspec

data/ext/gc_tracer/allocation_tracer.c

@@ -1,556 +0,0 @@
-/*
- * 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"
-
-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;
-};
-
-extern VALUE rb_mGCTracer;
-
-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_mGCTracer, rb_intern("newobj_hook"))) == Qnil) {
-	rb_ivar_set(rb_mGCTracer, rb_intern("newobj_hook"), newobj_hook = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, arg));
-	rb_ivar_set(rb_mGCTracer, rb_intern("freeobj_hook"), freeobj_hook = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, arg));
-    }
-    else {
-	freeobj_hook = rb_ivar_get(rb_mGCTracer, 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_mGCTracer, rb_intern("newobj_hook"));
-	VALUE freeobj_hook = rb_ivar_get(rb_mGCTracer, 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;
-}
-
-VALUE
-gc_tracer_stop_allocation_tracing(VALUE self)
-{
-    stop_allocation_tracing(self);
-    return aggregate_result(get_traceobj_arg());
-}
-
-VALUE
-gc_tracer_start_allocation_tracing(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_mGCTracer);
-
-	if (rb_block_given_p()) {
-	    rb_ensure(rb_yield, Qnil, stop_allocation_tracing, Qnil);
-	    return aggregate_result(get_traceobj_arg());
-	}
-    }
-
-    return Qnil;
-}
-
-VALUE
-gc_tracer_setup_allocation_tracing(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
-gc_tracer_header_of_allocation_tracing(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;
-}
-