gc_tracer 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ad7a07f89e6474de38728bba4e183173133c727
-  data.tar.gz: 1be0ad94f2746c7fee8880725827a386cde7ef75
+  metadata.gz: 830cc27b4a444096a36db13d0425b920cd87c8e4
+  data.tar.gz: a331e1b13ea0f3c61af86c166c1592cb21fb67cd
 SHA512:
-  metadata.gz: b3410157161b046b7870da5caae27c0be60968c825f38908a18907e7ee8941effa28240e32f05ce769a5ad459064ec9784b0ec42746c989d486b2b2a65805c45
-  data.tar.gz: a168bf9cd168fbc5d4c80eacfb44d4b7dcc52053f5ba89bf821bb7a372dd874e9b06ed65073c21a02eda04b34321d6ee484a06513d5d42dac8b4cb95b053200c
+  metadata.gz: 61150fdea8743a53a2f2d7954d2cb969e75ff46b23ddb7bbb50afaccb2885632067533b10c5bac91b2fe393d8cd739b59eb3de16b521ed4869cdb6c18dfcdbd0
+  data.tar.gz: 66bcc1e1a75d05caf7dc54a655a4ebc657db34fb9fa6410dbef5faebeb0783248851cbf9ea8ae1936a2348d95c0232ceddd22979494516d9268e80818a46287b

data/README.md

@@ -20,6 +20,12 @@ Or install it yourself as:
 
 ## Usage
 
+gc_tracer gem adds GC::Tracer module. GC::Tracer module has the following features.
+
+- Logging GC statistics information
+- Allocation tracing information
+- ObjectSpace recorder
+
 ### Logging
 
 You can get GC statistics information in block form like this:
@@ -54,6 +60,69 @@ 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.
+
+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 
@@ -77,7 +146,7 @@ You can view all converted png images with "dirname/viewer.html" file in animati
 
 This feature is supported only latest Ruby versions (2.2, and later).
 
