ruby-prof 0.4.0

data/lib/ruby-prof/profiletask.rb

@@ -0,0 +1,150 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'rake/tasklib'
+
+module RubyProf
+
+  # Create a profile task.  All of the options provided by
+  # the Rake:TestTask are supported except the loader
+  # which is set to ruby-prof.  For detailed information
+  # please refer to the Rake:TestTask documentation.
+  #
+  # ruby-prof specific options include:
+  #
+  #		output_dir - For each file specified an output 
+  #							   file with profile information will be
+  #								 written to the output directory.
+  #								 By default, the output directory is
+  #								 called "profile" and is created underneath
+  # 							 the current working directory.
+  #
+  # 	printer - Specifies the output printer.  Valid values include
+  # 						:flat, :graph, and :graph_html.
+  #
+  #   min_percent - Methods that take less than the specified percent
+  #								  will not be written out.
+  #
+  # Example:
+  #   
+  #   require 'ruby-prof/task'
+  #   
+  #   ruby-prof::RubyProfTask.new do |t|
+  #     t.test_files = FileList['test/test*.rb']
+  #			t.output_dir = "c:/temp"
+  #		  t.printer = :graph
+  #     t.min_percent = 10
+  #   end
+  #
+  # If the task is invoked with a "test=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "options=options" command line option,
+  # then the given options are passed to ruby-prof.
+  #
+  # If rake is invoked with a "ruby-profPATH=path/to/ruby-prof" command line option,
+  # then the given ruby-prof executable will be used; otherwise the one in your
+  # PATH will be used.
+  #
+  # Examples:
+  #
+  #   rake ruby-prof                           # profiles all unit tests
+  #   rake ruby-prof TEST=just_one_file.rb     # profiles one unit test
+  #   rake ruby-prof PATTERN=*.rb    					 # profiles all files
+  
+  class ProfileTask < Rake::TestTask
+    attr_writer :output_dir 
+    attr_writer :min_percent 
+    attr_writer :printer
+    
+    def initialize(name=:profile)
+      @name = name
+      @libs = ["lib"]
+      @pattern = nil
+      @options = Array.new
+      @test_files = nil
+      @verbose = false
+      @warning = false
+      @loader = :ruby_prof
+      @ruby_opts = []
+      @output_dir =  File.join(Dir.getwd, "profile")
+      @printer = :graph
+      @min_percent = 0
+      yield self if block_given?
+      @pattern = 'test/test*.rb' if @pattern.nil? && @test_files.nil?
+      define
+    end
+  
+    # Create the tasks defined by this task lib.
+    def define
+      create_output_directory
+      
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      desc "Profile" + (@name==:profile ? "" : " for #{@name}")
+      
+      task @name do
+	 			@ruby_opts.unshift( "-I#{lib_path}" )
+	 			@ruby_opts.unshift( "-w" ) if @warning
+				@ruby_opts.push("-S ruby-prof")
+				@ruby_opts.push("--printer #{@printer}")
+				@ruby_opts.push("--min_percent #{@min_percent}")
+
+        file_list.each do |file_path|	 
+          run_script(file_path)
+        end
+    	end
+      self
+    end
+    
+    # Run script
+    def run_script(script_path)
+			run_code = ''
+			RakeFileUtils.verbose(@verbose) do
+				file_name = File.basename(script_path, File.extname(script_path))
+				case @printer
+					when :flat, :graph
+						file_name += ".txt"
+					when :graph_html
+						file_name += ".html"
+					else
+						file_name += ".txt"
+				end
+	  			
+				output_file_path = File.join(output_directory, file_name)
+					
+				command_line = @ruby_opts.join(" ") + 
+				              " --file=" + output_file_path +
+				              " " + script_path
+
+				puts "ruby " + command_line	
+				# We have to catch the exeption to continue on.  However,
+				# the error message will have been output to STDERR
+				# already by the time we get here so we don't have to
+				# do that again
+				begin
+					ruby command_line
+       	rescue
+        end
+        puts ""
+        puts ""
+			end
+    end
+
+    def output_directory
+      File.expand_path(@output_dir)
+    end
+    
+    def create_output_directory
+      if not File.exist?(output_directory)
+      	Dir.mkdir(output_directory)
+      end
+    end
+
+    def option_list # :nodoc:
+      ENV['TESTOPTS'] || @options.join(" ") || ""
+    end
+  end
+end
+

data/lib/unprof.rb

@@ -0,0 +1,8 @@
+require "ruby-prof"
+
+at_exit {
+  result = RubyProf.stop
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+}
+RubyProf.start

