stackprof 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e9663289cf7257e1ce593f22f1bc635b0d4406d
+  data.tar.gz: 56484ba1a6c48b2c9c41bb056500b7aa432db974
+SHA512:
+  metadata.gz: 4a0062a181c777976147420395729d65eff6fa4ef10a6624153629bcaed7a5ed8c6b071e2e30176d6a28b3d6c0dcd4ed1ab5b4cc8373fbdbc814ed57dff20a93
+  data.tar.gz: 1e004d7757b016d00cda696be9fe6a4769aa11b97651228069d63df4193219c16bbc2f9c44800234d9d98855db04dde6f1cbcc68a7c1913949c43f18c68a419e

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    stackprof (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.1.0)
+    rake-compiler (0.9.1)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake-compiler
+  stackprof!

data/README.md

@@ -0,0 +1,197 @@
+## stackprof
+
+a sampling call-stack profiler for ruby 2.1+
+
+inspired heavily by [gperftools](https://code.google.com/p/gperftools/),
+and written as a replacement for [perftools.rb](https://github.com/tmm1/perftools.rb)
+
+### sampling
+
+three 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`)
+
+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)
+  - object allocation: sample every _interval_ allocations (default: 1)
+
+samples are taken using a combination of three new C-APIs in ruby 2.1:
+
+  - signal handlers enqueue a sampling job using `rb_postponed_job_register_one`.
+    this ensures callstack samples can be taken safely, in case the VM is garbage collecting
+    or in some other inconsistent state during the interruption.
+
+  - stack frames are collected via `rb_profile_frames`, which provides low-overhead C-API access
+    to the VM's call stack. no object allocations occur in this path, allowing stackprof to collect
+    callstacks in allocation mode.
+
+  - in allocation mode, samples are taken via `rb_tracepoint_new(RUBY_INTERNAL_EVENT_NEWOBJ)`,
+    which provides a notification every time the VM allocates a new object.
+
+### aggregation
+
+each sample consists of N stack frames, where a frame looks something like `MyClass#method` or `block in MySingleton.method`.
+for each of these frames in the sample, the profiler collects a few pieces of metadata:
+
+  - samples: number of samples where this was the topmost frame
+  - total_samples: samples where this frame was in the stack
+  - lines: samples per line number in this frame
+  - edges: samples per callee frame (methods invoked by this frame)
+
+the aggregation algorithm is roughly equivalent to the following pseudo code:
+
+``` ruby
+trap('PROF') do
+  top, *rest = caller
+
+  top.samples += 1
+  top.lines[top.lineno] += 1
+  top.total_samples += 1
+
+  prev = top
+  rest.each do |frame|
+    frame.edges[prev] += 1
+    frame.total_samples += 1
+    prev = frame
+  end
+end
+```
+
+this technique builds up an incremental callgraph from the samples. on any given frame,
+the sum of the outbound edge weights is equal to total samples collected on that frame
+(`frame.total_samples == frame.edges.values.sum`).
+
+### reporting
+
+three reporting modes are supported:
+  - text
+  - dotgraph
+  - source annotation
+
+#### `StackProf::Report.new(data).print_text`
+
+```
+     TOTAL    (pct)     SAMPLES    (pct)     FRAME
+        91  (48.4%)          91  (48.4%)     A#pow
+        58  (30.9%)          58  (30.9%)     A.newobj
+        34  (18.1%)          34  (18.1%)     block in A#math
+       188 (100.0%)           3   (1.6%)     block (2 levels) in <main>
+       185  (98.4%)           1   (0.5%)     A#initialize
+        35  (18.6%)           1   (0.5%)     A#math
+       188 (100.0%)           0   (0.0%)     <main>
+       188 (100.0%)           0   (0.0%)     block in <main>
+       188 (100.0%)           0   (0.0%)     <main>
+```
+
+#### `StackProf::Report.new(data).print_graphviz`
+
+![](http://cl.ly/image/2t3l2q0l0B0A/content)
+
+```
+digraph profile {
+  70346498324780 [size=23.5531914893617] [fontsize=23.5531914893617] [shape=box] [label="A#pow\n91 (48.4%)\r"];
+  70346498324680 [size=18.638297872340424] [fontsize=18.638297872340424] [shape=box] [label="A.newobj\n58 (30.9%)\r"];
+  70346498324480 [size=15.063829787234042] [fontsize=15.063829787234042] [shape=box] [label="block in A#math\n34 (18.1%)\r"];
+  70346498324220 [size=10.446808510638299] [fontsize=10.446808510638299] [shape=box] [label="block (2 levels) in <main>\n3 (1.6%)\rof 188 (100.0%)\r"];
+  70346498324220 -> 70346498324900 [label="185"];
+  70346498324900 [size=10.148936170212766] [fontsize=10.148936170212766] [shape=box] [label="A#initialize\n1 (0.5%)\rof 185 (98.4%)\r"];
+  70346498324900 -> 70346498324780 [label="91"];
+  70346498324900 -> 70346498324680 [label="58"];
+  70346498324900 -> 70346498324580 [label="35"];
+  70346498324580 [size=10.148936170212766] [fontsize=10.148936170212766] [shape=box] [label="A#math\n1 (0.5%)\rof 35 (18.6%)\r"];
+  70346498324580 -> 70346498324480 [label="34"];
+  70346497983360 [size=10.0] [fontsize=10.0] [shape=box] [label="<main>\n0 (0.0%)\rof 188 (100.0%)\r"];
+  70346497983360 -> 70346498325080 [label="188"];
+  70346498324300 [size=10.0] [fontsize=10.0] [shape=box] [label="block in <main>\n0 (0.0%)\rof 188 (100.0%)\r"];
+  70346498324300 -> 70346498324220 [label="188"];
+  70346498325080 [size=10.0] [fontsize=10.0] [shape=box] [label="<main>\n0 (0.0%)\rof 188 (100.0%)\r"];
+  70346498325080 -> 70346498324300 [label="188"];
+}
+```
+
+#### `StackProf::Report.new(data).print_source(/pow|newobj|math/)`
+
+```
+A#pow (/Users/tmm1/code/stackprof/sample.rb:11)
+                         |    11  |   def pow
+   91  (48.4% / 100.0%)  |    12  |     2 ** 100
+                         |    13  |   end
+A.newobj (/Users/tmm1/code/stackprof/sample.rb:15)
+                         |    15  |   def self.newobj
+   33  (17.6% /  56.9%)  |    16  |     Object.new
+   25  (13.3% /  43.1%)  |    17  |     Object.new
+                         |    18  |   end
+A#math (/Users/tmm1/code/stackprof/sample.rb:20)
+                         |    20  |   def math
+    1   (0.5% / 100.0%)  |    21  |     2.times do
+                         |    22  |       2 + 3 * 4 ^ 5 / 6
+block in A#math (/Users/tmm1/code/stackprof/sample.rb:21)
+                         |    21  |     2.times do
+   34  (18.1% / 100.0%)  |    22  |       2 + 3 * 4 ^ 5 / 6
+                         |    23  |     end
+```
+
+### usage
+
+the profiler is compiled as a C-extension and exposes a simple api: `StackProf.run(mode, interval)`.
+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
+  MyCode.execute
+end
+```
+
+this profile data structure is part of the public API, and is intended to be saved
+(as json/marshal for example) for later processing. the reports above can be generated
+by passing this structure into `StackProf::Report.new`.
+
+the format itself is very simple. it contains a header and a list of frames. each frame has a unique id and
+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.
+
+```
+{:version=>1.0,
+ :mode=>"cpu(1000)",
+ :samples=>188,
+ :frames=>
+  {70346498324780=>
+    {:name=>"A#pow",
+     :file=>"/Users/tmm1/code/stackprof/sample.rb",
+     :line=>11,
+     :total_samples=>91,
+     :samples=>91,
+     :lines=>{12=>91}},
+   70346498324900=>
+    {:name=>"A#initialize",
+     :file=>"/Users/tmm1/code/stackprof/sample.rb",
+     :line=>5,
+     :total_samples=>185,
+     :samples=>1,
+     :edges=>{70346498324780=>91, 70346498324680=>58, 70346498324580=>35},
+     :lines=>{8=>1}},
+```
+
+above, `A#pow` was involved in 91 samples, and in all cases it was at the top of the stack on line 12.
+
+`A#initialize` was in 185 samples, but it was at the top of the stack in only 1 sample. the rest of the samples are
+divided up between its callee edges. all 91 calls to `A#pow` came from `A#initialize`, as seen by the edge numbered
+`70346498324780`.
+
+### advanced usage
+
+the profiler can be started, paused, resumed and stopped manually for greater control.
+
+```
+StackProf.running?
+StackProf.start
+StackProf.pause
+StackProf.paused?
+StackProf.resume
+StackProf.stop
+StackProf.results
+```

data/Rakefile

@@ -0,0 +1,31 @@
+task :default => :test
+
+# ==========================================================
+# Packaging
+# ==========================================================
+
+GEMSPEC = eval(File.read('stackprof.gemspec'))
+
+require 'rubygems/package_task'
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+end
+
+# ==========================================================
+# Ruby Extension
+# ==========================================================
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('stackprof', GEMSPEC) do |ext|
+  ext.ext_dir = 'ext'
+end
+task :build => :compile
+
+# ==========================================================
+# Testing
+# ==========================================================
+
+require 'rake/testtask'
+Rake::TestTask.new 'test' do |t|
+  t.test_files = FileList['test/test_*.rb']
+end
+task :test => :build

data/bin/stackprof

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'stackprof'

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('stackprof')

data/ext/stackprof.c

@@ -0,0 +1,315 @@
+/**********************************************************************
+
+  stackprof.c - Sampling call-stack frame profiler for MRI.
+
+  $Author$
+  created at: Thu May 30 17:55:25 2013
+
+  NOTE: This extension library is not expected to exist except C Ruby.
+
+  All the files in this distribution are covered under the Ruby's
+  license (see the file COPYING).
+
+**********************************************************************/
+
+#include <ruby/ruby.h>
+#include <ruby/debug.h>
+#include <ruby/st.h>
+#include <sys/time.h>
+
+#define BUF_SIZE 2048
+
+typedef struct {
+    size_t total_samples;
+    size_t caller_samples;
+    st_table *edges;
+    st_table *lines;
+} frame_data_t;
+
+static struct {
+    enum {
+	PROF_NONE = 0,
+	PROF_CPU,
+	PROF_WALL,
+	PROF_OBJECT
+    } type;
+
+    size_t overall_samples;
+    st_table *frames;
+
+    VALUE frames_buffer[BUF_SIZE];
+    int lines_buffer[BUF_SIZE];
+} _results;
+
+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 gc_hook;
+
+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)
+{
+    if (type == sym_object) {
+	_results.type = PROF_OBJECT;
+	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;
+
+	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);
+
+	struct itimerval timer;
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_usec = NUM2LONG(usec);
+	timer.it_value = timer.it_interval;
+	setitimer(_results.type == PROF_WALL ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+stackprof_stop(VALUE self)
+{
+    if (_results.type == PROF_OBJECT) {
+	rb_tracepoint_disable(objtracer);
+    } else {
+	struct itimerval timer;
+	memset(&timer, 0, sizeof(timer));
+	setitimer(_results.type == PROF_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);
+    }
+
+    return Qnil;
+}
+
+static int
+frame_edges_i(st_data_t key, st_data_t val, st_data_t arg)
+{
+    VALUE edges = (VALUE)arg;
+
+    intptr_t weight = (intptr_t)val;
+    rb_hash_aset(edges, rb_obj_id((VALUE)key), INT2FIX(weight));
+    return ST_CONTINUE;
+}
+
+static int
+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));
+    return ST_CONTINUE;
+}
+
+static int
+frame_i(st_data_t key, st_data_t val, st_data_t arg)
+{
+    VALUE frame = (VALUE)key;
+    frame_data_t *frame_data = (frame_data_t *)val;
+    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);
+
+    name = rb_profile_frame_full_label(frame);
+    rb_hash_aset(details, sym_name, name);
+
+    file = rb_profile_frame_absolute_path(frame);
+    if (NIL_P(file))
+	file = rb_profile_frame_path(frame);
+    rb_hash_aset(details, sym_file, file);
+
+    if ((line = rb_profile_frame_first_lineno(frame)) != INT2FIX(0))
+	rb_hash_aset(details, sym_line, line);
+
+    rb_hash_aset(details, sym_total_samples, SIZET2NUM(frame_data->total_samples));
+    rb_hash_aset(details, sym_samples, SIZET2NUM(frame_data->caller_samples));
+
+    if (frame_data->edges) {
+        edges = rb_hash_new();
+        rb_hash_aset(details, sym_edges, edges);
+        st_foreach(frame_data->edges, frame_edges_i, (st_data_t)edges);
+        st_free_table(frame_data->edges);
+        frame_data->edges = NULL;
+    }
+
+    if (frame_data->lines) {
+	lines = rb_hash_new();
+	rb_hash_aset(details, sym_lines, lines);
+	st_foreach(frame_data->lines, frame_lines_i, (st_data_t)lines);
+	st_free_table(frame_data->lines);
+	frame_data->lines = NULL;
+    }
+
+    xfree(frame_data);
+    return ST_DELETE;
+}
+
+static VALUE
+stackprof_run(VALUE self, VALUE type, VALUE usec)
+{
+    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);
+
+    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));
+
+    frames = rb_hash_new();
+    rb_hash_aset(results, sym_frames, frames);
+    st_foreach(_results.frames, frame_i, (st_data_t)frames);
+
+    return results;
+}
+
+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)) {
+        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);
+    }
+
+    return frame_data;
+}
+
+void
+st_numtable_increment(st_table *table, st_data_t key)
+{
+    intptr_t weight = 0;
+    st_lookup(table, key, (st_data_t *)&weight);
+    weight++;
+    st_insert(table, key, weight);
+}
+
+static void
+stackprof_sample()
+{
+    int num, i;
+    VALUE prev_frame;
+    st_data_t key;
+
+    _results.overall_samples++;
+    num = rb_profile_frames(0, sizeof(_results.frames_buffer), _results.frames_buffer, _results.lines_buffer);
+
+    for (i = 0; i < num; i++) {
+	int line = _results.lines_buffer[i];
+	VALUE frame = _results.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);
+	}
+
+	prev_frame = frame;
+    }
+}
+
+static void
+stackprof_job_handler(void *data)
+{
+    static int in_signal_handler = 0;
+    if (in_signal_handler) return;
+
+    in_signal_handler++;
+    stackprof_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);
+}
+
+static void
+stackprof_newobj_handler(VALUE tpval, void *data)
+{
+    stackprof_job_handler(0);
+}
+
+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);
+    return ST_CONTINUE;
+}
+
+static void
+stackprof_gc_mark()
+{
+    if (_results.frames)
+	st_foreach(_results.frames, frame_mark_i, 0);
+}
+
+void
+Init_stackprof(void)
+{
+    sym_object = ID2SYM(rb_intern("object"));
+    sym_name = ID2SYM(rb_intern("name"));
+    sym_wall = ID2SYM(rb_intern("wall"));
+    sym_file = ID2SYM(rb_intern("file"));
+    sym_line = ID2SYM(rb_intern("line"));
+    sym_total_samples = ID2SYM(rb_intern("total_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_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_autoload(rb_mStackProf, rb_intern_const("Report"), "stackprof/report.rb");
+}

data/lib/stackprof/report.rb

@@ -0,0 +1,71 @@
+require 'pp'
+
+module StackProf
+  class Report
+    def initialize(data)
+      @data = data
+    end
+
+    def frames
+      @data[:frames].sort_by{ |iseq, stats| -stats[:samples] }
+    end
+
+    def overall_samples
+      @data[:samples]
+    end
+
+    def print_debug
+      pp @data
+    end
+
+    def print_graphviz
+      f = STDOUT
+      f.puts "digraph profile {"
+      frames.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
+
+        f.puts "  #{frame} [size=#{size}] [fontsize=#{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}\"];"
+          end
+        end
+      end
+      f.puts "}"
+    end
+
+    def print_text
+      printf "% 10s    (pct)  % 10s    (pct)     FRAME\n" % ["TOTAL", "SAMPLES"]
+      frames.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]
+      end
+    end
+
+    def print_source(name)
+      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
+
+        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
+          else
+            printf "                         | % 5d  | %s", i+1, code
+          end
+        end
+      end
+    end
+  end
+end

data/sample.rb

@@ -0,0 +1,43 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'stackprof'
+
+class A
+  def initialize
+    pow
+    self.class.newobj
+    math
+  end
+
+  def pow
+    2 ** 100
+  end
+
+  def self.newobj
+    Object.new
+    Object.new
+  end
+
+  def math
+    2.times do
+      2 + 3 * 4 ^ 5 / 6
+    end
+  end
+end
+
+#profile = StackProf.run(:object, 1) do
+#profile = StackProf.run(:wall, 1000) do
+profile = StackProf.run(:cpu, 1000) do
+  1_000_000.times do
+    A.new
+  end
+end
+
+result = StackProf::Report.new(profile)
+puts
+result.print_source(/pow|newobj|math/)
+puts
+result.print_text
+puts
+result.print_graphviz
+puts
+result.print_debug

data/stackprof.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |s|
+  s.name = 'stackprof'
+  s.version = '0.1.0'
+  s.homepage = 'http://github.com/tmm1/stackprof'
+
+  s.authors = 'Aman Gupta'
+  s.email   = 'aman@tmm1.net'
+
+  s.files = `git ls-files`.split("\n")
+  s.extensions = 'ext/extconf.rb'
+
+  s.bindir = 'bin'
+  s.executables << 'stackprof'
+
+  s.summary = 'sampling callstack-profiler for ruby 2.1+'
+  s.description = 'stackprof is a fast sampling profiler for ruby code, with cpu, wallclock and object allocation samplers.'
+
+  s.license = 'MIT'
+
+  s.add_development_dependency 'rake-compiler'
+end

data/test/test_stackprof.rb

@@ -0,0 +1,57 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'stackprof'
+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]
+    assert_equal 0, profile[:samples]
+  end
+
+  def test_object_allocation
+    profile = StackProf.run(:object, 1) do
+      Object.new
+      Object.new
+    end
+    assert_equal "object(1)", profile[:mode]
+    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]
+  end
+
+  def test_cputime
+    profile = StackProf.run(:cpu, 1000) do
+      math
+    end
+
+    frame = profile[:frames].values.first
+    assert_equal "block in StackProfTest#math", frame[:name]
+  end
+
+  def test_walltime
+    profile = StackProf.run(:wall, 1000) do
+      idle
+    end
+
+    frame = profile[:frames].values.first
+    assert_equal "StackProfTest#idle", frame[:name]
+    assert_in_delta 200, frame[:samples], 5
+  end
+
+  def math
+    250_000.times do
+      2 ** 10
+    end
+  end
+
+  def idle
+    sleep 0.2
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: stackprof
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aman Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: stackprof is a fast sampling profiler for ruby code, with cpu, wallclock
+  and object allocation samplers.
+email: aman@tmm1.net
+executables:
+- stackprof
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/stackprof
+- ext/extconf.rb
+- ext/stackprof.c
+- lib/stackprof/report.rb
+- sample.rb
+- stackprof.gemspec
+- test/test_stackprof.rb
+homepage: http://github.com/tmm1/stackprof
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0.preview.1
+signing_key: 
+specification_version: 4
+summary: sampling callstack-profiler for ruby 2.1+
+test_files: []