rubyperf 1.3.5 → 1.3.6

data/VERSION

@@ -1 +1 @@
-1.3.5
+1.3.6

data/lib/perf/meter.rb

@@ -14,9 +14,22 @@ module Perf
 
   class Meter
 
+    # Constant for accuracy. The constant represents the upper bound of its description.
+
+    ACCURACY_UNKNOWN   = 0.0
+    ACCURACY_VERY_POOR = 1.0
+    ACCURACY_POOR      = 50.0
+    ACCURACY_FAIR      = 100.0
+    ACCURACY_GOOD      = 1000.0
+    ACCURACY_EXCELLENT = 1.0/0
+
+    # Name of the path roots
+
     PATH_MEASURES  = '\blocks'
     PATH_METHODS   = '\methods'
 
+    # Hash keys for instrumented methods
+
     METHOD_TYPE_INSTANCE = :instance
     METHOD_TYPE_CLASS    = :class
 
@@ -27,7 +40,7 @@ module Perf
 
     # Overhead calculation tuning constants
     OVERHEAD_CALC_MAX_REPETITIONS = 1000
-    OVERHEAD_CALC_RUNS            = 100
+    OVERHEAD_CALC_RUNS            = 10
     OVERHEAD_CALC_MIN_TIME        = 0.1
 
     # Creation of a Perf::Meter allows you to specify if you want to consider the overhead in the calculation or not.
@@ -41,19 +54,42 @@ module Perf
       @measurements             = {}      # A hash of Measure
       @current_path             = nil
       @instrumented_methods     = {METHOD_TYPE_INSTANCE=>[],METHOD_TYPE_CLASS=>[]}
-      @class_methods            = []
       @subtract_overhead        = @options[:subtract_overhead]
       if @@overhead.nil?
-        @@overhead              ||= measure_overhead
-        @measurements             = {}      # A hash of Measure; must repeat here to cleanup what measure_overhead did
+        @@overhead              = measure_overhead
+        @measurements           = {}      # A hash of Measure; must repeat here to cleanup what measure_overhead did
       end
     end
 
     def overhead
       if @subtract_overhead
-        @@overhead.clone
+        @@overhead.dup
       else
-        Benchmark::Tms.new
+        {:time=>Benchmark::Tms.new,:count=>0}
+      end
+    end
+
+    def adjusted_time(m)
+      return m.time if !@subtract_overhead || !@overhead
+
+      utime,stime,cutime,cstime,real = nil,nil,nil,nil,nil
+
+      adj=m.time-((@overhead[:time]*m.count)/@overhead[:count])
+
+      utime  = 0.0 if adj.utime  < 0.0
+      stime  = 0.0 if adj.stime  < 0.0
+      cutime = 0.0 if adj.cutime < 0.0
+      cstime = 0.0 if adj.cstime < 0.0
+      real   = 0.0 if adj.real   < 0.0
+
+      if utime || stime || cutime || cstime || real
+        Benchmark::Tms.new(utime  || adj.utime,
+                           stime  || adj.stime,
+                           cutime || adj.cutime,
+                           cstime || adj.cstime,
+                           real   || adj.real)
+      else
+        adj
       end
     end
 
@@ -124,17 +160,14 @@ module Perf
       begin
         m=get_measurement(@current_path)
         m.count     += 1
+        root.count  += 1 if root
         m.measuring +=1
         if m.measuring>1
           res=code.call
         else
           t = Benchmark.measure { res=code.call }
-          t -= @@overhead if @subtract_overhead && @@overhead  # Factor out the overhead of measure, if we are asked to do so
-          root.count += m.count if root
-          if t.total>=0 || t.real>=0
-            m.time += t
-            root.time  += t if root
-          end
+          root.time  += t if root
+          m.time     += t
         end
       ensure
         @current_path=current_path
@@ -317,15 +350,22 @@ module Perf
 
     def accuracy(path)
       if @@overhead
-        over=@@overhead.total+@@overhead.real
-        if over>0 && @@overhead.total>=0 && @@overhead.real>=0
+        over=@@overhead[:time].total+@@overhead[:time].real
+        if over>0
           m=get_measurement(path)
-          if m.count>0 && (m.time.total+m.time.real)>0
-            return (m.time.total+m.time.real) / (over*m.count)
-          end
+          return ((m.time.total+m.time.real)*@@overhead[:count] / (over*m.count)) if m.count>0
         end
       end
-      -1
+      -1.0
+    end
+
+    # The overhead cannot be larger that any of the measures taken. If a measure taken is larger than the overhead,
+    # than this function takes care of adjusting the overhead. This is called by the ReportFormat class just before
+    # rendering the report, so you should not have to call this by hand unless you are interested in getting the
+    # overhead.
+
+    def adjust_overhead
+      false
     end
 
 protected
@@ -347,7 +387,7 @@ protected
         cnt  += runs     # Count the total runs
         runs *= 2        # Increases the number of runs to quickly adapt to the speed of the machine
       end
-      t/cnt
+      {:time=>t,:count=>cnt}
     end
 
     def set_measurement(path,m)

data/lib/perf/report_format.rb

@@ -13,8 +13,20 @@ module Perf
   #
   class ReportFormat
 
+    # Descrition of the accuracy, as reported by the reports
+
+    ACCURACY_DESCRIPTION = {Perf::Meter::ACCURACY_UNKNOWN    => "?",
+                            Perf::Meter::ACCURACY_VERY_POOR  => "very poor",
+                            Perf::Meter::ACCURACY_POOR       => "poor",
+                            Perf::Meter::ACCURACY_FAIR       => "fair",
+                            Perf::Meter::ACCURACY_GOOD       => "good",
+                            Perf::Meter::ACCURACY_EXCELLENT  => "excellent"}
+
+    # Largest accuracy description length
+    MAX_ACCURACY_SIZE   = ACCURACY_DESCRIPTION.values.map{|x| x.length}.max+1        # Maximium size of the accuracy value returned by format_accuracy
+
+    # Minimum possible time
     MIN_TOTAL_TIME      = 1.0e-10
-    MAX_ACCURACY_SIZE = 10
 
     # Format takes a Perf::Meter plus a hash of options and converts it into a header, followed by a series
     # of entries in a hash format that can be easily converted in any other format such as Text, HTML, XML, etc.
@@ -29,6 +41,9 @@ module Perf
     #
 
     def format(perf,options={})
+
+      perf.adjust_overhead
+
       options||={}
       options[:max_count_len] ||= 6
       options[:filter_below_accuracy] ||= nil
@@ -48,10 +63,10 @@ module Perf
         max_title = title_len             if title_len>max_title
         max_count = m.count.to_s.length   if m.count.to_s.length>max_count
 
-        total += m.time if path.size==2    # This calculates the max of the level-1 entries needed for the root entry.
+        total += perf.adjusted_time(m) if path.size==2    # This calculates the max of the level-1 entries needed for the root entry.
       end
 
-      totals=[total.real]
+      totals=[total.real+total.total]
       depth=1
       keys_in_order.each do |what|
         m = perf.measurements[what]
@@ -64,9 +79,10 @@ module Perf
           end
           depth=path.size-1
         end
-        totals[totals.size-1] = m.time.real
-        totals[totals.size-1] = MIN_TOTAL_TIME if totals[totals.size-1]<MIN_TOTAL_TIME
-        percents[what]=(m.time.real*100.0)/totals[totals.size-2]
+        adj=perf.adjusted_time(m)
+        totals[totals.size-1] = adj.real+adj.total
+        #totals[totals.size-1] = MIN_TOTAL_TIME if totals[totals.size-1]<MIN_TOTAL_TIME
+        percents[what]=((adj.real+adj.total)*100.0)/totals[totals.size-2]
       end
 
       # Header
@@ -74,7 +90,7 @@ module Perf
                            :percent    => "percent",
                            :count      => "count",        :max_count  => max_count,
                            :time       => Benchmark::Tms::CAPTION,
-                           :accuracy  => "accuracy",      :max_accuracy => MAX_ACCURACY_SIZE,
+                           :accuracy   => "accuracy",      :max_accuracy => MAX_ACCURACY_SIZE,
                            :options    => options)
 
       # Root
@@ -89,7 +105,7 @@ module Perf
         rep << format_measure(:title      => title,                     :max_title  => max_title,
                               :percent    => percents[what]||0.0,
                               :count      => m.count,                   :max_count  => max_count,
-                              :time       => m.time,
+                              :time       => perf.adjusted_time(m),
                               :accuracy   => format_accuracy(accuracy), :max_accuracy => MAX_ACCURACY_SIZE,
                               :options    => options)
       end
@@ -143,19 +159,7 @@ module Perf
     # See Perf::Meter#accuracy for more information
 
     def format_accuracy(accuracy)
-      if accuracy<0
-        "unknown"
-      elsif accuracy<=1
-        "very poor"
-      elsif accuracy<=50
-        "poor"
-      elsif accuracy<=100
-        "fair"
-      elsif accuracy<=1000
-        "good"
-      else
-        "excellent"
-      end
+      ACCURACY_DESCRIPTION[ACCURACY_DESCRIPTION.keys.sort.find{|a| a>=accuracy}]
     end
 
   end

data/rubyperf.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyperf}
-  s.version = "1.3.5"
+  s.version = "1.3.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["lpasqualis"]
-  s.date = %q{2012-01-16}
+  s.date = %q{2012-01-17}
   s.description = %q{Used to easily measure the performance of blocks of Ruby code, expressions and methods; provides reporting in various formats}
   s.email = %q{lpasqualis@gmail.com}
   s.extra_rdoc_files = [

data/test/test_perf_meter.rb

@@ -66,7 +66,7 @@ class TestPerfMeter < Test::Unit::TestCase
       Array.new(1000000,"abc").reverse.sort
     end
 
-    assert_equal ['\blocks,10',
+    assert_equal ['\blocks,9',
     '\blocks\empty,1',
     '\blocks\emtpy_loop,1',
     '\blocks\rough_overhead_x10000,1',
@@ -131,12 +131,11 @@ class TestPerfMeter < Test::Unit::TestCase
     m.measure(:a) do
       ("123"*1_000_000).reverse
     end
-    assert m.accuracy(m.measurements['\blocks'].path) >= 0
-    assert m.accuracy(m.measurements['\blocks\a'].path) >= 0
-    assert m.accuracy(m.measurements['\blocks\b'].path) < 0
-    assert_equal 2,m.report_list_of_measures(:filter_below_accuracy=>0.0001).length
-    assert_equal 2,m.report_list_of_measures(:filter_below_percent=>1).length
-    assert_equal 3,m.report_list_of_measures(:filter_below_accuracy=>-10).length
+    assert m.accuracy(m.measurements['\blocks'].path) > Perf::Meter::ACCURACY_UNKNOWN
+    assert m.accuracy(m.measurements['\blocks\a'].path) > Perf::Meter::ACCURACY_UNKNOWN
+    assert m.accuracy(m.measurements['\blocks\b'].path) < Perf::Meter::ACCURACY_VERY_POOR
+    assert_equal 2,m.report_list_of_measures(:filter_below_accuracy=>1).length
+    assert_equal 3,m.report_list_of_measures(:filter_below_accuracy=>Perf::Meter::ACCURACY_UNKNOWN).length
     assert_equal 3,m.report_list_of_measures(:filter_below_percent=>-10).length
   end
 
@@ -151,8 +150,8 @@ class TestPerfMeter < Test::Unit::TestCase
     m.measure(:c) do
       sleep(0.0001)
     end
+    #puts m.report_simple
     assert_equal 4,m.report_list_of_measures.length
-    assert_equal 3,m.report_list_of_measures(:filter_below_accuracy=>1).length
     assert_equal 3,m.report_list_of_measures(:filter_below_accuracy=>500).length
     assert_equal 3,m.report_list_of_measures(:filter_below_percent=>10).length
     assert_equal 2,m.report_list_of_measures(:filter_below_percent=>45).length
@@ -299,13 +298,21 @@ class TestPerfMeter < Test::Unit::TestCase
                   '\blocks\some_expressions\expression1 = "1111",1',
                   '\blocks\some_expressions\expression1 = "13579",1',
                   '\blocks\some_expressions\expression2 = "string",1',
-                  '\methods,5',
+                  '\methods,4',
                   '\methods\#<Class:PerfTestExample>.static_method,1',
                   '\methods\PerfTestExample.test,1',
                   '\methods\PerfTestExample.test_np,2'],
                   m.report_list_of_measures
   end
 
+  def test_precision
+    runs=1_000
+    a=(1..100_000).to_a
+    m=Perf::Meter.new
+    runs.times { m.measure(:a) { a.reverse! } }
+    m.measure(:b) { runs.times { a.reverse! } }
+    # TODO find proper assert
+  end
 
   def test_overhead
     runs=1_000
@@ -319,7 +326,7 @@ class TestPerfMeter < Test::Unit::TestCase
     b2_yes_overhead=Benchmark.measure { runs.times { a.reverse!                 } }
 
 
-    assert_equal  ['\blocks,500500',
+    assert_equal  ['\blocks,1000',
                    '\blocks\a,1000'],
                   m_no_overhead.report_list_of_measures
 
@@ -338,6 +345,8 @@ class TestPerfMeter < Test::Unit::TestCase
     #puts m_no_overhead.report_simple
     #puts m_yes_overhead.report_simple
     #
-    #assert m_no_overhead.blocks_time.total > m_yes_overhead.blocks_time.total
+    # puts m_no_overhead.blocks_time
+    # puts m_yes_overhead.blocks_time
+    # assert m_no_overhead.blocks_time.total+m_no_overhead.blocks_time.real <= m_yes_overhead.blocks_time.total+m_no_overhead.blocks_time.real
   end
 end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 3
-  - 5
+  - 6
   segments_generated: true
-  version: 1.3.5
+  version: 1.3.6
 platform: ruby
 authors: 
 - lpasqualis
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-16 00:00:00 -08:00
+date: 2012-01-17 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency