ruby-prof 0.13.1 → 1.4.2

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

@@ -1,92 +1,151 @@
-# 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
-        when RubyProf::PROCESS_TIME
-          @value_scale = RubyProf::CLOCKS_PER_SEC;
-          @output << 'process_time'
-        when RubyProf::WALL_TIME
-          @value_scale = 1_000_000
-          @output << 'wall_time'
-        when RubyProf.const_defined?(:CPU_TIME) && RubyProf::CPU_TIME
-          @value_scale = RubyProf.cpu_frequency
-          @output << 'cpu_time'
-        when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
-          @value_scale = 1
-          @output << 'allocations'
-        when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
-          @value_scale = 1
-          @output << 'memory'
-        when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
-          @value_scale = 1
-          @output << 'gc_runs'
-        when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
-          @value_scale = 1000000
-          @output << 'gc_time'
-        else
-          raise "Unknown measure mode: #{RubyProf.measure_mode}"
-      end
-      @output << "\n\n"
-
-      print_threads
-    end
-
-    def print_threads
-      @result.threads.each do |thread|
-        print_thread(thread)
-      end
-    end
-
-    def convert(value)
-      (value * @value_scale).round
-    end
-
-    def file(method)
-      File.expand_path(method.source_file)
-    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"
-        end
-      @output << "\n"
-      end
-    end #end print_methods
-  end # end class
-end # end packages
+# encoding: utf-8
+
+require 'fiber'
+require 'thread'
+require 'fileutils'
+
+module RubyProf
+  # Generates profiling information in callgrind format for use by
+  # kcachegrind and similar tools.
+
+  class CallTreePrinter < AbstractPrinter
+    def calltree_name(method_info)
+      klass_path = method_info.klass_name.gsub("::", '/')
+      result = "#{klass_path}::#{method_info.method_name}"
+
+      case method_info.klass_flags
+        when 0x2
+          "#{result}^"
+        when 0x4
+          "#{result}^"
+        when 0x8
+         "#{result}*"
+        else
+         result
+      end
+    end
+
+    def determine_event_specification_and_value_scale
+      @event_specification = "events: "
+      case RubyProf.measure_mode
+        when RubyProf::PROCESS_TIME
+          @value_scale = RubyProf::CLOCKS_PER_SEC
+          @event_specification << 'process_time'
+        when RubyProf::WALL_TIME
+          @value_scale = 1_000_000
+          @event_specification << 'wall_time'
+        when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
+          @value_scale = 1
+          @event_specification << 'allocations'
+        when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
+          @value_scale = 1
+          @event_specification << 'memory'
+        when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
+          @value_scale = 1
+          @event_specification << 'gc_runs'
+        when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
+          @value_scale = 1000000
+          @event_specification << 'gc_time'
+        else
+          raise "Unknown measure mode: #{RubyProf.measure_mode}"
+      end
+    end
+
+    def print(options = {})
+      validate_print_params(options)
+      setup_options(options)
+      determine_event_specification_and_value_scale
+      print_threads
+    end
+
+    def validate_print_params(options)
+      if options.is_a?(IO)
+        raise ArgumentError, "#{self.class.name}#print cannot print to IO objects"
+      elsif !options.is_a?(Hash)
+        raise ArgumentError, "#{self.class.name}#print requires an options hash"
+      end
+    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
+    end
+
+    def convert(value)
+      (value * @value_scale).round
+    end
+
+    def file(method)
+      method.source_file ? File.expand_path(method.source_file) : ''
+    end
+
+    def print_thread(thread)
+      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
+      end
+    end
+
+    def path
+      @options[:path] || "."
+    end
+
+    def self.needs_dir?
+      true
+    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=#{self.calltree_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.call_trees.callees.each do |callee|
+        output << "cfl=#{file(callee.target)}\n"
+        output << "cfn=#{self.calltree_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

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

@@ -1,132 +1,132 @@
-# 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)
-      
-      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
-    
-    def print_threads
-      @result.threads.each do |thread|
-        puts "subgraph \"Thread #{thread.id}\" {"
-
-        print_thread(thread)
-        puts "}"
-        
-        print_classes(thread)
-      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_thread(thread)
-      total_time = thread.total_time
-      thread.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)
-      grouped = {}
-      thread.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 = methods2.select{|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
+# 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::Proile.
+    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)
+
+      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
+
+    def print_threads
+      @result.threads.each do |thread|
+        puts "subgraph \"Thread #{thread.id}\" {"
+
+        print_thread(thread)
+        puts "}"
+
+        print_classes(thread)
+      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_thread(thread)
+      total_time = thread.total_time
+      thread.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.full_name.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)
+      grouped = {}
+      thread.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 = methods2.select{|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.call_trees.callers.sort_by(&:total_time).reverse.each do |call_tree|
+        target_percentage = (call_tree.target.total_time / total_time) * 100.0
+        next if target_percentage < min_percent
+
+        # Get children method
+        puts "#{dot_id(method)} -> #{dot_id(call_tree.target)} [label=\"#{call_tree.called}/#{call_tree.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