rubyperf 0.1.0 → 1.0.0

data/VERSION

@@ -1 +1 @@
-0.1.0
+1.0.0

data/lib/perf/measure.rb

@@ -0,0 +1,28 @@
+require 'rubyperf'
+
+module Perf
+  class Measure
+    attr_accessor :path
+    attr_accessor :count
+    attr_accessor :time
+    attr_accessor :measuring
+
+    def initialize(measure_path)
+      @path      = measure_path
+      @count     = 0
+      @time      = Benchmark::Tms.new
+      @measuring = 0
+    end
+
+    def measuring?
+      @measuring>0
+    end
+
+    def merge(m)
+      @count      +=  m.count
+      @time       +=  m.time
+      @measuring  +=  m.measuring
+    end
+
+  end
+end

data/lib/perf/meter.rb

@@ -20,13 +20,19 @@ module Perf
     METHOD_TYPE_CLASS    = :class
 
     attr_accessor :measurements
-    attr_accessor :current_stack
+    attr_accessor :current_path
 
     def initialize
-      @measurements             = {}
-      @current_stack            = []
+      @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
+      @measurements             = {}      # A hash of Measure
     end
 
     # Takes a description and a code block and measures the performance of the block.
@@ -69,15 +75,33 @@ module Perf
     #  end
     #
 
-    def measure(what,&code)
-      path="#{PATH_MEASURES}\\#{get_current_path}"
-      @current_stack.push what
+    def measure(what,root_path=PATH_MEASURES,&code)
+      current_path=@current_path
+      if @current_path.nil?
+        @current_path=root_path
+        root=get_measurement(@current_path)
+      else
+        root=nil
+      end
+      @current_path+= "\\#{what}"
+      res=nil
       begin
-        res=measure_full_path(PATH_MEASURES) do
-          measure_full_path("#{path}#{what}",&code)
+        m=get_measurement(@current_path)
+        m.count     += 1
+        m.measuring +=1
+        if m.measuring>1
+          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
         end
       ensure
-        @current_stack.pop
+        @current_path=current_path
+        m.measuring-=1
       end
       res
     end
@@ -104,7 +128,7 @@ module Perf
     #
 
     def measure_result(what,&code)
-      res=measure(what,&code)
+      res=measure(what,PATH_MEASURES,&code)
       merge_measures(what,"#{what} = \"#{res.to_s}\"")
       res
     end
@@ -247,29 +271,10 @@ module Perf
       restore_all_class_methods(klass)
     end
 
-    # Measures a block of code given a full path. Should not be called directly unless you know what you are doing.
-
-    def measure_full_path(path,&code)
-      m=get_measurement(path)
-      m[:count] += 1
-      if m[:measuring]
-        res=code.call
-      else
-        res=nil
-        m[:measuring]  = true
-        begin
-          m[:time]      += Benchmark.measure { res=code.call }
-        ensure
-          m[:measuring]  = false
-        end
-      end
-      res
-    end
-
-private
+protected
 
     def set_measurement(path,m)
-      @measurements[path]=m
+      @measurements[path]=m  if m.is_a? Perf::Measure
     end
 
     def get_current_path
@@ -277,14 +282,14 @@ private
     end
 
     def merge_measures(what_from,what_to)
-      measurement_root = "#{PATH_MEASURES}\\#{get_current_path}"
-      path_from        = "#{measurement_root}#{what_from}"
-      path_to          = "#{measurement_root}#{what_to}"
+      path_from        = "#{@current_path || PATH_MEASURES}\\#{what_from}"
+      path_to          = "#{@current_path || PATH_MEASURES}\\#{what_to}"
+
       m_from = get_measurement(path_from)
       m_to   = get_measurement(path_to)
-      m_to[:time]       +=  m_from[:time]
-      m_to[:count]      +=  m_from[:count]
-      m_to[:measuring]  ||= m_from[:measuring]
+
+      m_to.merge(m_from)
+
       clear_measurement(path_from)
     end
 
