ruby-prof 0.11.0.rc3-x86-mingw32 → 0.11.2-x86-mingw32

data/ext/ruby_prof/ruby_prof.h

@@ -42,11 +42,13 @@ void method_key(prof_method_key_t* key, VALUE klass, ID mid);
 typedef struct
 {
     VALUE running;
+    VALUE paused;
     prof_measurer_t* measurer;
     VALUE threads;
     st_table* threads_tbl;
     st_table* exclude_threads_tbl;
     thread_data_t* last_thread_data;
+    double measurement_at_pause_resume;
 } prof_profile_t;
 
 

data/ext/ruby_prof/vc/ruby_prof_18.vcxproj

@@ -64,6 +64,8 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <LinkIncremental>true</LinkIncremental>
     <OutDir>C:\MinGW\local\src\ruby-prof\lib\1.8</OutDir>
+    <TargetExt>.so</TargetExt>
+    <TargetName>ruby_prof</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
@@ -81,6 +83,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>C:\MinGW\local\ruby187vc\lib</AdditionalLibraryDirectories>
       <AdditionalDependencies>msvcr100-ruby18.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

data/ext/ruby_prof/version.h

@@ -1,7 +1,7 @@
 /* Copyright (C) 2005-2011 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
    Please see the LICENSE file for copyright and distribution information */
 
-#define RUBY_PROF_VERSION  "0.11.0" // for easy parsing from rake files
+#define RUBY_PROF_VERSION  "0.11.2" // for easy parsing from rake files
 #define RUBY_PROF_VERSION_MAJ   0
 #define RUBY_PROF_VERSION_MIN   11
-#define RUBY_PROF_VERSION_MIC   0
+#define RUBY_PROF_VERSION_MIC   2

data/lib/ruby-prof/compatibility.rb

@@ -18,7 +18,7 @@ module RubyProf
   def self.measure_cpu_time
     Measure::CpuTime.measure
   end
-  
+
   def self.measure_gc_runs
     Measure::GcRuns.measure
   end
@@ -38,7 +38,7 @@ module RubyProf
   def self.measure_wall_time
     Measure::WallTime.measure
   end
-  
+
   # call-seq:
   # measure_mode -> measure_mode
   #
@@ -51,11 +51,11 @@ module RubyProf
   # *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
   #
@@ -71,33 +71,31 @@ module RubyProf
   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
+    ensure_not_running!
     @profile = Profile.new(self.measure_mode, self.exclude_threads)
+    enable_gc_stats_if_needed
     @profile.start
   end
 
   def self.pause
-    unless running?
-      raise(RuntimeError, "RubyProf.start was not yet called");
-    end
+    ensure_running!
+    disable_gc_stats_if_needed
     @profile.pause
   end
 
@@ -110,25 +108,47 @@ module RubyProf
   end
 
   def self.resume
-    unless running?
-      raise(RuntimeError, "RubyProf.start was not yet called");
-    end
+    ensure_running!
+    enable_gc_stats_if_needed
     @profile.resume
   end
 
   def self.stop
-    unless running?
-      raise(RuntimeError, "RubyProf.start was not yet called");
-    end
+    ensure_running!
+    disable_gc_stats_if_needed
     result = @profile.stop
     @profile = nil
     result
   end
 
+  # Profile a block
   def self.profile(&block)
-    if running?
-      raise(RuntimeError, "RubyProf is already running");
+    ensure_not_running!
+    gc_stat_was_enabled = enable_gc_stats_if_needed
+    res = Profile.profile(self.measure_mode, self.exclude_threads, &block)
+    disable_gc_stats_if_needed(gc_stat_was_enabled)
+    res
+  end
+
+
+private
+  def self.ensure_running!
+    raise(RuntimeError, "RubyProf.start was not yet called") unless running?
+  end
+
+  def self.ensure_not_running!
+    raise(RuntimeError, "RubyProf is already running") if running?
+  end
+
+  # for GC.allocated_size to work GC statistics should be enabled
+  def self.enable_gc_stats_if_needed
+    if self.measure_mode == RubyProf::MEMORY && GC.respond_to?(:enable_stats)
+      @gc_stat_was_enabled = GC.enable_stats
     end
