benchmark-ips 1.0.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2012-03-23
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,11 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/benchmark_ips
+lib/benchmark/compare.rb
+lib/benchmark/helpers.rb
+lib/benchmark/ips.rb
+lib/benchmark/timing.rb
+test/test_benchmark_ips.rb

data/README.txt

@@ -0,0 +1,80 @@
+= benchmark-ips
+
+* http://github.com/evanphx/benchmark-ips
+
+== DESCRIPTION:
+
+A iterations per second enhancement to Benchmark
+
+== FEATURES/PROBLEMS:
+
+ * benchmark/ips - benchmarks a blocks iterations/second. For short snippits
+   of code, ips automatically figures out how many times to run the code
+   to get interesting data. No more guessing at random iteration counts!
+
+== SYNOPSIS:
+
+require 'benchmark/ips'
+
+Benchmark.ips do
+  # Typical mode, runs the block as many times as it can
+  x.report("addition") { 1 + 2 }
+
+  # To reduce overhead, the number of iterations is passed in
+  # and the block must run the code the specific number of times.
+  # Used for when the workload is very small and any overhead
+  # introduces incorrectable errors.
+  x.report("addition2") do |times|
+    i = 0
+    while i < times
+      1 + 2
+    end
+  end
+
+  # To reduce overhead even more, grafts the code given into
+  # the loop that performs the iterations internally to reduce
+  # overhead. Typically not needed, use the |times| form instead.
+  x.report("addition3", "1 + 2")
+end
+
+== REQUIREMENTS:
+
+* None!
+
+== INSTALL:
+
+* gem install benchmark-ips
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 Evan Phoenix
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'benchmark-ips' do
+  developer('Evan Phoenix', 'evan@phx.io')
+end
+
+# vim: syntax=ruby

data/bin/benchmark_ips

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "you need to write me"

data/lib/benchmark/compare.rb

@@ -0,0 +1,41 @@
+module Benchmark
+  def compare(*reports)
+    return if reports.size < 2
+
+    iter = false
+    sorted = reports.sort do |a,b|
+      if a.respond_to? :ips
+        iter = true
+        b.ips <=> a.ips
+      else
+        a.runtime <=> b.runtime
+      end
+    end
+
+    best = sorted.shift
+
+    STDOUT.puts "\nComparison:"
+
+    if iter
+      STDOUT.printf "%20s: %10.1f i/s\n", best.label, best.ips
+    else
+      STDOUT.puts "#{best.rjust(20)}: #{best.runtime}s"
+    end
+
+    sorted.each do |report|
+      name = report.label
+
+      if iter
+        x = (best.ips.to_f / report.ips.to_f)
+        STDOUT.printf "%20s: %10.1f i/s - %.2fx slower\n", name, report.ips, x
+      else
+        x = "%.2f" % (report.ips.to_f / best.ips.to_f)
+        STDOUT.puts "#{name.rjust(20)}: #{report.runtime}s - #{x}x slower"
+      end
+    end
+
+    STDOUT.puts
+  end
+
+  module_function :compare
+end

data/lib/benchmark/helpers.rb

@@ -0,0 +1,46 @@
+module Benchmark
+  module Helpers
+
+    def fixnum_max
+      if Object.const_defined?(:RUBY_ENGINE)
+        case RUBY_ENGINE
+        when "ruby"
+          2 ** (wordsize - 2) - 1
+        when "rbx"
+          Fixnum::MAX
+        when "jruby"
+          9223372036854775807
+        else
+          raise "Maximum Fixnum size now known yet for #{RUBY_ENGINE}"
+        end
+      else
+        2 ** (wordsize - 2) - 1
+      end
+    end
+    module_function :fixnum_max
+
+    def fixnum_min
+       if Object.const_defined?(:RUBY_ENGINE)
+        case RUBY_ENGINE
+        when "ruby"
+          - 2 ** (wordsize - 2)
+        when "rbx"
+          Fixnum::MIN
+        when "jruby"
+          -9223372036854775808
+        else
+          raise "Maximum Fixnum size now known yet for #{RUBY_ENGINE}"
+        end
+      else
+        - 2 ** (wordsize - 2)
+      end
+   end
+    module_function :fixnum_min
+
+    def wordsize
+      8 * 1.size
+    end
+    module_function :wordsize
+
+  end
+end

