allocation_tracer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79049581513cae857637ce2a806116bb7f4f409a
-  data.tar.gz: 0d24ddb1dd4328def9f76afce88761364fcea0e8
+  metadata.gz: e21df296d813762ba6a5b3393ae95cbc09fa2560
+  data.tar.gz: 089e3fcaa7df385f58c91a3762d1c1f714cbb50a
 SHA512:
-  metadata.gz: 6e5d80fbdfd2e5bde9c13d05ccebc4ec3bd87425b0599e83d277fe690366d428352f8acaa2892a92b9dc6d4f7d23a440978412692e5c245b3bc5633b661fec69
-  data.tar.gz: 81f1ab724b85bb73c079490c065b1649a4ef721a6e84ccd7e5e2a3b1f97c023628e82b2eddd4c5517c433b89dee017cb6603190931b291ff68dcd26244116316
+  metadata.gz: a9f98fcbbd4a1e7cac48aaab69e10e9857b63050ffb8ec7e9d8ef9800d9668cfb2715ec2414ed277276edaf3ca53527f1606ec589656b71ea972d33d4a3d8765
+  data.tar.gz: 7d34cd7d37a60411664a82b94edb9b832cbe00a351c5b9b4da33adce9ee354b98f3f79d99ab594b6253675c1ffe4c6e3a3487052f4e7f7ba9ad586e823ff2f7d

data/README.md

@@ -151,6 +151,40 @@ test.rb 7       50000   41650   0       5
 
 (tab separated colums)
 
+### Lifetime table
+
+You can collect lifetime statistics with 
+ObjectSpace::AllocationTracer.lifetime_table method.
+
+```ruby
+require 'pp'
+require 'allocation_tracer'
+
+ObjectSpace::AllocationTracer.lifetime_table_setup true
+result = ObjectSpace::AllocationTracer.trace do
+  100000.times{
+    Object.new
+    ''
+  }
+end
+pp ObjectSpace::AllocationTracer.lifetime_table
+```
+
+will show
+
+```
+{:T_OBJECT=>[3434, 96563, 0, 0, 1, 0, 0, 2],
+ :T_STRING=>[3435, 96556, 2, 1, 1, 1, 1, 1, 2]}
+```
+
+This output means that the age of 3434 T_OBJECT objects are 0, 96563 
+objects are 1 and 2 objects are 7. Also the age of 3435 T_STRING 
+objects are 0, 96556 are 1 and so on.
+
+Note that these number includes living objects and dead objects.  For 
+dead object, age means lifetime. For living objects, age means current 
+age.
+
 ## Contributing
 
 1. Fork it ( http://github.com/<my-github-username>/allocation_tracer/fork )

data/ext/allocation_tracer/allocation_tracer.c

@@ -13,6 +13,19 @@ size_t rb_obj_memsize_of(VALUE obj); /* in gc.c */
 
 static VALUE rb_mAllocationTracer;
 
+struct traceobj_arg {
+    int running;
+    int keys, vals;
+    st_table *object_table;     /* obj (VALUE)      -> allocation_info */
+    st_table *str_table;        /* cstr             -> refcount */
+
+    st_table *aggregate_table;  /* user defined key -> [count, total_age, max_age, min_age] */
+    struct allocation_info *freed_allocation_info;
+
+    /* */
+    size_t **lifetime_table;
+};
+
 struct allocation_info {
     struct allocation_info *next;
 
@@ -44,15 +57,6 @@ struct allocation_info {
 #define VAL_MAX_AGE   (1<<5)
 #define VAL_MEMSIZE   (1<<6)
 
-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)
 {
@@ -145,6 +149,7 @@ get_traceobj_arg(void)
 	tmp_trace_arg->object_table = st_init_numtable();
 	tmp_trace_arg->str_table = st_init_strtable();
 	tmp_trace_arg->freed_allocation_info = NULL;
+	tmp_trace_arg->lifetime_table = NULL;
     }
     return tmp_trace_arg;
 }
@@ -182,6 +187,17 @@ clear_traceobj_arg(void)
     st_clear(arg->object_table);
     st_foreach(arg->str_table, free_keys_i, 0);
     st_clear(arg->str_table);
+
+    if (arg->lifetime_table) {
+	int i;
+
+	for (i=0; i<T_MASK; i++) {
+	    if (arg->lifetime_table[i] != NULL) {
+		free(arg->lifetime_table[i]);
+		arg->lifetime_table[i] = NULL;
+	    }
+	}
+    }
 }
 
 static struct allocation_info *
