rubyperf 1.0.1 → 1.1.0

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.1.0

data/lib/perf/meter.rb

@@ -22,19 +22,48 @@ module Perf
     attr_accessor :measurements
     attr_accessor :current_path
 
-    def initialize
+    @@overhead = nil
+
+    # Overhead calculation tuning constants
+    OVERHEAD_CALC_MAX_REPETITIONS = 1000
+    OVERHEAD_CALC_RUNS            = 100
+    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.
+    # The overhead is calculated once and stored away. That way it is always the same in a single run.
+
+    def initialize(options={})
+      @options = options.clone
+
+      @options[:subtract_overhead] = true if @options[:subtract_overhead].nil? # Never use ||= with booleans
+
       @measurements             = {}      # A hash of Measure
       @current_path             = nil
       @instrumented_methods     = {METHOD_TYPE_INSTANCE=>[],METHOD_TYPE_CLASS=>[]}
       @class_methods            = []
-      #@overhead = nil
-      #@overhead = Benchmark.measure do
-      #  measure(:a) {}
-      #end
-      #@overhead = nil
+      @subtract_overhead        = @options[:subtract_overhead]
+      @@overhead              ||= measure_overhead  if @subtract_overhead
       @measurements             = {}      # A hash of Measure
     end
 
+    def overhead
+      if @subtract_overhead
+        @@overhead.clone
+      else
+        Benchmark::Tms.new
+      end
+    end
+
+    # Returns the total time - expressed with a Benchmark::Tms object - for all the blocks measures
+    def blocks_time
+      @measurements[PATH_MEASURES].time if @measurements[PATH_MEASURES]
+    end
+
+    # Returns the total time - expressed with a Benchmark::Tms object - for all the methods measures
+    def methods_time
+      @measurements[PATH_METHODS].time if @measurements[PATH_METHODS]
+    end
+
     # Takes a description and a code block and measures the performance of the block.
     # It returns the value returned by the block
     #
@@ -93,11 +122,11 @@ module Perf
           res=code.call
         else
           t = Benchmark.measure { res=code.call }
-          #t -= @overhead if @overhead
-          #if t.total>=0 && t.real>=0
-          m.time    += t
-          root.time += t if root
-          #end
+          t -= @@overhead if @subtract_overhead && @@overhead  # Factor out the overhead of measure, if we are asked to do so
+          if t.total>=0 && t.real>=0
+            m.time    += t
+            root.time += t if root
+          end
         end
       ensure
         @current_path=current_path
@@ -273,6 +302,26 @@ module Perf
 
 protected
 
+    # This method measures the overhead of calling "measure" on an instace of Perf::Meter.
+    # It will run OVERHEAD_CALC_RUNS measures of an empty block until the total time taken
+    # exceeds OVERHEAD_CALC_MIN_TIME.
+
+    def measure_overhead
+      t=Benchmark::Tms.new
+      cnt=0
+      rep=0
+      runs=OVERHEAD_CALC_RUNS
+      while t.total<OVERHEAD_CALC_MIN_TIME && rep<OVERHEAD_CALC_MAX_REPETITIONS
+        t+=Benchmark.measure do
+          runs.times {measure(:a) {}}
+        end
+        rep  += 1        # Count the repetitions
+        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
+    end
+
     def set_measurement(path,m)
       @measurements[path]=m  if m.is_a? Perf::Measure
     end

data/lib/perf/meter_factory.rb

@@ -5,42 +5,112 @@
 
 module Perf
 
-  # Simple Perf::Meter factory and singleton management.
+  # Very simple Perf::Meter factory and singleton management.
+  #
   # Useful to not have to pass around Perf::Meter objects and still be able to generate stats in various parts of
-  # the code.
+  # the code. For complex situations where you have multiple Perf::Meter objects you might need to consider
+  # either creating a factory that fulfills your needs, or create Perf::Meter objects and pass them around or use
+  # this factory will well planned out key values so that you won't have conflicts and overrides.
+  #
+  # MeterFactory works keeping a global cache of Perf::Meter objects by key. Multiple independent parts
+  # of your code using this factory could get into trouble and trample on each other if they use the same key, or the
+  # default key.
+  #
+  # Example of usage where it would be inconvenient to pass around the Perf::Meter object from example to function2:
+  #
+  # def example
+  #   Perf::MeterFactory.get.measure(:function1)
+  #     function1()
+  #   end
+  # end
+  #
+  # def function1()
+  #    ..
+  #    function2()
+  #    ..
+  # end
+  #
+  # def function2()
+  #   ..
+  #   Perf::MeterFactory.get.measure(:some_hot_code_in_function2)
+  #     ...
+  #   end
+  #   ..
+  # end
+  #
 
   class MeterFactory
 
     DEFAULT_METER = :default
 
-    @@perf_meters=nil
+    @@perf_meters       = nil
+    @@new_meter_options = {}
+    @@factory_options   = {:noop=>false}
 
-    # Returns a Perf::Meter with a given key, and creates it lazly if it doesn't exist'.
-    def self.get(key=DEFAULT_METER)
+    # Returns a Perf::Meter with a given key, and creates it lazily if it doesn't exist'.
+    # NOTE: The options are set ONLY the first time that get is called on a specific key.
+    #       After that the options will be ignored!
+
+    def self.get(key=DEFAULT_METER,new_meter_options=nil)
       @@perf_meters ||= {}
-      @@perf_meters[key] ||= Perf::Meter.new
+      if !@@factory_options[:noop]
+        # Creates a real meter
+        @@perf_meters[key] ||= Perf::Meter.new(new_meter_options || @@new_meter_options)
+      else
+        # If noop is set, creates a no-nop version of the meter, unless a meter with this key has already been
+        # created.
+        @@perf_meters[key] ||= Perf::NoOpMeter.new
+      end
+    end
+
+    # To set options for new meters created by get, when specific options are not passed, you can do so with this
+    # method.
+
+    def self.set_new_meters_options(options)
+      @@new_meter_options.merge(options)
+    end
+
+    # Set options for the factory behaviour.
+
+    def self.set_factory_options(options)
+      @@factory_options.merge!(options)
+    end
+
+    # If you use set_new_meters_options, or if you pass options to Perf::MeterFactory.get, you are setting options
+    # only for if the meter is created. For this reason you might need to find out if the meter already exist.
+
+    def exists?(key=DEFAULT_METER)
+      !@@perf_meters[key].nil?
     end
 
     # Pushes a Perf::Meter into a key
+
     def self.set_meter(key,meter)
       @@perf_meters ||= {}
       @@perf_meters[key]=meter
     end
 
     # Sets the default meter.
+
     def self.set_default(meter)
       set_meter(DEFAULT_METER,meter)
     end
 
+    # Returns a hash of existing meters.
+
     def self.all
       @@perf_meters ||= {}
       return @@perf_meters.clone
     end
 
+    # Removes an existing meter from the cache
+
     def self.clear_meter(key=DEFAULT_METER)
       @@perf_meters.delete(key) if @@perf_meters
     end
 
+    # Clears the entire cache of meters.
+
     def self.clear_all!
       @@perf_meters=nil
     end

data/lib/perf/no_op_meter.rb

@@ -12,7 +12,7 @@ module Perf
   #
   class NoOpMeter
 
-    def initialize(logger = nil)
+    def initialize(options=nil)
     end
 
     def clear
@@ -33,7 +33,7 @@ module Perf
     def measure_instance_method(klass,method_name)
     end
 
-    def measure_instance_method(klass,method_name)
+    def restore_instance_method(klass,method_name)
     end
 
     def restore_all_instance_methods(klass)
@@ -51,14 +51,24 @@ module Perf
     def restore_all_methods(klass)
     end
 
-    def measure_full_path(path,&code)
-      yield
+    def overhead
+      Benchmark::Tms.new
+    end
+
+    # Returns the total time - expressed with a Benchmark::Tms object - for all the blocks measures
+    def blocks_time
+      Benchmark::Tms.new
+    end
+
+    # Returns the total time - expressed with a Benchmark::Tms object - for all the methods measures
+    def methods_time
+      Benchmark::Tms.new
     end
 
     def method_missing(method_sym, *arguments, &block)
       if method_sym.to_s =~ /^report_(.*)$/
         klass=Object.const_get("Perf").const_get("ReportFormat#{$1.capitalize}")
-        return klass.new.format(self) if klass
+        return nil if klass
       end
       super
     end

data/lib/perf/report_format.rb

@@ -62,7 +62,7 @@ module Perf
       end
 
       # Header
-      rep << format_header(:title      => "measure path", :max_title  => max_title,
+      rep << format_header(:title      => "measure",      :max_title  => max_title,
                            :percent    => "percent",
                            :count      => "count",        :max_count  => max_count,
                            :time       => Benchmark::Tms::CAPTION,

data/rubyperf.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyperf}
-  s.version = "1.0.1"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["lpasqualis"]
@@ -43,14 +43,13 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/lpasqualis/rubyperf}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.4.2}
   s.summary = %q{rubyperf helps you measure ruby code performance}
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])

data/test/test_meter_factory.rb

@@ -14,6 +14,74 @@ require 'perf_test_example'
 
 class TestMeterFactory < Test::Unit::TestCase
 
+  def setup()
+    Perf::MeterFactory.clear_all!
+  end
+
+  def teardown()
+    Perf::MeterFactory.clear_all!
+    Perf::MeterFactory.set_factory_options(:noop=>false)
+  end
+
+  def test_noop
+    Perf::MeterFactory.set_factory_options(:noop=>true)
+    m1=Perf::MeterFactory.get()
+    assert m1.is_a? Perf::NoOpMeter
+    m1.measure(:something) do
+      # ...
+    end
+    assert m1.report_simple.nil?
+  end
+
+  def test_noop2
+    Perf::MeterFactory.set_factory_options(:noop=>true)
+    m=Perf::MeterFactory.get()
+    assert m.is_a? Perf::NoOpMeter
+    m.measure(:string_operations) do
+      m.measure(:ciao) do
+        10.times do; "CIAO"*100; end
+      end
+    end
+    m.measure(:string_operations) do
+      m.measure(:help) do
+        10.times do; "HELP"*100; end
+      end
+    end
+    m.measure(:emtpy_loop) do
+      500.times do; end;
+    end
+    m.measure(:rough_overhead_x10000) do
+      10.times do
+        m.measure(:block_1) do
+          m.measure(:block_1_1) do
+          end
+          m.measure(:block_1_2) do
+            m.measure(:block_1_2_1) do
+            end
+            m.measure(:block_1_2_2) do
+            end
+            m.measure(:block_1_2_3) do
+              assert_equal false,m.measure_result(:bool_exp_1_2_3) { false }
+              m.measure_result(:bool_exp_1_2_3) { true }
+            end
+          end
+        end
+      end
+    end
+
+    m.measure(:empty) do
+    end
+    m.measure_result("test") { "something" }
+    m.measure_result("test") { false }
+    m.measure_result("test") { false }
+
+    m.method_meters(Array,[:sort,:reverse],[:new]) do
+      Array.new(1000000,"abc").reverse.sort
+    end
+    assert_equal 123,m.measure(:blah) {123}
+    assert m.report_simple.nil?
+  end
+
   def test_basic
     Perf::MeterFactory.clear_all!
     m1=Perf::MeterFactory.get()

data/test/test_perf_meter.rb

@@ -107,25 +107,8 @@ class TestPerfMeter < Test::Unit::TestCase
     assert PerfTestExample.methods.sort     == cmethods
     assert PerfTestExample.new.methods.sort == imethods
 
-    assert_equal ['\methods,0',
-                  '\methods\#<Class:PerfTestExample>.static_method,1',
-                  '\methods\PerfTestExample.test,1',
-                  '\methods\PerfTestExample.test_np,1'],
-                 m.report_list_of_measures
-
     assert_equal 6,m.report_simple.length
     assert_equal 6,m.report_html.length
-  end
-
-  def test_method_metering
-    m=Perf::Meter.new
-    m.method_meters(PerfTestExample,[:test,:test_np],[:static_method]) do
-      a=PerfTestExample.new
-      a.test(1,2,3)
-      a.test_np
-      PerfTestExample.static_method
-    end
-
     assert_equal ['\methods,0',
                   '\methods\#<Class:PerfTestExample>.static_method,1',
                   '\methods\PerfTestExample.test,1',
@@ -285,13 +268,34 @@ class TestPerfMeter < Test::Unit::TestCase
   def test_overhead
     runs=1_000
     a=(1..100_000).to_a
-    m=Perf::Meter.new
-    b1=Benchmark.measure { runs.times { m.measure(:a) { a.reverse! } } }
-    b2=Benchmark.measure { runs.times { a.reverse!                 } }
+    m_no_overhead=Perf::Meter.new(:subtract_overhead=>true)
+    b1_no_overhead=Benchmark.measure { runs.times { m_no_overhead.measure(:a) { a.reverse! } } }
+    b2_no_overhead=Benchmark.measure { runs.times { a.reverse!                 } }
+
+    m_yes_overhead=Perf::Meter.new(:subtract_overhead=>false)
+    b1_yes_overhead=Benchmark.measure { runs.times { m_yes_overhead.measure(:a) { a.reverse! } } }
+    b2_yes_overhead=Benchmark.measure { runs.times { a.reverse!                 } }
+
+
     assert_equal  ['\blocks,0',
                    '\blocks\a,1000'],
-                  m.report_list_of_measures
-    # Here we should assert if the overhead is > a certain percentage.
-    # puts "Measurement overhead x 1000 = #{b1-b2}"
+                  m_no_overhead.report_list_of_measures
+
+    assert_equal  m_no_overhead.report_list_of_measures,
+                  m_yes_overhead.report_list_of_measures
+
+    # TODO: find the magic assert that ensures that the overhead calculation is correct. Ensure that such assert
+    #       is machine independent and that will pass the test of time (new hardware getting faster and faster)
+
+    #calculated_overhead_1= (b1_no_overhead-b2_no_overhead)/runs
+    #calculated_overhead_2= (b1_yes_overhead-b2_yes_overhead)/runs
+    #
+    #puts (calculated_overhead_1-m_no_overhead.overhead)
+    #puts (calculated_overhead_2-m_yes_overhead.overhead)
+    #
+    #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
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rubyperf
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 19
+  prerelease: 
   segments: 
   - 1
-  - 0
   - 1
-  segments_generated: true
-  version: 1.0.1
+  - 0
+  version: 1.1.0
 platform: ruby
 authors: 
 - lpasqualis
@@ -20,60 +20,64 @@ default_executable:
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  type: :development
-  name: shoulda
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
-        segments_generated: true
         version: "0"
-  requirement: *id001
+  type: :development
+  name: shoulda
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  type: :development
-  name: bundler
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 1
         - 0
         - 0
-        segments_generated: true
         version: 1.0.0
-  requirement: *id002
+  type: :development
+  name: bundler
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  type: :development
-  name: jeweler
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 1
         - 6
         - 4
-        segments_generated: true
         version: 1.6.4
-  requirement: *id003
+  type: :development
+  name: jeweler
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  type: :development
-  name: rcov
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
-        segments_generated: true
         version: "0"
-  requirement: *id004
+  type: :development
+  name: rcov
+  version_requirements: *id004
 description: Used to easily measure the performance of blocks of Ruby code, expressions and methods; provides reporting in various formats
 email: lpasqualis@gmail.com
 executables: []
@@ -116,25 +120,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
-      segments_generated: true
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
-      segments_generated: true
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: rubyperf helps you measure ruby code performance