honkster-perftools.rb 0.5.6

data/patches/perftools-debug.patch

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

data/patches/perftools-frames.patch

@@ -0,0 +1,13 @@
+diff --git a/src/profiledata.h b/src/profiledata.h
+index ccdf96f..0517614 100644
+--- a/src/profiledata.h
++++ b/src/profiledata.h
+@@ -106,7 +106,7 @@ class ProfileData {
+     int      frequency_;                  // Sample frequency.
+   };
+ 
+-  static const int kMaxStackDepth = 64;  // Max stack depth stored in profile
++  static const int kMaxStackDepth = 300;  // Max stack depth stored in profile
+ 
+   ProfileData();
+   ~ProfileData();

data/patches/perftools-gc.patch

@@ -0,0 +1,107 @@
+diff --git a/src/profiledata.cc b/src/profiledata.cc
+index e6240d9..b901ee8 100644
+--- a/src/profiledata.cc
++++ b/src/profiledata.cc
+@@ -198,6 +198,29 @@ static void DumpProcSelfMaps(int fd) {
+   }
+ }
+ 
++#ifdef BUILD_FOR_RUBY
++void ProfileData::GcMark(void (*mark)(VALUE)) {
++  if (!enabled()) {
++    return;
++  }
++
++  for (int b = 0; b < kBuckets; b++) {
++    Bucket* bucket = &hash_[b];
++    for (int a = 0; a < kAssociativity; a++) {
++      if (bucket->entry[a].count > 0) {
++        Entry e = bucket->entry[a];
++        if (e.depth > 1)
++          for (int n=0; n<e.depth; n+=3) {
++            if (e.stack[n])
++              mark(e.stack[n]);
++            mark(e.stack[n+1]);
++          }
++      }
++    }
++  }
++}
++#endif
++
+ void ProfileData::Stop() {
+   if (!enabled()) {
+     return;
+diff --git a/src/profiledata.h b/src/profiledata.h
+index 67c463d..a68e12f 100644
+--- a/src/profiledata.h
++++ b/src/profiledata.h
+@@ -40,6 +40,12 @@
+ #ifndef BASE_PROFILEDATA_H_
+ #define BASE_PROFILEDATA_H_
+ 
++#ifdef BUILD_FOR_RUBY
++extern "C" {
++  typedef unsigned long VALUE;
++}
++#endif
++
+ #include <config.h>
+ #include <time.h>   // for time_t
+ #include <stdint.h>
+@@ -141,6 +147,10 @@ class ProfileData {
+   // Get the current state of the data collector.
+   void GetCurrentState(State* state) const;
+ 
++#ifdef BUILD_FOR_RUBY
++  void GcMark(void (*cb)(VALUE));
++#endif
++
+  private:
+   static const int kAssociativity = 4;          // For hashtable
+   static const int kBuckets = 1 << 10;          // For hashtable
+diff --git a/src/profiler.cc b/src/profiler.cc
+index d89a53a..37234b2 100644
+--- a/src/profiler.cc
++++ b/src/profiler.cc
+@@ -87,6 +87,10 @@ class CpuProfiler {
+   // Write the data to disk (and continue profiling).
+   void FlushTable();
+ 
++#ifdef BUILD_FOR_RUBY
++  void GcMark(void (*cb)(VALUE));
++#endif
++
+   bool Enabled();
+ 
+   void GetCurrentState(ProfilerState* state);
+@@ -221,6 +225,16 @@ void CpuProfiler::FlushTable() {
+   EnableHandler();
+ }
+ 
++#ifdef BUILD_FOR_RUBY
++void CpuProfiler::GcMark(void (*cb)(VALUE)) {
++  if (!collector_.enabled()) {
++    return;
++  }
++
++  collector_.GcMark(cb);
++}
++#endif
++
+ bool CpuProfiler::Enabled() {
+   SpinLockHolder cl(&lock_);
+   return collector_.enabled();
+@@ -300,6 +314,12 @@ extern "C" PERFTOOLS_DLL_DECL void ProfilerFlush() {
+   CpuProfiler::instance_.FlushTable();
+ }
+ 
++#ifdef BUILD_FOR_RUBY
++extern "C" PERFTOOLS_DLL_DECL void ProfilerGcMark(void (*cb)(VALUE)) {
++  CpuProfiler::instance_.GcMark(cb);
++}
++#endif
++
+ extern "C" PERFTOOLS_DLL_DECL int ProfilingIsEnabledForAllThreads() {
+   return CpuProfiler::instance_.Enabled();
+ }

data/patches/perftools-notests.patch

@@ -0,0 +1,15 @@
+diff --git a/Makefile.in b/Makefile.in
+index b301f4d..969db5e 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -65,9 +65,7 @@ host_triplet = @host@
+ @ENABLE_FRAME_POINTERS_TRUE@@X86_64_AND_NO_FP_BY_DEFAULT_TRUE@am__append_3 = -fno-omit-frame-pointer
+ @ENABLE_FRAME_POINTERS_FALSE@@X86_64_AND_NO_FP_BY_DEFAULT_TRUE@am__append_4 = -DNO_FRAME_POINTER
+ @MINGW_TRUE@am__append_5 = -Wl,-u__tcmalloc
+-noinst_PROGRAMS = $(am__EXEEXT_1) $(am__EXEEXT_2) $(am__EXEEXT_3) \
+-	$(am__EXEEXT_4) $(am__EXEEXT_5) $(am__EXEEXT_6) \
+-	$(am__EXEEXT_7) $(am__EXEEXT_8) $(am__EXEEXT_23)
++noinst_PROGRAMS =
+ bin_PROGRAMS =
+ @MINGW_TRUE@am__append_6 = libwindows.la libspinlock.la
+ 

data/patches/perftools-objects.patch

@@ -0,0 +1,85 @@
+diff --git a/src/profile-handler.cc b/src/profile-handler.cc
+index 5df5054..2335617 100644
+--- a/src/profile-handler.cc
++++ b/src/profile-handler.cc
+@@ -395,6 +395,8 @@ void ProfileHandler::GetState(ProfileHandlerState* state) {
+ }
+ 
+ void ProfileHandler::StartTimer() {
++  if (getenv("CPUPROFILE_OBJECTS") || getenv("CPUPROFILE_METHODS")) return;
++
+   struct itimerval timer;
+   timer.it_interval.tv_sec = 0;
+   timer.it_interval.tv_usec = 1000000 / frequency_;
+@@ -403,12 +405,16 @@ void ProfileHandler::StartTimer() {
+ }
+ 
+ void ProfileHandler::StopTimer() {
++  if (getenv("CPUPROFILE_OBJECTS") || getenv("CPUPROFILE_METHODS")) return;
++
+   struct itimerval timer;
+   memset(&timer, 0, sizeof timer);
+   setitimer(timer_type_, &timer, 0);
+ }
+ 
+ bool ProfileHandler::IsTimerRunning() {
++  if (getenv("CPUPROFILE_OBJECTS") || getenv("CPUPROFILE_METHODS")) return false;
++
+   struct itimerval current_timer;
+   RAW_CHECK(0 == getitimer(timer_type_, &current_timer), "getitimer");
+   return (current_timer.it_value.tv_sec != 0 ||
+@@ -416,6 +422,8 @@ bool ProfileHandler::IsTimerRunning() {
+ }
+ 
+ void ProfileHandler::EnableHandler() {
++  if (getenv("CPUPROFILE_OBJECTS") || getenv("CPUPROFILE_METHODS")) return;
++
+   struct sigaction sa;
+   sa.sa_sigaction = SignalHandler;
+   sa.sa_flags = SA_RESTART | SA_SIGINFO;
+@@ -425,6 +433,8 @@ void ProfileHandler::EnableHandler() {
+ }
+ 
+ void ProfileHandler::DisableHandler() {
++  if (getenv("CPUPROFILE_OBJECTS") || getenv("CPUPROFILE_METHODS")) return;
++
+   struct sigaction sa;
+   sa.sa_handler = SIG_IGN;
+   sa.sa_flags = SA_RESTART;
+diff --git a/src/profiler.cc b/src/profiler.cc
+index f408cf8..7645c45 100644
+--- a/src/profiler.cc
++++ b/src/profiler.cc
+@@ -102,6 +102,10 @@ class CpuProfiler {
+ 
+   static CpuProfiler instance_;
+ 
++  // Signal handler that records the interrupted pc in the profile data.
++  static void prof_handler(int sig, siginfo_t*, void* signal_ucontext,
++                           void* cpu_profiler);
++
+  private:
+   // This lock implements the locking requirements described in the ProfileData
+   // documentation, specifically:
+@@ -130,10 +134,6 @@ class CpuProfiler {
+ 
+   // Disables receiving SIGPROF interrupt.
+   void DisableHandler();
+-
+-  // Signal handler that records the interrupted pc in the profile data.
+-  static void prof_handler(int sig, siginfo_t*, void* signal_ucontext,
+-                           void* cpu_profiler);
+ };
+ 
+ // Profile data structure singleton: Constructor will check to see if
+@@ -323,6 +323,10 @@ extern "C" PERFTOOLS_DLL_DECL void ProfilerFlush() {
+ extern "C" PERFTOOLS_DLL_DECL void ProfilerGcMark(void (*cb)(VALUE)) {
+   CpuProfiler::instance_.GcMark(cb);
+ }
++
++extern "C" PERFTOOLS_DLL_DECL void ProfilerRecord(int sig, siginfo_t* info, void* signal_ucontext) {
++  CpuProfiler::prof_handler(sig, info, signal_ucontext, (void*)&CpuProfiler::instance_);
++}
+ #endif
+ 
+ extern "C" PERFTOOLS_DLL_DECL int ProfilingIsEnabledForAllThreads() {

data/patches/perftools-osx.patch

@@ -0,0 +1,13 @@
+diff --git a/Makefile.in b/Makefile.in
+index 566d77c..c3bf409 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -1397,7 +1397,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-pprof.patch

@@ -0,0 +1,76 @@
+commit 1828f461a3ea523b7018d03ab83850621cf66ba9
+Author: Aman Gupta <aman@tmm1.net>
+Date:   Fri Nov 12 16:33:15 2010 -0600
+
+    perftools-pprof
+
+diff --git a/src/pprof b/src/pprof
+index e67e42e..b04d988 100755
+--- a/src/pprof
++++ b/src/pprof
+@@ -560,7 +560,8 @@ sub Main() {
+   my $symbol_map = {};
+ 
+   # 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
+@@ -589,7 +590,18 @@ sub Main() {
+ 
+   # Collect symbols
+   my $symbols;
+-  if ($main::use_symbolized_profile) {
++  if (-e "$fname.symbols") {
++    open(SYMBOLS, "<$fname.symbols");
++    while(<SYMBOLS>){
++      chop;
++      if (m/(.+?)\s*:\s*(.*)/){
++        $symbols->{$1}[0] = $2;
++        $symbols->{$1}[1] = "?";
++        $symbols->{$1}[2] = $2;
++      }
++    }
++    close(SYMBOLS);
++  } elsif ($main::use_symbolized_profile) {
+     $symbols = FetchSymbols($pcs, $symbol_map);
+   } elsif ($main::use_symbol_page) {
+     $symbols = FetchSymbols($pcs);
+@@ -2425,6 +2437,10 @@ sub RemoveUninterestingFrames {
+     foreach my $name ('ProfileData::Add',           # historical
+                       'ProfileData::prof_handler',  # historical
+                       'CpuProfiler::prof_handler',
++                      'PerfTools::CpuProfiler.start',
++                      'Array#each',
++                      'Proc#call',
++                      'Class#new',
+                       '__FRAME_END__',
+                       '__pthread_sighandler',
+                       '__restore') {
+@@ -2434,6 +2450,7 @@ sub RemoveUninterestingFrames {
+     # Nothing skipped for unknown types
+   }
+ 
++=pod
+   if ($main::profile_type eq 'cpu') {
+     # If all the second-youngest program counters are the same,
+     # this STRONGLY suggests that it is an artifact of measurement,
+@@ -2458,6 +2475,7 @@ sub RemoveUninterestingFrames {
+       $profile = $result;
+     }
+   }
++=cut
+ 
+   my $result = {};
+   foreach my $k (keys(%{$profile})) {
+@@ -3360,7 +3378,7 @@ sub ReadCPUProfile {
+       # file, in which case the subtract-one was done when the file
+       # was written.
+       if ($j > 0 && !$main::use_symbolized_profile) {
+-        $pc--;
++        # $pc--;
+       }
+       $pc = sprintf("%0*x", $address_length, $pc);
+       $pcs->{$pc} = 1;

data/patches/perftools-stddef.patch

@@ -0,0 +1,34 @@
+Only in ./: perftools-stddef.patch
+diff -ru .//src/base/vdso_support.h ../google-perftools-1.6-patched/src/base/vdso_support.h
+--- .//src/base/vdso_support.h	2010-08-03 03:32:20.000000000 +0800
++++ ../google-perftools-1.6-patched/src/base/vdso_support.h	2011-06-16 14:33:10.000000000 +0800
+@@ -38,6 +38,7 @@
+ #define HAVE_VDSO_SUPPORT 1
+ 
+ #include <stdlib.h>     // for NULL
++#include <stddef.h>
+ #include <link.h>  // for ElfW
+ #include "base/basictypes.h"
+ 
+diff -ru .//src/symbolize.h ../google-perftools-1.6-patched/src/symbolize.h
+--- .//src/symbolize.h	2009-11-11 03:59:46.000000000 +0800
++++ ../google-perftools-1.6-patched/src/symbolize.h	2011-06-16 14:32:55.000000000 +0800
+@@ -38,6 +38,7 @@
+ #include <stdint.h>  // for uintptr_t
+ #endif
+ #include <map>
++#include <stddef.h>
+ 
+ using std::map;
+ 
+diff -ru .//src/system-alloc.h ../google-perftools-1.6-patched/src/system-alloc.h
+--- .//src/system-alloc.h	2010-04-01 07:50:18.000000000 +0800
++++ ../google-perftools-1.6-patched/src/system-alloc.h	2011-06-16 14:32:38.000000000 +0800
+@@ -38,6 +38,7 @@
+ 
+ #include <config.h>
+ #include "internal_logging.h"
++#include <stddef.h>
+ 
+ // REQUIRES: "alignment" is a power of two or "0" to indicate default alignment
+ //

data/patches/perftools.patch

@@ -0,0 +1,266 @@
+diff --git a/Makefile.in b/Makefile.in
+index 232d2ec..566d77c 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -1367,13 +1367,13 @@ AUTOMAKE = @AUTOMAKE@
+ AWK = @AWK@
+ CC = @CC@
+ CCDEPMODE = @CCDEPMODE@
+-CFLAGS = @CFLAGS@
++CFLAGS = @CFLAGS@ -DBUILD_FOR_RUBY -fPIC
+ CPP = @CPP@
+ CPPFLAGS = @CPPFLAGS@
+ CXX = @CXX@
+ CXXCPP = @CXXCPP@
+ CXXDEPMODE = @CXXDEPMODE@
+-CXXFLAGS = @CXXFLAGS@
++CXXFLAGS = @CXXFLAGS@ -DBUILD_FOR_RUBY -fPIC
+ CYGPATH_W = @CYGPATH_W@
+ DEFS = @DEFS@
+ DEPDIR = @DEPDIR@
+diff --git a/src/profile-handler.cc b/src/profile-handler.cc
+index e658d30..370d012 100644
+--- a/src/profile-handler.cc
++++ b/src/profile-handler.cc
+@@ -264,6 +264,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.
+@@ -305,6 +310,7 @@ void ProfileHandler::RegisterThread() {
+       StartTimer();
+       break;
+   }
++#endif
+ }
+ 
+ ProfileHandlerToken* ProfileHandler::RegisterCallback(
+diff --git a/src/profiledata.cc b/src/profiledata.cc
+index 5f2531b..ea95493 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,61 @@ void ProfileData::Stop() {
+     return;
+   }
+ 
++#ifdef BUILD_FOR_RUBY
++  FILE *symbols;
++  int precision;
++
++  symbols = fopen(sym_fname_, "w");
++  if (!symbols) {
++    fprintf(stderr, "PROFILER ERROR: Unable to open %s (%s)\n", sym_fname_, strerror(errno));
++    Reset();
++    return;
++  }
++
++  precision = sizeof(unsigned long)*2;
++  fprintf(symbols, "%0*lx: garbage_collector\n", precision, (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) {
++            VALUE self = e.stack[n];
++            VALUE klass = e.stack[n+1];
++            ID method = e.stack[n+2];
++
++            ID sym = self + klass + method; // unique identifer
++
++            if (known_symbols.find(sym) == known_symbols.end()) {
++              fprintf(symbols, "%0*lx: ", precision, sym);
++
++              if (self) { // class method
++                fprintf(symbols, "%s.%s\n", rb_class2name(self), rb_id2name(method));
++              } else { // instance method
++                fprintf(symbols, "%s#%s\n", rb_class2name(klass), rb_id2name(method));
++              }
++
++              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 +293,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 183a7c7..d89a53a 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..e8509fe 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