benchmark-ips 1.2.0 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 21b099f60a4072356c1870798deab178dc6fe7f5
+  data.tar.gz: 173c42ebe9730b48a3cf019b8f92c093066cd497
+SHA512:
+  metadata.gz: cd342a80b701d34c2034462a3ee765ac92ef809e2345fac3be3a05673fa34662c1db4ad618065eafd74c50078ab77081ccf3f70efdd63045efc4156a88dd88cb
+  data.tar.gz: 09e2598b1fb76dde4abe095703d3ffea4f5f8dcd30b53492168e69b437d04ca59198d003da417637cc09beecc2f87d025754522fe30915e499606389865fe85a

data/History.txt

@@ -1,3 +1,21 @@
+=== 2.0.0 / 2014-06-18
+
+* The 'Davy Stevenson' release!
+  * Codename: Springtime Hummingbird Dance
+
+ * Big API refactoring so the internal bits are easier to use
+ * Bump to 2.0 because return types changed to make the API better
+
+* Contributors added:
+  *  Davy Stevenson
+  *  Juanito Fatas
+  *  Benoit Daloze
+  *  Matias
+  *  Tony Arcieri
+  *  Vipul A M
+  *  Zachary Scott
+  *  schneems (Richard Schneeman)
+
 === 1.0.0 / 2012-03-23
 
 * 1 major enhancement

data/Manifest.txt

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

data/{README.txt → README.md}

@@ -1,22 +1,33 @@
-= benchmark-ips
+[![Build Status](https://secure.travis-ci.org/evanphx/benchmark-ips.png)](http://travis-ci.org/evanphx/benchmark-ips)
+
+# benchmark-ips
 
 * http://github.com/evanphx/benchmark-ips
 
-== DESCRIPTION:
+## DESCRIPTION:
 
 A iterations per second enhancement to Benchmark
 
-== FEATURES/PROBLEMS:
+## 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:
+## SYNOPSIS:
 
+```ruby
 require 'benchmark/ips'
 
 Benchmark.ips do |x|
+  # Configure the number of seconds used during
+  # the warmup phase and calculation phase
+  x.config(:time => 5, :warmup => 2)
+
+  # These parameters can also be configured this way
+  x.time = 5
+  x.warmup = 2
+
   # Typical mode, runs the block as many times as it can
   x.report("addition") { 1 + 2 }
 
@@ -28,6 +39,7 @@ Benchmark.ips do |x|
     i = 0
     while i < times
       1 + 2
+      i += 1
     end
   end
 
@@ -35,26 +47,58 @@ Benchmark.ips do |x|
   # the loop that performs the iterations internally to reduce
   # overhead. Typically not needed, use the |times| form instead.
   x.report("addition3", "1 + 2")
+
+  # Really long labels should be formatted correctly
+  x.report("addition-test-long-label") { 1 + 2 }
+
+  # Compare the iterations per second of the various reports!
+  x.compare!
 end
+```
 
-== REQUIREMENTS:
+This will generate the following report:
+
+```
+Calculating -------------------------------------
+   addition    147625 i/100ms
+  addition2    151046 i/100ms
+  addition3    172914 i/100ms
+-------------------------------------------------
+   addition  9247039.5 (±13.2%) i/s -   45320875 in   5.009003s
+  addition2 26436533.8 (±22.1%) i/s -  124461904 in   4.994989s
+  addition3 32227427.9 (±13.0%) i/s -  157524654 in   5.002928s
+```
+
+Benchmark/ips will report the number of iterations per second for a given block
+of code. When analyzing the results, notice the percent of [standard
+deviation](http://en.wikipedia.org/wiki/Standard\_deviation) which tells us how
+spread out our measurements are from the average. A high standard deviation
+could indicate the results having too much variability.
+
+One benefit to using this method is benchmark-ips automatically determines the
+data points for testing our code, so we can focus on the results instead of
+guessing iteration counts as we do with the traditional Benchmark library.
+
+## REQUIREMENTS:
 
 * None!
 
-== INSTALL:
+## INSTALL:
 
-* gem install benchmark-ips
+    $ gem install benchmark-ips
 
-== DEVELOPERS:
+## DEVELOPERS:
 
 After checking out the source, run:
 
-  $ rake newb
+    $ rake newb
 
 This task will install any missing dependencies, run the tests/specs,
 and generate the RDoc.
 
-== LICENSE:
+Run the example file `bin/benchmark_ips` to test that everything is working properly.
+
+## LICENSE:
 
 (The MIT License)
 

data/Rakefile

@@ -3,8 +3,14 @@
 require 'rubygems'
 require 'hoe'
 
+Hoe.plugin :minitest
+
 Hoe.spec 'benchmark-ips' do
   developer('Evan Phoenix', 'evan@phx.io')
+
+  self.readme_file = 'README.md'
+
+  license "MIT"
 end
 
 # vim: syntax=ruby

data/lib/benchmark/compare.rb

@@ -1,41 +1,44 @@
 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
+  module Compare
+
+    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
-    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
+      best = sorted.shift
 
-    sorted.each do |report|
-      name = report.label
+      STDOUT.puts "\nComparison:"
 
       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
+        STDOUT.printf "%20s: %10.1f i/s\n", best.label, best.ips
       else
-        x = "%.2f" % (report.ips.to_f / best.ips.to_f)
-        STDOUT.puts "#{name.rjust(20)}: #{report.runtime}s - #{x}x slower"
+        STDOUT.puts "#{best.rjust(20)}: #{best.runtime}s"
       end
-    end
 
-    STDOUT.puts
+      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
   end
 
-  module_function :compare
+  extend Benchmark::Compare
 end

data/lib/benchmark/helpers.rb

@@ -20,7 +20,7 @@ module Benchmark
     module_function :fixnum_max
 
     def fixnum_min
-       if Object.const_defined?(:RUBY_ENGINE)
+      if Object.const_defined?(:RUBY_ENGINE)
         case RUBY_ENGINE
         when "ruby"
           - 2 ** (wordsize - 2)
@@ -29,12 +29,12 @@ module Benchmark
         when "jruby"
           -9223372036854775808
         else
-          raise "Maximum Fixnum size now known yet for #{RUBY_ENGINE}"
+          raise "Minimum Fixnum size now known yet for #{RUBY_ENGINE}"
         end
       else
         - 2 ** (wordsize - 2)
       end
-   end
+    end
     module_function :fixnum_min
 
     def wordsize

data/lib/benchmark/ips.rb

@@ -1,267 +1,54 @@
 # encoding: utf-8
 require 'benchmark/timing'
 require 'benchmark/compare'
+require 'benchmark/ips/report'
+require 'benchmark/ips/job'
 
 module Benchmark
+  module IPS
+    VERSION = "2.0.0"
+    CODENAME = "Springtime Hummingbird Dance"
 
-  class IPSReport
-    VERSION = "1.2.0"
+    def ips(time=nil, warmup=nil)
+      suite = nil
 
-    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" % [@iterations, runtime])
-    end
-
-    def header
-      @label.rjust(20)
-    end
+      sync, $stdout.sync = $stdout.sync, true
 
-    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
+      if defined? Benchmark::Suite and Suite.current
+        suite = Benchmark::Suite.current
       end
 
-      attr_reader :label, :action
+      quiet = suite && !suite.quiet?
 
-      def as_action?
-        @as_action
-      end
+      job = Job.new({:suite => suite,
+                     :quiet => quiet
+      })
 
-      def call_times(times)
-        return @action.call(times) if @call_loop
+      job_opts = {}
+      job_opts[:time] = time unless time.nil?
+      job_opts[:warmup] = warmup unless warmup.nil?
 
-        act = @action
+      job.config job_opts
 
-        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
+      yield job
 
-    # 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
+      $stdout.puts "Calculating -------------------------------------" unless quiet
 
-    quiet = suite && !suite.quiet?
+      job.run_warmup
 
-    job = IPSJob.new
-    yield job
+      $stdout.puts "-------------------------------------------------" unless quiet
 
-    reports = []
+      job.run
 
-    timing = {}
+      $stdout.sync = sync
 
-    $stdout.puts "Calculating -------------------------------------" unless quiet
-
-    job.list.each do |item|
-      suite.warming item.label, warmup if suite
-
-      Timing.clean_env
-
-      unless 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
-
-      timing[item] = cycles_per_100ms
-
-      $stdout.printf "%10d i/100ms\n", cycles_per_100ms unless quiet
-
-      suite.warmup_stats warmup_time, cycles_per_100ms if suite
-    end
-
-    $stdout.puts "-------------------------------------------------" unless quiet
-
-    job.list.each do |item|
-      unless quiet
-        if item.label.size > 20
-          $stdout.print "#{item.label}\n#{' ' * 20}"
-        else
-          $stdout.print item.label.rjust(20)
-        end
-      end
-
-      Timing.clean_env
-
-      suite.running item.label, time if suite
-
-      iter = 0
-
-      target = Time.now + time
-
-      measurements = []
-
-      cycles_per_100ms = timing[item]
-
-      while Time.now < target
-        before = Time.now
-        item.call_times cycles_per_100ms
-        after = Time.now
-
-        # If for some reason the timing said this too no time (O_o)
-        # then ignore the iteration entirely and start another.
-        #
-        m = ((after.to_f - before.to_f) * 1_000_000.0)
-        next if m <= 0.0
-
-        iter += cycles_per_100ms
-
-        measurements << m
+      if job.compare?
+        job.run_comparison
       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}" unless quiet
-
-      suite.add_report rep, caller(1).first if suite
-
-      reports << rep
+      return job.full_report
     end
-
-    $stdout.sync = sync
-
-    if job.compare
-      Benchmark.compare(*reports)
-    end
-
-    return reports
   end
 
-
-  module_function :ips
+  extend Benchmark::IPS
 end

data/lib/benchmark/ips/job.rb

@@ -0,0 +1,243 @@
+module Benchmark
+  module IPS
+    class Job
+
+      MICROSECONDS_PER_100MS = 100_000
+      MICROSECONDS_PER_SECOND = 1_000_000
+
+      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 label_rjust
+          if @label.size > 20
+            "#{@label}\n#{' ' * 20}"
+          else
+            @label.rjust(20)
+          end
+        end
+
+        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
+
+      # An array of 2-element arrays, consisting of label and block pairs.
+      attr_reader :list
+
+      # Boolean determining whether to run comparison utility
+      attr_reader :compare
+
+      # Report object containing information about the run
+      attr_reader :full_report
+
+      attr_accessor :warmup, :time
+      attr_reader :timing
+
+      def initialize opts={}
+        @suite = opts[:suite] || nil
+        @quiet = opts[:quiet] || false
+        @list = []
+        @compare = false
+
+        @timing = {}
+        @full_report = Report.new
+
+        # defaults
+        @warmup = 2
+        @time = 5
+      end
+
+      def config opts
+        @warmup = opts[:warmup] if opts[:warmup]
+        @time = opts[:time] if opts[:time]
+      end
+
+      def compare?
+        @compare
+      end
+
+      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 ArgumentError, "specify a block and a str, but not both"
+        end
+
+        action = str || blk
+        raise ArgumentError, "no block or string" unless action
+
+        @list.push Entry.new(label, action)
+        self
+      end
+      alias_method :report, :item
+
+      # calculate the cycles needed to run for approx 100ms
+      # given the number of iterations to run the given time
+      def cycles_per_100ms time_msec, iters
+        cycles = ((MICROSECONDS_PER_100MS / time_msec) * iters).to_i
+        cycles = 1 if cycles <= 0
+        cycles
+      end
+
+      # calculate the difference in microseconds between
+      # before and after
+      def time_us before, after
+        (after.to_f - before.to_f) * MICROSECONDS_PER_SECOND
+      end
+
+      # calculate the interations per second given the number
+      # of cycles run and the time in microseconds that elapsed
+      def iterations_per_sec cycles, time_us
+        MICROSECONDS_PER_SECOND * (cycles.to_f / time_us.to_f)
+      end
+
+      def run_warmup
+        @list.each do |item|
+          @suite.warming item.label, @warmup if @suite
+
+          unless @quiet
+            $stdout.printf item.label_rjust
+          end
+
+          Timing.clean_env
+
+          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_us = time_us before, after
+
+          @timing[item] = cycles_per_100ms warmup_time_us, warmup_iter
+
+          $stdout.printf "%10d i/100ms\n", @timing[item] unless @quiet
+
+          @suite.warmup_stats warmup_time_us, @timing[item] if @suite
+        end
+      end
+
+      def run
+        @list.each do |item|
+          @suite.running item.label, @time if @suite
+
+          unless @quiet
+            $stdout.print item.label_rjust
+          end
+
+          Timing.clean_env
+
+          iter = 0
+
+          target = Time.now + @time
+
+          measurements_us = []
+
+          # running this number of cycles should take around 100ms
+          cycles = @timing[item]
+
+          while Time.now < target
+            before = Time.now
+            item.call_times cycles
+            after = Time.now
+
+            # If for some reason the timing said this took no time (O_o)
+            # then ignore the iteration entirely and start another.
+            #
+            iter_us = time_us before, after
+            next if iter_us <= 0.0
+
+            iter += cycles
+
+            measurements_us << iter_us
+          end
+
+          measured_us = measurements_us.inject(0) { |a,i| a + i }
+
+          all_ips = measurements_us.map { |time_us|
+            iterations_per_sec cycles, time_us
+          }
+
+          avg_ips = Timing.mean(all_ips)
+          sd_ips =  Timing.stddev(all_ips).round
+
+          rep = create_report(item, measured_us, iter, avg_ips, sd_ips, cycles)
+
+          $stdout.puts " #{rep.body}" unless @quiet
+
+          @suite.add_report rep, caller(1).first if @suite
+        end
+      end
+
+      def run_comparison
+        @full_report.run_comparison
+      end
+
+      def create_report(item, measured_us, iter, avg_ips, sd_ips, cycles)
+        @full_report.add_entry item.label, measured_us, iter, avg_ips, sd_ips, cycles
+      end
+
+    end
+  end
+end

data/lib/benchmark/ips/report.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+module Benchmark
+  module IPS
+    class Report
+
+      class Entry
+
+        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" % [@iterations, runtime])
+        end
+
+        def header
+          @label.rjust(20)
+        end
+
+        def to_s
+          "#{header} #{body}"
+        end
+
+        def display
+          $stdout.puts to_s
+        end
+      end
+
+      attr_reader :entries
+
+      def initialize
+        @entries = []
+      end
+
+      def add_entry label, microseconds, iters, ips, ips_sd, measurement_cycle
+        @entries << Entry.new(label, microseconds, iters, ips, ips_sd, measurement_cycle)
+        @entries.last
+      end
+
+      def run_comparison
+        Benchmark.compare(*@entries)
+      end
+
+    end
+  end
+end

data/test/test_benchmark_ips.rb

@@ -1,8 +1,8 @@
-require "test/unit"
+require "minitest/autorun"
 require "benchmark/ips"
 require "stringio"
 
-class TestBenchmarkIPS < Test::Unit::TestCase
+class TestBenchmarkIPS < Minitest::Test
   def setup
     @old_stdout = $stdout
     $stdout = StringIO.new
@@ -13,14 +13,60 @@ class TestBenchmarkIPS < Test::Unit::TestCase
   end
 
   def test_ips
-    reports = Benchmark.ips(1,1) do |x|
-      x.report("sleep") { sleep(0.25) }
+    report = Benchmark.ips do |x|
+      x.config(:time => 1, :warmup => 1)
+      x.report("sleep 0.25") { sleep(0.25) }
+      x.report("sleep 0.05") { sleep(0.05) }
+      x.compare!
     end
 
-    rep = reports.first
+    rep1 = report.entries[0]
+    rep2 = report.entries[1]
 
-    assert_equal "sleep", rep.label
+    assert_equal "sleep 0.25", rep1.label
+    assert_equal 4, rep1.iterations
+    assert_in_delta 4.0, rep1.ips, 0.2
+
+    assert_equal "sleep 0.05", rep2.label
+    assert_equal 20, rep2.iterations
+    assert_in_delta 20.0, rep2.ips, 1.0
+  end
+
+  def test_ips_alternate_config
+    report = Benchmark.ips do |x|
+      x.time = 1
+      x.warmup = 1
+      x.report("sleep 0.25") { sleep(0.25) }
+    end
+
+    rep = report.entries.first
+
+    assert_equal "sleep 0.25", rep.label
     assert_equal 4, rep.iterations
     assert_in_delta 4.0, rep.ips, 0.2
   end
+
+  def test_ips_old_config
+    report = Benchmark.ips(1,1) do |x|
+      x.report("sleep 0.25") { sleep(0.25) }
+    end
+
+    rep = report.entries.first
+
+    assert_equal "sleep 0.25", rep.label
+    assert_equal 4, rep.iterations
+    assert_in_delta 4.0, rep.ips, 0.2
+  end
+
+  def test_ips_defaults
+    report = Benchmark.ips do |x|
+      x.report("sleep 0.25") { sleep(0.25) }
+    end
+
+    rep = report.entries.first
+
+    assert_equal "sleep 0.25", rep.label
+    assert_equal 4*5, rep.iterations
+    assert_in_delta 4.0, rep.ips, 0.2
+  end
 end

metadata

@@ -1,109 +1,105 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: benchmark-ips
-version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: 
-  segments: 
-  - 1
-  - 2
-  - 0
-  version: 1.2.0
+version: !ruby/object:Gem::Version
+  version: 2.0.0
 platform: ruby
-authors: 
+authors:
 - Evan Phoenix
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-03-27 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rdoc
+date: 2014-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 19
-        segments: 
-        - 3
-        - 10
-        version: "3.10"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
   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: 35
-        segments: 
-        - 2
-        - 16
-        version: "2.16"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
   type: :development
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
 description: A iterations per second enhancement to Benchmark
-email: 
+email:
 - evan@phx.io
-executables: 
-- benchmark_ips
+executables: []
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - History.txt
 - Manifest.txt
-- README.txt
-files: 
-- .autotest
+- README.md
+files:
+- ".autotest"
+- ".gemtest"
 - History.txt
 - Manifest.txt
-- README.txt
+- README.md
 - Rakefile
-- bin/benchmark_ips
 - lib/benchmark/compare.rb
 - lib/benchmark/helpers.rb
 - lib/benchmark/ips.rb
+- lib/benchmark/ips/job.rb
+- lib/benchmark/ips/report.rb
 - lib/benchmark/timing.rb
 - test/test_benchmark_ips.rb
-- .gemtest
 homepage: http://github.com/evanphx/benchmark-ips
-licenses: []
-
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --main
-- README.txt
-require_paths: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  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
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: benchmark-ips
-rubygems_version: 1.8.21
+rubyforge_project: 
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A iterations per second enhancement to Benchmark
-test_files: 
+test_files:
 - test/test_benchmark_ips.rb

data/bin/benchmark_ips

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