data/lib/benchmark/ips.rb

@@ -0,0 +1,238 @@
+# encoding: utf-8
+require 'benchmark/timing'
+require 'benchmark/compare'
+
+module Benchmark
+
+  class IPSReport
+    VERSION = "1.0.0"
+
+    def initialize(label, us, iters, ips, ips_sd, cycles)
+      @label = label
+      @microseconds = us
+      @iterations = iters
+      @ips = ips
+      @ips_sd = ips_sd
+      @measurement_cycle = cycles
+    end
+
+    attr_reader :label, :microseconds, :iterations, :ips, :ips_sd, :measurement_cycle
+
+    def seconds
+      @microseconds.to_f / 1_000_000.0
+    end
+
+    def stddev_percentage
+      100.0 * (@ips_sd.to_f / @ips.to_f)
+    end
+
+    alias_method :runtime, :seconds
+
+    def body
+      left = "%10.1f (±%.1f%%) i/s" % [ips, stddev_percentage]
+      left.ljust(20) + (" - %10d in %10.6fs (cycle=%d)" % 
+                          [@iterations, runtime, @measurement_cycle])
+    end
+
+    def header
+      @label.rjust(20)
+    end
+
+    def to_s
+      "#{header} #{body}"
+    end
+
+    def display
+      $stdout.puts to_s
+    end
+  end
+
+  class IPSJob
+    class Entry
+      def initialize(label, action)
+        @label = label
+
+        if action.kind_of? String
+          compile action
+          @action = self
+          @as_action = true
+        else
+          unless action.respond_to? :call
+            raise ArgumentError, "invalid action, must respond to #call"
+          end
+
+          @action = action
+
+          if action.respond_to? :arity and action.arity > 0
+            @call_loop = true
+          else
+            @call_loop = false
+          end
+
+          @as_action = false
+        end
+      end
+
+      attr_reader :label, :action
+
+      def as_action?
+        @as_action
+      end
+
+      def call_times(times)
+        return @action.call(times) if @call_loop
+
+        act = @action
+
+        i = 0
+        while i < times
+          act.call
+          i += 1
+        end
+      end
+
+      def compile(str)
+        m = (class << self; self; end)
+        code = <<-CODE
+          def call_times(__total);
+            __i = 0
+            while __i < __total
+              #{str};
+              __i += 1
+            end
+          end
+        CODE
+        m.class_eval code
+      end
+    end
+
+    def initialize
+      @list = []
+      @compare = false
+    end
+
+    attr_reader :compare
+
+    def compare!
+      @compare = true
+    end
+
+    #
+    # Registers the given label and block pair in the job list.
+    #
+    def item(label="", str=nil, &blk) # :yield:
+      if blk and str
+        raise ArgmentError, "specify a block and a str, but not both"
+      end
+
+      action = str || blk
+      raise ArgmentError, "no block or string" unless action
+
+      @list.push Entry.new(label, action)
+      self
+    end
+
+    alias_method :report, :item
+
+    # An array of 2-element arrays, consisting of label and block pairs.
+    attr_reader :list
+  end
+
+  def ips(time=5, warmup=2)
+    suite = nil
+
+    sync, $stdout.sync = $stdout.sync, true
+
+    if defined? Benchmark::Suite and Suite.current
+      suite = Benchmark::Suite.current
+    end
+
+    job = IPSJob.new
+    yield job
+
+    reports = []
+
+    job.list.each do |item|
+      suite.warming item.label, warmup if suite
+
+      Timing.clean_env
+
+      if !suite or !suite.quiet?
+        if item.label.size > 20
+          $stdout.print "#{item.label}\n#{' ' * 20}"
+        else
+          $stdout.print item.label.rjust(20)
+        end
+      end
+
+      before = Time.now
+      target = Time.now + warmup
+
+      warmup_iter = 0
+
+      while Time.now < target
+        item.call_times(1)
+        warmup_iter += 1
+      end
+
+      after = Time.now
+
+      warmup_time = (after.to_f - before.to_f) * 1_000_000.0
+
+      # calculate the time to run approx 100ms
+      
+      cycles_per_100ms = ((100_000 / warmup_time) * warmup_iter).to_i
+      cycles_per_100ms = 1 if cycles_per_100ms <= 0
+
+      suite.warmup_stats warmup_time, cycles_per_100ms if suite
+
+      Timing.clean_env
+
+      suite.running item.label, time if suite
+
+      iter = 0
+
+      target = Time.now + time
+
+      measurements = []
+
+      while Time.now < target
+        before = Time.now
+        item.call_times cycles_per_100ms
+        after = Time.now
+
+        iter += cycles_per_100ms
+
+        measurements << ((after.to_f - before.to_f) * 1_000_000.0)
+      end
+
+      measured_us = measurements.inject(0) { |a,i| a + i }
+
+      seconds = measured_us.to_f / 1_000_000.0
+
+      all_ips = measurements.map { |i| cycles_per_100ms.to_f / (i.to_f / 1_000_000) }
+
+      avg_ips = Timing.mean(all_ips)
+      sd_ips =  Timing.stddev(all_ips).round
+
+      rep = IPSReport.new(item.label, measured_us, iter, avg_ips, sd_ips, cycles_per_100ms)
+
+      $stdout.puts " #{rep.body}" if !suite or !suite.quiet?
+
+      suite.add_report rep, caller(1).first if suite
+
+      $stdout.sync = sync
+
+      reports << rep
+    end
+
+    if job.compare
+      Benchmark.compare(*reports)
+    end
+
+    return reports
+  end
+
+
+  module_function :ips
+end

data/lib/benchmark/timing.rb

@@ -0,0 +1,61 @@
+module Benchmark
+  module Timing
+    def self.resolution
+      samples = []
+
+      t1 = TimeVal.new
+      t2 = TimeVal.new
+
+      30.times do
+        t1.update!
+
+        while true
+          t2.update!
+          break if t2 != t1
+        end
+
+        samples << t1.diff(t2)
+      end
+
+      sum = samples.inject(0) { |acc, i| acc + i }
+      sum / 30
+    end
+
+    def self.mean(samples)
+      sum = samples.inject(0) { |acc, i| acc + i }
+      sum / samples.size
+    end
+
+    def self.variance(samples, m=nil)
+      m ||= mean(samples)
+
+      total = samples.inject(0) { |acc, i| acc + ((i - m) ** 2) }
+
+      total / samples.size
+    end
+
+    def self.stddev(samples, m=nil)
+      Math.sqrt variance(samples, m)
+    end
+
+    def self.resample_mean(samples, resample_times=100)
+      resamples = []
+
+      resample_times.times do
+        resample = samples.map { samples[rand(samples.size)] }
+        resamples << Timing.mean(resample)
+      end
+
+      resamples
+    end
+
+    def self.clean_env
+      # rbx
+      if GC.respond_to? :run
+        GC.run(true)
+      else
+        GC.start
+      end
+    end
+  end
+end

data/test/test_benchmark_ips.rb

@@ -0,0 +1,26 @@
+require "test/unit"
+require "benchmark/ips"
+require "stringio"
+
+class TestBenchmarkIPS < Test::Unit::TestCase
+  def setup
+    @old_stdout = $stdout
+    $stdout = StringIO.new
+  end
+
+  def teardown
+    $stdout = @old_stdout
+  end
+
+  def test_ips
+    reports = Benchmark.ips(1,1) do |x|
+      x.report("sleep") { sleep(0.25) }
+    end
+
+    rep = reports.first
+
+    assert_equal "sleep", rep.label
+    assert_equal 4, rep.iterations
+    assert_in_delta 4.0, rep.ips, 0.2
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: benchmark-ips
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Evan Phoenix
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-24 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 3
+        - 10
+        version: "3.10"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 2
+        - 14
+        version: "2.14"
+  type: :development
+  version_requirements: *id002
+description: A iterations per second enhancement to Benchmark
+email: 
+- evan@phx.io
+executables: 
+- benchmark_ips
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/benchmark_ips
+- lib/benchmark/compare.rb
+- lib/benchmark/helpers.rb
+- lib/benchmark/ips.rb
+- lib/benchmark/timing.rb
+- test/test_benchmark_ips.rb
+- .gemtest
+homepage: http://github.com/evanphx/benchmark-ips
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: benchmark-ips
+rubygems_version: 1.8.18
+signing_key: 
+specification_version: 3
+summary: A iterations per second enhancement to Benchmark
+test_files: 
+- test/test_benchmark_ips.rb