data/test/basic_test.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+
+class C1
+  def C1.hello
+  end
+  
+  def hello
+  end
+end
+
+module M1
+  def hello
+  end
+end
+
+class C2
+  include M1
+  extend M1
+end
+
+class C3
+  def hello
+  end
+end
+
+module M4
+  def hello
+  end
+end
+
+module M5
+  include M4
+  def goodbye
+    hello
+  end
+end
+
+class C6
+  include M5
+  def test
+    goodbye
+  end
+end
+
+class BasicTest < Test::Unit::TestCase
+  def test_double_profile
+    RubyProf.start
+    assert_raise(RuntimeError) do
+    	RubyProf.start
+    end
+    
+    assert_raise(RuntimeError) do
+      RubyProf.profile do
+        puts 1
+      end
+    end
+    RubyProf.stop
+  end
+  
+  
+  def test_no_block
+    assert_raise(ArgumentError) do
+			RubyProf.profile
+  	end
+  end
+  
+  def test_class_and_instance_methods
+    result = RubyProf.profile do
+	    C1.hello
+	    C1.new.hello
+    end
+  
+    methods = result.threads.values.first
+    
+    # Length should be 6:
+    # 	1 top level,
+    # 	1 Class.new
+    #		1 Class:Object allocate
+    #   1 for Object.initialize
+    #   1 for Class hello
+    #   1 for Object hello
+    assert_equal(6, methods.length)
+    
+    # Check class method
+    method1 = methods['<Class::C1>#hello']
+    assert_not_nil(method1)
+    
+    # Check instance method
+    method1 = methods['C1#hello']
+    assert_not_nil(method1)
+  end
+  
+  def test_module_methods
+    result = RubyProf.profile do
+	  	C2.hello
+	    C2.new.hello
+    end
+  
+    methods = result.threads.values.first
+   
+    # Length should be 5:
+    # 	1 top level,
+    # 	1 Class.new
+    #		1 Class:Object allocate
+    #   1 for Object.initialize
+    #   1 for hello
+    assert_equal(5, methods.length)
+    
+    # Check class method
+    method1 = methods['M1#hello']
+    assert_not_nil(method1)
+    assert_equal(2, method1.called)
+  end
+  
+  def test_singleton
+    c3 = C3.new
+    
+    class << c3
+    	def hello
+    	end
+  	end
+  
+    result = RubyProf.profile do
+	  	c3.hello
+    end
+  
+    methods = result.threads.values.first
+    
+    # Length should be 2 - one for top level
+    # and one for the singleton method.
+    assert_equal(2, methods.length)
+    
+    # Check singleton method
+    method1 = methods['<Object::C3>#hello']
+    assert_not_nil(method1)
+  end
+end

data/test/clock_mode_test.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+require 'prime'
+
+
+# --  Tests ----
+class ClockModeTest < Test::Unit::TestCase
+  def test_clock
+    return
+    RubyProf::clock_mode = RubyProf::PROCESS_TIME
+    assert_equal(RubyProf::PROCESS_TIME, RubyProf::clock_mode)
+    result = RubyProf.profile do
+			run_primes
+		end
+		
+		print_results(result)
+    
+    result.threads.values.each do |methods|
+			methods.values.each do |method|
+    		check_parent_times(method)
+    		check_parent_calls(method)
+    		check_child_times(method)		
+			end
+  	end
+  end
+  
+  def test_gettimeofday
+    return
+    RubyProf::clock_mode = RubyProf::WALL_TIME
+    assert_equal(RubyProf::WALL_TIME, RubyProf::clock_mode)
+    result = RubyProf.profile do
+			run_primes
+		end
+    
+		print_results(result)
+		
+    result.threads.values.each do |methods|
+			methods.values.each do |method|
+    		check_parent_times(method)
+    		check_parent_calls(method)
+    		check_child_times(method)		
+			end
+  	end
+  end
+  
+  def test_cpu
+    #return
+    RubyProf::clock_mode = RubyProf::CPU_TIME
+    assert_equal(RubyProf::CPU, RubyProf::clock_mode)
+    result = RubyProf.profile do
+			run_primes
+		end
+    
+		print_results(result)
+		
+    result.threads.values.each do |methods|
+			methods.values.each do |method|
+    		check_parent_times(method)
+    		check_parent_calls(method)
+    		check_child_times(method)		
+			end
+  	end
+  end
+  
+  def test_invalid
+    assert_raise(ArgumentError) do
+    	RubyProf::clock_mode = 7777
+    end
+  end
+end

data/test/module_test.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ruby-prof'
+require 'test_helper'
+
+
+module Foo
+  def Foo::hello
+  end
+end
+
+module Bar
+  def Bar::hello
+    Foo::hello
+  end
+  
+  def hello
+    Bar::hello
+  end
+end
+
+include Bar
+
+class BasicTest < Test::Unit::TestCase
+  def test_nested_modules
+		result = RubyProf.profile do
+			hello
+		end
+
+		methods = result.threads.values.first
+	    
+  	# Length should be 4s
+  	assert_equal(4, methods.length)
+    
+  	method1 = methods['Bar#hello']
+  	assert_not_nil(method1)
+  	
+  	method1 = methods['<Module::Bar>#hello']
+  	assert_not_nil(method1)
+  	
+  	method1 = methods['<Module::Foo>#hello']
+  	assert_not_nil(method1)
+	end	
+end

data/test/prime.rb

@@ -0,0 +1,58 @@
+# A silly little test program that finds prime numbers.  It
+# is intentionally badly designed to show off the use
+# or ruby-prof.
+# 
+# Source from http://people.cs.uchicago.edu/~bomb154/154/maclabs/profilers-lab/
+
+def make_random_array(length, maxnum)
+	result = Array.new(length)
+	result.each_index do |i|
+		result[i] = rand(maxnum)
+	end
+		
+	result
+end
+ 
+def is_prime(x)
+	y = 2
+	y.upto(x-1) do |i|
+		return false if (x % i) == 0
+	end
+	true
+end
+
+def find_primes(arr)
+	result = arr.select do |value|
+		is_prime(value)
+	end
+	result
+end
+
+def find_largest(primes)
+	largest = primes.first
+
+	# Intentionally use upto for example purposes
+	# (upto is also called from is_prime)
+	0.upto(primes.length-1) do |i|
+    sleep(0.02)
+    prime = primes[i]
+		if prime > largest
+			largest = prime
+		end
+	end
+	largest
+end
+
+def run_primes
+	length = 500	
+  maxnum = 10000
+  
+  # Create random numbers
+ 	random_array = make_random_array(length, maxnum)
+ 	
+ 	# Find the primes
+  primes = find_primes(random_array)
+  
+  # Find the largest primes
+ 	largest = find_largest(primes)
+end