ruby-prof 0.14.2 → 0.15.0

data/CHANGES

@@ -1,3 +1,7 @@
+0.15.0 (2014-05-02)
+======================
+* improved cpu time measurement (Charlie Somerville)
+
 0.14.2 (2014-01-05)
 ======================
 * hopefully fixed compile problem under Windows

data/doc/created.rid

@@ -1,4 +1,4 @@
-Sun, 05 Jan 2014 09:38:34 +0100
+Fri, 02 May 2014 08:21:06 +0200
 bin/ruby-prof	Wed, 25 Dec 2013 08:28:55 +0100
 bin/ruby-prof-check-trace	Sun, 10 Mar 2013 10:57:14 +0100
 examples/flat.txt	Tue, 29 Jan 2013 16:43:39 +0100
@@ -24,7 +24,7 @@ lib/ruby-prof/profile.rb	Wed, 25 Dec 2013 08:59:06 +0100
 lib/ruby-prof/rack.rb	Wed, 25 Dec 2013 09:34:14 +0100
 lib/ruby-prof/task.rb	Tue, 29 Jan 2013 16:43:39 +0100
 lib/ruby-prof/thread.rb	Wed, 25 Dec 2013 09:34:14 +0100
-lib/ruby-prof/version.rb	Sun, 05 Jan 2014 09:33:26 +0100
+lib/ruby-prof/version.rb	Fri, 02 May 2014 08:18:49 +0200
 lib/unprof.rb	Tue, 29 Jan 2013 16:43:39 +0100
 ext/ruby_prof/ruby_prof.c	Mon, 30 Dec 2013 14:56:05 +0100
 README.rdoc	Wed, 25 Dec 2013 10:55:27 +0100

data/ext/ruby_prof/rp_measure_cpu_time.c

@@ -5,11 +5,10 @@
 
 static VALUE cMeasureCpuTime;
 
-static unsigned long long cpu_frequency = 0;
-
 /* The _WIN32 check is needed for msys (and maybe cygwin?) */
 #if defined(__GNUC__) && !defined(_WIN32)
 
+#include <sys/resource.h>
 #include <stdint.h>
 #include <time.h>
 
@@ -18,63 +17,93 @@ static unsigned long long get_cpu_time()
 #if defined(__i386__) || defined(__x86_64__)
     uint32_t a, d;
     __asm__ volatile("rdtsc" : "=a" (a), "=d" (d));
-   return ((uint64_t)d << 32) + a;
+    return ((uint64_t)d << 32) + a;
 #elif defined(__powerpc__) || defined(__ppc__)
     unsigned long long x, y;
 
     __asm__ __volatile__ ("\n\
-1:      mftbu   %1\n\
-  mftb    %L0\n\
-  mftbu   %0\n\
-  cmpw    %0,%1\n\
-  bne-    1b"
-  : "=r" (x), "=r" (y));
-   return x;
+    1:  mftbu   %1\n\
+        mftb    %L0\n\
+        mftbu   %0\n\
+        cmpw    %0,%1\n\
+        bne-    1b"
+        : "=r" (x), "=r" (y));
+
+    return x;
 #endif
 }
 
 static unsigned long long get_cpu_frequency()
 {
-    unsigned long long x, y;
+    static unsigned long long cpu_frequency;
+
+    if(!cpu_frequency) {
+        unsigned long long x, y;
+
+        struct timespec ts;
+        ts.tv_sec = 0;
+        ts.tv_nsec = 500000000;
+        x = get_cpu_time();
+        nanosleep(&ts, NULL);
+        y = get_cpu_time();
+        cpu_frequency = (y - x) * 2;
+    }
+
+    return cpu_frequency;
+}
+
+static double
+measure_cpu_time()
+{
+    struct rusage rusage;
+    getrusage(RUSAGE_SELF, &rusage);
 
-    struct timespec ts;
-    ts.tv_sec = 0;
-    ts.tv_nsec = 500000000;
-    x = get_cpu_time();
-    nanosleep(&ts, NULL);
-    y = get_cpu_time();
-    return (y - x) * 2;
+    double seconds = 0;
+
+    seconds += rusage.ru_utime.tv_sec;
+    seconds += rusage.ru_stime.tv_sec;
+
+    seconds += rusage.ru_utime.tv_usec / 1000000.0;
+    seconds += rusage.ru_stime.tv_usec / 1000000.0;
+
+    return seconds;
 }
 
 #elif defined(_WIN32)
 
 static unsigned long long get_cpu_time()
 {
-	LARGE_INTEGER time;
-	QueryPerformanceCounter(&time);
-	return time.QuadPart;
-};
+    LARGE_INTEGER time;
+    QueryPerformanceCounter(&time);
+    return time.QuadPart;
+}
 
 static unsigned long long get_cpu_frequency()
 {
-	LARGE_INTEGER cpu_frequency;
-	QueryPerformanceFrequency(&cpu_frequency);
-	return cpu_frequency.QuadPart;
-};
-#endif
+    static unsigned long long cpu_frequency;
+
+    if(!cpu_frequency) {
+        LARGE_INTEGER cpu_frequency_struct;
+        QueryPerformanceFrequency(&cpu_frequency_struct);
+        cpu_frequency = cpu_frequency_struct.QuadPart;
+    }
+
+    return cpu_frequency;
+}
 
 static double
 measure_cpu_time()
 {
-    return ((double)get_cpu_time()) / cpu_frequency;
+    return ((double)get_cpu_time()) / get_cpu_frequency();
 }
+#endif
 
 
 prof_measurer_t* prof_measurer_cpu_time()
 {
-  prof_measurer_t* measure = ALLOC(prof_measurer_t);
-  measure->measure = measure_cpu_time;
-  return measure;
+    prof_measurer_t* measure = ALLOC(prof_measurer_t);
+    measure->measure = measure_cpu_time;
+    return measure;
 }
 
 /* call-seq:
@@ -95,18 +124,15 @@ RubyProf::measure_mode is set to CPU_TIME. */
 static VALUE
 prof_get_cpu_frequency(VALUE self)
 {
-	return ULL2NUM(cpu_frequency);
+    return ULL2NUM(get_cpu_frequency());
 }
 
 void rp_init_measure_cpu_time()
 {
     rb_define_const(mProf, "CPU_TIME", INT2NUM(MEASURE_CPU_TIME));
-	rb_define_const(mProf, "CPU_TIME_ENABLED", Qtrue);
+    rb_define_const(mProf, "CPU_TIME_ENABLED", Qtrue);
 
     cMeasureCpuTime = rb_define_class_under(mMeasure, "CpuTime", rb_cObject);
     rb_define_singleton_method(cMeasureCpuTime, "measure", prof_measure_cpu_time, 0);
     rb_define_singleton_method(cMeasureCpuTime, "frequency", prof_get_cpu_frequency, 0);
-
-    /* Get cpu_frequency */
-    cpu_frequency = get_cpu_frequency();
 }

data/ext/ruby_prof/rp_method.c

@@ -104,11 +104,11 @@ method_name(ID mid)
 static VALUE
 full_name(VALUE klass, ID mid)
 {
-  VALUE result = klass_name(klass);
-  rb_str_cat2(result, "#");
-  rb_str_append(result, method_name(mid));
+    VALUE result = rb_str_dup(klass_name(klass));
+    rb_str_cat2(result, "#");
+    rb_str_append(result, method_name(mid));
 
-  return result;
+    return result;
 }
 
 void

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "0.14.2"
+  VERSION = "0.15.0"
 end

data/test/fiber_test.rb

@@ -50,14 +50,14 @@ class FiberTest < Test::Unit::TestCase
     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.01)
-    assert_in_delta(0.2, enum_fiber_profile.total_time, 0.01)
+    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.01)
-    assert_in_delta(0.2, method_each.total_time, 0.01)
+    assert_in_delta(0.2, method_next.total_time, 0.05)
+    assert_in_delta(0.2, method_each.total_time, 0.05)
 
     # RubyProf::CallInfoPrinter.new(@result).print
   end