@@ -293,29 +298,19 @@ private
     end
 
     def get_measurement(path)
-      @measurements[path] ||= {:count      => 0,
-                               :time       => Benchmark::Tms.new,
-                               :measuring  => false}
+      @measurements[path] ||= Perf::Measure.new(path)
     end
 
     def measure_method_by_type(klass,method_name,type)
       unless @instrumented_methods[type].find{|x| x[:klass]==klass && x[:method]==method_name}
-        klass_path="#{PATH_METHODS}\\#{klass}"
-        m = get_measurement("#{klass_path}\\#{method_name}")
         old_method_symbol="rubyperf_org_#{method_name}".to_sym
-        @instrumented_methods[type] << { :klass=>klass, :method=>method_name, :perf=>m, :org=>old_method_symbol }
-        perf=self
+        @instrumented_methods[type] << { :klass=>klass, :method=>method_name, :org=>old_method_symbol }
         klass.send(:alias_method, old_method_symbol,method_name)
+        perf=self
         klass.send(:define_method,method_name) do |*args|
-          res=nil
-          m[:count] += 1
-          t = perf.measure_full_path(PATH_METHODS) do
-                perf.measure_full_path(klass_path) do
-                  Benchmark.measure{ res=self.send(old_method_symbol, *args) }
-                end
-              end
-          m[:time]  += t
-          res
+          perf.measure("#{klass}.#{method_name}",PATH_METHODS) do
+            self.send(old_method_symbol, *args)
+          end
         end
       end
     end

data/lib/perf/meter_factory.rb

@@ -8,11 +8,13 @@ module Perf
   # 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.
-  #
+
   class MeterFactory
 
     DEFAULT_METER = :default
 
+    @@perf_meters=nil
+
     # Returns a Perf::Meter with a given key, and creates it lazly if it doesn't exist'.
     def self.get(key=DEFAULT_METER)
       @@perf_meters ||= {}

data/lib/perf/no_op_meter.rb

@@ -3,6 +3,8 @@
 # https://github.com/lpasqualis/rubyperf
 #
 
+require "rubyperf"
+
 module Perf
   #
   # This class can be used in substitution to a Perf::Meter class to avoid overhead when performance measurements is not
@@ -16,8 +18,6 @@ module Perf
     def clear
     end
 
-    #############################################################################################################
-
     def measure(what,&code)
       yield
     end
@@ -55,6 +55,14 @@ module Perf
       yield
     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
+      end
+      super
+    end
+
   end
 
 end

data/lib/perf/report_format.rb

@@ -38,15 +38,15 @@ module Perf
         path = what.split("\\")
 
         max_title = title_len             if title_len>max_title
-        max_count = m[:count].to_s.length if m[:count].to_s.length>max_count
+        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 += m.time if path.size==2    # This calculates the max of the level-1 entries needed for the root entry.
       end
 
       totals=[total.real]
       depth=1
       keys_in_order.each do |what|
-        m=perf.measurements[what]
+        m = perf.measurements[what]
         path = what.split("\\")
         if path.size-1 != depth
           if path.size-1 > depth
@@ -56,9 +56,9 @@ module Perf
           end
           depth=path.size-1
         end
-        totals[totals.size-1] = m[:time].real
+        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]
+        percents[what]=(m.time.real*100.0)/totals[totals.size-2]
       end
 
       # Header
@@ -76,8 +76,8 @@ module Perf
         title = format_title(what,options)
         rep << format_measure(:title      => title,              :max_title  => max_title,
                               :percent    => percents[what]||0.0,
-                              :count      => m[:count],          :max_count  => max_count,
-                              :time       => m[:time],
+                              :count      => m.count,            :max_count  => max_count,
+                              :time       => m.time,
                               :options    => options)
       end
 

data/lib/perf/report_format_html.rb

@@ -9,8 +9,8 @@ require 'cgi'
 module Perf
   class ReportFormatHtml < ReportFormat
 
-    PERCENT_FORMAT            = "%.3f"
-    INDENT = "&nbsp;"*3
+    PERCENT_FORMAT    = "%.3f"
+    INDENT            = "&nbsp;"*3
 
     def format_header(v)
       "<table class='rubyperf_report_format_html_table'><tr><th>#{v[:title]}</th><th>%</th><th>count</th><th>user</th><th>system</th><th>total</th><th>real</th></tr>"

data/lib/rubyperf.rb

@@ -146,6 +146,7 @@
 #  * Eliminate the overhead of the perf meter operations from the computation of times.
 #
 
+require 'perf/measure'
 require 'perf/meter'
 require 'perf/meter_factory'
 require 'perf/no_op_meter'

data/rubyperf.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyperf}
-  s.version = "0.1.0"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["lpasqualis"]
@@ -24,10 +24,10 @@ Gem::Specification.new do |s|
     "README.rdoc",
     "Rakefile",
     "VERSION",
+    "lib/perf/measure.rb",
     "lib/perf/meter.rb",
     "lib/perf/meter_factory.rb",
     "lib/perf/no_op_meter.rb",
-    "lib/perf/noop_measure.rb",
     "lib/perf/report_format.rb",
     "lib/perf/report_format_html.rb",
     "lib/perf/report_format_simple.rb",
@@ -36,18 +36,20 @@ Gem::Specification.new do |s|
     "test/helper.rb",
     "test/perf_test_example.rb",
     "test/rubyperf_test_helpers.rb",
+    "test/test_meter_factory.rb",
     "test/test_perf_meter.rb"
   ]
   s.homepage = %q{http://github.com/lpasqualis/rubyperf}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.2}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{A gem to 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::VERSION) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::RubyGemsVersion) >= 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

@@ -0,0 +1,50 @@
+#
+# Copyright (c) 2012 Lorenzo Pasqualis - DreamBox Learning, Inc
+# https://github.com/lpasqualis/rubyperf
+#
+
+require "test/unit"
+
+require 'helper'
+
+require 'rubyperf'
+
+require 'rubyperf_test_helpers'
+require 'perf_test_example'
+
+class TestPerfMeter < Test::Unit::TestCase
+
+  def test_basic
+    m1=Perf::MeterFactory.get()
+    m2=Perf::MeterFactory.get()
+
+    m1.measure(:a) {}
+    m1.measure(:b) {}
+
+    assert m1.eql?(m2)
+    assert_equal 3, m2.measurements.count
+    assert_equal 3, m1.measurements.count
+    assert_equal 1,Perf::MeterFactory.all.length
+
+    m3=Perf::MeterFactory.get(:some_meter)
+    m4=Perf::MeterFactory.get(:some_meter)
+
+    assert m3.eql? m4
+    assert !(m1.eql? m3)
+    assert_equal 2,Perf::MeterFactory.all.length
+
+    Perf::MeterFactory.clear_meter(:some_meter)
+    assert_equal 1,Perf::MeterFactory.all.length
+
+    Perf::MeterFactory.clear_all!
+    assert_equal 0,Perf::MeterFactory.all.length
+
+    ameter = Perf::Meter.new
+    Perf::MeterFactory.set_meter(:ameter,ameter)
+    assert (ameter.eql? Perf::MeterFactory.get(:ameter))
+
+    Perf::MeterFactory.set_default(ameter)
+    assert (ameter.eql? Perf::MeterFactory.get)
+  end
+
+end

data/test/test_perf_meter.rb

@@ -4,27 +4,24 @@
 #
 
 require "test/unit"
-
 require 'helper'
-
 require 'rubyperf'
-
 require 'rubyperf_test_helpers'
 require 'perf_test_example'
 
 class TestPerfMeter < Test::Unit::TestCase
 
-  # Called before every test method runs. Can be used
-  # to set up fixture information.
-  def setup
-    # Do nothing
-  end
+  ALLOW_OUTPUT = false
 
-  # Called after every test method runs. Can be used to tear
-  # down fixture information.
+  def test_overhead
+    runs=3000
+    m=Perf::Meter.new
+    b1=Benchmark.measure { runs.times { m.measure(:a) { } }}
+    b2=Benchmark.measure {runs.times {} }
 
-  def teardown
-    # Do nothing
+    puts b1      if ALLOW_OUTPUT
+    puts b2      if ALLOW_OUTPUT
+    puts b1-b2   if ALLOW_OUTPUT
   end
 
   def test_method_not_corrupted_after_restoring
@@ -39,6 +36,7 @@ class TestPerfMeter < Test::Unit::TestCase
     end
     assert PerfTestExample.methods.sort     == cmethods
     assert PerfTestExample.new.methods.sort == imethods
+    puts m.report_simple if ALLOW_OUTPUT
   end
 
   def test_method_metering
@@ -49,7 +47,7 @@ class TestPerfMeter < Test::Unit::TestCase
       a.test_np
       PerfTestExample.static_method
     end
-    m.report_simple
+    puts m.report_simple if ALLOW_OUTPUT
   end
 
   def test_base_report
@@ -57,23 +55,28 @@ class TestPerfMeter < Test::Unit::TestCase
     m.measure(:a) { }
     m.measure(:b) { }
     m.measure(:d) { m.measure(:c) { m.measure(:d) {} }}
+
     assert_not_nil m.measurements["#{Perf::Meter::PATH_MEASURES}\\d\\c\\d"]
     assert_not_nil m.measurements["#{Perf::Meter::PATH_MEASURES}\\d\\c"]
     assert_not_nil m.measurements["#{Perf::Meter::PATH_MEASURES}\\d"]
     assert_not_nil m.measurements["#{Perf::Meter::PATH_MEASURES}\\b"]
     assert_not_nil m.measurements["#{Perf::Meter::PATH_MEASURES}\\a"]
     assert_not_nil m.measurements["#{Perf::Meter::PATH_MEASURES}"]
+    assert_equal 6,m.measurements.size
+
     assert_nil m.measurements["#{Perf::Meter::PATH_MEASURES}\\huh"]
     assert RubyperfTestHelpers.verify_report(m,["#{Perf::Meter::PATH_MEASURES}\\d\\c\\d",
                                                 "#{Perf::Meter::PATH_MEASURES}\\d\\c",
                                                 "#{Perf::Meter::PATH_MEASURES}\\d",
                                                 "#{Perf::Meter::PATH_MEASURES}\\b",
                                                 "#{Perf::Meter::PATH_MEASURES}"])
+    puts m.report_simple if ALLOW_OUTPUT
   end
 
   def test_output_html
     m=RubyperfTestHelpers.get_measure
-    m.report_html
+    htmlcode=m.report_html
+    puts htmlcode if ALLOW_OUTPUT
   end
 
   def test_exception_handling
@@ -86,20 +89,23 @@ class TestPerfMeter < Test::Unit::TestCase
 
     begin
       m.measure(:some_exception) do
+        sleep 0.2
         a=12/0   # Divide by zero
+        sleep 0.2
       end
     rescue
       exception_raised=true
     ensure
       measuring_correct=true
       m.measurements.each_pair do |_,x|
-        measuring_correct=false if x[:measuring]
+        measuring_correct=false if x.measuring?
       end
-      stack_correct = (m.current_stack.size==0)
+      stack_correct = m.current_path.nil?
     end
     assert exception_raised
     assert measuring_correct
     assert stack_correct
+    puts m.report_simple if ALLOW_OUTPUT
   end
 
   def test_return_values
@@ -110,6 +116,13 @@ class TestPerfMeter < Test::Unit::TestCase
 
     assert_equal 5,m.measure_result(:five) {5}
     assert_equal "byebye",m.measure_result(:byebye) {"bye"+"bye"}
+
+    m.measure(:in_here_too) do
+      assert_equal 5,m.measure_result(:five) {5}
+      assert_equal "byebye",m.measure_result(:byebye) {"bye"+"bye"}
+    end
+
+    puts m.report_simple if ALLOW_OUTPUT
   end
 
   def test_nesting_measure
@@ -124,6 +137,7 @@ class TestPerfMeter < Test::Unit::TestCase
     assert_not_nil m.measurements["#{Perf::Meter::PATH_MEASURES}\\a"]
     assert_not_nil m.measurements["#{Perf::Meter::PATH_MEASURES}"]
     assert_nil m.measurements["#{Perf::Meter::PATH_MEASURES}\\huh"]
+    puts m.report_simple if ALLOW_OUTPUT
   end
 
   def test_measure_instance_method
@@ -166,6 +180,7 @@ class TestPerfMeter < Test::Unit::TestCase
     a.test_np
     #puts puts m.report_simple
     m.restore_all_methods(PerfTestExample)
+    puts m.report_simple if ALLOW_OUTPUT
   end
 
   def test_basic
@@ -223,5 +238,7 @@ class TestPerfMeter < Test::Unit::TestCase
       Array.new(1000000,"abc").reverse.sort
     end
 
+    puts m.report_simple if ALLOW_OUTPUT
+
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rubyperf
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: 
+  prerelease: false
   segments: 
-  - 0
   - 1
   - 0
-  version: 0.1.0
+  - 0
+  segments_generated: true
+  version: 1.0.0
 platform: ruby
 authors: 
 - lpasqualis
@@ -20,62 +20,58 @@ default_executable:
 dependencies: 
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  name: shoulda
   type: :development
+  name: shoulda
   version_requirements: &id001 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
+        segments_generated: true
         version: "0"
   requirement: *id001
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  name: bundler
   type: :development
+  name: bundler
   version_requirements: &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
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  name: jeweler
   type: :development
+  name: jeweler
   version_requirements: &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
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  name: rcov
   type: :development
+  name: rcov
   version_requirements: &id004 !ruby/object:Gem::Requirement 
-    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
+        segments_generated: true
         version: "0"
   requirement: *id004
 description: Measures the performance of blocks of code, and provide reporting in various formats
@@ -95,10 +91,10 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- lib/perf/measure.rb
 - lib/perf/meter.rb
 - lib/perf/meter_factory.rb
 - lib/perf/no_op_meter.rb
-- lib/perf/noop_measure.rb
 - lib/perf/report_format.rb
 - lib/perf/report_format_html.rb
 - lib/perf/report_format_simple.rb
@@ -107,6 +103,7 @@ files:
 - test/helper.rb
 - test/perf_test_example.rb
 - test/rubyperf_test_helpers.rb
+- test/test_meter_factory.rb
 - test/test_perf_meter.rb
 has_rdoc: true
 homepage: http://github.com/lpasqualis/rubyperf
@@ -118,27 +115,25 @@ 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.4.2
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A gem to measure ruby code performance

data/lib/perf/noop_measure.rb

@@ -1,39 +0,0 @@
-#
-# Copyright (c) 2012 Lorenzo Pasqualis - DreamBox Learning, Inc
-# https://github.com/lpasqualis/rubyperf
-#
-
-module Perf
-  #
-  # This class can be used in substitution to a Perf::Measure class to avoid overhead when performance measurments is not
-  # required. It needs to maintain the same API as Perf::Measure.
-  #
-  class NoopMeasure
-
-    def measurements
-      {}
-    end
-
-    def current_stack
-      {}
-    end
-
-    def initialize(logger = nil)
-    end
-
-    def clear
-    end
-
-    #############################################################################################################
-
-    def measure(what,type=nil)
-      yield
-    end
-
-    def count_value(what_to_count)
-      nil
-    end
-
-  end
-
-end