rblineprof 0.2.7 → 0.3.2

data/ext/extconf.rb

@@ -1,16 +1,11 @@
 require 'mkmf'
 
 if RUBY_VERSION >= "1.9"
-  begin
-    require "debugger/ruby_core_source"
-  rescue LoadError
-    require 'rubygems/dependency_installer'
-    installer = Gem::DependencyInstaller.new
-    installer.install 'debugger-ruby_core_source'
-    require "debugger/ruby_core_source"
-  end
+  require "debugger/ruby_core_source"
 
   hdrs = proc {
+    have_type("rb_iseq_location_t", "vm_core.h")
+
     have_header("vm_core.h") and
     have_header("iseq.h")
   }

data/ext/rblineprof.c

@@ -1,5 +1,8 @@
 #include <ruby.h>
 #include <stdbool.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 
 #ifdef RUBY_VM
   #include <ruby/re.h>
@@ -20,17 +23,27 @@
   typedef rb_event_t rb_event_flag_t;
 #endif
 
-typedef uint64_t prof_time_t;
 static VALUE gc_hook;
 
 /*
- * Struct representing an individual line of
- * Ruby source code
+ * Time in microseconds
+ */
+typedef uint64_t prof_time_t;
+
+/*
+ * Profiling snapshot
+ */
+typedef struct snapshot {
+  prof_time_t wall_time;
+  prof_time_t cpu_time;
+} snapshot_t;
+
+/*
+ * A line of Ruby source code
  */
 typedef struct sourceline {
-  uint64_t calls; // total number of calls
-  prof_time_t total_time;
-  prof_time_t max_time;
+  uint64_t calls; // total number of call/c_call events
+  snapshot_t total;
 } sourceline_t;
 
 /*
@@ -38,11 +51,17 @@ typedef struct sourceline {
  */
 typedef struct sourcefile {
   char *filename;
+
+  /* per line timing */
   long nlines;
   sourceline_t *lines;
 
-  prof_time_t exclusive_start;
-  prof_time_t exclusive_time;
+  /* overall file timing */
+  snapshot_t total;
+  snapshot_t child;
+  uint64_t depth;
+  snapshot_t exclusive_start;
+  snapshot_t exclusive;
 } sourcefile_t;
 
 /*
@@ -64,7 +83,7 @@ typedef struct stackframe {
   char *filename;
   long line;
 
-  prof_time_t start;
+  snapshot_t start;
   sourcefile_t *srcfile;
 } stackframe_t;
 
@@ -79,9 +98,6 @@ static struct {
   stackframe_t stack[MAX_STACK_DEPTH];
   uint64_t stack_depth;
 
-  // current file
-  sourcefile_t *curr_srcfile;
-
   // single file mode, store filename and line data directly
   char *source_filename;
   sourcefile_t file;
@@ -102,7 +118,30 @@ rblineprof = {
 };
 
 static prof_time_t
-timeofday_usec()
+cputime_usec()
+{
+#if defined(__linux__)
+  struct timespec ts;
+
+  if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == 0) {
+    return (prof_time_t)ts.tv_sec*1e6 +
+           (prof_time_t)ts.tv_nsec*1e-3;
+  }
+#endif
+
+#if defined(RUSAGE_SELF)
+  struct rusage usage;
+
+  getrusage(RUSAGE_SELF, &usage);
+  return (prof_time_t)usage.ru_utime.tv_sec*1e6 +
+         (prof_time_t)usage.ru_utime.tv_usec;
+#endif
+
+  return 0;
+}
+
+static prof_time_t
+walltime_usec()
 {
   struct timeval tv;
   gettimeofday(&tv, NULL);
@@ -110,8 +149,26 @@ timeofday_usec()
          (prof_time_t)tv.tv_usec;
 }
 
+static inline snapshot_t
+snapshot_diff(snapshot_t *t1, snapshot_t *t2)
+{
+  snapshot_t diff = {
+    .wall_time         = t1->wall_time - t2->wall_time,
+    .cpu_time          = t1->cpu_time  - t2->cpu_time,
+  };
+
+  return diff;
+}
+
 static inline void
-stackframe_record(stackframe_t *frame, prof_time_t now)
+snapshot_increment(snapshot_t *s, snapshot_t *inc)
+{
+  s->wall_time         += inc->wall_time;
+  s->cpu_time          += inc->cpu_time;
+}
+
+static inline void
+stackframe_record(stackframe_t *frame, snapshot_t now, stackframe_t *caller_frame)
 {
   sourcefile_t *srcfile = frame->srcfile;
   long line = frame->line;
@@ -132,13 +189,35 @@ stackframe_record(stackframe_t *frame, prof_time_t now)
     MEMZERO(srcfile->lines + prev_nlines, sourceline_t, srcfile->nlines - prev_nlines);
   }
 
-  /* record the sample */
-  prof_time_t diff = now - frame->start;
+  snapshot_t diff = snapshot_diff(&now, &frame->start);
   sourceline_t *srcline = &(srcfile->lines[line]);
