stackprof 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e9663289cf7257e1ce593f22f1bc635b0d4406d
-  data.tar.gz: 56484ba1a6c48b2c9c41bb056500b7aa432db974
+  metadata.gz: c4d9be2e4ad16929b326e3a1e86c841ad0e13dc6
+  data.tar.gz: 826eff5e56b4ae6c03c613dd9937a5ae396efa98
 SHA512:
-  metadata.gz: 4a0062a181c777976147420395729d65eff6fa4ef10a6624153629bcaed7a5ed8c6b071e2e30176d6a28b3d6c0dcd4ed1ab5b4cc8373fbdbc814ed57dff20a93
-  data.tar.gz: 1e004d7757b016d00cda696be9fe6a4769aa11b97651228069d63df4193219c16bbc2f9c44800234d9d98855db04dde6f1cbcc68a7c1913949c43f18c68a419e
+  metadata.gz: 6153df14d977ffa0b1445950de2e779a8e8dd6606e665ad22bad348619b16659862bce078d1c12eb0d48f6bb90a5c0bd8ae73bc2c4d861466d6f16cda285d4c1
+  data.tar.gz: 06ccf3dc44113e69b544aab7d9c4820daec59ec4b0d3b5e9784960d52b6ead75907f320d66cf4084319567f890862e4ab6954211e1b5c09d114f8553942e51ad

data/.gitignore

@@ -1,2 +1,3 @@
 /tmp
 /lib/stackprof.bundle
