easy_bench 1.0

data/lib/easy_bench.rb

@@ -0,0 +1,121 @@
+require 'forwardable'
+require 'sometimes_memoize'
+
+class EasyBench
+  extend Forwardable
+
+  VERSION = '1.0'
+
+  attr_reader :dataset
+
+  def initialize(title=nil)
+    @dataset = DataSet.new(title)
+  end
+
+  def caller
+    start_time = Time.now
+    res = yield
+    elapsed_time = Time.now - start_time
+
+    @dataset.runs << elapsed_time
+    if @dataset.min_run_time.nil? || @dataset.min_run_time > elapsed_time
+      @dataset.min_run_time = elapsed_time
+    end
+    if @dataset.max_run_time.nil? || @dataset.max_run_time < elapsed_time
+      @dataset.max_run_time = elapsed_time
+    end
+
+    res
+  end
+
+  def_delegators :dataset, :report, :stats
+
+  def self.log_times(logger, label)
+    start_time = Time.now
+    logger.info('Starting ' + label + ' at ' + start_time.to_s)
+    res = yield
+    end_time = Time.now
+    logger.info('Finished ' + label + ' at ' + end_time.to_s + ' (' + (end_time - start_time).to_s + 's)')
+    res
+  end
+  
+  class DataSet
+    include SometimesMemoize
+
+    attr_accessor :runs, :min_run_time, :max_run_time
+    attr_reader :title
+
+    def initialize(title)
+      @title = title
+      @runs = []
+    end
+
+    def total_runs
+      @runs.size
+    end
+
+    def total_run_time
+      @runs.inject(0.0){|sum, run| sum + run}
+    end
+    sometimes_memoize :total_run_time
+
+    def ave_run_time
+      (self.total_run_time / self.total_runs)
+    end
+    
+    def report(bars=false)
+      memoizing do
+        if @title
+          puts @title
+          puts
+        end
+        print_table
+        if bars
+          puts
+          draw_bars
+        end
+        puts
+      end
+    end
+
+    def stats
+      memoizing do
+        {
+          :count => total_runs,
+          :total => total_run_time,
+          :min => min_run_time,
+          :max => max_run_time,
+          :mean => ave_run_time
+        }
+      end
+    end
+
+    def print_table
+      puts "num runs       : #{total_runs}"
+      puts "total run time : #{total_run_time}s"
+      puts "min run time   : #{min_run_time}s"
+      puts "max run time   : #{max_run_time}s"
+      puts "ave run time   : #{ave_run_time}s"
+    end
+
+    def draw_bars(include_values=false)
+      if total_runs > 0
+        band_height = (max_run_time - min_run_time) / 4.0
+        (0..4).to_a.reverse.each do |band|
+          bars = []
+          @runs.each do |run|
+            if run >= min_run_time + (band.to_f * band_height)
+              bars << '*'
+            else
+              bars << ' '
+            end
+          end
+          puts bars.join(' ')
+        end
+      end
+      puts runs.join(' ') if include_values
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: easy_bench
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  version: "1.0"
+platform: ruby
+authors: 
+- Ben Lund
+- Academia, Inc
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-05 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sometimes_memoize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A quick and easy benchmarking library for Ruby. Useful for benchmarking only part of an iteration, and accumulating the data to report later in the code.
+email: ben@academia.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/easy_bench.rb
+has_rdoc: true
+homepage: http://github.com/academia-edu/easy_bench
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Measure the call times of only some of the expressions in your interation -- the timer is explicitly started and stopped for the duration of a block. The result of the operation inside then benchmarked block is returned from the benchmarking call, so an EasyBench call can be wrapped around existing code with no changes. This style allows for interleaving of two or more alternatives being benchmarked within an interaction, which can correct for ramp-up effects you might see if you benchmarked the alternatives sequentially. Simple report output shows minimum, maximum, and mean call times. The report output can also include a simple bar chart to visually inspect the data for outliners (only really useful for small runs of 20 iterations or so)
+test_files: []
+