tmm1-perftools.rb 0.1.1

data/README

@@ -0,0 +1,151 @@
+google-perftools for ruby code
+  (c) 2009 Aman Gupta (tmm1)
+
+=== Usage
+
+  Run the profiler with a block:
+
+    require 'perftools'
+    PerfTools::CpuProfiler.start("/tmp/add_numbers_profile") do
+      5_000_000.times{ 1+2+3+4+5 }
+    end
+
+  Start and stop the profiler manually:
+
+    require 'perftools'
+    PerfTools::CpuProfiler.start("/tmp/add_numbers_profile")
+    5_000_000.times{ 1+2+3+4+5 }
+    PerfTools::CpuProfiler.stop
+
+  Profile an existing ruby application without modifying it:
+
+    $ CPUPROFILE=/tmp/my_app_profile RUBYOPT="-r`gem which perftools | tail -1`" ruby my_app.rb
+
+
+=== Reporting
+
+  pprof.rb --text /tmp/add_numbers_profile
+
+  pprof.rb --pdf /tmp/add_numbers_profile > /tmp/add_numbers_profile.pdf
+
+  pprof.rb --gif /tmp/add_numbers_profile > /tmp/add_numbers_profile.gif
+
+  pprof.rb --callgrind /tmp/add_numbers_profile > /tmp/add_numbers_profile.grind
+  kcachegrind /tmp/add_numbers_profile.grind
+
+  pprof.rb --gif --focus=Integer /tmp/add_numbers_profile > /tmp/add_numbers_custom.gif
+
+  pprof.rb --text --ignore=Gem /tmp/my_app_profile
+
+
+  For more options, see http://google-perftools.googlecode.com/svn/trunk/doc/cpuprofile.html#pprof
+
+
+=== Examples
+
+  pprof.rb --text
+
+    Total: 1735 samples
+        1487  85.7%  85.7%     1735 100.0% Integer#times
+         248  14.3% 100.0%      248  14.3% Fixnum#+
+
+  pprof.rb --gif
+
+    Simple require 'rubygems' profile
+
+      http://github.com/tmm1/perftools.rb/blob/master/examples/rubygems.gif
+
+    Comparing redis-rb with and without SystemTimer based socket timeouts
+
+      http://github.com/tmm1/perftools.rb/blob/master/examples/redis-rb.gif
+      http://github.com/tmm1/perftools.rb/blob/master/examples/redis-rb-notimeout.gif
+
+    Sinatra vs. Merb vs. Rails
+
+      http://github.com/tmm1/perftools.rb/blob/master/examples/sinatra.gif
+      http://github.com/tmm1/perftools.rb/blob/master/examples/merb.gif
+      http://github.com/tmm1/perftools.rb/blob/master/examples/rails.gif
+
+    C-level profile of EventMachine + epoll + Ruby threads
+      before http://timetobleed.com/6-line-eventmachine-bugfix-2x-faster-gc-1300-requestssec/
+
+      http://github.com/tmm1/perftools.rb/blob/master/examples/eventmachine-epoll+nothreads.gif
+      http://github.com/tmm1/perftools.rb/blob/master/examples/eventmachine-epoll+threads.gif
+
+    C-level profile of the ruby interpreter
+      12% time spent in re_match_exec because of excessive calls to rb_str_sub_bang by Date.parse
+      easily fixed by using the ThirdBase gem
+
+      http://github.com/tmm1/perftools.rb/blob/master/examples/ruby_interpreter.gif
+
+
+=== Installation
+
+  You'll need a patched version of Ruby 1.8:
+
+    wget ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.6-p368.tar.gz
+    tar zxvf ruby-1.8.6-p368.tar.gz
+    cd ruby-1.8.6-p368
+
+    wget http://github.com/tmm1/perftools.rb/raw/master/patches/ruby.patch
+    patch -p1 < ruby.patch
+
+    ./configure --prefix=/opt/ruby-profiling
+    make
+    sudo make install
+
+  Install rubygems:
+
+    wget http://rubyforge.org/frs/download.php/57643/rubygems-1.3.4.tgz
+    tar zxvf rubygems-1.3.4.tgz
+    cd rubygems-1.3.4
+    /opt/ruby-profiling/bin/ruby setup.rb
+
+  Install the perftools.rb gem, which will download and compile google-perftools for you:
+
+    git clone git://github.com/tmm1/perftools.rb
+    cd perftools.rb
+    gem build perftools.rb.gemspec
+    /opt/ruby-profiling/bin/gem install perftools.rb
+
+
+=== Advantages over ruby-prof
+
+  Sampling profiler
+
+    perftools samples your process using setitimer() so it can be used in production with minimal overhead.
+
+
+=== Profiling the Ruby VM and C extensions
+
+  To profile C code, simply download and build perftools (libunwind or ./configure --enable-frame-pointers required on x86_64):
+
+    wget http://google-perftools.googlecode.com/files/google-perftools-1.2.tar.gz
+    tar zxvf google-perftools-1.2.tar.gz
+    cd google-perftools-1.2
+
+    ./configure --prefix=/opt --disable-shared
+    make
+    sudo make install
+
+    export LD_PRELOAD=/opt/lib/libprofiler.so                 # for linux
+    export DYLD_INSERT_LIBRARIES=/opt/lib/libprofiler.dylib   # for osx
+    CPUPROFILE=/tmp/ruby_interpreter.profile ruby -e' 5_000_000.times{ "hello world" } '
+
+    pprof `which ruby` --text /tmp/ruby_interpreter.profile
+
+
+=== TODO
+
+  * Add support for heap profiling to find memory leaks (PerfTools::HeapProfiler)
+  * Allow both C and Ruby profiling
+  * Add setter for the sampling interval
+
+
+=== Resources
+
+  Google Perftools
+    http://code.google.com/p/google-perftools/
+
+  Analyzing profiles and interpreting different output formats
+    http://google-perftools.googlecode.com/svn/trunk/doc/cpuprofile.html#pprof

data/bin/pprof.rb

@@ -0,0 +1,3 @@
+#!/bin/sh
+# XXX assuming that we're going to be run from inside the gem installation
+`dirname $0`/pprof `which ruby` $*

data/ext/extconf.rb

@@ -0,0 +1,46 @@
+require 'mkmf'
+require 'fileutils'
+require 'net/http'
+
+# http://google-perftools.googlecode.com/files/google-perftools-1.2.tar.gz
+perftools = "google-perftools-1.2.tar.gz"
+dir = File.basename(perftools, '.tar.gz')
+
+Logging.message "(I'm about to download and compile google-perftools.. this will definitely take a while)"
+
+FileUtils.mkdir("src") unless File.exists?("src")
+Dir.chdir("src") do
+  Net::HTTP.start("google-perftools.googlecode.com") { |http|
+    resp = http.get("/files/#{perftools}")
+    open(perftools, "wb") { |file|
+      file.write(resp.body)
+    }
+  } unless File.exists?(perftools)
+
+  unless File.exists?(dir)
+    xsystem("tar zxvf #{perftools}")
+    Dir.chdir(dir) do
+      xsystem("patch -p1 < ../../../patches/perftools.patch")
+      xsystem("patch -p1 < ../../../patches/perftools-static.patch")
+      xsystem("patch -p1 < ../../../patches/perftools-osx.patch") if RUBY_PLATFORM =~ /darwin/
+      xsystem("patch -p1 < ../../../patches/perftools-debug.patch")# if ENV['DEBUG']
+    end
+  end
+
+  unless File.exists?('../bin/pprof')
+    Dir.chdir(dir) do
+      FileUtils.cp 'src/pprof', '../../../bin/'
+    end
+  end
+
+  unless File.exists?('../libprofiler.a')
+    Dir.chdir(dir) do
+      xsystem("./configure --disable-heap-profiler --disable-heap-checker --disable-minimal --disable-shared")
+      xsystem("make")
+      FileUtils.cp '.libs/libprofiler.a', '../../'
+    end
+  end
+end
+
+$libs = append_library($libs, 'profiler')
+create_makefile 'perftools'

data/ext/perftools.c

@@ -0,0 +1,54 @@
+#include <ruby.h>
+
+static VALUE cPerfTools;
+static VALUE cCpuProfiler;
+static VALUE bProfilerRunning;
+
+VALUE
+cpuprofiler_running_p(VALUE self)
+{
+  return bProfilerRunning;
+}
+
+VALUE
+cpuprofiler_stop(VALUE self)
+{
+  if (!bProfilerRunning)
+    return Qfalse;
+
+  bProfilerRunning = Qfalse;
+  ProfilerStop();
+  ProfilerFlush();
+  return Qtrue;
+}
+
+VALUE
+cpuprofiler_start(VALUE self, VALUE filename)
+{
+  StringValue(filename);
+
+  if (bProfilerRunning)
+    return Qfalse;
+
+  ProfilerStart(RSTRING_PTR(filename));
+  bProfilerRunning = Qtrue;
+
+  if (rb_block_given_p()) {
+    rb_yield(Qnil);
+    cpuprofiler_stop(self);
+  }
+
+  return Qtrue;
+}
+
+void
+Init_perftools()
+{
+  cPerfTools = rb_define_class("PerfTools", rb_cObject);
+  cCpuProfiler = rb_define_class_under(cPerfTools, "CpuProfiler", rb_cObject);
+  bProfilerRunning = Qfalse;
+
+  rb_define_singleton_method(cCpuProfiler, "running?", cpuprofiler_running_p, 0);
+  rb_define_singleton_method(cCpuProfiler, "start", cpuprofiler_start, 1);
+  rb_define_singleton_method(cCpuProfiler, "stop", cpuprofiler_stop, 0);
+}

data/patches/perftools-debug.patch

@@ -0,0 +1,20 @@
+diff --git a/Makefile.in b/Makefile.in
+index 1247b91..45179f3 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -989,13 +989,13 @@ AUTOMAKE = @AUTOMAKE@
+ AWK = @AWK@
+ CC = @CC@
+ CCDEPMODE = @CCDEPMODE@
+-CFLAGS = @CFLAGS@ -DBUILD_FOR_RUBY
++CFLAGS = @CFLAGS@ -DBUILD_FOR_RUBY -O0 -ggdb
+ CPP = @CPP@
+ CPPFLAGS = @CPPFLAGS@
+ CXX = @CXX@
+ CXXCPP = @CXXCPP@
+ CXXDEPMODE = @CXXDEPMODE@
+-CXXFLAGS = @CXXFLAGS@ -DBUILD_FOR_RUBY
++CXXFLAGS = @CXXFLAGS@ -DBUILD_FOR_RUBY -O0 -ggdb
+ CYGPATH_W = @CYGPATH_W@
+ DEFS = @DEFS@
+ DEPDIR = @DEPDIR@

data/patches/perftools-osx.patch

@@ -0,0 +1,13 @@
+diff --git a/Makefile.in b/Makefile.in
+index 1247b91..3f6e133 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -1017,7 +1017,7 @@ INSTALL_DATA = @INSTALL_DATA@
+ INSTALL_PROGRAM = @INSTALL_PROGRAM@
+ INSTALL_SCRIPT = @INSTALL_SCRIPT@
+ INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+-LDFLAGS = @LDFLAGS@
++LDFLAGS = @LDFLAGS@ -Wl,-flat_namespace,-undefined,dynamic_lookup
+ LIBOBJS = @LIBOBJS@
+ LIBS = @LIBS@
+ LIBSTDCXX_LA_LINKER_FLAG = @LIBSTDCXX_LA_LINKER_FLAG@

data/patches/perftools-static.patch

@@ -0,0 +1,27 @@
+diff --git a/Makefile.in b/Makefile.in
+index 1247b91..e7c5bca 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -3736,14 +3736,14 @@ uninstall-man: uninstall-man1
+ # (since it does work only in global constructors and destructors).
+ # We just replace the .a with an 'ld-r-ized' version under libtool's
+ # nose.
+-@WITH_CPU_PROFILER_TRUE@libprofiler.o: libprofiler.la $(libprofiler_la_OBJECTS) $(libprofiler_la_DEPENDENCIES) $(libprofiler_la_LIBADD)
+-@WITH_CPU_PROFILER_TRUE@	$(CXXLINK) $(libprofiler_la_OBJECTS) $(libprofiler_la_LIBADD)
+-@WITH_CPU_PROFILER_TRUE@	cp -f "$@" .libs/libprofiler.a
+-@WITH_CPU_PROFILER_TRUE@profiler_unittest.sh$(EXEEXT): $(top_srcdir)/$(profiler_unittest_sh_SOURCES) \
+-@WITH_CPU_PROFILER_TRUE@                               profiler1_unittest profiler2_unittest \
+-@WITH_CPU_PROFILER_TRUE@                               profiler3_unittest profiler4_unittest
+-@WITH_CPU_PROFILER_TRUE@	rm -f $@
+-@WITH_CPU_PROFILER_TRUE@	cp -p $(top_srcdir)/$(profiler_unittest_sh_SOURCES) $@
++# @WITH_CPU_PROFILER_TRUE@libprofiler.o: libprofiler.la $(libprofiler_la_OBJECTS) $(libprofiler_la_DEPENDENCIES) $(libprofiler_la_LIBADD)
++# @WITH_CPU_PROFILER_TRUE@	$(CXXLINK) $(libprofiler_la_OBJECTS) $(libprofiler_la_LIBADD)
++# @WITH_CPU_PROFILER_TRUE@	cp -f "$@" .libs/libprofiler.a
++# @WITH_CPU_PROFILER_TRUE@profiler_unittest.sh$(EXEEXT): $(top_srcdir)/$(profiler_unittest_sh_SOURCES) \
++# @WITH_CPU_PROFILER_TRUE@                               profiler1_unittest profiler2_unittest \
++# @WITH_CPU_PROFILER_TRUE@                               profiler3_unittest profiler4_unittest
++# @WITH_CPU_PROFILER_TRUE@	rm -f $@
++# @WITH_CPU_PROFILER_TRUE@	cp -p $(top_srcdir)/$(profiler_unittest_sh_SOURCES) $@
+ 
+ rpm: dist-gzip packages/rpm.sh packages/rpm/rpm.spec
+ 	@cd packages && ./rpm.sh ${PACKAGE} ${VERSION}