+
+  /* Line profiler metrics.
+   */
+
   srcline->calls++;
-  srcline->total_time += diff;
-  if (diff > srcline->max_time)
-    srcline->max_time = diff;
+
+  /* Increment current line's total_time.
+   *
+   * Skip the special case where the stack frame we're returning to
+   * had the same file/line. This fixes double counting on crazy one-liners.
+   */
+  if (!(caller_frame && caller_frame->srcfile == frame->srcfile && caller_frame->line == frame->line))
+    snapshot_increment(&srcline->total, &diff);
+
+  /* File profiler metrics.
+   */
+
+  /* Increment the caller file's child_time.
+   */
+  if (caller_frame && caller_frame->srcfile != srcfile)
+    snapshot_increment(&caller_frame->srcfile->child, &diff);
+
+  /* Increment current file's total_time, but only when we return
+   * to the outermost stack frame when we first entered the file.
+   */
+  if (srcfile->depth == 0)
+    snapshot_increment(&srcfile->total, &diff);
 }
 
 static inline sourcefile_t*
@@ -165,7 +244,12 @@ sourcefile_lookup(char *filename)
       return NULL;
 
     if (!srcfile) { // unknown file, check against regex
-      if (rb_reg_search(rblineprof.source_regex, rb_str_new2(filename), 0, 0) >= 0) {
+      VALUE backref = rb_backref_get();
+      rb_match_busy(backref);
+      long rc = rb_reg_search(rblineprof.source_regex, rb_str_new2(filename), 0, 0);
+      rb_backref_set(backref);
+
+      if (rc >= 0) {
         srcfile = ALLOC_N(sourcefile_t, 1);
         MEMZERO(srcfile, sourcefile_t, 1);
         srcfile->filename = strdup(filename);
@@ -188,6 +272,7 @@ sourcefile_lookup(char *filename)
  * top-most cfp on the stack in these cases points to the 'def method' line, so we skip
  * these and grab the second caller instead.
  */
+static inline
 rb_control_frame_t *
 rb_vm_get_caller(rb_thread_t *th, rb_control_frame_t *cfp, ID mid)
 {
@@ -205,6 +290,26 @@ rb_vm_get_caller(rb_thread_t *th, rb_control_frame_t *cfp, ID mid)
 
   return 0;
 }
+
+#ifdef HAVE_TYPE_RB_ISEQ_LOCATION_T
+inline static int
+calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
+{
+  return rb_iseq_line_no(iseq, pc - iseq->iseq_encoded);
+}
+
+int
+rb_vm_get_sourceline(const rb_control_frame_t *cfp)
+{
+  int lineno = 0;
+  const rb_iseq_t *iseq = cfp->iseq;
+
+  if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
+    lineno = calc_lineno(cfp->iseq, cfp->pc);
+  }
+  return lineno;
+}
+#endif
 #endif
 
 static void
@@ -216,40 +321,8 @@ profiler_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass
 {
   char *file;
   long line;
-  stackframe_t *frame = NULL;
-  sourcefile_t *srcfile, *curr_srcfile;
-  prof_time_t now = timeofday_usec();
-
-#if 0
-  /* file profiler: when invoking a method in a new file, account elapsed
-   * time to the current file and start a new timer.
-   */
-#ifndef RUBY_VM
-  if (!node) return;
-  file = node->nd_file;
-  line = nd_line(node);
-#else
-  // this returns filename (instead of filepath) on 1.9
-  file = (char *) rb_sourcefile();
-  line = rb_sourceline();
-#endif
-
-  if (!file) return;
-  if (line <= 0) return;
-
-  srcfile = sourcefile_lookup(file);
-  curr_srcfile = rblineprof.curr_srcfile;
-
-  if (curr_srcfile != srcfile) {
-    if (curr_srcfile)
-      curr_srcfile->exclusive_time += now - curr_srcfile->exclusive_start;
-
-    if (srcfile)
-      srcfile->exclusive_start = now;
-
-    rblineprof.curr_srcfile = srcfile;
-  }
-#endif
+  stackframe_t *frame = NULL, *prev = NULL;
+  sourcefile_t *srcfile;
 
   /* line profiler: maintain a stack of CALL events with timestamps. for
    * each corresponding RETURN, account elapsed time to the calling line.
@@ -264,14 +337,21 @@ profiler_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass
   file = caller_node->nd_file;
   line = nd_line(caller_node);
 #else
-  rb_thread_t *th = GET_THREAD();
+  rb_thread_t *th = ruby_current_thread;
   rb_control_frame_t *cfp = rb_vm_get_caller(th, th->cfp, mid);
   if (!cfp) return;
 
-  if (RTEST(cfp->iseq->filepath))
-    file = StringValueCStr(cfp->iseq->filepath);
-  else
-    file = StringValueCStr(cfp->iseq->filename);
+  #ifdef HAVE_TYPE_RB_ISEQ_LOCATION_T
+    if (RTEST(cfp->iseq->location.absolute_path))
+      file = StringValueCStr(cfp->iseq->location.absolute_path);
+    else
+      file = StringValueCStr(cfp->iseq->location.path);
+  #else
+    if (RTEST(cfp->iseq->filepath))
+      file = StringValueCStr(cfp->iseq->filepath);
+    else
+      file = StringValueCStr(cfp->iseq->filename);
+  #endif
   line = rb_vm_get_sourceline(cfp);
 #endif
 
@@ -294,46 +374,115 @@ profiler_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass
   rblineprof.cache.srcfile = srcfile;
   if (!srcfile) return; /* skip line profiling for this file */
 
+  snapshot_t now = {
+    .wall_time         = walltime_usec(),
+    .cpu_time          = cputime_usec(),
+  };
+
   switch (event) {
     case RUBY_EVENT_CALL:
     case RUBY_EVENT_C_CALL:
+      /* Create a stack frame entry with this event,
+       * the current file, and a snapshot of metrics.
+       *
+       * On a corresponding RETURN event later, we can
+       * pop this stack frame and accumulate metrics to the
+       * associated file and line.
+       */
       rblineprof.stack_depth++;
       if (rblineprof.stack_depth > 0 && rblineprof.stack_depth < MAX_STACK_DEPTH) {
         frame = &rblineprof.stack[rblineprof.stack_depth-1];
         frame->event = event;
-
-#ifdef RUBY_VM
-        frame->thread = th;
-#else
-        frame->node = node;
-#endif
         frame->self = self;
         frame->mid = mid;
         frame->klass = klass;
         frame->line = line;
         frame->start = now;
         frame->srcfile = srcfile;
+#ifdef RUBY_VM
+        frame->thread = th;
+#else
+        frame->node = node;
+#endif
+      }
+
+      /* Record when we entered this file for the first time.
+       * The difference is later accumulated into exclusive_time,
+       * e.g. on the next event if the file changes.
+       */
+      if (srcfile->depth == 0)
+        srcfile->exclusive_start = now;
+      srcfile->depth++;
+
+      if (rblineprof.stack_depth > 1) { // skip if outermost frame
+        prev = &rblineprof.stack[rblineprof.stack_depth-2];
+
+        /* If we just switched files, record time that was spent in
+         * the previous file.
+         */
+        if (prev->srcfile != frame->srcfile) {
+          snapshot_t diff = snapshot_diff(&now, &prev->srcfile->exclusive_start);
+          snapshot_increment(&prev->srcfile->exclusive, &diff);
+          prev->srcfile->exclusive_start = now;
+        }
       }
       break;
 
     case RUBY_EVENT_RETURN:
     case RUBY_EVENT_C_RETURN:
+      /* Find the corresponding CALL for this event.
+       *
+       * We loop here instead of a simple pop, because in the event of a
+       * raise/rescue several stack frames could have disappeared.
+       */
       do {
-        if (rblineprof.stack_depth > 0 && rblineprof.stack_depth < MAX_STACK_DEPTH)
+        if (rblineprof.stack_depth > 0 && rblineprof.stack_depth < MAX_STACK_DEPTH) {
           frame = &rblineprof.stack[rblineprof.stack_depth-1];
-        else
+          if (frame->srcfile->depth > 0)
+            frame->srcfile->depth--;
+        } else
           frame = NULL;
+
         rblineprof.stack_depth--;
       } while (frame &&
 #ifdef RUBY_VM
                frame->thread != th &&
 #endif
+               /* Break when we find a matching CALL/C_CALL.
+                */
+               frame->event != (event == RUBY_EVENT_CALL ? RUBY_EVENT_RETURN : RUBY_EVENT_C_RETURN) &&
                frame->self != self &&
                frame->mid != mid &&
                frame->klass != klass);
 
+      if (rblineprof.stack_depth > 0) {
+        // The new top of the stack (that we're returning to)
+        prev = &rblineprof.stack[rblineprof.stack_depth-1];
+
+        /* If we're leaving this frame to go back to a different file,
+         * accumulate time we spent in this file.
+         *
+         * Note that we do this both when entering a new file and leaving to
+         * a new file to ensure we only count time spent exclusively in that file.
+         * Consider the following scenario:
+         *
+         *     call (a.rb:1)
+         *       call (b.rb:1)         <-- leaving a.rb, increment into exclusive_time
+         *         call (a.rb:5)
+         *         return              <-- leaving a.rb, increment into exclusive_time
+         *       return
+         *     return
+         */
+        if (frame->srcfile != prev->srcfile) {
+          snapshot_t diff = snapshot_diff(&now, &frame->srcfile->exclusive_start);
+          snapshot_increment(&frame->srcfile->exclusive, &diff);
+          frame->srcfile->exclusive_start = now;
+          prev->srcfile->exclusive_start = now;
+        }
+      }
+
       if (frame)
-        stackframe_record(frame, now);
+        stackframe_record(frame, now, prev);
 
       break;
   }
@@ -364,9 +513,21 @@ summarize_files(st_data_t key, st_data_t record, st_data_t arg)
   VALUE ary = rb_ary_new();
   long i;
 
-  rb_ary_store(ary, 0, ULL2NUM(srcfile->exclusive_time));
+  rb_ary_store(ary, 0, rb_ary_new3(6,
+    ULL2NUM(srcfile->total.wall_time),
+    ULL2NUM(srcfile->child.wall_time),
+    ULL2NUM(srcfile->exclusive.wall_time),
+    ULL2NUM(srcfile->total.cpu_time),
+    ULL2NUM(srcfile->child.cpu_time),
+    ULL2NUM(srcfile->exclusive.cpu_time)
+  ));
+
   for (i=1; i<srcfile->nlines; i++)
-    rb_ary_store(ary, i, rb_ary_new3(2, ULL2NUM(srcfile->lines[i].total_time), ULL2NUM(srcfile->lines[i].calls)));
+    rb_ary_store(ary, i, rb_ary_new3(3,
+      ULL2NUM(srcfile->lines[i].total.wall_time),
+      ULL2NUM(srcfile->lines[i].total.cpu_time),
+      ULL2NUM(srcfile->lines[i].calls)
+    ));
   rb_hash_aset(ret, rb_str_new2(srcfile->filename), ary);
 
   return ST_CONTINUE;
@@ -408,7 +569,6 @@ lineprof(VALUE self, VALUE filename)
   }
 
   // reset state
-  rblineprof.curr_srcfile = NULL;
   st_foreach(rblineprof.files, cleanup_files, 0);
   if (rblineprof.file.lines) {
     xfree(rblineprof.file.lines);
@@ -427,10 +587,6 @@ lineprof(VALUE self, VALUE filename)
 
   rb_ensure(rb_yield, Qnil, lineprof_ensure, self);
 
-  sourcefile_t *curr_srcfile = rblineprof.curr_srcfile;
-  if (curr_srcfile)
-    curr_srcfile->exclusive_time += timeofday_usec() - curr_srcfile->exclusive_start;
-
   VALUE ret = rb_hash_new();
   VALUE ary = Qnil;
 

data/rblineprof.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'rblineprof'
-  s.version = '0.2.7'
+  s.version = '0.3.2'
   s.homepage = 'http://github.com/tmm1/rblineprof'
 
   s.authors = 'Aman Gupta'
@@ -11,4 +11,6 @@ Gem::Specification.new do |s|
 
   s.summary = 'line-profiler for ruby'
   s.description = 'rblineprof shows you lines of code that are slow.'
+
+  s.add_dependency 'debugger-ruby_core_source', '~> 1.2'
 end

data/test.rb

@@ -9,6 +9,40 @@ class Obj
   def another(options={})
     sleep 0.001
   end
+
+  def out=(*)
+  end
+
+  def with_defaults(arg=self.object_id.to_s)
+    another
+    list = [1,2,3]
+    # for cookie in list
+    #   self.out=(
+        dummy(
+          1, "str
+          ing")
+        dummy <<-EOS
+          hi
+        EOS
+        dummy \
+          1234
+        dummy :a => 'b',
+          :c => 'd',
+          :e => 1024**1024,
+          'something' => dummy(:ok)
+    #   )
+    # end
+  end
+
+  def dummy(*args)
+    args.inspect
+  end
+
+  class_eval <<-RUBY, 'otherfile.rb', 1
+    def other_file
+      another
+    end
+  RUBY
 end
 
 def inner
@@ -22,10 +56,29 @@ def inner
   o = Obj.new
   o.inner_block
   o.another
+  o.other_file
+  o.with_defaults
 end
 
 def outer
-  sleep 0.001
+  sleep 0.01
+
+  3000.times{ 2**1024 }
+  for i in 1..3000 do 2**1024 end
+
+  for i in 1..3000
+    2**1024
+  end
+
+  (fibonacci = Hash.new{ |h,k| h[k] = k < 2 ?  k : h[k-1] + h[k-2] })[500]
+
+  (fibonacci = Hash.new{ |h,k|
+    h[k] = k < 2 ?
+      k :
+      h[k-1] +
+      h[k-2]
+  })
+  fibonacci[500]
 
   100.times do
     inner
@@ -34,16 +87,30 @@ def outer
   inner
 end
 
+file = RUBY_VERSION > '1.9' ? File.expand_path(__FILE__) : __FILE__
+
+# profile = lineprof(file) do
 profile = lineprof(/./) do
   outer
 end
 
-file = File.expand_path(__FILE__)
 File.readlines(file).each_with_index do |line, num|
-  time, calls = profile[file][num+1]
+  wall, cpu, calls = profile[file][num+1]
   if calls && calls > 0
-    printf "% 8.1fms (% 5d) | %s", time/1000.0, calls, line
+    printf "% 8.1fms + % 8.1fms (% 5d) | %s", cpu/1000.0, (wall-cpu)/1000.0, calls, line
+    # printf "% 8.1fms (% 5d) | %s", wall/1000.0, calls, line
   else
-    printf "                   | %s", line
+    printf "                                | %s", line
+    # printf "                   | %s", line
   end
 end
+
+puts
+profile.each do |file, data|
+  total, child, exclusive = data[0]
+  puts file
+  printf "  % 10.1fms in this file\n", exclusive/1000.0
+  printf "  % 10.1fms in this file + children\n", total/1000.0
+  printf "  % 10.1fms in children\n", child/1000.0
+  puts
+end

metadata

@@ -1,23 +1,46 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: rblineprof
-version: !ruby/object:Gem::Version
-  version: 0.2.7
+version: !ruby/object:Gem::Version 
+  hash: 23
   prerelease: 
+  segments: 
+  - 0
+  - 3
+  - 2
+  version: 0.3.2
 platform: ruby
-authors:
+authors: 
 - Aman Gupta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-13 00:00:00.000000000 Z
-dependencies: []
+
+date: 2013-04-19 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: debugger-ruby_core_source
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  type: :runtime
+  version_requirements: *id001
 description: rblineprof shows you lines of code that are slow.
 email: aman@tmm1.net
 executables: []
-extensions:
+
+extensions: 
 - ext/extconf.rb
 extra_rdoc_files: []
-files:
+
+files: 
 - README.md
 - ext/.gitignore
 - ext/extconf.rb
@@ -26,26 +49,37 @@ files:
 - test.rb
 homepage: http://github.com/tmm1/rblineprof
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: line-profiler for ruby
 test_files: []
+
+has_rdoc: