ruby-prof 0.8.1-x86-mingw32 → 0.11.0.rc1-x86-mingw32

data/lib/ruby-prof/call_tree_printer.rb

@@ -1,14 +1,26 @@
-require 'ruby-prof/abstract_printer'
+# encoding: utf-8
 
 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)
-        
+
       # add a header - this information is somewhat arbitrary
       @output << "events: "
       case RubyProf.measure_mode
@@ -55,15 +67,11 @@ module RubyProf
       File.expand_path(method.source_file)
     end
 
-    def name(method)
-      "#{method.klass_name}::#{method.method_name}"
-    end
-
     def print_methods(thread_id, methods)
-      methods.reverse_each do |method| 
+      methods.reverse_each do |method|
         # Print out the file and method name
         @output << "fl=#{file(method)}\n"
-        @output << "fn=#{name(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"
@@ -71,7 +79,7 @@ module RubyProf
         # Now print out all the children methods
         method.children.each do |callee|
           @output << "cfl=#{file(callee.target)}\n"
-          @output << "cfn=#{name(callee.target)}\n"
+          @output << "cfn=#{method_name(callee.target)}\n"
           @output << "calls=#{callee.called} #{callee.line}\n"
 
           # Print out total times here!

data/lib/ruby-prof/compatibility.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+# These methods are here for backwards compatability with previous RubyProf releases
+module RubyProf
+  # Measurements
+  def self.cpu_frequency
+    Measure::CpuTime.frequency
+  end
+
+  def self.cpu_frequency=(value)
+    Measure::CpuTime.frequency = value
+  end
+
+  def self.measure_allocations
+    Measure::Allocations.measure
+  end
+
+  def self.measure_cpu_time
+    Measure::CpuTime.measure
+  end
+  
+  def self.measure_gc_runs
+    Measure::GcRuns.measure
+  end
+
+  def self.measure_gc_time
+    Measure::GcTime.measure
+  end
+
+  def self.measure_memory
+    Measure::Memory.measure
+  end
+
+  def self.measure_process_time
+    Measure::ProcessTime.measure
+  end
+
+  def self.measure_wall_time
+    Measure::WallTime.measure
+  end
+  
+  # call-seq:
+  # measure_mode -> measure_mode
+  #
+  # 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::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.
+  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+  
+  def self.measure_mode
+    @measure_mode ||= RubyProf::WALL_TIME
+  end
+  
+  # call-seq:
+  # measure_mode=value -> void
+  #
+  # 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::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.
+  # *RubyProf::GC_RUNS - Measure number of garbage collections.  This requires a patched Ruby interpreter.
+  # *RubyProf::GC_TIME - Measure time spent doing garbage collection.  This requires a patched Ruby interpreter.*/
+  def self.measure_mode=(value)
+    @measure_mode = value
+  end
+  
+  # call-seq:
+  # exclude_threads= -> void
+  #
+  # Specifies what threads ruby-prof should exclude from profiling
+  
+  def self.exclude_threads
+    @exclude_threads ||= Array.new
+  end
+  
+  def self.exclude_threads=(value)
+    @exclude_threads = value
+  end
+  
+  # Profiling
+  def self.start
+    if running?
+      raise(RuntimeError, "RubyProf is already running");
+    end
+    @profile = Profile.new(self.measure_mode, self.exclude_threads)
+    @profile.start
+  end
+
+  def self.pause
+    unless running?
+      raise(RuntimeError, "RubyProf.start was not yet called");
+    end
+    @profile.pause
+  end
+
+  def self.running?
+    if defined?(@profile) and @profile
+      @profile.running?
+    else
+      false
+    end
+  end
+
+  def self.resume
+    unless running?
+      raise(RuntimeError, "RubyProf.start was not yet called");
+    end
+    @profile.resume
+  end
+
+  def self.stop
+    unless running?
+      raise(RuntimeError, "RubyProf.start was not yet called");
+    end
+    result = @profile.stop
+    @profile = nil
+    result
+  end
+
+  def self.profile(&block)
+    if running?
+      raise(RuntimeError, "RubyProf is already running");
+    end
+    Profile.profile(self.measure_mode, self.exclude_threads, &block)
+  end
+end

