ruby-prof 1.0.0 → 1.1.0

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

@@ -67,6 +67,15 @@ module RubyProf
       end
     end
 
+    def method_href(thread, method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + thread.fiber_id.to_s)
+    end
+
+    def open_asset(file)
+      path = File.join(File.expand_path('../../assets', __FILE__), file)
+      File.open(path, 'rb').read
+    end
+
     def print_threads
       @result.threads.each do |thread|
         print_thread(thread)

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

@@ -17,7 +17,7 @@ module RubyProf
   #   printer = RubyProf::CallStackPrinter.new(result)
   #   printer.print(STDOUT)
 
-class CallStackPrinter < AbstractPrinter
+  class CallStackPrinter < AbstractPrinter
     include ERB::Util
 
     # Specify print options.
@@ -44,41 +44,18 @@ class CallStackPrinter < AbstractPrinter
     #   :application - a String to overide the name of the application,
     #                  as it appears on the report.
     def print(output = STDOUT, options = {})
-      @output = output
       setup_options(options)
-      if @graph_html = options.delete(:graph)
-        @graph_html = "file://" + @graph_html if @graph_html[0]=="/"
-      end
-
-      print_header
-
-      @overall_threads_time = @result.threads.inject(0) do |val, thread|
-        val += thread.total_time
-      end
-
-      @result.threads.each do |thread|
-        @current_thread_id = thread.fiber_id
-        @overall_time = thread.total_time
-				thread_info = String.new("Thread: #{thread.id}")
-        thread_info << ", Fiber: #{thread.fiber_id}" unless thread.id == thread.fiber_id
-        thread_info << " (#{"%4.2f%%" % ((@overall_time/@overall_threads_time)*100)} ~ #{@overall_time})"
-        @output.print "<div class=\"thread\">#{thread_info}</div>"
-        @output.print "<ul name=\"thread\">"
-        thread.methods.each do |m|
-          # $stderr.print m.dump
-          next unless m.root?
-          m.callers.each do |call_info|
-            visited = Set.new
-            print_stack(visited, call_info, thread.total_time)
-          end
-        end
-        @output.print "</ul>"
-      end
+      output << @erb.result(binding)
+      a = 1
+    end
 
-      print_footer
+    # :enddoc:
+    def setup_options(options)
+      super(options)
+      @erb = ERB.new(self.template)
     end
 
-    def print_stack(visited, call_info, parent_time)
+    def print_stack(output, visited, call_info, parent_time)
       total_time = call_info.total_time
       percent_parent = (total_time/parent_time)*100
       percent_total = (total_time/@overall_time)*100
@@ -88,35 +65,36 @@ class CallStackPrinter < AbstractPrinter
       visible = percent_total >= threshold
       expanded = percent_total >= expansion
       display = visible ? "block" : "none"
-      @output.print "<li class=\"color#{color}\" style=\"display:#{display}\">"
 
-      if kids.empty?
-        @output.print "<a href=\"#\" class=\"toggle empty\" ></a>"
-      else
-        visible_children = kids.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
-        image = visible_children ? (expanded ? "minus" : "plus") : "empty"
-        @output.print "<a href=\"#\" class=\"toggle #{image}\" ></a>"
-      end
-      @output.printf "<span> %4.2f%% (%4.2f%%) %s %s</span>\n", percent_total, percent_parent, link(call_info), graph_link(call_info)
+      output << "<li class=\"color#{color}\" style=\"display:#{display}\">" << "\n"
 
       if visited.include?(call_info)
-        return
+        output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
+        output << "<span>%s %s</span>" % [link(call_info.target, true), graph_link(call_info)] << "\n"
       else
         visited << call_info
-      end
 
-      unless kids.empty?
-        if expanded
-          @output.print "<ul>"
+        if kids.empty?
+          output << "<a href=\"#\" class=\"toggle empty\" ></a>" << "\n"
         else