@@ -261,7 +277,7 @@ aggregate_each_info(struct traceobj_arg *arg, struct allocation_info *info, size
     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);
+	struct memcmp_key_data *key_buff = ruby_xmalloc(sizeof(struct memcmp_key_data));
 	key_buff->n = key_data.n;
 
 	for (i=0; i<key_data.n; i++) {
@@ -315,6 +331,34 @@ move_to_freed_list(struct traceobj_arg *arg, struct allocation_info *info)
     arg->freed_allocation_info = info;
 }
 
+static void
+add_lifetime_table(size_t **lines, int type, struct allocation_info *info)
+{
+    size_t age = rb_gc_count() - info->generation;
+    size_t *line = lines[type];
+    size_t len, i;
+
+    if (line == NULL) {
+	len = age + 1;
+	line = lines[type] = malloc(sizeof(size_t) * (1 + len));
+	line[0] = len;
+	for (i=0; i<len; i++) line[i+1] = 0;
+    }
+    else {
+	len = line[0];
+
+	if (len < age + 1) {
+	    size_t old_len = len;
+	    len = age + 1;
+	    line = lines[type] = realloc(line, sizeof(size_t) * (1 + len));
+	    for (i=old_len; i<len; i++) line[i+1] = 0;
+	    line[0] = len;
+	}
+    }
+
+    line[age + 1]++;
+}
+
 static void
 freeobj_i(VALUE tpval, void *data)
 {
@@ -331,6 +375,20 @@ freeobj_i(VALUE tpval, void *data)
 	if (arg->freed_allocation_info == NULL) {
 	    rb_postponed_job_register_one(0, aggregate_freed_info, arg);
 	}
+
+	if (arg->lifetime_table) {
+	    add_lifetime_table(arg->lifetime_table, BUILTIN_TYPE(obj), info);
+	}
+    }
+}
+
+static void
+check_tracer_running(void)
+{
+    struct traceobj_arg * arg = get_traceobj_arg();
+
+    if (!arg->running) {
+	rb_raise(rb_eRuntimeError, "not started yet");
     }
 }
 
@@ -339,6 +397,8 @@ enable_newobj_hook(void)
 {
     VALUE newobj_hook;
 
+    check_tracer_running();
+
     if ((newobj_hook = rb_ivar_get(rb_mAllocationTracer, rb_intern("newobj_hook"))) == Qnil) {
 	rb_raise(rb_eRuntimeError, "not started.");
     }
@@ -354,6 +414,8 @@ disable_newobj_hook(void)
 {
     VALUE newobj_hook;
 
+    check_tracer_running();
+
     if ((newobj_hook = rb_ivar_get(rb_mAllocationTracer, rb_intern("newobj_hook"))) == Qnil) {
 	rb_raise(rb_eRuntimeError, "not started.");
     }
@@ -364,16 +426,6 @@ disable_newobj_hook(void)
     rb_tracepoint_disable(newobj_hook);
 }
 
-static void
-check_tracer_running(void)
-{
-    struct traceobj_arg * arg = get_traceobj_arg();
-
-    if (!arg->running) {
-	rb_raise(rb_eRuntimeError, "not started yet");
-    }
-}
-
 static void
 start_alloc_hooks(VALUE mod)
 {
@@ -412,39 +464,49 @@ stop_alloc_hooks(VALUE self)
     return Qnil;
 }
 
-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);
+static VALUE
+type_sym(int type)
+{
+    static VALUE syms[T_MASK];
+
+    if (syms[0] == 0) {
+	int i;
+	for (i=0; i<T_MASK; i++) {
+	    switch (i) {
+#define TYPE_NAME(t) case (t): syms[i] = ID2SYM(rb_intern(#t)); break;
+		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);
+	      default:
+		syms[i] = ID2SYM(rb_intern("unknown"));
 #undef TYPE_NAME
+	    }
+	}
     }
-    return "unknown";
+
+    return syms[type];
 }
 
 struct arg_and_result {
@@ -467,14 +529,6 @@ aggregate_result_i(st_data_t key, st_data_t val, void *data)
 			  INT2FIX(val_buff[4]), INT2FIX(val_buff[5]));
     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) {
@@ -493,7 +547,7 @@ aggregate_result_i(st_data_t key, st_data_t val, void *data)
     if (arg->keys & KEY_TYPE) {
 	int sym_index = key_buff->data[i++];
 	assert(T_MASK > sym_index);
-	rb_ary_push(k, type_symbols[sym_index]);
+	rb_ary_push(k, type_sym(sym_index));
     }
     if (arg->keys & KEY_CLASS) {
 	VALUE klass = key_buff->data[i++];
@@ -532,6 +586,32 @@ aggregate_live_object_i(st_data_t key, st_data_t val, void *data)
     return ST_CONTINUE;
 }
 
+static int
+lifetime_table_for_live_objects_i(st_data_t key, st_data_t val, st_data_t data)
+{
+    struct allocation_info *info = (struct allocation_info *)val;
+    VALUE h = (VALUE)data;
+    int type = info->flags & T_MASK;
+    VALUE sym = type_sym(type);
+    size_t age = rb_gc_count() - info->generation;
+    VALUE line;
+    size_t count, i;
+
+    if ((line = rb_hash_aref(h, sym)) == Qnil) {
+	line = rb_ary_new();
+	rb_hash_aset(h, sym, line);
+    }
+
+    for (i=RARRAY_LEN(line); i<age+1; i++) {
+	rb_ary_push(line, INT2FIX(0));
+    }
+
+    count = NUM2SIZET(RARRAY_AREF(line, age));
+    RARRAY_ASET(line, age, SIZET2NUM(count + 1));
+
+    return ST_CONTINUE;
+}
+
 static VALUE
 aggregate_result(struct traceobj_arg *arg)
 {
@@ -560,15 +640,33 @@ aggregate_result(struct traceobj_arg *arg)
 
 	arg->aggregate_table = dead_object_aggregate_table;
     }
-    return aar.result;
-}
 
-static VALUE
-allocation_tracer_stop(VALUE self)
-{
-    VALUE result = aggregate_result(get_traceobj_arg());
-    stop_alloc_hooks(self);
-    return result;
+    /* lifetime table */
+    if (arg->lifetime_table) {
+	VALUE h = rb_hash_new();
+	int i;
+
+	for (i=0; i<T_MASK; i++) {
+	    size_t *line = arg->lifetime_table[i];
+
+	    if (line) {
+		size_t len = line[0], j;
+		VALUE ary = rb_ary_new();
+		VALUE sym = type_sym(i);
+
+		for (j=0; j<len; j++) {
+		    rb_ary_push(ary, SIZET2NUM(line[j+1]));
+		}
+
+		rb_hash_aset(h, sym, ary);
+	    }
+	}
+
+	st_foreach(arg->object_table, lifetime_table_for_live_objects_i, (st_data_t)h);
+	rb_ivar_set(rb_mAllocationTracer, rb_intern("lifetime_table"), h);
+    }
+
+    return aar.result;
 }
 
 static VALUE
@@ -577,8 +675,6 @@ allocation_tracer_result(VALUE self)
     VALUE result;
     struct traceobj_arg *arg = get_traceobj_arg();
 
-    check_tracer_running();
-
     disable_newobj_hook();
     result = aggregate_result(arg);
     enable_newobj_hook();
@@ -620,10 +716,20 @@ allocation_tracer_trace(VALUE self)
     return Qnil;
 }
 
+static VALUE
+allocation_tracer_stop(VALUE self)
+{
+    VALUE result;
+
+    disable_newobj_hook();
+    result = aggregate_result(get_traceobj_arg());
+    stop_alloc_hooks(self);
+    return result;
+}
+
 static VALUE
 allocation_tracer_pause(VALUE self)
 {
-    check_tracer_running();
     disable_newobj_hook();
     return Qnil;
 }
@@ -631,7 +737,6 @@ allocation_tracer_pause(VALUE self)
 static VALUE
 allocation_tracer_resume(VALUE self)
 {
-    check_tracer_running();
     enable_newobj_hook();
     return Qnil;
 }
@@ -689,6 +794,39 @@ allocation_tracer_header(VALUE self)
     return ary;
 }
 
+static VALUE
+allocation_tracer_lifetime_table_setup(VALUE self, VALUE set)
+{
+    struct traceobj_arg * arg = get_traceobj_arg();
+
+    if (arg->running) {
+	rb_raise(rb_eRuntimeError, "can't change configuration during running");
+    }
+
+    if (RTEST(set)) {
+	if (arg->lifetime_table == NULL) {
+	    arg->lifetime_table = (size_t **)calloc(sizeof(size_t **), T_MASK);
+	    
+	}
+    }
+    else {
+	if (arg->lifetime_table != NULL) {
+	    free(arg->lifetime_table);
+	    arg->lifetime_table = NULL;
+	}
+    }
+
+    return Qnil;
+}
+
+static VALUE
+allocation_tracer_lifetime_table(VALUE self)
+{
+    VALUE result = rb_ivar_get(rb_mAllocationTracer, rb_intern("lifetime_table"));
+    rb_ivar_set(rb_mAllocationTracer, rb_intern("lifetime_table"), Qnil);
+    return result;
+}
+
 void
 Init_allocation_tracer(void)
 {
@@ -706,4 +844,7 @@ Init_allocation_tracer(void)
     rb_define_module_function(mod, "clear", allocation_tracer_clear, 0);
     rb_define_module_function(mod, "setup", allocation_tracer_setup, -1);
     rb_define_module_function(mod, "header", allocation_tracer_header, 0);
+
+    rb_define_module_function(mod, "lifetime_table_setup", allocation_tracer_lifetime_table_setup, 1);
+    rb_define_module_function(mod, "lifetime_table", allocation_tracer_lifetime_table, 0);
 }

data/lib/allocation_tracer/version.rb

@@ -1,3 +1,3 @@
 module ObjectSpace::AllocationTracer
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/allocation_tracer_spec.rb

@@ -164,4 +164,43 @@ describe ObjectSpace::AllocationTracer do
       end
     end
   end
+
+  describe 'collect lifetime_table' do
+    before do
+      ObjectSpace::AllocationTracer.lifetime_table_setup true
+    end
+
+    after do
+      ObjectSpace::AllocationTracer.lifetime_table_setup false
+    end
+
+    it 'should make lifetime table' do
+      ObjectSpace::AllocationTracer.trace do
+        100000.times{
+          Object.new
+          ''
+        }
+      end
+      table = ObjectSpace::AllocationTracer.lifetime_table
+
+      expect(table[:T_OBJECT].inject(&:+)).to be >= 10_000
+      expect(table[:T_STRING].inject(&:+)).to be >= 10_000
+      expect(table[:T_NONE]).to be nil
+    end
+
+    it 'should nil when ObjectSpace::AllocationTracer.lifetime_table_setup is nil' do
+      ObjectSpace::AllocationTracer.lifetime_table_setup false
+
+      ObjectSpace::AllocationTracer.trace do
+        100000.times{
+          Object.new
+          ''
+        }
+      end
+
+      table = ObjectSpace::AllocationTracer.lifetime_table
+
+      expect(table).to be nil
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allocation_tracer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Koichi Sasada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-21 00:00:00.000000000 Z
+date: 2014-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,7 +84,6 @@ files:
 - 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