+/lib/stackprof.so

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stackprof (0.1.0)
+    stackprof (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -7,16 +7,17 @@ and written as a replacement for [perftools.rb](https://github.com/tmm1/perftool
 
 ### sampling
 
-three sampling modes are supported:
+four sampling modes are supported:
 
-  - cpu time (using `ITIMER_PROF` and `SIGPROF`)
-  - wall time (using `ITIMER_REAL` and `SIGALRM`)
-  - object allocation (using `RUBY_INTERNAL_EVENT_NEWOBJ`)
+  - :wall (using `ITIMER_REAL` and `SIGALRM`) [default mode]
+  - :cpu (using `ITIMER_PROF` and `SIGPROF`)
+  - :object (using `RUBY_INTERNAL_EVENT_NEWOBJ`)
+  - :custom (user-defined via `StackProf.sample`)
 
 samplers have a tuneable interval which can be used to reduce overhead or increase granularity:
 
-  - cpu time: sample every _interval_ microseconds of cpu activity (default: 10000 = 10 milliseconds)
-  - wall time: sample every _interval_ microseconds of wallclock time (default: 10000)
+  - wall time: sample every _interval_ microseconds of wallclock time (default: 1000)
+  - cpu time: sample every _interval_ microseconds of cpu activity (default: 1000 = 1 millisecond)
   - object allocation: sample every _interval_ allocations (default: 1)
 
 samples are taken using a combination of three new C-APIs in ruby 2.1:
@@ -137,11 +138,12 @@ block in A#math (/Users/tmm1/code/stackprof/sample.rb:21)
 
 ### usage
 
-the profiler is compiled as a C-extension and exposes a simple api: `StackProf.run(mode, interval)`.
+the profiler is compiled as a C-extension and exposes a simple api: `StackProf.run(mode: [:cpu|:wall|:object])`.
 the `run` method takes a block of code and returns a profile as a simple hash.
 
 ``` ruby
-profile = StackProf.run(sampling_mode, sampling_interval) do
+# sample after every 1ms of cpu activity
+profile = StackProf.run(mode: :cpu, interval: 1000) do
   MyCode.execute
 end
 ```
@@ -154,10 +156,12 @@ the format itself is very simple. it contains a header and a list of frames. eac
 identifying information such as its name, file and line. the frame also contains sampling data, including per-line
 samples, and a list of relationships to other frames represented as weighted edges.
 
-```
+``` ruby
 {:version=>1.0,
- :mode=>"cpu(1000)",
+ :mode=>:cpu,
+ :inteval=>1000,
  :samples=>188,
+ :missed_samples=>0,
  :frames=>
   {70346498324780=>
     {:name=>"A#pow",
@@ -184,14 +188,17 @@ divided up between its callee edges. all 91 calls to `A#pow` came from `A#initia
 
 ### advanced usage
 
-the profiler can be started, paused, resumed and stopped manually for greater control.
+the profiler can be started and stopped manually. results are accumulated until retrieval, across
+multiple start/stop invocations.
 
-```
+``` ruby
 StackProf.running?
 StackProf.start
-StackProf.pause
-StackProf.paused?
-StackProf.resume
 StackProf.stop
 StackProf.results
 ```
+
+### todo
+
+* file/iseq blacklist
+* restore signal handlers on stop

data/bin/stackprof

@@ -1,3 +1,46 @@
 #!/usr/bin/env ruby
 require 'optparse'
 require 'stackprof'
+
+options = {
+  :format => :text,
+  :sort => false,
+  :limit => 30
+}
+
+OptionParser.new(ARGV) do |o|
+  o.banner = 'stackprof-report [file.dump]+'
+
+  o.on('--text', 'Text output (default)'){ options[:format] = :text }
+  o.on('--callgrind'){ options[:format] = :callgrind }
+  o.on('--graphviz'){ options[:format] = :graphviz }
+  o.on('--file [grep]'){ |f| options[:format] = :file; options[:filter] = f }
+  o.on('--files'){ |f| options[:format] = :files }
+  o.on('--method [grep]'){ |f| options[:format] = :method; options[:filter] = f }
+  o.on('--debug'){ options[:format] = :debug }
+  o.on('--sort-total'){ options[:sort] = true }
+  o.on('--limit [num]', Integer){ |n| options[:limit] = n }
+end.parse!
+
+reports = []
+while ARGV.size > 0
+  reports << StackProf::Report.new(Marshal.load(IO.binread(ARGV.pop)))
+end
+report = reports.inject(:+)
+
+case options[:format]
+when :text
+  report.print_text(options[:sort], options[:limit])
+when :callgrind
+  report.print_callgrind
+when :graphviz
+  report.print_graphviz
+when :method
+  report.print_method(options[:filter])
+when :file
+  report.print_file(options[:filter])
+when :files
+  report.print_files(options[:sort], options[:limit])
+else
+  raise ArgumentError, "unknown format: #{options[:format]}"
+end

data/ext/extconf.rb

@@ -1,2 +1,9 @@
 require 'mkmf'
-create_makefile('stackprof')
+if have_func('rb_postponed_job_register_one') &&
+   have_func('rb_profile_frames') &&
+   have_func('rb_tracepoint_new') &&
+   have_const('RUBY_INTERNAL_EVENT_NEWOBJ')
+  create_makefile('stackprof')
+else
+  fail 'missing API: are you using ruby 2.1+?'
+end

data/ext/stackprof.c

@@ -15,7 +15,9 @@
 #include <ruby/ruby.h>
 #include <ruby/debug.h>
 #include <ruby/st.h>
+#include <signal.h>
 #include <sys/time.h>
+#include <pthread.h>
 
 #define BUF_SIZE 2048
 
@@ -27,76 +29,112 @@ typedef struct {
 } frame_data_t;
 
 static struct {
-    enum {
-	PROF_NONE = 0,
-	PROF_CPU,
-	PROF_WALL,
-	PROF_OBJECT
-    } type;
+    int running;
+    VALUE mode;
+    VALUE interval;
 
+    size_t overall_signals;
     size_t overall_samples;
+    size_t during_gc;
     st_table *frames;
 
     VALUE frames_buffer[BUF_SIZE];
     int lines_buffer[BUF_SIZE];
-} _results;
+} _stackprof;
 
-static VALUE sym_object, sym_wall, sym_name, sym_file, sym_line;
-static VALUE sym_samples, sym_total_samples, sym_edges, sym_lines;
-static VALUE sym_version, sym_mode, sym_frames;
-static VALUE objtracer;
+static VALUE sym_object, sym_wall, sym_cpu, sym_custom, sym_name, sym_file, sym_line;
+static VALUE sym_samples, sym_total_samples, sym_missed_samples, sym_edges, sym_lines;
+static VALUE sym_version, sym_mode, sym_interval, sym_frames;
+static VALUE sym_gc_samples, objtracer;
 static VALUE gc_hook;
+static VALUE rb_mStackProf;
 
 static void stackprof_newobj_handler(VALUE, void*);
 static void stackprof_signal_handler(int sig, siginfo_t* sinfo, void* ucontext);
 
 static VALUE
-stackprof_start(VALUE self, VALUE type, VALUE usec)
+stackprof_start(int argc, VALUE *argv, VALUE self)
 {
-    if (type == sym_object) {
-	_results.type = PROF_OBJECT;
+    struct sigaction sa;
+    struct itimerval timer;
+    VALUE opts = Qnil, mode = Qnil, interval = Qnil;
+
+    if (_stackprof.running)
+	return Qfalse;
+
+    rb_scan_args(argc, argv, "0:", &opts);
+
+    if (RTEST(opts)) {
+	mode = rb_hash_aref(opts, sym_mode);
+	interval = rb_hash_aref(opts, sym_interval);
+    }
+    if (!RTEST(mode)) mode = sym_wall;
+
+    if (!_stackprof.frames) {
+	_stackprof.frames = st_init_numtable();
+	_stackprof.overall_signals = 0;
+	_stackprof.overall_samples = 0;
+	_stackprof.during_gc = 0;
+    }
+
+    if (mode == sym_object) {
+	if (!RTEST(interval)) interval = INT2FIX(1);
+
 	objtracer = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, stackprof_newobj_handler, 0);
 	rb_tracepoint_enable(objtracer);
-    } else {
-	if (type == sym_wall)
-	    _results.type = PROF_WALL;
-	else
-	    _results.type = PROF_CPU;
+    } else if (mode == sym_wall || mode == sym_cpu) {
+	if (!RTEST(interval)) interval = INT2FIX(1000);
 
-	struct sigaction sa;
 	sa.sa_sigaction = stackprof_signal_handler;
 	sa.sa_flags = SA_RESTART | SA_SIGINFO;
 	sigemptyset(&sa.sa_mask);
-	sigaction(_results.type == PROF_WALL ? SIGALRM : SIGPROF, &sa, NULL);
+	sigaction(mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL);
 
-	struct itimerval timer;
 	timer.it_interval.tv_sec = 0;
-	timer.it_interval.tv_usec = NUM2LONG(usec);
+	timer.it_interval.tv_usec = NUM2LONG(interval);
 	timer.it_value = timer.it_interval;
-	setitimer(_results.type == PROF_WALL ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
+	setitimer(mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
+    } else if (mode == sym_custom) {
+	/* sampled manually */
+	interval = Qnil;
+    } else {
+	rb_raise(rb_eArgError, "unknown profiler mode");
     }
 
-    return Qnil;
+    _stackprof.running = 1;
+    _stackprof.mode = mode;
+    _stackprof.interval = interval;
+
+    return Qtrue;
 }
 
 static VALUE
 stackprof_stop(VALUE self)
 {
-    if (_results.type == PROF_OBJECT) {
+    struct sigaction sa;
+    struct itimerval timer;
+
+    if (!_stackprof.running)
+	return Qfalse;
+    _stackprof.running = 0;
+
+    if (_stackprof.mode == sym_object) {
 	rb_tracepoint_disable(objtracer);
-    } else {
-	struct itimerval timer;
+    } else if (_stackprof.mode == sym_wall || _stackprof.mode == sym_cpu) {
 	memset(&timer, 0, sizeof(timer));
-	setitimer(_results.type == PROF_WALL ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
+	setitimer(_stackprof.mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
 
-	struct sigaction sa;
 	sa.sa_handler = SIG_IGN;
 	sa.sa_flags = SA_RESTART;
 	sigemptyset(&sa.sa_mask);
-	sigaction(_results.type == PROF_WALL ? SIGALRM : SIGPROF, &sa, NULL);
+	sigaction(_stackprof.mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL);
+    } else if (_stackprof.mode == sym_custom) {
+	/* sampled manually */
+    } else {
+	rb_raise(rb_eArgError, "unknown profiler mode");
     }
 
-    return Qnil;
+    return Qtrue;
 }
 
 static int
@@ -114,8 +152,11 @@ frame_lines_i(st_data_t key, st_data_t val, st_data_t arg)
 {
     VALUE lines = (VALUE)arg;
 
-    intptr_t weight = (intptr_t)val;
-    rb_hash_aset(lines, INT2FIX(key), INT2FIX(weight));
+    size_t weight = (size_t)val;
+    size_t total = weight & (~(size_t)0 << (8*SIZEOF_SIZE_T/2));
+    weight -= total;
+    total = total >> (8*SIZEOF_SIZE_T/2);
+    rb_hash_aset(lines, INT2FIX(key), rb_ary_new3(2, ULONG2NUM(total), ULONG2NUM(weight)));
     return ST_CONTINUE;
 }
 
@@ -127,7 +168,6 @@ frame_i(st_data_t key, st_data_t val, st_data_t arg)
     VALUE results = (VALUE)arg;
     VALUE details = rb_hash_new();
     VALUE name, file, edges, lines;
-    VALUE label, method_name;
     VALUE line;
 
     rb_hash_aset(results, rb_obj_id(frame), details);
@@ -167,85 +207,114 @@ frame_i(st_data_t key, st_data_t val, st_data_t arg)
 }
 
 static VALUE
-stackprof_run(VALUE self, VALUE type, VALUE usec)
+stackprof_results(VALUE self)
 {
     VALUE results, frames;
-    rb_need_block();
-    if (!_results.frames)
-	_results.frames = st_init_numtable();
-    _results.overall_samples = 0;
 
-    stackprof_start(self, type, usec);
-    rb_yield(Qundef);
-    stackprof_stop(self);
+    if (!_stackprof.frames || _stackprof.running)
+	return Qnil;
 
     results = rb_hash_new();
-    rb_hash_aset(results, sym_version, DBL2NUM(1.0));
-    rb_hash_aset(results, sym_mode, rb_sprintf("%"PRIsVALUE"(%"PRIsVALUE")", type, usec));
-    rb_hash_aset(results, sym_samples, SIZET2NUM(_results.overall_samples));
+    rb_hash_aset(results, sym_version, DBL2NUM(1.1));
+    rb_hash_aset(results, sym_mode, _stackprof.mode);
+    rb_hash_aset(results, sym_interval, _stackprof.interval);
+    rb_hash_aset(results, sym_samples, SIZET2NUM(_stackprof.overall_samples));
+    rb_hash_aset(results, sym_gc_samples, SIZET2NUM(_stackprof.during_gc));
+    rb_hash_aset(results, sym_missed_samples, SIZET2NUM(_stackprof.overall_signals - _stackprof.overall_samples));
 
     frames = rb_hash_new();
     rb_hash_aset(results, sym_frames, frames);
-    st_foreach(_results.frames, frame_i, (st_data_t)frames);
+    st_foreach(_stackprof.frames, frame_i, (st_data_t)frames);
+
+    st_free_table(_stackprof.frames);
+    _stackprof.frames = NULL;
 
     return results;
 }
 
+static VALUE
+stackprof_run(int argc, VALUE *argv, VALUE self)
+{
+    rb_need_block();
+    stackprof_start(argc, argv, self);
+    rb_ensure(rb_yield, Qundef, stackprof_stop, self);
+    return stackprof_results(self);
+}
+
+static VALUE
+stackprof_running_p(VALUE self)
+{
+    return _stackprof.running ? Qtrue : Qfalse;
+}
+
 static inline frame_data_t *
 sample_for(VALUE frame)
 {
     st_data_t key = (st_data_t)frame, val = 0;
     frame_data_t *frame_data;
 
-    if (st_lookup(_results.frames, key, &val)) {
+    if (st_lookup(_stackprof.frames, key, &val)) {
         frame_data = (frame_data_t *)val;
     } else {
         frame_data = ALLOC_N(frame_data_t, 1);
         MEMZERO(frame_data, frame_data_t, 1);
         val = (st_data_t)frame_data;
-        st_insert(_results.frames, key, val);
+        st_insert(_stackprof.frames, key, val);
     }
 
     return frame_data;
 }
 
+static int
+numtable_increment_callback(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
+{
+    size_t *weight = (size_t *)value;
+    size_t increment = (size_t)arg;
+
+    if (existing)
+	(*weight) += increment;
+    else
+	*weight = increment;
+
+    return ST_CONTINUE;
+}
+
 void
-st_numtable_increment(st_table *table, st_data_t key)
+st_numtable_increment(st_table *table, st_data_t key, size_t increment)
 {
-    intptr_t weight = 0;
-    st_lookup(table, key, (st_data_t *)&weight);
-    weight++;
-    st_insert(table, key, weight);
+    st_update(table, key, numtable_increment_callback, (st_data_t)increment);
 }
 
-static void
-stackprof_sample()
+void
+stackprof_record_sample()
 {
     int num, i;
-    VALUE prev_frame;
-    st_data_t key;
+    VALUE prev_frame = Qnil;
 
-    _results.overall_samples++;
-    num = rb_profile_frames(0, sizeof(_results.frames_buffer), _results.frames_buffer, _results.lines_buffer);
+    _stackprof.overall_samples++;
+    num = rb_profile_frames(0, sizeof(_stackprof.frames_buffer), _stackprof.frames_buffer, _stackprof.lines_buffer);
 
     for (i = 0; i < num; i++) {
-	int line = _results.lines_buffer[i];
-	VALUE frame = _results.frames_buffer[i];
+	int line = _stackprof.lines_buffer[i];
+	VALUE frame = _stackprof.frames_buffer[i];
 	frame_data_t *frame_data = sample_for(frame);
 
 	frame_data->total_samples++;
 
 	if (i == 0) {
 	    frame_data->caller_samples++;
-	    if (line > 0) {
-		if (!frame_data->lines)
-		    frame_data->lines = st_init_numtable();
-		st_numtable_increment(frame_data->lines, (st_data_t)line);
-	    }
 	} else {
 	    if (!frame_data->edges)
 		frame_data->edges = st_init_numtable();
-	    st_numtable_increment(frame_data->edges, (st_data_t)prev_frame);
+	    st_numtable_increment(frame_data->edges, (st_data_t)prev_frame, 1);
+	}
+
+	if (line > 0) {
+	    if (!frame_data->lines)
+		frame_data->lines = st_init_numtable();
+	    size_t half = (size_t)1<<(8*SIZEOF_SIZE_T/2);
+	    size_t increment = i == 0 ? half + 1 : half;
+	    st_numtable_increment(frame_data->lines, (st_data_t)line, increment);
 	}
 
 	prev_frame = frame;
@@ -257,59 +326,122 @@ stackprof_job_handler(void *data)
 {
     static int in_signal_handler = 0;
     if (in_signal_handler) return;
+    if (!_stackprof.running) return;
 
     in_signal_handler++;
-    stackprof_sample();
+    stackprof_record_sample();
     in_signal_handler--;
 }
 
 static void
 stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
 {
-    rb_postponed_job_register_one(0, stackprof_job_handler, 0);
+    _stackprof.overall_signals++;
+    if (rb_during_gc())
+	_stackprof.during_gc++, _stackprof.overall_samples++;
+    else
+	rb_postponed_job_register_one(0, stackprof_job_handler, 0);
 }
 
 static void
 stackprof_newobj_handler(VALUE tpval, void *data)
 {
+    _stackprof.overall_signals++;
+    stackprof_job_handler(0);
+}
+
+static VALUE
+stackprof_sample(VALUE self)
+{
+    if (!_stackprof.running)
+	return Qfalse;
+
+    _stackprof.overall_signals++;
     stackprof_job_handler(0);
+    return Qtrue;
 }
 
 static int
 frame_mark_i(st_data_t key, st_data_t val, st_data_t arg)
 {
     VALUE frame = (VALUE)key;
-    rb_gc_mark_maybe(frame);
+    rb_gc_mark(frame);
     return ST_CONTINUE;
 }
 
 static void
-stackprof_gc_mark()
+stackprof_gc_mark(void *data)
+{
+    if (_stackprof.frames)
+	st_foreach(_stackprof.frames, frame_mark_i, 0);
+}
+
+static void
+stackprof_atfork_prepare(void)
 {
-    if (_results.frames)
-	st_foreach(_results.frames, frame_mark_i, 0);
+    struct itimerval timer;
+    if (_stackprof.running) {
+	if (_stackprof.mode == sym_wall || _stackprof.mode == sym_cpu) {
+	    memset(&timer, 0, sizeof(timer));
+	    setitimer(_stackprof.mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
+	}
+    }
+}
+
+static void
+stackprof_atfork_parent(void)
+{
+    struct itimerval timer;
+    if (_stackprof.running) {
+	if (_stackprof.mode == sym_wall || _stackprof.mode == sym_cpu) {
+	    timer.it_interval.tv_sec = 0;
+	    timer.it_interval.tv_usec = NUM2LONG(_stackprof.interval);
+	    timer.it_value = timer.it_interval;
+	    setitimer(_stackprof.mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
+	}
+    }
+}
+
+static void
+stackprof_atfork_child(void)
+{
+    stackprof_stop(rb_mStackProf);
 }
 
 void
 Init_stackprof(void)
 {
     sym_object = ID2SYM(rb_intern("object"));
-    sym_name = ID2SYM(rb_intern("name"));
+    sym_custom = ID2SYM(rb_intern("custom"));
     sym_wall = ID2SYM(rb_intern("wall"));
+    sym_cpu = ID2SYM(rb_intern("cpu"));
+    sym_name = ID2SYM(rb_intern("name"));
     sym_file = ID2SYM(rb_intern("file"));
     sym_line = ID2SYM(rb_intern("line"));
     sym_total_samples = ID2SYM(rb_intern("total_samples"));
+    sym_gc_samples = ID2SYM(rb_intern("gc_samples"));
+    sym_missed_samples = ID2SYM(rb_intern("missed_samples"));
     sym_samples = ID2SYM(rb_intern("samples"));
     sym_edges = ID2SYM(rb_intern("edges"));
     sym_lines = ID2SYM(rb_intern("lines"));
     sym_version = ID2SYM(rb_intern("version"));
     sym_mode = ID2SYM(rb_intern("mode"));
+    sym_interval = ID2SYM(rb_intern("interval"));
     sym_frames = ID2SYM(rb_intern("frames"));
 
     gc_hook = Data_Wrap_Struct(rb_cObject, stackprof_gc_mark, NULL, NULL);
     rb_global_variable(&gc_hook);
 
-    VALUE rb_mStackProf = rb_define_module("StackProf");
-    rb_define_singleton_method(rb_mStackProf, "run", stackprof_run, 2);
+    rb_mStackProf = rb_define_module("StackProf");
+    rb_define_singleton_method(rb_mStackProf, "running?", stackprof_running_p, 0);
+    rb_define_singleton_method(rb_mStackProf, "run", stackprof_run, -1);
+    rb_define_singleton_method(rb_mStackProf, "start", stackprof_start, -1);
+    rb_define_singleton_method(rb_mStackProf, "stop", stackprof_stop, 0);
+    rb_define_singleton_method(rb_mStackProf, "results", stackprof_results, 0);
+    rb_define_singleton_method(rb_mStackProf, "sample", stackprof_sample, 0);
+
     rb_autoload(rb_mStackProf, rb_intern_const("Report"), "stackprof/report.rb");
+    rb_autoload(rb_mStackProf, rb_intern_const("Middleware"), "stackprof/middleware.rb");
+
+    pthread_atfork(stackprof_atfork_prepare, stackprof_atfork_parent, stackprof_atfork_child);
 }

data/lib/stackprof/middleware.rb

@@ -0,0 +1,31 @@
+require 'fileutils'
+
+module StackProf
+  class Middleware
+    def initialize(app)
+      @app = app
+      at_exit{ Middleware.save if Middleware.enabled? }
+    end
+
+    def call(env)
+      StackProf.start(mode: :cpu, interval: 1000) if self.class.enabled?
+      @app.call(env)
+    ensure
+      StackProf.stop if self.class.enabled?
+    end
+
+    class << self
+      attr_accessor :enabled
+      alias enabled? enabled
+
+      def save
+        if results = StackProf.results
+          FileUtils.mkdir_p('tmp')
+          File.open("tmp/stackprof-#{results[:mode]}-#{Process.pid}-#{Time.now.to_i}.dump", 'w') do |f|
+            f.write Marshal.dump(results)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stackprof/report.rb

@@ -1,71 +1,279 @@
 require 'pp'
+require 'digest/md5'
 
 module StackProf
   class Report
     def initialize(data)
       @data = data
+
+      frames = {}
+      @data[:frames].each{ |k,v| frames[k.to_s] = v }
+      @data[:frames] = frames
+    end
+    attr_reader :data
+
+    def frames(sort_by_total=false)
+      Hash[ *@data[:frames].sort_by{ |iseq, stats| -stats[sort_by_total ? :total_samples : :samples] }.flatten(1) ]
+    end
+
+    def normalized_frames
+      id2hash = {}
+      @data[:frames].each do |frame, info|
+        id2hash[frame.to_s] = info[:hash] = Digest::MD5.hexdigest("#{info[:name]}#{info[:file]}#{info[:line]}")
+      end
+      @data[:frames].inject(Hash.new) do |hash, (frame, info)|
+        info = hash[id2hash[frame.to_s]] = info.dup
+        info[:edges] = info[:edges].inject(Hash.new){ |edges, (edge, weight)| edges[id2hash[edge.to_s]] = weight; edges } if info[:edges]
+        hash
+      end
     end
 
-    def frames
-      @data[:frames].sort_by{ |iseq, stats| -stats[:samples] }
+    def version
+      @data[:version]
+    end
+
+    def modeline
+      "#{@data[:mode]}(#{@data[:interval]})"
     end
 
     def overall_samples
       @data[:samples]
     end
 
+    def max_samples
+      @data[:max_samples] ||= frames.max_by{ |addr, frame| frame[:samples] }.last[:samples]
+    end
+
+    def files
+      @data[:files] ||= @data[:frames].inject(Hash.new) do |hash, (addr, frame)|
+        if file = frame[:file] and lines = frame[:lines]
+          hash[file] ||= Hash.new
+          lines.each do |line, weight|
+            hash[file][line] = add_lines(hash[file][line], weight)
+          end
+        end
+        hash
+      end
+    end
+
+    def add_lines(a, b)
+      return b if a.nil?
+      return a+b if a.is_a? Fixnum
+      return [ a[0], a[1]+b ] if b.is_a? Fixnum
+      [ a[0]+b[0], a[1]+b[1] ]
+    end
+
     def print_debug
       pp @data
     end
 
-    def print_graphviz
-      f = STDOUT
+    def print_graphviz(filter = nil, f = STDOUT)
+      if filter
+        mark_stack = []
+        list = frames
+        list.each{ |addr, frame| mark_stack << addr if frame[:name] =~ filter }
+        while addr = mark_stack.pop
+          frame = list[addr]
+          unless frame[:marked]
+            $stderr.puts frame[:edges].inspect
+            mark_stack += frame[:edges].map{ |addr, weight| addr.to_s if list[addr.to_s][:total_samples] <= weight*1.2 }.compact if frame[:edges]
+            frame[:marked] = true
+          end
+        end
+        list = list.select{ |addr, frame| frame[:marked] }
+        list.each{ |addr, frame| frame[:edges] && frame[:edges].delete_if{ |k,v| list[k.to_s].nil? } }
+        list
+      else
+        list = frames
+      end
+
       f.puts "digraph profile {"
-      frames.each do |frame, info|
+      list.each do |frame, info|
         call, total = info.values_at(:samples, :total_samples)
         sample = ''
         sample << "#{call} (%2.1f%%)\\rof " % (call*100.0/overall_samples) if call < total
         sample << "#{total} (%2.1f%%)\\r" % (total*100.0/overall_samples)
-        size = (1.0 * call / overall_samples) * 28 + 10
+        fontsize = (1.0 * call / max_samples) * 28 + 10
+        size = (1.0 * total / overall_samples) * 2.0 + 0.5
 
-        f.puts "  #{frame} [size=#{size}] [fontsize=#{size}] [shape=box] [label=\"#{info[:name]}\\n#{sample}\"];"
+        f.puts "  #{frame} [size=#{size}] [fontsize=#{fontsize}] [penwidth=\"#{size}\"] [shape=box] [label=\"#{info[:name]}\\n#{sample}\"];"
         if edges = info[:edges]
           edges.each do |edge, weight|
-            size = (1.0 * weight / overall_samples) * 28
-            f.puts "  #{frame} -> #{edge} [label=\"#{weight}\"];"
+            size = (1.0 * weight / overall_samples) * 2.0 + 0.5
+            f.puts "  #{frame} -> #{edge} [label=\"#{weight}\"] [weight=\"#{weight}\"] [penwidth=\"#{size}\"];"
           end
         end
       end
       f.puts "}"
     end
 
-    def print_text
-      printf "% 10s    (pct)  % 10s    (pct)     FRAME\n" % ["TOTAL", "SAMPLES"]
-      frames.each do |frame, info|
+    def print_text(sort_by_total=false, limit=nil, f = STDOUT)
+      f.puts "=================================="
+      f.printf "  Mode: #{modeline}\n"
+      f.printf "  Samples: #{@data[:samples]} (%.2f%% miss rate)\n", 100.0*@data[:missed_samples]/(@data[:missed_samples]+@data[:samples])
+      f.printf "  GC: #{@data[:gc_samples]} (%.2f%%)\n", 100.0*@data[:gc_samples]/@data[:samples]
+      f.puts "=================================="
+      f.printf "% 10s    (pct)  % 10s    (pct)     FRAME\n" % ["TOTAL", "SAMPLES"]
+      list = frames(sort_by_total)
+      list = list.first(limit) if limit
+      list.each do |frame, info|
         call, total = info.values_at(:samples, :total_samples)
-        printf "% 10d % 8s  % 10d % 8s     %s\n", total, "(%2.1f%%)" % (total*100.0/overall_samples), call, "(%2.1f%%)" % (call*100.0/overall_samples), info[:name]
+        f.printf "% 10d % 8s  % 10d % 8s     %s\n", total, "(%2.1f%%)" % (total*100.0/overall_samples), call, "(%2.1f%%)" % (call*100.0/overall_samples), info[:name]
       end
     end
 
-    def print_source(name)
+    def print_callgrind(f = STDOUT)
+      f.puts "version: 1"
+      f.puts "creator: stackprof"
+      f.puts "pid: 0"
+      f.puts "cmd: ruby"
+      f.puts "part: 1"
+      f.puts "desc: mode: #{modeline}"
+      f.puts "desc: missed: #{@data[:missed_samples]})"
+      f.puts "positions: line"
+      f.puts "events: Instructions"
+      f.puts "summary: #{@data[:samples]}"
+
+      list = frames
+      list.each do |addr, frame|
+        f.puts "fl=#{frame[:file]}"
+        f.puts "fn=#{frame[:name]}"
+        frame[:lines].each do |line, weight|
+          f.puts "#{line} #{weight.is_a?(Array) ? weight[1] : weight}"
+        end if frame[:lines]
+        frame[:edges].each do |edge, weight|
+          oframe = list[edge.to_s]
+          f.puts "cfl=#{oframe[:file]}" unless oframe[:file] == frame[:file]
+          f.puts "cfn=#{oframe[:name]}"
+          f.puts "calls=#{weight} #{frame[:line] || 0}\n#{oframe[:line] || 0} #{weight}"
+        end if frame[:edges]
+        f.puts
+      end
+
+      f.puts "totals: #{@data[:samples]}"
+    end
+
+    def print_method(name, f = STDOUT)
       name = /#{Regexp.escape name}/ unless Regexp === name
       frames.each do |frame, info|
         next unless info[:name] =~ name
         file, line = info.values_at(:file, :line)
-
-        maxline = info[:lines] ? info[:lines].keys.max : line + 5
-        printf "%s (%s:%d)\n", info[:name], file, line
+        line ||= 1
 
         lines = info[:lines]
-        source = File.readlines(file).each_with_index do |code, i|
-          next unless (line-1..maxline).include?(i)
-          if lines and samples = lines[i+1]
-            printf "% 5d % 7s / % 7s  | % 5d  | %s", samples, "(%2.1f%%" % (100.0*samples/overall_samples), "%2.1f%%)" % (100.0*samples/info[:samples]), i+1, code
+        maxline = lines ? lines.keys.max : line + 5
+        f.printf "%s (%s:%d)\n", info[:name], file, line
+        f.printf "  samples: % 5d self (%2.1f%%)  /  % 5d total (%2.1f%%)\n", info[:samples], 100.0*info[:samples]/overall_samples, info[:total_samples], 100.0*info[:total_samples]/overall_samples
+
+        if (callers = data[:frames].map{ |id, other| [other[:name], other[:edges][frame.to_i]] if other[:edges] && other[:edges].include?(frame.to_i) }.compact).any?
+          f.puts "  callers:"
+          callers = callers.sort_by(&:last).reverse
+          callers.each do |name, weight|
+            f.printf "   % 5d  (% 8s)  %s\n", weight, "%3.1f%%" % (100.0*weight/info[:total_samples]), name
+          end
+        end
+
+        if callees = info[:edges]
+          f.printf "  callees (%d total):\n", info[:total_samples]-info[:samples]
+          callees = callees.map{ |k, weight| [data[:frames][k.to_s][:name], weight] }
+          callees.each do |name, weight|
+            f.printf "   % 5d  (% 8s)  %s\n", weight, "%3.1f%%" % (100.0*weight/(info[:total_samples]-info[:samples])), name
+          end
+        end
+
+        f.puts "  code:"
+        source_display(f, file, lines, line-1..maxline)
+      end
+    end
+
+    def print_files(sort_by_total=false, limit=nil, f = STDOUT)
+      list = files.map{ |file, vals| [file, vals.values.inject([0,0]){ |sum, n| add_lines(sum, n) }] }
+      list = list.sort_by{ |file, samples| -samples[1] }
+      list = list.first(limit) if limit
+      list.each do |file, vals|
+        total_samples, samples = *vals
+        f.printf "% 5d  (%2.1f%%) / % 5d  (%2.1f%%) %s\n", total_samples, (100.0*total_samples/overall_samples), samples, (100.0*samples/overall_samples), file
+      end
+    end
+
+    def print_file(filter, f = STDOUT)
+      filter = /#{Regexp.escape filter}/ unless Regexp === filter
+      list = files
+      list.select!{ |name, lines| name =~ filter }
+      list.sort_by{ |file, vals| -vals.values.inject(0){ |sum, n| sum + (n.is_a?(Array) ? n[1] : n) } }.each do |file, lines|
+        source_display(f, file, lines)
+      end
+    end
+
+    private
+
+    def source_display(f, file, lines, range=nil)
+      File.readlines(file).each_with_index do |code, i|
+        next unless range.nil? || range.include?(i)
+        if lines and lineinfo = lines[i+1]
+          total_samples, samples = lineinfo
+          if version == 1.0
+            samples = total_samples
+            f.printf "% 5d % 7s  | % 5d  | %s", samples, "(%2.1f%%)" % (100.0*samples/overall_samples), i+1, code
+          elsif samples > 0
+            f.printf "% 5d  % 8s / % 5d  % 7s  | % 5d  | %s", total_samples, "(%2.1f%%)" % (100.0*total_samples/overall_samples), samples, "(%2.1f%%)" % (100.0*samples/overall_samples), i+1, code
           else
-            printf "                         | % 5d  | %s", i+1, code
+            f.printf "% 5d  % 8s                   | % 5d  | %s", total_samples, "(%3.1f%%)" % (100.0*total_samples/overall_samples), i+1, code
+          end
+        else
+          if version == 1.0
+            f.printf "               | % 5d  | %s", i+1, code
+          else
+            f.printf "                                  | % 5d  | %s", i+1, code
+          end
+        end
+      end
+    end
+
+    def +(other)
+      raise ArgumentError, "cannot combine #{other.class}" unless self.class == other.class
+      raise ArgumentError, "cannot combine #{modeline} with #{other.modeline}" unless modeline == other.modeline
+      raise ArgumentError, "cannot combine v#{version} with v#{other.version}" unless version == other.version
+
+      f1, f2 = normalized_frames, other.normalized_frames
+      frames = (f1.keys + f2.keys).uniq.inject(Hash.new) do |hash, id|
+        if f1[id].nil?
+          hash[id] = f2[id]
+        elsif f2[id]
+          hash[id] = f1[id]
+          hash[id][:total_samples] += f2[id][:total_samples]
+          hash[id][:samples] += f2[id][:samples]
+          if f2[id][:edges]
+            edges = hash[id][:edges] ||= {}
+            f2[id][:edges].each do |edge, weight|
+              edges[edge] ||= 0
+              edges[edge] += weight
+            end
           end
+          if f2[id][:lines]
+            lines = hash[id][:lines] ||= {}
+            f2[id][:lines].each do |line, weight|
+              lines[line] = add_lines(lines[line], weight)
+            end
+          end
+        else
+          hash[id] = f1[id]
         end
+        hash
       end
+
+      d1, d2 = data, other.data
+      data = {
+        version: version,
+        mode: d1[:mode],
+        interval: d1[:interval],
+        samples: d1[:samples] + d2[:samples],
+        gc_samples: d1[:gc_samples] + d2[:gc_samples],
+        missed_samples: d1[:missed_samples] + d2[:missed_samples],
+        frames: frames
+      }
+
+      self.class.new(data)
     end
   end
 end

data/stackprof.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'stackprof'
-  s.version = '0.1.0'
+  s.version = '0.2.0'
   s.homepage = 'http://github.com/tmm1/stackprof'
 
   s.authors = 'Aman Gupta'
@@ -17,5 +17,6 @@ Gem::Specification.new do |s|
 
   s.license = 'MIT'
 
+#  s.add_dependency 'yajl-ruby'
   s.add_development_dependency 'rake-compiler'
 end

data/test/test_stackprof.rb

@@ -4,39 +4,65 @@ require 'test/unit'
 
 class StackProfTest < Test::Unit::TestCase
   def test_info
-    profile = StackProf.run(:wall, 1000){}
-    assert_equal 1.0, profile[:version]
-    assert_equal "wall(1000)", profile[:mode]
+    profile = StackProf.run{}
+    assert_equal 1.1, profile[:version]
+    assert_equal :wall, profile[:mode]
+    assert_equal 1000, profile[:interval]
     assert_equal 0, profile[:samples]
   end
 
+  def test_running
+    assert_equal false, StackProf.running?
+    StackProf.run{ assert_equal true, StackProf.running? }
+  end
+
+  def test_start_stop_results
+    assert_equal nil, StackProf.results
+    assert_equal true, StackProf.start
+    assert_equal false, StackProf.start
+    assert_equal true, StackProf.running?
+    assert_equal nil, StackProf.results
+    assert_equal true, StackProf.stop
+    assert_equal false, StackProf.stop
+    assert_equal false, StackProf.running?
+    assert_kind_of Hash, StackProf.results
+    assert_equal nil, StackProf.results
+  end
+
   def test_object_allocation
-    profile = StackProf.run(:object, 1) do
+    profile = StackProf.run(mode: :object) do
       Object.new
       Object.new
     end
-    assert_equal "object(1)", profile[:mode]
+    assert_equal :object, profile[:mode]
+    assert_equal 1, profile[:interval]
     assert_equal 2, profile[:samples]
 
     frame = profile[:frames].values.first
     assert_equal "block in StackProfTest#test_object_allocation", frame[:name]
     assert_equal 2, frame[:samples]
-    assert_equal 14, frame[:line]
-    assert_equal 1, frame[:lines][15]
-    assert_equal 1, frame[:lines][16]
+    line = __LINE__
+    assert_equal line-11, frame[:line]
+    assert_equal [1, 1], frame[:lines][line-10]
+    assert_equal [1, 1], frame[:lines][line-9]
+
+    frame = profile[:frames].values[1]
+    assert_equal [2, 0], frame[:lines][line-11]
   end
 
   def test_cputime
-    profile = StackProf.run(:cpu, 1000) do
+    profile = StackProf.run(mode: :cpu, interval: 500) do
       math
     end
 
+    assert_operator profile[:samples], :>, 1
     frame = profile[:frames].values.first
     assert_equal "block in StackProfTest#math", frame[:name]
+    File.open('/tmp/cputime.dump','w'){|f| f.write Marshal.dump(profile) }
   end
 
   def test_walltime
-    profile = StackProf.run(:wall, 1000) do
+    profile = StackProf.run(mode: :wall) do
       idle
     end
 
@@ -45,6 +71,43 @@ class StackProfTest < Test::Unit::TestCase
     assert_in_delta 200, frame[:samples], 5
   end
 
+  def test_custom
+    profile = StackProf.run(mode: :custom) do
+      10.times do
+        StackProf.sample
+      end
+    end
+
+    assert_equal :custom, profile[:mode]
+    assert_equal 10, profile[:samples]
+
+    frame = profile[:frames].values.first
+    assert_equal "block (2 levels) in StackProfTest#test_custom", frame[:name]
+    assert_equal __LINE__-10, frame[:line]
+    assert_equal [10, 10], frame[:lines][__LINE__-10]
+  end
+
+  def test_fork
+    StackProf.run do
+      pid = fork do
+        exit! StackProf.running?? 1 : 0
+      end
+      Process.wait(pid)
+      assert_equal 0, $?.exitstatus
+      assert_equal true, StackProf.running?
+    end
+  end
+
+  def test_gc
+    profile = StackProf.run(mode: :cpu, interval: 100) do
+      GC.start
+    end
+
+    assert_empty profile[:frames]
+    assert_operator profile[:gc_samples], :>, 0
+    assert_equal 0, profile[:missed_samples]
+  end
+
   def math
     250_000.times do
       2 ** 10
@@ -52,6 +115,10 @@ class StackProfTest < Test::Unit::TestCase
   end
 
   def idle
-    sleep 0.2
+    r, w = IO.pipe
+    IO.select([r], nil, nil, 0.2)
+  ensure
+    r.close
+    w.close
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackprof
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Aman Gupta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-14 00:00:00.000000000 Z
+date: 2013-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -41,6 +41,7 @@ files:
 - bin/stackprof
 - ext/extconf.rb
 - ext/stackprof.c
+- lib/stackprof/middleware.rb
 - lib/stackprof/report.rb
 - sample.rb
 - stackprof.gemspec
@@ -65,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0.preview.1
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: sampling callstack-profiler for ruby 2.1+