allocation_tracer 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89fd66efaa24f2319186b9499095bad976c68bfe
-  data.tar.gz: dff3b6ab0c8ba0a3db0a1140285dcdd9e06c569c
+  metadata.gz: 1a8521b2ac3ab75ead4770b8aa3b9982f8467d84
+  data.tar.gz: a4b23c68be89223a669d149cf08bd6105cbcaf7e
 SHA512:
-  metadata.gz: 07a014504c663e8ff614ebeec62c49c2dcfb1cf30be1c3009cfa9da0c2d1f7a44ca8789db5919f1aeb6b337719fe0a6f614756749ac8c5aec0c91a766bb33085
-  data.tar.gz: 96fcd0458afc5d052843b269693c9f1fbffaa2df341abca68b11fd8e28bab04464cb0202b85629c61d3f22ed93ade287c656f06c43ac6b3da8204553b89177fe
+  metadata.gz: 58e5ab416b474b20fedef2a0a99e39d0da0dde7074f50a28047e0205240aa4ae660e9c4df114acfcacf496d657d6cc660b8fbaf4353369c5d400b3b70ab14d78
+  data.tar.gz: c4176f951ee62200e6e4faace8b9c5e7d0240d8bf4217a868d120758eed8725ba007e059d7af62c7bfe1835a18b953a46cb7adf3db9b23863d4cc9a5ca336776

data/README.md

@@ -30,10 +30,10 @@ Or install it yourself as:
 
 You can trace allocation and aggregate information. Information includes:
 
-    count - how many objects are created.
-    total_age - total age of objects which created here
-    max_age - age of longest living object created here
-    min_age - age of shortest living object created here
+* count - how many objects are created.
+* total_age - total age of objects which created here
+* max_age - age of longest living object created here
+* min_age - age of shortest living object created here
 
 Age of Object can be calculated by this formula: [current GC count] - [birth time GC count]
 