-    Profile.profile(self.measure_mode, self.exclude_threads, &block)
+  end
+
+  def self.disable_gc_stats_if_needed(was_enabled=nil)
+    was_enabled ||= defined?(@gc_stat_was_enabled) && @gc_stat_was_enabled
+    GC.disable_stats if self.measure_mode == RubyProf::MEMORY && GC.respond_to?(:disable_stats) && !was_enabled
   end
 end

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

@@ -62,7 +62,7 @@ module RubyProf
 
     def print_footer(thread)
       @output << "\n"
-      @output << "* in front of method name means it is recursively called\n"
+      @output << "* indicates recursively called methods\n"
     end
   end
 end

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

@@ -235,7 +235,7 @@ module RubyProf
         </tbody>
         <tfoot>
           <tr>
-            <td colspan="9">* in front of method name means it is recursively called</td>
+            <td colspan="9">* indicates recursively called methods</td>
           </tr>
         </tfoot>
       </table>

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

@@ -109,7 +109,7 @@ module RubyProf
 
     def print_footer(thread)
       @output << "\n"
-      @output << "* in front of method name means it is recursively called\n"
+      @output << "* indicates recursively called methods\n"
     end
   end
 end

data/ruby-prof.gemspec

@@ -6,8 +6,7 @@ version_header = File.read(File.expand_path('../ext/ruby_prof/version.h', __FILE
 match = version_header.match(/RUBY_PROF_VERSION\s*"([^"]+)"/)
 raise(RuntimeError, "Could not determine RUBY_PROF_VERSION") if not match
 
-# For now make this an rc1
-RUBY_PROF_VERSION = "#{match[1]}.rc3"
+RUBY_PROF_VERSION = "#{match[1]}"
 
 Gem::Specification.new do |spec|
   spec.name = "ruby-prof"

data/test/basic_test.rb

@@ -39,4 +39,58 @@ class BasicTest < Test::Unit::TestCase
 
     RubyProf.stop
   end
-end
+
+  def test_pause_seq
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    p.start ; assert !p.paused?
+    p.pause ; assert p.paused?
+    p.resume; assert !p.paused?
+    p.pause ; assert p.paused?
+    p.pause ; assert p.paused?
+    p.resume; assert !p.paused?
+    p.resume; assert !p.paused?
+    p.stop  ; assert !p.paused?
+  end
+
+  def test_pause_block
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    p.start
+    p.pause
+    assert p.paused?
+
+    times_block_invoked = 0
+    retval= p.resume{
+      times_block_invoked += 1
+      120 + times_block_invoked
+    }
+    assert_equal 1, times_block_invoked
+    assert p.paused?
+
+    assert_equal 121, retval, "resume() should return the result of the given block."
+
+    p.stop
+  end
+
+  def test_pause_block_with_error
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    p.start
+    p.pause
+    assert p.paused?
+
+    begin
+      p.resume{ raise }
+      flunk 'Exception expected.'
+    rescue
+      assert p.paused?
+    end
+
+    p.stop
+  end
+
+  def test_resume_when_not_paused
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+    p.start ; assert !p.paused?
+    p.resume; assert !p.paused?
+    p.stop  ; assert !p.paused?
+  end
+end

data/test/line_number_test.rb

@@ -5,11 +5,9 @@ require File.expand_path('../test_helper', __FILE__)
 
 class LineNumbers
   def method1
-    3
   end
 
   def method2
-    3
     method1
   end
 
@@ -32,11 +30,11 @@ class LineNumbersTest < Test::Unit::TestCase
 
     method = methods[0]
     assert_equal('LineNumbersTest#test_function_line_no', method.full_name)
-    assert_equal(27, method.line)
+    assert_equal(25, method.line)
 
     method = methods[1]
     assert_equal('LineNumbers#method2', method.full_name)
-    assert_equal(11, method.line)
+    assert_equal(10, method.line)
 
     method = methods[2]
     assert_equal('LineNumbers#method1', method.full_name)
@@ -64,10 +62,10 @@ class LineNumbersTest < Test::Unit::TestCase
 
     method = methods[1]
     assert_equal('LineNumbers#method3', method.full_name)
-    assert_equal(16, method.line)
+    assert_equal(14, method.line)
 
     method = methods[2]
     assert_equal('LineNumbersTest#test_c_function', method.full_name)
-    assert_equal(50, method.line)
+    assert_equal(48, method.line)
   end
 end

data/test/measure_cpu_time_test.rb

@@ -23,9 +23,6 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
       RubyProf::C1.hello
     end
 
-    printer = RubyProf::FlatPrinter.new(result)
-    printer.print
-
     # Length should be 3:
     #   MeasureCpuTimeTest#test_class_methods
     #   <Class::RubyProf::C1>#hello

data/test/multi_printer_test.rb

@@ -57,7 +57,6 @@ class MultiPrinterTest < Test::Unit::TestCase
 \s*</table>')
     assert graph =~ re
     display_time = $1.to_f
-    difference = (expected_time-display_time).abs
     assert_in_delta expected_time, display_time, 0.005
   end
 

data/test/pause_resume_test.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class PauseResumeTest < Test::Unit::TestCase
+
+  # pause/resume in the same frame
+  def test_pause_resume_1
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+
+    p.start
+    method_1a
+
+    p.pause
+    method_1b
+
+    p.resume
+    method_1c
+
+    r= p.stop
+    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_1$/}[0].total_time, 0.05)
+  end
+  def method_1a; sleep 0.2 end
+  def method_1b; sleep 1   end
+  def method_1c; sleep 0.4 end
+
+  # pause in parent frame, resume in child
+  def test_pause_resume_2
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+
+    p.start
+    method_2a
+
+    p.pause
+    sleep 0.5
+    method_2b(p)
+
+    r= p.stop
+    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_2$/}[0].total_time, 0.05)
+  end
+  def method_2a; sleep 0.2 end
+  def method_2b(p); sleep 0.5; p.resume; sleep 0.4 end
+
+  # pause in child frame, resume in parent
+  def test_pause_resume_3
+    p= RubyProf::Profile.new(RubyProf::WALL_TIME,[])
+
+    p.start
+    method_3a(p)
+
+    sleep 0.5
+    p.resume
+    method_3b
+
+    r= p.stop
+    assert_in_delta(0.6, r.threads[0].methods.select{|m| m.full_name =~ /test_pause_resume_3$/}[0].total_time, 0.05)
+  end
+  def method_3a(p); sleep 0.2; p.pause; sleep 0.5 end
+  def method_3b; sleep 0.4 end
+end

data/test/pause_test.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class PauseTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_pause_resume
+    RubyProf.start
+    # Measured
+    RubyProf::C1.hello
+    RubyProf.pause
+
+    # Not measured
+    RubyProf::C1.hello
+
+    RubyProf.resume
+    # Measured
+    RubyProf::C1.hello
+    result = RubyProf.stop
+
+    printer = RubyProf::FlatPrinter.new(result)
+    printer.print
+
+    # Length should be 3:
+    #   PauseTest#test_pause_resume
+    #   <Class::RubyProf::C1>#hello
+    #   Kernel#sleep
+
+    methods = result.threads.first.methods.sort.reverse
+    assert_equal(3, methods.length)
+
+    # Check the names
+    assert_equal('PauseTest#test_pause_resume', methods[0].full_name)
+    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
+    assert_equal('Kernel#sleep', methods[2].full_name)
+
+    # Check times
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+
+  end
+
+end