-          @output.print '<ul style="display:none">'
+          visible_children = kids.any?{|ci| (ci.total_time/@overall_time)*100 >= threshold}
+          image = visible_children ? (expanded ? "minus" : "plus") : "empty"
+          output << "<a href=\"#\" class=\"toggle #{image}\" ></a>" << "\n"
         end
-        kids.sort_by{|c| -c.total_time}.each do |child_call_info|
-          print_stack(visited, child_call_info, total_time)
+        output << "<span>%4.2f%% (%4.2f%%) %s %s</span>" % [percent_total, percent_parent,
+                                                            link(call_info.target, false), graph_link(call_info)] << "\n"
+
+        unless kids.empty?
+          output <<  (expanded ? '<ul>' : '<ul style="display:none">')  << "\n"
+          kids.sort_by{|c| -c.total_time}.each do |child_call_info|
+            print_stack(output, visited, child_call_info, total_time)
+          end
+          output << '</ul>' << "\n"
         end
-        @output.print "</ul>"
+
+        visited.delete(call_info)
       end
-      @output.print "</li>"
+      output << '</li>' << "\n"
     end
 
     def name(call_info)
@@ -124,25 +102,25 @@ class CallStackPrinter < AbstractPrinter
       method.full_name
     end
 
-    def link(call_info)
-      method = call_info.target
+    def link(method, recursive)
+      method_name = "#{recursive ? '*' : ''}#{method.full_name}"
       if method.source_file.nil?
-        h(name(call_info))
+        h method_name
       else
         file = File.expand_path(method.source_file)
-       "<a href=\"file://#{file}##{method.line}\">#{h(name(call_info))}</a>"
+       "<a href=\"file://#{file}##{method.line}\">#{h method_name}</a>"
       end
     end
 
     def graph_link(call_info)
-      total_calls = call_info.target.callers.inject(0){|t, ci| t += ci.called}
-      href = "#{@graph_html}##{method_href(call_info.target)}"
-      totals = @graph_html ? "<a href='#{href}'>#{total_calls}</a>" : total_calls.to_s
+      total_calls = call_info.target.called
+      href = "#{method_href(call_info.target)}"
+      totals = total_calls.to_s
       "[#{call_info.called} calls, #{totals} total]"
     end
 
     def method_href(method)
-      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + @current_thread_id.to_s)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_"))
     end
 
     def total_time(call_infos)
@@ -190,80 +168,15 @@ class CallStackPrinter < AbstractPrinter
       @options[:expansion] || 10.0
     end
 
-    def print_header
-      @output.puts "<html><head>"
-      @output.puts '<meta http-equiv="content-type" content="text/html; charset=utf-8">'
-      @output.puts "<title>#{h title}</title>"
-      print_css
-      print_java_script
-      @output.puts '</head><body><div style="display: inline-block;">'
-      print_title_bar
-      print_commands
-      print_help
-    end
-
-    def print_footer
-      @output.puts '<div id="sentinel"></div></div></body></html>'
-    end
-
-    def open_asset(file)
-      path = File.join(File.expand_path('../../assets', __FILE__), file)
-      File.open(path, 'rb').read
-    end
-
-    def print_css
-      html = open_asset('call_stack_printer.css.html')
-      @output.puts html.gsub('%s', base64_image)
-    end
-
     def base64_image