data/test/measure_cpu_time_test.rb

@@ -5,7 +5,6 @@ require File.expand_path('../test_helper', __FILE__)
 
 class MeasureCpuTimeTest < Test::Unit::TestCase
   def setup
-    # Need to use wall time for this test due to the sleep calls
     RubyProf::measure_mode = RubyProf::CPU_TIME
   end
 
@@ -20,107 +19,74 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
 
   def test_class_methods
     result = RubyProf.profile do
-      RubyProf::C1.hello
+      RubyProf::C7.hello
     end
 
-    # Length should be 3:
+    # Length should be greater 2:
     #   MeasureCpuTimeTest#test_class_methods
     #   <Class::RubyProf::C1>#hello
-    #   Kernel#sleep
+    #   ....
 
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
+    methods = result.threads.first.methods.sort.reverse[0..1]
+    assert_equal(2, methods.length)
 
     # Check the names
     assert_equal('MeasureCpuTimeTest#test_class_methods', methods[0].full_name)
-    assert_equal('<Class::RubyProf::C1>#hello', methods[1].full_name)
-    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_equal('<Class::RubyProf::C7>#hello', methods[1].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[0].total_time, 0.02)
+    assert_in_delta(0, methods[0].wait_time, 0.02)
+    assert_in_delta(0, methods[0].self_time, 0.02)
 
-    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)
+    assert_in_delta(0.1, methods[1].total_time, 0.02)
+    assert_in_delta(0, methods[1].wait_time, 0.02)
+    assert_in_delta(0, methods[1].self_time, 0.02)
   end
 
   def test_instance_methods
     result = RubyProf.profile do
-      RubyProf::C1.new.hello
+      RubyProf::C7.new.hello
     end
 
-    # Methods called
+    methods = result.threads.first.methods.sort.reverse[0..1]
+    assert_equal(2, methods.length)
+
+    # Methods at this point:
     #   MeasureCpuTimeTest#test_instance_methods
-    #   Class.new
-    #   Class:Object#allocate
-    #   for Object#initialize
-    #   C1#hello
-    #   Kernel#sleep
+    #   C7#hello
+    #   ...
 
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(RubyProf.ruby_2? ? 5 : 6, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureCpuTimeTest#test_instance_methods', names[0])
-    assert_equal('RubyProf::C1#hello', names[1])
-    assert_equal('Kernel#sleep', names[2])
-    assert_equal('Class#new', names[3])
-
-    # order can differ
-    assert(names.include?("#{RubyProf.parent_object}#initialize"))
-    unless RubyProf.ruby_2?
-      assert(names.include?("<Class::#{RubyProf.parent_object}>#allocate"))
-    end
+    assert_equal('RubyProf::C7#hello', names[1])
 
-    # Check times
-    assert_in_delta(0.2, methods[0].total_time, 0.02)
-    assert_in_delta(0, methods[0].wait_time, 0.02)
-    assert_in_delta(0, methods[0].self_time, 0.02)
 
-    assert_in_delta(0.2, methods[1].total_time, 0.02)
-    assert_in_delta(0, methods[1].wait_time, 0.02)
-    assert_in_delta(0, methods[1].self_time, 0.02)
-
-    assert_in_delta(0.2, methods[2].total_time, 0.02)
-    assert_in_delta(0, methods[2].wait_time, 0.02)
-    assert_in_delta(0.2, methods[2].self_time, 0.02)
-
-    assert_in_delta(0, methods[3].total_time, 0.01)
-    assert_in_delta(0, methods[3].wait_time, 0.01)
-    assert_in_delta(0, methods[3].self_time, 0.01)
-
-    assert_in_delta(0, methods[4].total_time, 0.01)
-    assert_in_delta(0, methods[4].wait_time, 0.01)
-    assert_in_delta(0, methods[4].self_time, 0.01)
+    # Check times
+    assert_in_delta(0.2, methods[0].total_time, 0.03)
+    assert_in_delta(0, methods[0].wait_time, 0.03)
+    assert_in_delta(0, methods[0].self_time, 0.03)
 
-    unless RubyProf.ruby_2?
-      assert_in_delta(0, methods[5].total_time, 0.01)
-      assert_in_delta(0, methods[5].wait_time, 0.01)
-      assert_in_delta(0, methods[5].self_time, 0.01)
-    end
+    assert_in_delta(0.2, methods[1].total_time, 0.03)
+    assert_in_delta(0, methods[1].wait_time, 0.03)
+    assert_in_delta(0, methods[1].self_time, 0.1)
   end
 
   def test_module_methods
     result = RubyProf.profile do
-      RubyProf::C2.hello
+      RubyProf::C8.hello
     end
 
     # Methods:
     #   MeasureCpuTimeTest#test_module_methods
     #   M1#hello
-    #   Kernel#sleep
+    #   ...
 
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(3, methods.length)
+    methods = result.threads.first.methods.sort.reverse[0..1]
+    assert_equal(2, methods.length)
 
     assert_equal('MeasureCpuTimeTest#test_module_methods', methods[0].full_name)
-    assert_equal('RubyProf::M1#hello', methods[1].full_name)
-    assert_equal('Kernel#sleep', methods[2].full_name)
+    assert_equal('RubyProf::M7#hello', methods[1].full_name)
 
     # Check times
     assert_in_delta(0.3, methods[0].total_time, 0.1)
@@ -129,39 +95,24 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
 
     assert_in_delta(0.3, methods[1].total_time, 0.1)
     assert_in_delta(0, methods[1].wait_time, 0.02)
-    assert_in_delta(0, methods[1].self_time, 0.02)
-
-    assert_in_delta(0.3, methods[2].total_time, 0.1)
-    assert_in_delta(0, methods[2].wait_time, 0.02)
-    assert_in_delta(0.3, methods[2].self_time, 0.1)
+    assert_in_delta(0, methods[1].self_time, 0.1)
   end
 
   def test_module_instance_methods
     result = RubyProf.profile do
-      RubyProf::C2.new.hello
+      RubyProf::C8.new.hello
     end
 
     # Methods:
     #   MeasureCpuTimeTest#test_module_instance_methods
-    #   Class#new
-    #   <Class::Object>#allocate
-    #   Object#initialize
-    #   M1#hello
-    #   Kernel#sleep
+    #   M7#hello
+    #   ...
 
-    methods = result.threads.first.methods.sort.reverse
-    assert_equal(RubyProf.ruby_2? ? 5 : 6, methods.length)
+    methods = result.threads.first.methods.sort.reverse[0..1]
+    assert_equal(2, methods.length)
     names = methods.map(&:full_name)
     assert_equal('MeasureCpuTimeTest#test_module_instance_methods', names[0])
-    assert_equal('RubyProf::M1#hello', names[1])
-    assert_equal('Kernel#sleep', names[2])
-    assert_equal('Class#new', names[3])
-
-    # order can differ
-    assert(names.include?("#{RubyProf.parent_object}#initialize"))
-    unless RubyProf.ruby_2?
-      assert(names.include?("<Class::#{RubyProf.parent_object}>#allocate"))
-    end
+    assert_equal('RubyProf::M7#hello', names[1])
 
     # Check times
     assert_in_delta(0.3, methods[0].total_time, 0.1)
@@ -170,25 +121,7 @@ class MeasureCpuTimeTest < Test::Unit::TestCase
 
     assert_in_delta(0.3, methods[1].total_time, 0.02)
     assert_in_delta(0, methods[1].wait_time, 0.01)
-    assert_in_delta(0, methods[1].self_time, 0.01)
-
-    assert_in_delta(0.3, methods[2].total_time, 0.02)
-    assert_in_delta(0, methods[2].wait_time, 0.01)
-    assert_in_delta(0.3, methods[2].self_time, 0.02)
-
-    assert_in_delta(0, methods[3].total_time, 0.01)
-    assert_in_delta(0, methods[3].wait_time, 0.01)
-    assert_in_delta(0, methods[3].self_time, 0.01)
-
-    assert_in_delta(0, methods[4].total_time, 0.01)
-    assert_in_delta(0, methods[4].wait_time, 0.01)
-    assert_in_delta(0, methods[4].self_time, 0.01)
-
-    unless RubyProf.ruby_2?
-      assert_in_delta(0, methods[5].total_time, 0.01)
-      assert_in_delta(0, methods[5].wait_time, 0.01)
-      assert_in_delta(0, methods[5].self_time, 0.01)
-    end
+    assert_in_delta(0, methods[1].self_time, 0.05)
   end
 
   def test_singleton

data/test/test_helper.rb

@@ -77,6 +77,30 @@ module RubyProf
     end
   end
 
+  class C7
+    def self.hello
+      t = Time.now.to_f
+      while Time.now.to_f - t < 0.1; end
+    end
+
+    def hello
+      t = Time.now.to_f
+      while Time.now.to_f - t < 0.2; end
+    end
+  end
+
+  module M7
+    def hello
+      t = Time.now.to_f
+      while Time.now.to_f - t < 0.3; end
+    end
+  end
+
+  class C8
+    include M7
+    extend M7
+  end
+
   def self.ruby_major_version
     match = RUBY_VERSION.match(/(\d)\.(\d)/)
     return Integer(match[1])

data/test/thread_test.rb

@@ -3,6 +3,7 @@
 
 require File.expand_path('../test_helper', __FILE__)
 require 'timeout'
+require 'benchmark'
 
 # --  Tests ----
 class ThreadTest < Test::Unit::TestCase
@@ -151,16 +152,20 @@ class ThreadTest < Test::Unit::TestCase
     assert_equal(0, call_info.children.length)
   end
 
-  # useless test
+  # useless test: what does it test?
   def test_thread_back_and_forth
+    result = nil
+    seconds = Benchmark.realtime do
       result = RubyProf.profile do
-              a = Thread.new { 100_000.times { sleep 0 }}
-              b = Thread.new { 100_000.times { sleep 0 }}
-              a.join
-              b.join
+        a = Thread.new { 100_000.times { sleep 0 }}
+        b = Thread.new { 100_000.times { sleep 0 }}
+        a.join
+        b.join
       end
-      methods = result.threads.map {|thread| thread.methods}
-      assert(methods.flatten.sort[-1].total_time < 10) # 10s. Amazingly, this can fail in OS X at times. Amazing.
+    end
+    methods = result.threads.map {|thread| thread.methods}
+    timings = methods.flatten.sort
+    assert(timings[-1].total_time < seconds)
   end
 
   def test_thread

metadata

@@ -2,63 +2,63 @@
 name: ruby-prof
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.14.2
+  version: 0.15.0
 platform: ruby
 authors:
 - Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-05 00:00:00.000000000 Z
+date: 2014-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '4.0'
+  requirement: !ruby/object:Gem::Requirement
     none: false
-  prerelease: false
-  type: :development
-  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '4.0'
-    none: false
+  prerelease: false
+  type: :development
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  requirement: !ruby/object:Gem::Requirement
     none: false
-  prerelease: false
-  type: :development
-  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+  prerelease: false
+  type: :development
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  requirement: !ruby/object:Gem::Requirement
     none: false
-  prerelease: false
-  type: :development
-  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+  prerelease: false
+  type: :development
 description: |
   ruby-prof is a fast code profiler for Ruby. It is a C extension and
   therefore is many times faster than the standard Ruby profiler. It
@@ -252,20 +252,20 @@ rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.3
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      hash: -374709300685905982
       segments:
       - 0
+      hash: -3641831805490330647
       version: '0'
-  none: false
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25