ruby-prof 0.15.9 → 0.16.0

data/ext/ruby_prof/ruby_prof.c

@@ -107,19 +107,21 @@ get_method(rb_event_flag_t event, VALUE klass, ID mid, thread_data_t* thread_dat
 static int
 pop_frames(st_data_t key, st_data_t value, st_data_t data)
 {
-    VALUE fiber_id = (VALUE)key;
     thread_data_t* thread_data = (thread_data_t *) value;
     prof_profile_t* profile = (prof_profile_t*) data;
-	double measurement = profile->measurer->measure();
-
-    if (!profile->last_thread_data || profile->last_thread_data->fiber_id != fiber_id)
-      thread_data = switch_thread(profile, Qnil, fiber_id);
+    VALUE thread_id = thread_data->thread_id;
+    VALUE fiber_id = thread_data->fiber_id;
+    double measurement = profile->measurer->measure();
+
+    if (!profile->last_thread_data
+        || (!profile->merge_fibers && profile->last_thread_data->fiber_id != fiber_id)
+        || profile->last_thread_data->thread_id != thread_id
+        )
+        thread_data = switch_thread(profile, thread_id, fiber_id);
     else
-      thread_data = profile->last_thread_data;
+        thread_data = profile->last_thread_data;
 
-    while (prof_stack_pop(thread_data->stack, measurement))
-    {
-    }
+    while (prof_stack_pop(thread_data->stack, measurement));
 
     return ST_CONTINUE;
 }
@@ -188,7 +190,7 @@ prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE kla
        module or cProfile class since they clutter
        the results but aren't important to them results. */
     if (self == mProf || klass == cProfile)
-		return;
+        return;
 
     if (trace_file != NULL)
     {
@@ -201,16 +203,31 @@ prof_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE kla
     fiber = rb_fiber_current();
     fiber_id = rb_obj_id(fiber);
 
-    if (st_lookup(profile->exclude_threads_tbl, (st_data_t) thread_id, 0))
+    /* Don't measure anything if the include_threads option has been specified
+       and the current thread is not in the list
+     */
+    if (profile->include_threads_tbl && !st_lookup(profile->include_threads_tbl, (st_data_t) thread_id, 0))
+    {
+        return;
+    }
+
+    /* Don't measure anything if the current thread is in the excluded thread table
+     */
+    if (profile->exclude_threads_tbl && st_lookup(profile->exclude_threads_tbl, (st_data_t) thread_id, 0))
     {
-      return;
+        return;
     }
 
-    /* Was there a context switch? */
-    if (!profile->last_thread_data || profile->last_thread_data->fiber_id != fiber_id)
-      thread_data = switch_thread(profile, thread_id, fiber_id);
+    /* We need to switch the profiling context if we either had none before,
+       we don't merge fibers and the fiber ids differ, or the thread ids differ.
+     */
+    if (!profile->last_thread_data
+        || (!profile->merge_fibers && profile->last_thread_data->fiber_id != fiber_id)
+        || profile->last_thread_data->thread_id != thread_id
+        )
+        thread_data = switch_thread(profile, thread_id, fiber_id);
     else
-      thread_data = profile->last_thread_data;
+        thread_data = profile->last_thread_data;
 
     /* Get the current frame for the current thread. */
     frame = prof_stack_peek(thread_data->stack);
@@ -301,7 +318,7 @@ collect_threads(st_data_t key, st_data_t value, st_data_t result)
 {
     thread_data_t* thread_data = (thread_data_t*) value;
     VALUE threads_array = (VALUE) result;
-	rb_ary_push(threads_array, prof_thread_wrap(thread_data));
+    rb_ary_push(threads_array, prof_thread_wrap(thread_data));
     return ST_CONTINUE;
 }
 
@@ -317,7 +334,7 @@ mark_threads(st_data_t key, st_data_t value, st_data_t result)
 static void
 prof_mark(prof_profile_t *profile)
 {
-	st_foreach(profile->threads_tbl, mark_threads, 0);
+    st_foreach(profile->threads_tbl, mark_threads, 0);
 }
 
 /* Freeing the profile creates a cascade of freeing.
@@ -326,16 +343,23 @@ prof_mark(prof_profile_t *profile)
 static void
 prof_free(prof_profile_t *profile)
 {
-	profile->last_thread_data = NULL;
+    profile->last_thread_data = NULL;
 
-	threads_table_free(profile->threads_tbl);
+    threads_table_free(profile->threads_tbl);
     profile->threads_tbl = NULL;
 
-    st_free_table(profile->exclude_threads_tbl);
-    profile->exclude_threads_tbl = NULL;
+    if (profile->exclude_threads_tbl) {
+        st_free_table(profile->exclude_threads_tbl);
+        profile->exclude_threads_tbl = NULL;
+    }
+
+    if (profile->include_threads_tbl) {
+        st_free_table(profile->include_threads_tbl);
+        profile->include_threads_tbl = NULL;
+    }
 
-	xfree(profile->measurer);
-	profile->measurer = NULL;
+    xfree(profile->measurer);
+    profile->measurer = NULL;
 
     xfree(profile);
 }
@@ -347,58 +371,86 @@ prof_allocate(VALUE klass)
     prof_profile_t* profile;
     result = Data_Make_Struct(klass, prof_profile_t, prof_mark, prof_free, profile);
     profile->threads_tbl = threads_table_create();
-	profile->exclude_threads_tbl = threads_table_create();
+    profile->exclude_threads_tbl = NULL;
+    profile->include_threads_tbl = NULL;
     profile->running = Qfalse;
+    profile->merge_fibers = 0;
     return result;
 }
 
 /* call-seq:
-   RubyProf::Profile.new(mode, exclude_threads) -> instance
-
-   Returns a new profiler.
-   
-   == Parameters
-   mode::  Measure mode (optional). Specifies the profile measure mode.  If not specified, defaults
-           to RubyProf::WALL_TIME.
-   exclude_threads:: Threads to exclude from the profiling results (optional). */
+   new()
+   new(options)
+
+   Returns a new profiler. Possible options for the options hash are:
+
+   measure_mode::    Measure mode. Specifies the profile measure mode.
+                     If not specified, defaults to RubyProf::WALL_TIME.
+   exclude_threads:: Threads to exclude from the profiling results.
+   include_threads:: Focus profiling on only the given threads. This will ignore
+                     all other threads.
+   merge_fibers::    Whether to merge all fibers under a given thread. This should be
+                     used when profiling for a callgrind printer.
+*/
 static VALUE
 prof_initialize(int argc,  VALUE *argv, VALUE self)
 {
     prof_profile_t* profile = prof_get_profile(self);
-    VALUE mode;
-    prof_measure_mode_t measurer = MEASURE_WALL_TIME;
-    VALUE exclude_threads;
+    VALUE mode_or_options;
+    VALUE mode = Qnil;
+    VALUE exclude_threads = Qnil;
+    VALUE include_threads = Qnil;
+    VALUE merge_fibers = Qnil;
     int i;
-    
-    switch (rb_scan_args(argc, argv, "02", &mode, &exclude_threads))
-    {
-      case 0:
-      {
-        measurer = MEASURE_WALL_TIME;
-        exclude_threads = rb_ary_new();
+
+    switch (rb_scan_args(argc, argv, "02", &mode_or_options, &exclude_threads)) {
+    case 0:
         break;
-      }
-      case 1:
-      {
-        measurer = (prof_measure_mode_t)NUM2INT(mode);
-        exclude_threads = rb_ary_new();
+    case 1:
+        if (FIXNUM_P(mode_or_options)) {
+            mode = mode_or_options;
+        }
+        else {
+            Check_Type(mode_or_options, T_HASH);
+            mode = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("measure_mode")));
+            merge_fibers = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("merge_fibers")));
+            exclude_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_threads")));
+            include_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("include_threads")));
+        }
         break;
-      }
-      case 2:
-      {
+    case 2:
         Check_Type(exclude_threads, T_ARRAY);
-        measurer = (prof_measure_mode_t)NUM2INT(mode);
         break;
-      }
     }
 
-    profile->measurer = prof_get_measurer(measurer);
+    if (mode == Qnil) {
+        mode = INT2NUM(MEASURE_WALL_TIME);
+    } else {
+        Check_Type(mode, T_FIXNUM);
+    }
+    profile->measurer = prof_get_measurer(NUM2INT(mode));
+    profile->merge_fibers = merge_fibers != Qnil && merge_fibers != Qfalse;
 
-    for (i = 0; i < RARRAY_LEN(exclude_threads); i++)
-    {
-        VALUE thread = rb_ary_entry(exclude_threads, i);
-        VALUE thread_id = rb_obj_id(thread);
-        st_insert(profile->exclude_threads_tbl, thread_id, Qtrue);
+    if (exclude_threads != Qnil) {
+        Check_Type(exclude_threads, T_ARRAY);
+        assert(profile->exclude_threads_tbl == NULL);
+        profile->exclude_threads_tbl = threads_table_create();
+        for (i = 0; i < RARRAY_LEN(exclude_threads); i++) {
+            VALUE thread = rb_ary_entry(exclude_threads, i);
+            VALUE thread_id = rb_obj_id(thread);
+            st_insert(profile->exclude_threads_tbl, thread_id, Qtrue);
+        }
+    }
+
+    if (include_threads != Qnil) {
+        Check_Type(include_threads, T_ARRAY);
+        assert(profile->include_threads_tbl == NULL);
+        profile->include_threads_tbl = threads_table_create();
+        for (i = 0; i < RARRAY_LEN(include_threads); i++) {
+            VALUE thread = rb_ary_entry(include_threads, i);
+            VALUE thread_id = rb_obj_id(thread);
+            st_insert(profile->include_threads_tbl, thread_id, Qtrue);
+        }
     }
 
     return self;
@@ -427,7 +479,7 @@ prof_running(VALUE self)
 }
 
 /* call-seq:
-   start -> RubyProf
+   start -> self
 
    Starts recording profile data.*/
 static VALUE
@@ -470,7 +522,7 @@ prof_start(VALUE self)
 }
 
 /* call-seq:
-   pause -> RubyProf
+   pause -> self
 
    Pauses collecting profile data. */
 static VALUE
@@ -493,7 +545,8 @@ prof_pause(VALUE self)
 }
 
 /* call-seq:
-   resume {block} -> RubyProf
+   resume -> self
+   resume(&block) -> self
 
    Resumes recording profile data.*/
 static VALUE
@@ -559,9 +612,12 @@ prof_stop(VALUE self)
 }
 
 /* call-seq:
-   profile {block} -> RubyProf::Result
+   profile(&block) -> self
+   profile(options, &block) -> self
 
-Profiles the specified block and returns a RubyProf::Result object. */
+Profiles the specified block and returns a RubyProf::Profile
+object. Arguments are passed to Profile initialize method.
+*/
 static VALUE
 prof_profile(int argc,  VALUE *argv, VALUE klass)
 {
@@ -579,14 +635,14 @@ prof_profile(int argc,  VALUE *argv, VALUE klass)
 }
 
 /* call-seq:
-   threads -> Array of RubyProf::Thread
+   threads -> array of RubyProf::Thread
 
 Returns an array of RubyProf::Thread instances that were executed
 while the the program was being run. */
 static VALUE
 prof_threads(VALUE self)
 {
-	VALUE result = rb_ary_new();
+    VALUE result = rb_ary_new();
     prof_profile_t* profile = prof_get_profile(self);
     st_foreach(profile->threads_tbl, collect_threads, result);
     return result;

data/ext/ruby_prof/ruby_prof.h

@@ -46,8 +46,10 @@ typedef struct
     VALUE threads;
     st_table* threads_tbl;
     st_table* exclude_threads_tbl;
+    st_table* include_threads_tbl;
     thread_data_t* last_thread_data;
     double measurement_at_pause_resume;
+    int merge_fibers;
 } prof_profile_t;
 
 

data/lib/ruby-prof.rb

@@ -9,27 +9,28 @@ rescue LoadError
 end
 
 require 'ruby-prof/version'
-require 'ruby-prof/aggregate_call_info'
 require 'ruby-prof/call_info'
-require 'ruby-prof/call_info_visitor'
 require 'ruby-prof/compatibility'
 require 'ruby-prof/method_info'
 require 'ruby-prof/profile'
 require 'ruby-prof/rack'
 require 'ruby-prof/thread'
 
-require 'ruby-prof/printers/abstract_printer'
-require 'ruby-prof/printers/call_info_printer'
-require 'ruby-prof/printers/call_stack_printer'
-require 'ruby-prof/printers/call_tree_printer'
-require 'ruby-prof/printers/dot_printer'
-require 'ruby-prof/printers/flat_printer'
-require 'ruby-prof/printers/flat_printer_with_line_numbers'
-require 'ruby-prof/printers/graph_html_printer'
-require 'ruby-prof/printers/graph_printer'
-require 'ruby-prof/printers/multi_printer'
-
 module RubyProf
+  autoload :AggregateCallInfo, 'ruby-prof/aggregate_call_info'
+  autoload :CallInfoVisitor, 'ruby-prof/call_info_visitor'
+
+  autoload :AbstractPrinter, 'ruby-prof/printers/abstract_printer'
+  autoload :CallInfoPrinter, 'ruby-prof/printers/call_info_printer'
+  autoload :CallStackPrinter, 'ruby-prof/printers/call_stack_printer'
+  autoload :CallTreePrinter, 'ruby-prof/printers/call_tree_printer'
+  autoload :DotPrinter, 'ruby-prof/printers/dot_printer'
+  autoload :FlatPrinter, 'ruby-prof/printers/flat_printer'
+  autoload :FlatPrinterWithLineNumbers, 'ruby-prof/printers/flat_printer_with_line_numbers'
+  autoload :GraphHtmlPrinter, 'ruby-prof/printers/graph_html_printer'
+  autoload :GraphPrinter, 'ruby-prof/printers/graph_printer'
+  autoload :MultiPrinter, 'ruby-prof/printers/multi_printer'
+
   # Checks if the user specified the clock mode via
   # the RUBY_PROF_MEASURE_MODE environment variable
   def self.figure_measure_mode

data/lib/ruby-prof/assets/call_stack_printer.js.html

@@ -61,7 +61,7 @@
 
   function setThresholdLI(li, threshold) {
     var img = li.firstChild;
-    var text = img.nextSibling;
+    var text = img.nextSibling.firstChild;
     var ul = findUlChild(li);
 
     var visible = aboveThreshold(text.nodeValue, threshold) ? 1 : 0;

data/lib/ruby-prof/compatibility.rb

@@ -40,8 +40,8 @@ module RubyProf
   #
   # Returns what ruby-prof is measuring.  Valid values include:
   #
-  # *RubyProf::PROCESS_TIME - Measure process time.  This is default.  It is implemented using the clock functions in the C Runtime library.
-  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows
+  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows.  This is default.
+  # *RubyProf::PROCESS_TIME - Measure process time.  It is implemented using the clock functions in the C Runtime library.
   # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
   # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
   # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
@@ -57,8 +57,8 @@ module RubyProf
   #
   # Specifies what ruby-prof should measure.  Valid values include:
   #
-  # *RubyProf::PROCESS_TIME - Measure process time.  This is default.  It is implemented using the clock functions in the C Runtime library.
-  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows
+  # *RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows.  This is default.
+  # *RubyProf::PROCESS_TIME - Measure process time.  It is implemented using the clock functions in the C Runtime library.
   # *RubyProf::CPU_TIME - Measure time using the CPU clock counter.  This mode is only supported on Pentium or PowerPC platforms.
   # *RubyProf::ALLOCATIONS - Measure object allocations.  This requires a patched Ruby interpreter.
   # *RubyProf::MEMORY - Measure memory size.  This requires a patched Ruby interpreter.
@@ -106,7 +106,7 @@ module RubyProf
 
   def self.start
     ensure_not_running!
-    @profile = Profile.new(self.measure_mode, self.exclude_threads)
+    @profile = Profile.new(measure_mode: measure_mode, exclude_threads: exclude_threads)
     enable_gc_stats_if_needed
     @profile.start
   end
@@ -140,12 +140,13 @@ module RubyProf
   end
 
   # Profile a block
-  def self.profile(&block)
+  def self.profile(options = {}, &block)
     ensure_not_running!
     gc_stat_was_enabled = enable_gc_stats_if_needed
-    res = Profile.profile(self.measure_mode, self.exclude_threads, &block)
+    options = { measure_mode: measure_mode, exclude_threads: exclude_threads }.merge!(options)
+    result = Profile.profile(options, &block)
     disable_gc_stats_if_needed(gc_stat_was_enabled)
-    res
+    result
   end
 
 

data/lib/ruby-prof/method_info.rb

@@ -115,7 +115,7 @@ module RubyProf
     end
 
     def to_s
-      "#{self.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, ct: #{self.children_time})"
+      "#{self.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, wt: #{wait_time}, ct: #{self.children_time})"
     end
 
     # remove method from the call graph. should not be called directly.

data/lib/ruby-prof/printers/call_tree_printer.rb

@@ -1,59 +1,58 @@
 # encoding: utf-8
 
+require 'fiber'
+require 'thread'
+require 'fileutils'
+
 module RubyProf
-  # Generate profiling information in calltree format
-  # for use by kcachegrind and similar tools.
-
-  class CallTreePrinter  < AbstractPrinter
-    # Specify print options.
-    #
-    # options - Hash table
-    #   :min_percent - Number 0 to 100 that specifes the minimum
-    #                  %self (the methods self time divided by the
-    #                  overall total time) that a method must take
-    #                  for it to be printed out in the report.
-    #                  Default value is 0.
-    #
-    #   :print_file  - True or false. Specifies if a method's source
-    #                  file should be printed.  Default value if false.
-    #
-    def print(output = STDOUT, options = {})
-      @output = output
-      setup_options(options)
+  # Generate profiling information in callgrind format for use by
+  # kcachegrind and similar tools.
+  #
+  # Note: when profiling for a callgrind printer, one should use the
+  # merge_fibers: true option when creating the profile. Otherwise
+  # each fiber would appear as a separate profile.
 
-      # add a header - this information is somewhat arbitrary
-      @output << "events: "
+  class CallTreePrinter < AbstractPrinter
+
+    def determine_event_specification_and_value_scale
+      @event_specification = "events: "
       case RubyProf.measure_mode
         when RubyProf::PROCESS_TIME
-          @value_scale = RubyProf::CLOCKS_PER_SEC;
-          @output << 'process_time'
+          @value_scale = RubyProf::CLOCKS_PER_SEC
+          @event_specification << 'process_time'
         when RubyProf::WALL_TIME
           @value_scale = 1_000_000
-          @output << 'wall_time'
+          @event_specification << 'wall_time'
         when RubyProf.const_defined?(:CPU_TIME) && RubyProf::CPU_TIME
           @value_scale = RubyProf.cpu_frequency
-          @output << 'cpu_time'
+          @event_specification << 'cpu_time'
         when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
           @value_scale = 1
-          @output << 'allocations'
+          @event_specification << 'allocations'
         when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
           @value_scale = 1
-          @output << 'memory'
+          @event_specification << 'memory'
         when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
           @value_scale = 1
-          @output << 'gc_runs'
+          @event_specification << 'gc_runs'
         when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
           @value_scale = 1000000
-          @output << 'gc_time'
+          @event_specification << 'gc_time'
         else
           raise "Unknown measure mode: #{RubyProf.measure_mode}"
       end
-      @output << "\n\n"
+    end
 
+    def print(options = {})
+      setup_options(options)
+      determine_event_specification_and_value_scale
       print_threads
     end
 
     def print_threads
+      remove_subsidiary_files_from_previous_profile_runs
+      # TODO: merge fibers of a given thread here, instead of relying
+      # on the profiler to merge fibers.
       @result.threads.each do |thread|
         print_thread(thread)
       end
@@ -68,25 +67,64 @@ module RubyProf
     end
 
     def print_thread(thread)
-      thread.methods.reverse_each do |method|
-        # Print out the file and method name
-        @output << "fl=#{file(method)}\n"
-        @output << "fn=#{method_name(method)}\n"
-
-        # Now print out the function line number and its self time
-        @output << "#{method.line} #{convert(method.self_time)}\n"
-
-        # Now print out all the children methods
-        method.children.each do |callee|
-          @output << "cfl=#{file(callee.target)}\n"
-          @output << "cfn=#{method_name(callee.target)}\n"
-          @output << "calls=#{callee.called} #{callee.line}\n"
-
-          # Print out total times here!
-          @output << "#{callee.line} #{convert(callee.total_time)}\n"
+      File.open(file_path_for_thread(thread), "w") do |f|
+        print_headers(f, thread)
+        thread.methods.reverse_each do |method|
+          print_method(f, method)
         end
-      @output << "\n"
       end
-    end #end print_methods
-  end # end class
-end # end packages
+    end
+
+    def path
+      @options[:path] || "."
+    end
+
+    def base_name
+      @options[:profile] || "profile"
+    end
+
+    def remove_subsidiary_files_from_previous_profile_runs
+      pattern = [base_name, "callgrind.out", $$, "*"].join(".")
+      files = Dir.glob(File.join(path, pattern))
+      FileUtils.rm_f(files)
+    end
+
+    def file_name_for_thread(thread)
+      if thread.fiber_id == Fiber.current.object_id
+        [base_name, "callgrind.out", $$].join(".")
+      else
+        [base_name, "callgrind.out", $$, thread.fiber_id].join(".")
+      end
+    end
+
+    def file_path_for_thread(thread)
+      File.join(path, file_name_for_thread(thread))
+    end
+
+    def print_headers(output, thread)
+      output << "#{@event_specification}\n\n"
+      # this doesn't work. kcachegrind does not fully support the spec.
+      # output << "thread: #{thread.id}\n\n"
+    end
+
+    def print_method(output, method)
+      # Print out the file and method name
+      output << "fl=#{file(method)}\n"
+      output << "fn=#{method_name(method)}\n"
+
+      # Now print out the function line number and its self time
+      output << "#{method.line} #{convert(method.self_time)}\n"
+
+      # Now print out all the children methods
+      method.children.each do |callee|
+        output << "cfl=#{file(callee.target)}\n"
+        output << "cfn=#{method_name(callee.target)}\n"
+        output << "calls=#{callee.called} #{callee.line}\n"
+
+        # Print out total times here!
+        output << "#{callee.line} #{convert(callee.total_time)}\n"
+      end
+      output << "\n"
+    end
+  end
+end