data/lib/ruby-prof/dot_printer.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+require 'set'
+
+module RubyProf
+  # Generates a graphviz graph in dot format.
+  # To use the dot printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::DotPrinter.new(result)
+  #   printer.print(STDOUT)
+  # 
+  # You can use either dot viewer such as GraphViz, or the dot command line tool
+  # to reformat the output into a wide variety of outputs:
+  # 
+  #   dot -Tpng graph.dot > graph.png
+  # 
+  class DotPrinter < RubyProf::AbstractPrinter  
+    CLASS_COLOR = '"#666666"'
+    EDGE_COLOR  = '"#666666"'
+    
+    # Creates the DotPrinter using a RubyProf::Result.
+    def initialize(result)
+      super(result)
+      @seen_methods = Set.new
+    end
+        
+    # Print a graph report to the provided output.
+    #  
+    # output - Any IO object, including STDOUT or a file. The default value is
+    # STDOUT.
+    #  
+    # options - Hash of print options.  See #setup_options 
+    # for more information.
+    #
+    # When profiling results that cover a large number of method calls it
+    # helps to use the :min_percent option, for example:
+    #  
+    #   DotPrinter.new(result).print(STDOUT, :min_percent=>5)
+    # 
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      
+      total_time = thread_times.values.inject{|a,b| a+b}
+      
+      puts 'digraph "Profile" {'
+      puts "label=\"#{mode_name} >=#{min_percent}%\\nTotal: #{total_time}\";"
+      puts "labelloc=t;"
+      puts "labeljust=l;"
+      print_threads
+      puts '}'
+    end
+
+    private 
+    
+    # Something of a hack, figure out which constant went with the
+    # RubyProf.measure_mode so that we can display it.  Otherwise it's easy to
+    # forget what measurement was made.
+    def mode_name
+      RubyProf.constants.find{|c| RubyProf.const_get(c) == RubyProf.measure_mode}
+    end
+    
+    # Computes the total time per thread:
+    def thread_times
+      @thread_times ||= begin
+        times = {}
+        @result.threads.each do |thread_id, methods|
+          toplevel = methods.sort.last
+
+          total_time = toplevel.total_time
+          # This looks like a hack for very small times... from GraphPrinter
+          total_time = 0.01 if total_time == 0 
+          times[thread_id] = total_time
+        end
+        
+        times
+      end
+    end
+    
+    def print_threads
+      # sort assumes that spawned threads have higher object_ids
+      @result.threads.sort.each do |thread_id, methods|
+        puts "subgraph \"Thread #{thread_id}\" {"
+        
+        print_methods(thread_id, methods)
+        puts "}"
+        
+        print_classes(thread_id, methods)
+      end
+    end
+    
+    # Determines an ID to use to represent the subject in the Dot file.
+    def dot_id(subject)
+      subject.object_id
+    end
+    
+    def print_methods(thread_id, methods)
+      total_time = thread_times[thread_id]
+      methods.sort_by(&sort_method).reverse_each do |method|
+        total_percentage = (method.total_time/total_time) * 100
+
+        next if total_percentage < min_percent
+        name = method_name(method).split("#").last
+        puts "#{dot_id(method)} [label=\"#{name}\\n(#{total_percentage.round}%)\"];"
+        @seen_methods << method
+        print_edges(total_time, method)
+      end
+    end
+      
+    def print_classes(thread_id, methods)
+      grouped = {}
+      methods.each{|m| grouped[m.klass_name] ||= []; grouped[m.klass_name] << m}
+      grouped.each do |cls, methods2|
+        # Filter down to just seen methods
+        big_methods, small_methods  = methods2.partition{|m| @seen_methods.include? m}
+        
+        if !big_methods.empty?
+          puts "subgraph cluster_#{cls.object_id} {"
+          puts "label = \"#{cls}\";"
+          puts "fontcolor = #{CLASS_COLOR};"
+          puts "fontsize = 16;"
+          puts "color = #{CLASS_COLOR};"
+          big_methods.each do |m|
+            puts "#{m.object_id};"
+          end
+          puts "}"  
+        end        
+      end
+    end
+    
+    def print_edges(total_time, method)
+      method.aggregate_children.sort_by(&:total_time).reverse.each do |child|
+        
+        target_percentage = (child.target.total_time / total_time) * 100.0
+        next if target_percentage < min_percent
+        
+        # Get children method
+        puts "#{dot_id(method)} -> #{dot_id(child.target)} [label=\"#{child.called}/#{child.target.called}\" fontsize=10 fontcolor=#{EDGE_COLOR}];"
+      end
+    end
+    
+    # Silly little helper for printing to the @output
+    def puts(str)
+      @output.puts(str)
+    end
+    
+  end
+end

data/lib/ruby-prof/flat_printer.rb

@@ -1,7 +1,7 @@
-require 'ruby-prof/abstract_printer'
+# encoding: utf-8
 
 module RubyProf
-  # Generates flat[link:files/examples/flat_txt.html] profile reports as text. 
+  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
   # To use the flat printer:
   #
   #   result = RubyProf.profile do
@@ -9,32 +9,35 @@ module RubyProf
   #   end
   #
   #   printer = RubyProf::FlatPrinter.new(result)
-  #   printer.print(STDOUT, 0)
+  #   printer.print(STDOUT, {})
   #
   class FlatPrinter < AbstractPrinter
     # Print a flat profile report to the provided output.
-    # 
-    # output - Any IO oject, including STDOUT or a file. 
+    #
+    # output - Any IO object, including STDOUT or a file.
     # The default value is STDOUT.
-    # 
-    # options - Hash of print options.  See #setup_options 
-    #           for more information.
+    #
+    # options - Hash of print options.  See #setup_options
+    # for more information.
     #
     def print(output = STDOUT, options = {})
       @output = output
+      # Now sort methods by largest self time by default,
+      # not total time like in other printouts
+      options[:sort_method] ||= :self_time
       setup_options(options)
       print_threads
-    end      
-    
-    private 
-    
+    end
+
+    private
+
     def print_threads
       @result.threads.each do |thread_id, methods|
         print_methods(thread_id, methods)
         @output << "\n" * 2
       end
     end
-    
+
     def print_methods(thread_id, methods)
       # Get total time
       toplevel = methods.max
@@ -42,27 +45,23 @@ module RubyProf
       if total_time == 0
         total_time = 0.01
       end
-      
-      # Now sort methods by largest self time,
-      # not total time like in other printouts
-      methods = methods.sort do |m1, m2|
-        m1.self_time <=> m2.self_time
-      end.reverse
-      
+
+      methods = methods.sort_by(&sort_method).reverse
+
       @output << "Thread ID: %d\n" % thread_id
       @output << "Total: %0.6f\n" % total_time
       @output << "\n"
       @output << " %self     total     self     wait    child    calls  name\n"
 
-      sum = 0    
+      sum = 0
       methods.each do |method|
         self_percent = (method.self_time / total_time) * 100
         next if self_percent < min_percent
-        
+
         sum += method.self_time
         #self_time_called = method.called > 0 ? method.self_time/method.called : 0
         #total_time_called = method.called > 0? method.total_time/method.called : 0
-        
+
         @output << "%6.2f  %8.2f %8.2f %8.2f %8.2f %8d  %s\n" % [
                       method.self_time / total_time * 100, # %self
                       method.total_time,                   # total
@@ -75,4 +74,4 @@ module RubyProf
       end
     end
   end
-end
+end

data/lib/ruby-prof/flat_printer_with_line_numbers.rb

@@ -1,7 +1,7 @@
-require 'ruby-prof/abstract_printer'
-require 'pathname'
+# encoding: utf-8
+
 module RubyProf
-  # Generates flat[link:files/examples/flat_txt.html] profile reports as text. 
+  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
   # To use the flat printer with line numbers:
   #
   #   result = RubyProf.profile do
@@ -9,7 +9,7 @@ module RubyProf
   #   end
   #
   #   printer = RubyProf::FlatPrinterWithLineNumbers.new(result)
-  #   printer.print(STDOUT, 0)
+  #   printer.print(STDOUT, {})
   #
   class FlatPrinterWithLineNumbers < FlatPrinter
 
@@ -20,26 +20,22 @@ module RubyProf
       if total_time == 0
         total_time = 0.01
       end
-      
-      # Now sort methods by largest self time,
-      # not total time like in other printouts
-      methods = methods.sort do |m1, m2|
-        m1.self_time <=> m2.self_time
-      end.reverse
-      
+
+      methods = methods.sort_by(&sort_method).reverse
+
       @output << "Thread ID: %d\n" % thread_id
       @output << "Total: %0.6f\n" % total_time
       @output << "\n"
       @output << " %self     total     self     wait    child    calls  name\n"
-      sum = 0    
+      sum = 0
       methods.each do |method|
         self_percent = (method.self_time / total_time) * 100
         next if self_percent < min_percent
-        
+
         sum += method.self_time
         #self_time_called = method.called > 0 ? method.self_time/method.called : 0
         #total_time_called = method.called > 0? method.total_time/method.called : 0
-        
+
         @output << "%6.2f  %8.2f %8.2f %8.2f %8.2f %8d  %s " % [
                       method.self_time / total_time * 100, # %self
                       method.total_time,                   # total
@@ -47,26 +43,26 @@ module RubyProf
                       method.wait_time,                    # wait
                       method.children_time,                # children
                       method.called,                       # calls
-                      method_name(method),                 # name                      
+                      method_name(method),                 # name
                   ]
          if method.source_file != 'ruby_runtime'
            @output << "  %s:%s" % [File.expand_path(method.source_file), method.line]
          end
          @output << "\n\tcalled from: "
-         
+
          # make sure they're unique
-         method.call_infos.map{|ci| 
+         method.call_infos.map{|ci|
            if ci.parent && ci.parent.target.source_file != 'ruby_runtime'
               [method_name(ci.parent.target), File.expand_path(ci.parent.target.source_file), ci.parent.target.line]
            else
               nil
-           end 
+           end
          }.compact.uniq.each{|args|
-             @output << " %s (%s:%s) " % args             
+             @output << " %s (%s:%s) " % args
          }
-         @output << "\n\n"         
+         @output << "\n\n"
       end
     end
   end
-end 
+end