-      file = open_asset('call_stack_printer.png')
-      Base64.encode64(file).gsub(/\n/, '')
-    end
-
-    def print_java_script
-      html = open_asset('call_stack_printer.js.html')
-      @output.puts html
-    end
-
-    def print_title_bar
-      @output.puts <<-"end_title_bar"
-<div id="titlebar">
-Call tree for application <b>#{h application} #{h arguments}</b><br/>
-Generated on #{Time.now} with options #{h @options.inspect}<br/>
-</div>
-end_title_bar
-    end
-
-    def print_commands
-      @output.puts <<-"end_commands"
-<div id=\"commands\">
-<span style=\"font-size: 11pt; font-weight: bold;\">Threshold:</span>
-<input value=\"#{h threshold}\" size=\"3\" id=\"threshold\" type=\"text\">
-<input value=\"Apply\" onclick=\"setThreshold();\" type=\"submit\">
-<input value=\"Expand All\" onclick=\"expandAll(event);\" type=\"submit\">
-<input value=\"Collapse All\" onclick=\"collapseAll(event);\" type=\"submit\">
-<input value=\"Show Help\" onclick=\"toggleHelp(this);\" type=\"submit\">
-</div>
-end_commands
+      @data ||= begin
+        file = open_asset('call_stack_printer.png')
+        Base64.encode64(file).gsub(/\n/, '')
+      end
     end
 
-    def print_help
-      @output.puts <<-'end_help'
-<div style="display: none;" id="help">
-&#8226; Enter a decimal value <i>d</i> into the threshold field and click "Apply"
-        to hide all nodes marked with time values lower than <i>d</i>.<br>
-&#8226; Click on "Expand All" for full tree expansion.<br>
-&#8226; Click on "Collapse All" to show only top level nodes.<br>
-&#8226; Use a, s, d, w as in Quake or Urban Terror to navigate the tree.<br>
-&#8226; Use f and b to navigate the tree in preorder forward and backwards.<br>
-&#8226; Use x to toggle visibility of a subtree.<br>
-&#8226; Use * to expand/collapse a whole subtree.<br>
-&#8226; Use h to navigate to thread root.<br>
-&#8226; Use n and p to navigate between threads.<br>
-&#8226; Click on background to move focus to a subtree.<br>
-</div>
-end_help
+    def template
+      open_asset('call_stack_printer.html.erb')
     end
   end
 end

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

@@ -57,8 +57,7 @@ module RubyProf
     end
 
     def template
-      path = File.expand_path(File.join(__FILE__, '..', '..', 'assets', 'graph_printer.html.erb'))
-      File.read(path, :mode => 'rb')
+      open_asset('graph_printer.html.erb')
     end
   end
 end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/test/fiber_test.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'fiber'
+require 'timeout'
+require 'set'
+
+# --  Tests ----
+class FiberTest < TestCase
+  def fiber_test
+    @fiber_ids << Fiber.current.object_id
+    enum = Enumerator.new do |yielder|
+      [1,2].each do |x|
+        @fiber_ids << Fiber.current.object_id
+        sleep 0.1
+        yielder.yield x
+      end
+    end
+    while true
+      begin
+        enum.next
+      rescue StopIteration
+        break
+      end
+    end
+    sleep 0.1
+  end
+
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    @fiber_ids  = Set.new
+    @root_fiber = Fiber.current.object_id
+    @thread_id  = Thread.current.object_id
+  end
+
+  def test_fibers
+    result  = RubyProf.profile { fiber_test }
+    profiled_fiber_ids = result.threads.map(&:fiber_id)
+    assert_equal(2, result.threads.length)
+    assert_equal([@thread_id], result.threads.map(&:id).uniq)
+    assert_equal(@fiber_ids, Set.new(profiled_fiber_ids))
+
+    assert profiled_fiber_ids.include?(@root_fiber)
+    assert(root_fiber_profile = result.threads.detect{|t| t.fiber_id == @root_fiber})
+    assert(enum_fiber_profile = result.threads.detect{|t| t.fiber_id != @root_fiber})
+
+    assert_in_delta(0.3, root_fiber_profile.total_time, 0.05)
+    assert_in_delta(0.2, enum_fiber_profile.total_time, 0.05)
+
+    assert(method_next = root_fiber_profile.methods.detect{|m| m.full_name == "Enumerator#next"})
+    assert(method_each = enum_fiber_profile.methods.detect{|m| m.full_name == "Enumerator#each"})
+
+    assert_in_delta(0.2, method_next.total_time, 0.05)
+    assert_in_delta(0.2, method_each.total_time, 0.05)
+  end
+
+  def test_merged_fibers
+    result  = RubyProf.profile(merge_fibers: true) { fiber_test }
+    assert_equal(1, result.threads.length)
+
+    thread = result.threads.first
+    assert_equal(thread.id, thread.fiber_id)
+    assert_in_delta(0.3, thread.total_time, 0.05)
+
+    assert(method_next = thread.methods.detect{|m| m.full_name == "Enumerator#next"})
+    assert(method_each = thread.methods.detect{|m| m.full_name == "Enumerator#each"})
+
+    assert_in_delta(0.2, method_next.total_time, 0.05)
+    assert_in_delta(0.2, method_each.total_time, 0.05)
+  end
+end

data/test/gc_test.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class GcTest < TestCase
+  def some_method
+    Array.new(3 * 4)
+  end
+
+  def run_profile
+    RubyProf.profile do
+      self.some_method
+    end
+  end
+
+  def test_hold_onto_thread
+    threads = 1000.times.reduce(Array.new) do |array, i|
+      array.concat(run_profile.threads)
+      GC.start
+      array
+    end
+
+    threads.each do |thread|
+      error = assert_raises(RuntimeError) do
+        thread.id
+      end
+      assert_match(/has already been freed/, error.message)
+    end
+    assert(true)
+  end
+
+  def test_hold_onto_method
+    methods = 1000.times.reduce(Array.new) do |array, i|
+      array.concat(run_profile.threads.map(&:methods).flatten)
+      GC.start
+      array
+    end
+
+    methods.each do |method|
+      error = assert_raises(RuntimeError) do
+        method.method_name
+      end
+      assert_match(/has already been freed/, error.message)
+    end
+    assert(true)
+  end
+
+  def test_hold_onto_parent_callers
+    call_infos = 1000.times.reduce(Array.new) do |array, i|
+      array.concat(run_profile.threads.map(&:methods).flatten.map(&:callers).flatten)
+      GC.start
+      array
+    end
+
+    call_infos.each do |call_info|
+      error = assert_raises(RuntimeError) do
+        call_info.source_file
+      end
+      assert_match(/has already been freed/, error.message)
+    end
+    assert(true)
+  end
+
+  def test_hold_onto_parent_callees
+    call_infos = 1000.times.reduce(Array.new) do |array, i|
+      array.concat(run_profile.threads.map(&:methods).flatten.map(&:callees).flatten)
+      GC.start
+      array
+    end
+
+    call_infos.each do |call_info|
+      error = assert_raises(RuntimeError) do
+        call_info.source_file
+      end
+      assert_match(/has already been freed/, error.message)
+    end
+    assert(true)
+  end
+
+  def test_hold_onto_measurements
+    measurements = 1000.times.reduce(Array.new) do |array, i|
+      array.concat(run_profile.threads.map(&:methods).flatten.map(&:callers).flatten.map(&:measurement))
+      GC.start
+      array
+    end
+
+    measurements.each do |measurement|
+      error = assert_raises(RuntimeError) do
+        measurement.total_time
+      end
+      assert_match(/has already been freed/, error.message)
+    end
+    assert(true)
+  end
+end

data/test/printer_call_stack_test.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require 'stringio'
+require 'fileutils'
+require 'tmpdir'
+require_relative 'prime'
+
+# --  Tests ----
+class PrinterCallStackTest < TestCase
+  def setup
+    # WALL_TIME so we can use sleep in our test and get same measurements on linux and windows
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+    @result = RubyProf.profile do
+      run_primes(1000, 5000)
+    end
+  end
+
+  def test_graph_html_string
+    output = ''
+    printer = RubyProf::CallStackPrinter.new(@result)
+    printer.print(output)
+
+    assert_match(/<!DOCTYPE html>/i, output)
+    assert_match(/Object#run_primes/i, output)
+  end
+end