data/patches/perftools.patch

@@ -0,0 +1,302 @@
+diff --git a/src/pprof b/src/pprof
+index f23786d..21ccd12 100755
+--- a/src/pprof
++++ b/src/pprof
+@@ -504,7 +504,8 @@ sub Main() {
+   FetchDynamicProfiles();
+     
+   # Read one profile, pick the last item on the list
+-  my $data = ReadProfile($main::prog, pop(@main::profile_files));
++  my $fname = pop(@main::profile_files);
++  my $data = ReadProfile($main::prog, $fname);
+   my $profile = $data->{profile};
+   my $pcs = $data->{pcs};
+   my $libs = $data->{libs};   # Info about main program and shared libraries
+@@ -536,6 +537,17 @@ sub Main() {
+     $symbols = ExtractSymbols($libs, $pcs);
+   }
+ 
++  if (-e "$fname.symbols") {
++    open(SYMBOLS, "<$fname.symbols");
++    while(<SYMBOLS>){
++      chop;
++      if (m/(.+?)\s*:\s*(.*)/){
++        $symbols->{$1}[0] = $2;
++      }
++    }
++    close(SYMBOLS);
++  }
++
+   my $calls = ExtractCalls($symbols, $profile);
+ 
+   # Remove uniniteresting stack items
+diff --git a/src/profile-handler.cc b/src/profile-handler.cc
+index 0a9f54c..5b99a81 100644
+--- a/src/profile-handler.cc
++++ b/src/profile-handler.cc
+@@ -263,6 +263,11 @@ ProfileHandler::~ProfileHandler() {
+ void ProfileHandler::RegisterThread() {
+   SpinLockHolder cl(&control_lock_);
+ 
++#ifdef BUILD_FOR_RUBY
++  timer_sharing_ = TIMERS_SHARED;
++  if (callback_count_ > 0 && !IsTimerRunning())
++    StartTimer();
++#else
+   // We try to detect whether timers are being shared by setting a
+   // timer in the first call to this function, then checking whether
+   // it's set in the second call.
+@@ -304,6 +309,7 @@ void ProfileHandler::RegisterThread() {
+       StartTimer();
+       break;
+   }
++#endif
+ }
+ 
+ ProfileHandlerToken* ProfileHandler::RegisterCallback(
+diff --git a/src/profiledata.cc b/src/profiledata.cc
+index 5f2531b..e6240d9 100644
+--- a/src/profiledata.cc
++++ b/src/profiledata.cc
+@@ -56,6 +56,19 @@ const int ProfileData::kAssociativity;
+ const int ProfileData::kBuckets;
+ const int ProfileData::kBufferLength;
+ 
++#ifdef BUILD_FOR_RUBY
++extern "C" {
++  typedef unsigned long ID;
++  typedef unsigned long VALUE;
++
++  void rb_gc();
++  const char *rb_id2name(ID);
++  const char *rb_class2name(VALUE);
++}
++
++#include <set>
++#endif
++
+ ProfileData::Options::Options()
+     : frequency_(1) {
+ }
+@@ -63,17 +76,33 @@ ProfileData::Options::Options()
+ // This function is safe to call from asynchronous signals (but is not
+ // re-entrant).  However, that's not part of its public interface.
+ void ProfileData::Evict(const Entry& entry) {
++#ifdef BUILD_FOR_RUBY
++  const int d = entry.depth == 1 ? 1 : entry.depth/3;
++#else
+   const int d = entry.depth;
++#endif
+   const int nslots = d + 2;     // Number of slots needed in eviction buffer
++
+   if (num_evicted_ + nslots > kBufferLength) {
+     FlushEvicted();
+     assert(num_evicted_ == 0);
+     assert(nslots <= kBufferLength);
+   }
++
+   evict_[num_evicted_++] = entry.count;
+   evict_[num_evicted_++] = d;
++
++#ifdef BUILD_FOR_RUBY
++  if (entry.depth > 1) {
++    for (int n=0; n<entry.depth; n+=3)
++      evict_[num_evicted_++] = entry.stack[n] + entry.stack[n+1] + entry.stack[n+2];
++  } else if (entry.depth == 1) {
++    evict_[num_evicted_++] = entry.stack[0];
++  }
++#else
+   memcpy(&evict_[num_evicted_], entry.stack, d * sizeof(Slot));
+   num_evicted_ += d;
++#endif
+ }
+ 
+ ProfileData::ProfileData()
+@@ -85,6 +114,7 @@ ProfileData::ProfileData()
+       evictions_(0),
+       total_bytes_(0),
+       fname_(0),
++      sym_fname_(0),
+       start_time_(0) {
+ }
+ 
+@@ -101,6 +131,13 @@ bool ProfileData::Start(const char* fname,
+     return false;
+   }
+ 
++#ifdef BUILD_FOR_RUBY
++  int len = strlen(fname);
++  sym_fname_ = (char*)malloc((len+9) * sizeof(char));
++  strncpy(sym_fname_, fname, len);
++  strcpy(sym_fname_+len, ".symbols");
++#endif
++
+   start_time_ = time(NULL);
+   fname_ = strdup(fname);
+ 
+@@ -166,16 +203,47 @@ void ProfileData::Stop() {
+     return;
+   }
+ 
++#ifdef BUILD_FOR_RUBY
++  FILE *symbols;
++  symbols = fopen(sym_fname_, "w");
++  fprintf(symbols, "%0*lx: garbage_collector\n", sizeof(unsigned long)*2, (ID)rb_gc);
++
++  std::set<ID> known_symbols;
++#endif
++
+   // Move data from hash table to eviction buffer
+   for (int b = 0; b < kBuckets; b++) {
+     Bucket* bucket = &hash_[b];
+     for (int a = 0; a < kAssociativity; a++) {
+       if (bucket->entry[a].count > 0) {
+-        Evict(bucket->entry[a]);
++        Entry e = bucket->entry[a];
++        Evict(e);
++#ifdef BUILD_FOR_RUBY
++        if (e.depth > 1)
++          for (int n=0; n<e.depth; n+=3) {
++            ID sym = e.stack[n] + e.stack[n+1] + e.stack[n+2];
++
++            if (known_symbols.find(sym) == known_symbols.end()) {
++              fprintf(symbols, "%0*lx: ", sizeof(unsigned long)*2, sym);
++
++              if (e.stack[n])
++                fprintf(symbols, "%s.", rb_class2name(e.stack[n]));
++              else
++                fprintf(symbols, "%s#", rb_class2name(e.stack[n+1]));
++
++              fprintf(symbols, "%s\n", rb_id2name(e.stack[n+2]));
++              known_symbols.insert(sym);
++            }
++          }
++#endif
+       }
+     }
+   }
+ 
++#ifdef BUILD_FOR_RUBY
++  fclose(symbols);
++#endif
++
+   if (num_evicted_ + 3 > kBufferLength) {
+     // Ensure there is enough room for end of data marker
+     FlushEvicted();
+@@ -211,6 +279,10 @@ void ProfileData::Reset() {
+   num_evicted_ = 0;
+   free(fname_);
+   fname_ = 0;
++#ifdef BUILD_FOR_RUBY
++  free(sym_fname_);
++  sym_fname_ = 0;
++#endif
+   start_time_ = 0;
+ 
+   out_ = -1;
+diff --git a/src/profiledata.h b/src/profiledata.h
+index da7ea9e..67c463d 100644
+--- a/src/profiledata.h
++++ b/src/profiledata.h
+@@ -169,6 +169,7 @@ class ProfileData {
+   int           evictions_;     // How many evictions
+   size_t        total_bytes_;   // How much output
+   char*         fname_;         // Profile file name
++  char*         sym_fname_;     // Symbol file name
+   time_t        start_time_;    // Start time, or 0
+ 
+   // Move 'entry' to the eviction buffer.
+diff --git a/src/profiler.cc b/src/profiler.cc
+index c51c7b2..21c7669 100644
+--- a/src/profiler.cc
++++ b/src/profiler.cc
+@@ -63,6 +63,12 @@ typedef int ucontext_t;   // just to quiet the compiler, mostly
+ #include "conflict-signal.h"          /* used on msvc machines */
+ #endif
+ 
++#ifdef BUILD_FOR_RUBY
++extern "C" {
++  int rb_stack_trace(void**,int);
++}
++#endif
++
+ using std::string;
+ 
+ // Collects up all profile data.  This is a singleton, which is
+@@ -261,6 +267,9 @@ void CpuProfiler::prof_handler(int sig, siginfo_t*, void* signal_ucontext,
+       (*instance->filter_)(instance->filter_arg_)) {
+     void* stack[ProfileData::kMaxStackDepth];
+ 
++#ifdef BUILD_FOR_RUBY
++    int depth = rb_stack_trace(stack, arraysize(stack));
++#else
+     // The top-most active routine doesn't show up as a normal
+     // frame, but as the "pc" value in the signal handler context.
+     stack[0] = GetPC(*reinterpret_cast<ucontext_t*>(signal_ucontext));
+@@ -274,8 +283,10 @@ void CpuProfiler::prof_handler(int sig, siginfo_t*, void* signal_ucontext,
+     int depth = GetStackTraceWithContext(stack + 1, arraysize(stack) - 1,
+                                          2, signal_ucontext);
+     depth++;  // To account for pc value in stack[0];
++#endif
+ 
+-    instance->collector_.Add(depth, stack);
++    if (depth > 0)
++      instance->collector_.Add(depth, stack);
+   }
+ }
+ 
+diff --git a/src/stacktrace.cc b/src/stacktrace.cc
+index d158eea..e4132fe 100644
+--- a/src/stacktrace.cc
++++ b/src/stacktrace.cc
+@@ -52,6 +52,7 @@
+ // correctly when GetStackTrace() is called with max_depth == 0.
+ // Some code may do that.
+ 
++#ifndef BUILD_FOR_RUBY
+ #include "config.h"
+ #include <google/stacktrace.h>
+ #include "stacktrace_config.h"
+@@ -69,3 +70,4 @@
+ #else
+ # error Cannot calculate stack trace: will need to write for your environment
+ #endif
++#endif
+
+diff --git a/Makefile.in b/Makefile.in
+index 1247b91..45179f3 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -989,13 +989,13 @@ AUTOMAKE = @AUTOMAKE@
+ AWK = @AWK@
+ CC = @CC@
+ CCDEPMODE = @CCDEPMODE@
+-CFLAGS = @CFLAGS@
++CFLAGS = @CFLAGS@ -DBUILD_FOR_RUBY
+ CPP = @CPP@
+ CPPFLAGS = @CPPFLAGS@
+ CXX = @CXX@
+ CXXCPP = @CXXCPP@
+ CXXDEPMODE = @CXXDEPMODE@
+-CXXFLAGS = @CXXFLAGS@
++CXXFLAGS = @CXXFLAGS@ -DBUILD_FOR_RUBY
+ CYGPATH_W = @CYGPATH_W@
+ DEFS = @DEFS@
+ DEPDIR = @DEPDIR@
+diff --git a/src/stacktrace_with_context.cc b/src/stacktrace_with_context.cc
+index f9fc28f..beb7562 100644
+--- a/src/stacktrace_with_context.cc
++++ b/src/stacktrace_with_context.cc
+@@ -41,6 +41,7 @@
+ // may inline this code anyway. Let's hope they respect
+ // ATTRIBUTE_NOINLINE.
+ 
++#ifndef BUILD_FOR_RUBY
+ #include "config.h"
+ #include <google/stacktrace.h>
+ #include "stacktrace_config.h"
+@@ -59,3 +60,4 @@ int GetStackTraceWithContext(void** result, int max_depth,
+   return GetStackTrace(result, max_depth, skip_count + 1);
+ }
+ #endif
++#endif

data/patches/ruby.patch

@@ -0,0 +1,72 @@
+diff --git a/eval.c b/eval.c
+index 4989aac..51fb0e5 100644
+--- a/eval.c
++++ b/eval.c
+@@ -6385,6 +6385,67 @@ backtrace(lev)
+     return ary;
+ }
+ 
++int
++rb_stack_trace(result, max_depth)
++  void** result;
++  int max_depth;
++{
++  int depth = 0;
++  struct FRAME *frame = ruby_frame;
++  NODE *n;
++  st_data_t key;
++
++  if (max_depth == 0) return 0;
++  // if (rb_prohibit_interrupt || !rb_trap_immediate) return 0;
++
++  if (rb_during_gc()) {
++    result[0] = rb_gc;
++    return 1;
++  }
++
++  if (frame->last_func == ID_ALLOCATOR) {
++    frame = frame->prev;
++  }
++
++  if (frame->last_func) {
++    VALUE klass = frame->last_class;
++    // if (BUILTIN_TYPE(klass) == T_ICLASS)
++    //   klass = RBASIC(klass)->klass;
++
++    if (FL_TEST(klass, FL_SINGLETON) && (BUILTIN_TYPE(frame->self) == T_CLASS || BUILTIN_TYPE(frame->self) == T_MODULE))
++      result[depth++] = frame->self;
++    else
++      result[depth++] = 0;
++
++    result[depth++] = klass;
++    result[depth++] = frame->last_func;
++  }
++
++  for (; frame && (n = frame->node); frame = frame->prev) {
++    if (frame->prev && frame->prev->last_func) {
++      if (frame->prev->node == n) {
++        if (frame->prev->last_func == frame->last_func) continue;
++      }
++
++      if (depth+3 > max_depth) break;
++
++      VALUE klass = frame->prev->last_class;
++      // if (BUILTIN_TYPE(klass) == T_ICLASS)
++      //   klass = RBASIC(klass)->klass;
++
++      if (FL_TEST(klass, FL_SINGLETON) && (BUILTIN_TYPE(frame->prev->self) == T_CLASS || BUILTIN_TYPE(frame->prev->self) == T_MODULE))
++        result[depth++] = frame->prev->self;
++      else
++        result[depth++] = 0;
++
++      result[depth++] = klass;
++      result[depth++] = frame->prev->last_func;
++    }
++  }
++
++  return depth;
++}
++
+ /*
+  *  call-seq:
+  *     caller(start=1)    => array

data/perftools.rb.gemspec

@@ -0,0 +1,31 @@
+spec = Gem::Specification.new do |s|
+  s.name = 'perftools.rb'
+  s.version = '0.1.1'
+  s.date = '2009-06-01'
+  s.summary = 'google-perftools for ruby code'
+  s.description = 'A sampling profiler for ruby code based on patches to google-perftools'
+
+  s.homepage = "http://github.com/tmm1/perftools.rb"
+
+  s.authors = ["Aman Gupta"]
+  s.email = "aman@tmm1.net"
+
+  s.has_rdoc = false
+  s.extensions = 'ext/extconf.rb'
+  s.bindir = 'bin'
+  s.executables << 'pprof.rb'
+
+  # ruby -rpp -e' pp `git ls-files | grep -v examples`.split("\n") '
+  s.files = [
+    "README",
+    "bin/pprof.rb",
+    "ext/extconf.rb",
+    "ext/perftools.c",
+    "patches/perftools-debug.patch",
+    "patches/perftools-osx.patch",
+    "patches/perftools-static.patch",
+    "patches/perftools.patch",
+    "patches/ruby.patch",
+    "perftools.rb.gemspec"
+  ]
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: tmm1-perftools.rb
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Aman Gupta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-01 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A sampling profiler for ruby code based on patches to google-perftools
+email: aman@tmm1.net
+executables: 
+- pprof.rb
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- README
+- bin/pprof.rb
+- ext/extconf.rb
+- ext/perftools.c
+- patches/perftools-debug.patch
+- patches/perftools-osx.patch
+- patches/perftools-static.patch
+- patches/perftools.patch
+- patches/ruby.patch
+- perftools.rb.gemspec
+has_rdoc: false
+homepage: http://github.com/tmm1/perftools.rb
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: google-perftools for ruby code
+test_files: []
+