@@ -55,14 +55,17 @@ pp ObjectSpace::AllocationTracer.trace{
 will show
 
 ```
-{["test.rb", 6]=>[50000, 44290, 0, 6],
- ["test.rb", 7]=>[50000, 44289, 0, 5],
- ["test.rb", 8]=>[50000, 44295, 0, 6]}
+{["test.rb", 6]=>[50000, 0, 47440, 0, 1, 0],
+ ["test.rb", 7]=>[50000, 4, 47452, 0, 6, 0],
+ ["test.rb", 8]=>[50000, 7, 47456, 0, 6, 0]}
 ```
 
-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.
+In this case, 
+* 50,000 objects are created at `test.rb:6' and
+  * 5 old objects created.
+  * 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
+  * 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.
@@ -87,12 +90,12 @@ 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]}
+{["test.rb", 8, :T_STRING]=>[50000, 15, 49165, 0, 16, 0],
+ ["test.rb", 8, :T_ARRAY]=>[50000, 12, 49134, 0, 16, 0],
+ ["test.rb", 9, :T_STRING]=>[100000, 27, 98263, 0, 16, 0],
+ ["test.rb", 9, :T_HASH]=>[50000, 16, 49147, 0, 16, 8998848],
+ ["test.rb", 10, :T_STRING]=>[100000, 36, 98322, 0, 16, 0],
+ ["test.rb", 10, :T_STRUCT]=>[50000, 16, 49147, 0, 16, 0]}
 ```
 
 Interestingly, you can not see array creations in a middle of block:
@@ -116,7 +119,7 @@ pp result
 and it prints:
 
 ```
-{["test.rb", 8, :T_STRING]=>[50000, 38322, 0, 2]}
+{["test.rb", 8, :T_STRING]=>[25015, 5, 16299, 0, 2, 0]}
 ```
 
 There are only string creation. This is because unused array creation is 
@@ -140,13 +143,13 @@ require 'allocation_tracer/trace'
 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
+path    line    count   old_count       total_age       min_age max_age total_memsize
+...rubygems/core_ext/kernel_require.rb 55     18       1       23      1       6       358
+...lib/allocation_tracer/lib/allocation_tracer/trace.rb       6       2      012      6       6       0
+test.rb 0       1       0       0       0       0       0
+test.rb 5       50000   4       41492   0       5       0
+test.rb 6       50000   3       41490   0       5       0
+test.rb 7       50000   7       41497   0       5       0
 ```
 
 (tab separated colums)

data/ext/allocation_tracer/allocation_tracer.c

@@ -526,6 +526,7 @@ type_sym(int type)
 }
 
 struct arg_and_result {
+    int update;
     struct traceobj_arg *arg;
     VALUE result;
 };
@@ -536,14 +537,9 @@ 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;
-
     size_t *val_buff = (size_t *)val;
     struct memcmp_key_data *key_buff = (struct memcmp_key_data *)key;
-    VALUE v = rb_ary_new3(6,
-			  INT2FIX(val_buff[0]), INT2FIX(val_buff[1]),
-			  INT2FIX(val_buff[2]), INT2FIX(val_buff[3]),
-			  INT2FIX(val_buff[4]), INT2FIX(val_buff[5]));
-    VALUE k = rb_ary_new();
+    VALUE v, oldv, k = rb_ary_new();
     int i = 0;
 
     i = 0;
@@ -577,6 +573,25 @@ aggregate_result_i(st_data_t key, st_data_t val, void *data)
 	}
     }
 
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+    if (aar->update && (oldv = rb_hash_aref(result, k)) != Qnil) {
+	v = rb_ary_new3(6,
+			INT2FIX(val_buff[0] + FIX2INT(RARRAY_AREF(oldv, 0))), /* count */
+			INT2FIX(val_buff[1] + FIX2INT(RARRAY_AREF(oldv, 1))), /* old count */
+			INT2FIX(val_buff[2] + FIX2INT(RARRAY_AREF(oldv, 2))), /* total_age */
+			INT2FIX(MIN(val_buff[3], FIX2INT(RARRAY_AREF(oldv, 3)))), /* min age */
+			INT2FIX(MAX(val_buff[4], FIX2INT(RARRAY_AREF(oldv, 4)))), /* max age */
+			INT2FIX(val_buff[5] + FIX2INT(RARRAY_AREF(oldv, 5)))); /* memsize_of */
+    }
+    else {
+	v = rb_ary_new3(6,
+			INT2FIX(val_buff[0]), INT2FIX(val_buff[1]),
+			INT2FIX(val_buff[2]), INT2FIX(val_buff[3]),
+			INT2FIX(val_buff[4]), INT2FIX(val_buff[5]));
+    }
+
     rb_hash_aset(result, k, v);
 
     return ST_CONTINUE;
@@ -627,6 +642,12 @@ lifetime_table_for_live_objects_i(st_data_t key, st_data_t val, st_data_t data)
     return ST_CONTINUE;
 }
 
+static int
+st_size(struct st_table *st)
+{
+    return st->num_bins;
+}
+
 static VALUE
 aggregate_result(struct traceobj_arg *arg)
 {
@@ -634,11 +655,14 @@ aggregate_result(struct traceobj_arg *arg)
     aar.result = rb_hash_new();
     aar.arg = arg;
 
-    /* aggregated table -> Ruby hash */
-    aggregate_freed_info(arg);
+    while (arg->freed_allocation_info) {
+	aggregate_freed_info(arg);
+    }
+
+    /* collect from recent-freed objects */
+    aar.update = 0;
     st_foreach(arg->aggregate_table, aggregate_result_i, (st_data_t)&aar);
 
-    /* collect live aggregate table */
     {
 	st_table *dead_object_aggregate_table = arg->aggregate_table;
 
@@ -647,6 +671,7 @@ aggregate_result(struct traceobj_arg *arg)
 	st_foreach(arg->object_table, aggregate_live_object_i, (st_data_t)arg);
 
 	/* aggregate table -> Ruby hash */
+	aar.update = 1;
 	st_foreach(arg->aggregate_table, aggregate_result_i, (st_data_t)&aar);
 
 	/* remove live object aggregate table */

data/lib/allocation_tracer/version.rb

@@ -1,3 +1,3 @@
 module ObjectSpace::AllocationTracer
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

data/lib/allocation_tracer.rb

@@ -2,6 +2,16 @@ require "allocation_tracer/version"
 require "allocation_tracer/allocation_tracer"
 
 module ObjectSpace::AllocationTracer
+
+  def self.output_lifetime_table table
+    out = (file = ENV['RUBY_ALLOCATION_TRACER_LIFETIME_OUT']) ? open(File.expand_path(file), 'w') : STDOUT
+    max_lines = table.inject(0){|r, (type, lines)| r < lines.size ? lines.size : r}
+    out.puts "type\t" + (0...max_lines).to_a.join("\t")
+    table.each{|type, line|
+      out.puts "#{type}\t#{line.join("\t")}"
+    }
+  end
+
   def self.collect_lifetime_talbe
     ObjectSpace::AllocationTracer.lifetime_table_setup true
 
@@ -10,7 +20,8 @@ module ObjectSpace::AllocationTracer
         ObjectSpace::AllocationTracer.trace do
           yield
         end
-        ObjectSpace::AllocationTracer.lifetime_table
+        result = ObjectSpace::AllocationTracer.lifetime_table
+        output_lifetime_table(result)
       ensure
         ObjectSpace::AllocationTracer.lifetime_table_setup false
       end
@@ -23,6 +34,7 @@ module ObjectSpace::AllocationTracer
     ObjectSpace::AllocationTracer.stop
     result = ObjectSpace::AllocationTracer.lifetime_table
     ObjectSpace::AllocationTracer.lifetime_table_setup false
+    output_lifetime_table(result)
     result
   end
 end

data/spec/allocation_tracer_spec.rb

@@ -25,6 +25,23 @@ describe ObjectSpace::AllocationTracer do
       expect(result[[__FILE__, line]]).to eq [1, 0, 0, 0, 0, 0]
     end
 
+    it 'should analyze many objects' do
+      line = __LINE__ + 3
+      result = ObjectSpace::AllocationTracer.trace do
+        50_000.times{|i|
+          i.to_s
+          i.to_s
+          i.to_s
+        }
+      end
+      #GC.start
+      #pp result
+
+      expect(result[[__FILE__, line + 0]][0]).to be >= 50_000
+      expect(result[[__FILE__, line + 1]][0]).to be >= 50_000
+      expect(result[[__FILE__, line + 2]][0]).to be >= 50_000
+    end
+
     it 'should count old objects' do
       a = nil
       line = __LINE__ + 2

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allocation_tracer
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Koichi Sasada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-23 00:00:00.000000000 Z
+date: 2014-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler