bnchmrkr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9f1258f5d0cea36bb610c16d36641e2969a8e28
+  data.tar.gz: 3bbc474bdb09cead4a2cd915bf6d4b6ebc1c87a2
+SHA512:
+  metadata.gz: d5ce962a867982f82026b0a2f4b0ad24f472dee6582e0dd330b5f360e1b2c5b3f1492f48f7bc87b80ce187efa73e1a49c983ab968dfab2848e43cad3461db1f8
+  data.tar.gz: 1db49c32999165c48192499d8d33d43f5e3d298af9adbc33b05cf95b4138ed69b0ae6b859169d40fde6d4412d0f10aae137cd8e5cf01a3164f6e4c6a5b43564f

data/Gemfile

@@ -0,0 +1,10 @@
+ruby '2.0.0'
+
+source 'https://rubygems.org'
+
+group :development do
+  gem 'jeweler', '~> 0'
+  gem 'test-unit', '~> 3.0.0', '>= 3.0.0'
+end
+
+

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    jeweler (0.11.1)
+      rubyforge
+      schacon-git (>= 1.1.1)
+    json_pure (1.8.3)
+    power_assert (0.2.7)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    schacon-git (1.2.2)
+    test-unit (3.0.9)
+      power_assert
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jeweler (~> 0)
+  test-unit (~> 3.0.0, >= 3.0.0)

data/README.md

@@ -0,0 +1,61 @@
+# bnchmrkr
+
+i hate the name too, [but..](https://github.com/chorankates/bnchmrkr/issues/1)
+
+Bnchmrkr (Benchmarker) is a tool to help benchmark different method implementations.
+
+
+# examples
+
+```rb
+tester = Bnchmrlr.new({
+  :count_to_1k   => lambda { 1.upto(1000).each   { |i| i } },
+  :count_to_5k   => lambda { 1.upto(5000).each   { |i| i } },
+  :count_to_10k  => lambda { 1.upto(10000).each  { |i| i } },
+  :count_to_50k  => lambda { 1.upto(50000).each  { |i| i } },
+  :count_to_100k => lambda { 1.upto(100000).each { |i| i } },
+}, 1000)
+
+tester.benchmark!
+
+puts tester
+```
+
+```
+$ ruby examples/ls_vs_stat.rb
+  fastest by type(ls) => 0.005704
+  fastest overall => {:name=>:ls, :measure=>0.005704}
+  slowest by type(stat) => 0.076243
+  slowest_overall => {:name=>:stat, :measure=>0.076243}
+  is_faster?(:ls, :stat) => true
+  is_slower?(:ls, :stat) => false
+ls:
+          fastest => 0.005704
+             mean => 0.008375
+           median => 0.006715
+          slowest => 0.024187
+            total => 0.083754
+stat:
+          fastest => 0.061403
+             mean => 0.069956
+           median => 0.073952
+          slowest => 0.076243
+            total => 0.699563
+overall:
+          fastest => ls [0.005704]
+          slowest => stat [0.076243]
+```
+
+# instance methods
+```
+  benchmark!
+  count
+  faster_by
+  fastest_by_type
+  fastest_overall
+  is_faster?
+  is_slower?
+  results
+  slowest_by_type
+  slowest_overall
+```

data/Rakefile

@@ -0,0 +1,40 @@
+require 'jeweler'
+require 'rake/testtask'
+
+$LOAD_PATH << File.join([File.dirname(__FILE__), 'lib'])
+$LOAD_PATH << File.dirname(__FILE__)
+require 'bnchmrkr'
+
+Jeweler::Tasks.new do |gem|
+  gem.name        = 'bnchmrkr'
+  gem.summary     = 'compare execution time'
+  gem.description = 'given a hash of lambdas, runs and compares the amount of time each implementation takes'
+  gem.email       = 'conor.code@gmail.com'
+  gem.homepage    = 'http://github.com/chorankates/bnchmrkr'
+  gem.authors     = ['Conor Horan-Kates']
+  gem.licenses    =  'MIT'
+
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+namespace :test do
+  Rake::TestTask.new do |t|
+    t.name = 'unit'
+    t.libs << 'lib'
+    t.test_files = FileList['test/unit/**/test_*.rb']
+    t.verbose = true
+  end
+
+end
+
+desc 'run all tests'
+task :test => ['test:unit'] do
+end
+
+desc 'run all examples'
+task :examples do
+  Dir.glob('examples/*.rb').each do |file|
+    sh "time ruby #{file}"
+    puts
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/examples/contrived.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+# contrived.rb - methods that intentionally take differing amounts of time
+require_relative File.expand_path(sprintf('%s/../lib/bnchmrkr', File.dirname(__FILE__)))
+
+tester = Bnchmrkr.new({
+  :count_to_1k   => lambda { 1.upto(1000).each   { |i| i } },
+  :count_to_5k   => lambda { 1.upto(5000).each   { |i| i } },
+  :count_to_10k  => lambda { 1.upto(10000).each  { |i| i } },
+  :count_to_50k  => lambda { 1.upto(50000).each  { |i| i } },
+  :count_to_100k => lambda { 1.upto(100000).each { |i| i } },
+}, 1000)
+
+tester.benchmark!
+
+puts tester

data/examples/fibonacci.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby
+# fibonacci.rb - comparing recursive vs. iterative functions
+
+require_relative File.expand_path(sprintf('%s/../lib/bnchmrkr', File.dirname(__FILE__)))
+
+require 'test-unit'
+
+def recursive(n)
+  if n <= 1
+    return n
+  end
+
+  ( recursive(n - 1) + recursive(n - 2) )
+end
+
+def iterative(target)
+
+  if target <= 1
+    return target
+  end
+
+  hash = {
+    0 => 0,
+    1 => 1,
+  }
+
+  2.upto(target).each do |e|
+    hash[e] = (hash[e - 1] + hash[e - 2])
+  end
+
+  hash[target]
+end
+
+class TestFibonacci < Test::Unit::TestCase
+
+  def test_fibonacci_equality
+
+    1.upto(25).each do |i|
+      recursive_result = recursive(i)
+      iterative_result = iterative(i)
+      assert_equal(recursive_result, iterative_result)
+    end
+
+  end
+
+  def test_fibonacci_speed
+
+    tester = Bnchmrkr.new({
+      :iterative => lambda { iterative(30) },
+      :recursive => lambda { recursive(30) },
+    }, 25)
+
+    tester.benchmark!
+    puts tester
+
+    assert_true(tester.is_faster?(:iterative, :recursive))
+    assert_true(tester.is_slower?(:recursive, :iterative))
+    assert_equal(:iterative, tester.fastest_overall[:name])
+    assert_equal(:recursive, tester.slowest_overall[:name])
+
+  end
+
+end

data/examples/file_reading.rb

@@ -0,0 +1,90 @@
+#
+# line by line vs. .read and then split
+
+require_relative File.expand_path(sprintf('%s/../lib/bnchmrkr', File.dirname(__FILE__)))
+
+class ReadAndSplit
+  attr_reader :file
+
+  def initialize(file)
+    @file = file
+  end
+
+  def read!
+    contents = File.read(@file).split("\n")
+  end
+end
+
+class ReadAndIterate
+  attr_reader :file
+
+  def initialize(file)
+    @file = file
+  end
+
+  def read!
+    contents = Array.new
+    f = File.new(file)
+    f.each_line do |line|
+      contents << line
+    end
+  end
+
+end
+
+def generate_ras_variances(files)
+  hash = Hash.new
+  name = :split
+  files.each do |file|
+    local_name = sprintf('%s_%s', name.to_s, File.basename(file)).to_sym
+    hash[local_name] = lambda {
+      brl = ReadAndSplit.new(file)
+      brl.read!
+    }
+  end
+  hash
+end
+
+def generate_rai_variances(files)
+  hash = Hash.new
+  name = :iterate
+  files.each do |file|
+    local_name = sprintf('%s_%s', name.to_s, File.basename(file)).to_sym
+    hash[local_name] = lambda {
+      rai = ReadAndIterate.new(file)
+      rai.read!
+    }
+  end
+  hash
+end
+
+
+files = [
+  File.expand_path(sprintf('%s/../resources/li-100kw.txt', File.dirname(__FILE__))),
+  File.expand_path(sprintf('%s/../resources/li-500kw.txt', File.dirname(__FILE__))),
+  File.expand_path(sprintf('%s/../resources/li-1Mw.txt', File.dirname(__FILE__))),
+]
+
+tester = Bnchmrkr.new({
+  :split => lambda {
+    brl = ReadAndSplit.new(files.first)
+    brl.read!
+  },
+  :iterate => lambda {
+    rai = ReadAndIterate.new(files.first)
+    rai.read!
+  }
+}, 500)
+
+tester.benchmark!
+puts tester
+
+tester2 = Bnchmrkr.new(
+  generate_rai_variances(files).merge(
+    generate_ras_variances(files)),
+  100)
+
+tester2.benchmark!
+puts tester2
+
+

data/examples/ls_vs_stat.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+# ls_vs_stat.rb - comparing `ls <dir>/*` to `stat <dir>/*`
+
+require_relative File.expand_path(sprintf('%s/../lib/bnchmrkr', File.dirname(__FILE__)))
+
+dir = File.dirname(__FILE__)
+dir = sprintf('%s/*', ENV['HOME'])
+
+tester = Bnchmrkr.new({
+    :ls   => lambda { `ls #{dir}` },
+    :stat => lambda { `stat #{dir}` },
+  },
+  10,
+)
+
+tester.benchmark!
+
+{
+  'fastest by type(ls)'    => tester.fastest_by_type(:ls),
+  'fastest overall'        => tester.fastest_overall,
+  'slowest by type(stat)'  => tester.slowest_by_type(:stat),
+  'slowest_overall'        => tester.slowest_overall,
+  'is_faster?(:ls, :stat)' => tester.is_faster?(:ls, :stat),
+  'is_slower?(:ls, :stat)' => tester.is_slower?(:ls, :stat),
+}.each_pair do |name, result|
+  puts sprintf('  %#15s => %s%s', name, result, "\n")
+end
+
+puts tester

data/lib/bnchmrkr.rb

@@ -0,0 +1,187 @@
+#!/usr/bin/ruby
+
+require 'benchmark'
+
+class Bnchmrkr
+
+  attr_reader :count, :results
+
+  def initialize(lambdas, count = 100)
+
+    @count    = count
+    @results  = Hash.new
+    @lambdas  = lambdas
+
+    @fastest = { :name => :unknown, :measure => 2 ** 10 } # TODO really need to find a better max int
+    @slowest = { :name => :unknown, :measure => 0 }
+
+    @cache = Hash.new
+
+    @lambdas.each_pair do |name, l|
+      unless name.class.eql?(Symbol) and l.class.eql?(Proc)
+        raise ArgumentError.new(sprintf('expecting[Symbol,Proc], got[%s,%s]', name.class, l.class))
+      end
+    end
+
+    raise ArgumentError.new(sprintf('expecting[Fixnum], got[%s]', count.class)) unless count.class.eql?(Fixnum)
+
+  end
+
+  # return list of named lambdas known
+  def types
+    @lambdas.keys
+  end
+
+  # 10 lines to actually do the work..
+  def benchmark!
+    @lambdas.each_pair do |name, l|
+      1.upto(@count).each do |round|
+        measure = Benchmark.measure {
+          l.call
+        }
+        add_measure(name, measure)
+      end
+    end
+
+  end
+
+  ## :specific => fastest, slowest, mean, median, total per lambda
+  ## :overall  => fastest, slowest for all
+  def inspect
+    { :overall  => calculate_overall, :specific => calculate_per_lambda }
+  end
+
+  # overly intricate output formatting of overall and specific results
+  def to_s
+    string     = String.new
+    inspection = self.inspect
+    return string unless inspection.nil? or inspection.has_key?(:overall)
+    longest_key = 15 # TODO determine this dynamically
+
+    inspection[:specific].keys.each do |i|
+      string << sprintf('%s:%s', i, "\n")
+      inspection[:specific][i].keys.sort.each do |k|
+        string << sprintf("  %#{longest_key}s => %s%s", k, inspection[:specific][i][k], "\n")
+      end
+    end
+
+    string << sprintf('overall:%s', "\n")
+    inspection[:overall].each_pair do |type, measure|
+      string << sprintf("  %#{longest_key}s => %s [%s]%s", type, measure[:name], measure[:measure], "\n")
+    end
+
+    string
+  end
+
+  # +type+ name of a lambda that is known
+  # find and return the fastest execution per lambda of +type+
+  def fastest_by_type(type)
+    results = @results
+    measures = Array.new
+
+    return nil unless results.has_key?(type)
+    results[type].collect { |r| measures << r.real}
+
+    measures.sort.first
+  end
+
+  # find and return the fastest overall execution (regardless of lambda type)
+  def fastest_overall
+    calculate_overall
+    @fastest
+  end
+
+  # +type+ name of a lambda that is known
+  # find and return the slowest execution per lambda of +type+
+  def slowest_by_type(type)
+    results  = @results
+    measures = Array.new
+
+    return nil unless results.has_key?(type)
+    results[type].collect { |r| measures << r.real }
+
+    measures.sort.last
+  end
+
+  # find and return the slowest overall execution (regardless of lambda type)
+  def slowest_overall
+    calculate_overall
+    @slowest
+  end
+
+  # +a+ {:name => name, :measure => measure}
+  # +b+ {:name => name, :measure => measure}
+  # +mode+ :fastest, :slowest, :mean, :median, :total
+  # return boolean if a is faster than b, false if invalid
+  def is_faster?(a, b, mode = :total)
+    result = calculate_per_lambda
+    return false unless result.has_key?(a[:name]) and result.has_key?(b[:name])
+    result[a[:name]][mode] < result[b[:name]][mode]
+  end
+
+  # +a+ {:name => name, :measure => measure}
+  # +b+ {:name => name, :measure => measure}
+  # +mode+ :fastest, :slowest, :mean, :median, :total
+  # return boolean if a is faster than b, false if invalid
+  def is_slower?(a, b, mode = :total)
+    ! is_faster?(a, b, mode)
+  end
+
+  # +a+ {:name => name, :measure => measure}
+  # +b+ {:name => name, :measure => measure}
+  # return Float representing difference in measure, or false, if b is slower than a
+  def faster_by(a, b, percent = true)
+    return false if b[:measure] < a[:measure]
+
+    faster = (b[:measure] - a[:measure]) / b[:measure]
+    percent ? sprintf('%4f%', faster * 100) : faster
+  end
+
+  private
+
+  def add_measure(name, measure)
+    self.results[name] = Array.new unless self.results.has_key?(name)
+    self.results[name] << measure
+  end
+
+  # from existing results, generate some statistics per lambda type
+  def calculate_per_lambda
+    hash = Hash.new
+
+    # TODO come up with way to not recompute unless contents have changed
+
+    @results.each_pair do |name, measures|
+      sorted = measures.sort { |a,b| a.real <=> b.real }
+
+      hash[name] = Hash.new
+
+      total = 0
+      measures.collect {|m| total += m.real }
+
+      # TODO do we want to determine the mode?
+      hash[name][:fastest] = sorted.first.real
+      hash[name][:slowest] = sorted.last.real
+      hash[name][:mean]    = sprintf('%5f', total / sorted.size)
+      hash[name][:median]  = sorted[(sorted.size / 2)].real
+      hash[name][:total]   = sprintf('%5f', total)
+    end
+
+    hash
+  end
+
+  # update fastest/slowest, return in a named Hash
+  def calculate_overall
+    calculate_per_lambda.each_pair do |name,results|
+      if results[:fastest] < @fastest[:measure]
+        @fastest = { :name => name, :measure => results[:fastest] }
+      end
+
+      if results[:slowest] > @slowest[:measure]
+        @slowest = { :name => name, :measure => results[:slowest] }
+      end
+    end
+
+    { :fastest => @fastest, :slowest => @slowest }
+  end
+
+end