-#### Examaple
+#### Example
 
 ```ruby
 require 'gc_tracer'

data/ext/gc_tracer/allocation_tracer.c

@@ -0,0 +1,388 @@
+/*
+ * 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;
+
+    /* allocation info */
+    const char *path;
+    unsigned long line;
+    const char *class_path;
+    VALUE mid;
+    size_t generation;
+
+    struct allocation_info *next;
+};
+
+struct traceobj_arg {
+    int running;
+    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 (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);
+	}
+    }
+}
+
+struct memcmp_key_data {
+    const char *path;
+    int line;
+};
+
+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 (k1->path == k2->path && k1->line == k2->line) ? 0 : 1;
+}
+
+static st_index_t
+memcmp_hash_hash(st_data_t a)
+{
+    struct memcmp_key_data *k1 = (struct memcmp_key_data *)a;
+    return (((st_index_t)k1->path) << 8) & (st_index_t)k1->line;
+}
+
+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->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->class_path);
+    ruby_xfree(info);
+}
+
+static void
+newobj_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);
+    VALUE path = rb_tracearg_path(tparg);
+    VALUE line = rb_tracearg_lineno(tparg);
+    VALUE mid = rb_tracearg_method_id(tparg);
+    VALUE klass = rb_tracearg_defined_class(tparg);
+    struct allocation_info *info;
+    const char *path_cstr = RTEST(path) ? make_unique_str(arg->str_table, RSTRING_PTR(path), RSTRING_LEN(path)) : 0;
+    VALUE class_path = (RTEST(klass) && !OBJ_FROZEN(klass)) ? rb_class_path_cached(klass) : Qnil;
+    const char *class_path_cstr = RTEST(class_path) ? make_unique_str(arg->str_table, RSTRING_PTR(class_path), RSTRING_LEN(class_path)) : 0;
+
+    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->class_path);
+    }
+    else {
+	info = create_allocation_info();
+    }
+
+    info->next = NULL;
+    info->living = 1;
+    info->flags = RBASIC(obj)->flags;
+    info->klass = RBASIC_CLASS(obj);
+
+    info->path = path_cstr;
+    info->line = NUM2INT(line);
+    info->mid = mid;
+    info->class_path = class_path_cstr;
+    info->generation = rb_gc_count();
+    st_insert(arg->object_table, (st_data_t)obj, (st_data_t)info);
+}
+
+#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);
+
+	key_data.path = info->path;
+	key_data.line = info->line;
+	key = (st_data_t)&key_data;
+	keep_unique_str(arg->str_table, info->path);
+
+	if (st_lookup(arg->aggregate_table, key, &val) == 0) {
+	    struct memcmp_key_data *key_buff = ALLOC_N(struct memcmp_key_data, 1);
+	    *key_buff = key_data;
+	    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;
+
+	    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 int
+aggregate_result_i(st_data_t key, st_data_t val, void *data)
+{
+    VALUE result = (VALUE)data;
+    int *val_buff = (int *)val;
+    struct memcmp_key_data *key_buff = (struct memcmp_key_data *)key;
+    VALUE k = rb_ary_new3(2, rb_str_new2(key_buff->path), INT2FIX(key_buff->line));
+    VALUE v = rb_ary_new3(4, INT2FIX(val_buff[0]), INT2FIX(val_buff[1]), INT2FIX(val_buff[2]), INT2FIX(val_buff[3]));
+
+    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)
+{
+    VALUE result = rb_hash_new();
+    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)result);
+    clear_traceobj_arg();
+    return result;
+}
+
+static VALUE
+stop_allocation_tracing(VALUE self)
+{
+    VALUE newobj_hook = rb_ivar_get(rb_mGCTracer, rb_intern("newobj_hook"));
+    VALUE freeobj_hook = rb_ivar_get(rb_mGCTracer, rb_intern("freeobj_hook"));
+
+    /* stop hooks */
+    if (newobj_hook && freeobj_hook) {
+	rb_tracepoint_disable(newobj_hook);
+	rb_tracepoint_disable(freeobj_hook);
+    }
+    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(int argc, VALUE *argv, VALUE self)
+{
+    if (rb_ivar_get(rb_mGCTracer, rb_intern("allocation_tracer")) != Qnil) {
+	rb_raise(rb_eRuntimeError, "can't run recursive");
+    }
+    else {
+	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;
+}
+

data/ext/gc_tracer/gc_tracer.c

@@ -781,6 +781,10 @@ 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(int argc, VALUE *argv, VALUE self);
+VALUE gc_tracer_stop_allocation_tracing(VALUE self);
+VALUE rb_mGCTracer;
+
 /**
  * GC::Tracer traces GC/ObjectSpace behavior.
  *
@@ -801,7 +805,7 @@ gc_tracer_start_objspace_recording(int argc, VALUE *argv, VALUE self)
 void
 Init_gc_tracer(void)
 {
-    VALUE mod = rb_define_module_under(rb_mGC, "Tracer");
+    VALUE mod = rb_mGCTracer = rb_define_module_under(rb_mGC, "Tracer");
 
     /* logging methods */
     rb_define_module_function(mod, "start_logging", gc_tracer_start_logging, -1);
@@ -814,6 +818,10 @@ 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, -1);
+    rb_define_module_function(mod, "stop_allocation_tracing", gc_tracer_stop_allocation_tracing, 0);
+
     /* setup default banners */
     setup_gc_trace_symbols();
     start_tick = tick();

data/lib/gc_tracer/allocation_trace.rb

@@ -0,0 +1,10 @@
+require 'gc_tracer'
+
+GC::Tracer.start_allocation_tracing
+
+at_exit{
+  puts "file\tline\tcount\ttotal_age\tmax_age\tmin_age"
+  GC::Tracer.stop_allocation_tracing.sort_by{|k, v| k}.each{|k, v|
+    puts (k+v).join("\t")
+  }
+}

data/lib/gc_tracer/version.rb

@@ -1,3 +1,3 @@
 module GC::Tracer
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/spec/gc_tracer_spec.rb

@@ -29,20 +29,20 @@ describe GC::Tracer do
   end
 
   shared_examples "objspace_recorder_test" do
-    DIRNAME = "gc_tracer_objspace_recorder_spec.#{$$}"
+    dirname = "gc_tracer_objspace_recorder_spec.#{$$}"
 
     it do
       begin
-        GC::Tracer.start_objspace_recording(DIRNAME){
+        GC::Tracer.start_objspace_recording(dirname){
           count.times{
             GC.start
           }
         }
-        expect(Dir.glob("#{DIRNAME}/ppm/*.ppm").size).to be >= count * 3
+        expect(Dir.glob("#{dirname}/ppm/*.ppm").size).to be >= count * 3
       rescue NoMethodError
         pending "start_objspace_recording requires MRI >= 2.2"
       ensure
-        FileUtils.rm_rf(DIRNAME) if File.directory?(DIRNAME)
+        FileUtils.rm_rf(dirname) if File.directory?(dirname)
       end
     end
   end
@@ -56,4 +56,16 @@ describe GC::Tracer do
     let(:count){2}
     it_behaves_like "objspace_recorder_test"
   end
+
+  describe 'GC::Tracer.start_allocation_tracing' do
+    it 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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gc_tracer
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Koichi Sasada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-06 00:00:00.000000000 Z
+date: 2014-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,10 +81,12 @@ 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
 - lib/gc_tracer.rb
+- lib/gc_tracer/allocation_trace.rb
 - lib/gc_tracer/version.rb
 - lib/gc_tracer/viewer.html.erb
 - public/jquery-2.1.0.min.js