motion-benchmark-ips 1.0 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14cfdbe4568670fda3739ecd7a9837aa0b21a7c7
-  data.tar.gz: 550e6b910b78289a5b525450ed4ad0238e1b2e82
+  metadata.gz: f60f433abf07be7027a49a2e7be67f9178e698ec
+  data.tar.gz: ae5e787909b978f143876b944d7631d875ed553d
 SHA512:
-  metadata.gz: 9acf976811223997ed734be9570a30e188b5282374fab9215d0028e12034106143464de40d3b1e144cc3bfb55b1f95f912a6d103d1f1181a776c77c118feca01
-  data.tar.gz: d00d71ba9fd3abdfaade152324a6b390099d5e5881be137ce8b856818d66f89edf64bcd10d90f19db13c6da9d14837aec4bda464c81a7e73d3f46857fd5128f6
+  metadata.gz: 1d90bd772df7e71967ea4d98a7e29d6fb229164da138a7a9104f68560fc62e7d4f0e5eba5497e401a447d93f9bbfa7fa0d6b3a71bf3e15128c012c9799834e9f
+  data.tar.gz: 6d4d4d8a635935c70cedbe1aeb48324f190f8449d21715074a9e212d2e32a53e4acad127b579f1e05a2a7f65407687f8b21c29a9dcc00bff77a35bf832d4efec

data/README.md

@@ -18,10 +18,36 @@ Or install it yourself as:
     $ gem install motion-benchmark-ips
 
 
+## Usage
+```
+Benchmark.ips do |x|
+  # 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
+      i += 1
+    end
+  end
+end
+```
+
+## Premium Support
+
+[motion-benchmark-ips](https://github.com/infinitered/motion-benchmark-ips), as an open source project, is free to use and always will be. [Infinite Red](https://infinite.red/) offers premium motion-benchmark-ips support and general mobile app design/development services. Email us at [hello@infinite.red](mailto:hello@infinite.red) to get in touch with us for more details.
+
+
 ## LICENSE:
 
 (The MIT License)
 
+```
 Copyright (c) 2014 Watson
 
 Permission is hereby granted, free of charge, to any person obtaining
@@ -42,3 +68,4 @@ 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/lib/project/compare.rb

@@ -1,41 +1,76 @@
+# encoding: utf-8
+
 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
+  # Functionality of performaing comparison between reports.
+  #
+  # Usage:
+  #
+  # Add +x.compare!+ to perform comparison between reports.
+  #
+  # Example:
+  #   > Benchmark.ips do |x|
+  #     x.report('Reduce using tag')     { [*1..10].reduce(:+) }
+  #     x.report('Reduce using to_proc') { [*1..10].reduce(&:+) }
+  #     x.compare!
+  #   end
+  #
+  #   Calculating -------------------------------------
+  #       Reduce using tag     19216 i/100ms
+  #   Reduce using to_proc     17437 i/100ms
+  #   -------------------------------------------------
+  #       Reduce using tag   278950.0 (±8.5%) i/s -    1402768 in   5.065112s
+  #   Reduce using to_proc   247295.4 (±8.0%) i/s -    1238027 in   5.037299s
+  #
+  #   Comparison:
+  #       Reduce using tag:   278950.0 i/s
+  #   Reduce using to_proc:   247295.4 i/s - 1.13x slower
+  #
+  # Besides regular Calculating report, this will also indicates which one is slower.
+  module Compare
 
-    best = sorted.shift
+    # Compare between reports, prints out facts of each report:
+    # runtime, comparative speed difference.
+    # @param entries [Array<Report::Entry>] Reports to compare.
+    def compare(*entries)
+      return if entries.size < 2
 
-    STDOUT.puts "\nComparison:"
+      sorted = entries.sort_by{ |e| e.stats.central_tendency }.reverse
 
-    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
+
+      $stdout.puts "\nComparison:"
+
+      $stdout.printf "%20s: %10.1f i/s\n", best.label, best.stats.central_tendency
 
-    sorted.each do |report|
-      name = report.label
+      sorted.each do |report|
+        name = report.label.to_s
 
-      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"
+        $stdout.printf "%20s: %10.1f i/s - ", name, report.stats.central_tendency
+
+        best_low = best.stats.central_tendency - best.stats.error
+        report_high = report.stats.central_tendency + report.stats.error
+        overlaps = report_high > best_low
+
+        if overlaps
+          $stdout.print "same-ish: difference falls within error"
+        else
+          slowdown, error = report.stats.slowdown(best.stats)
+          $stdout.printf "%.2fx ", slowdown
+          if error
+            $stdout.printf " (± %.2f)", error
+          end
+          $stdout.print " slower"
+        end
+
+        $stdout.puts
       end
-    end
 
-    STDOUT.puts
+      footer = best.stats.footer
+      $stdout.puts footer.rjust(40) if footer
+
+      $stdout.puts
+    end
   end
 
-  module_function :compare
+  extend Benchmark::Compare
 end

data/lib/project/ips.rb

@@ -1,265 +1,96 @@
 # encoding: utf-8
-# require 'benchmark/timing'
-# require 'benchmark/compare'
-
+# Performance benchmarking library
 module Benchmark
-
-  class IPSReport
-    VERSION = "1.1.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" % [@iterations, runtime])
-    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
+  # Benchmark in iterations per second, no more guessing!
+  # @see https://github.com/evanphx/benchmark-ips
+  module IPS
+
+    # Benchmark-ips Gem version.
+    VERSION = "2.7.2"
+
+    # CODENAME of current version.
+    CODENAME = "Cultivating Confidence"
+
+    # Measure code in block, each code's benchmarked result will display in
+    # iteration per second with standard deviation in given time.
+    # @param time [Integer] Specify how long should benchmark your code in seconds.
+    # @param warmup [Integer] Specify how long should Warmup time run in seconds.
+    # @return [Report]
+    def ips(*args)
+      if args[0].is_a?(Hash)
+        time, warmup, quiet = args[0].values_at(:time, :warmup, :quiet)
+      else
+        time, warmup, quiet = args
       end
 
-      attr_reader :label, :action
+      suite = nil
 
-      def as_action?
-        @as_action
-      end
+      sync, $stdout.sync = $stdout.sync, true
 
-      def call_times(times)
-        return @action.call(times) if @call_loop
-
-        act = @action
-
-        i = 0
-        while i < times
-          act.call
-          i += 1
-        end
+      if defined? Benchmark::Suite and Suite.current
+        suite = Benchmark::Suite.current
       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
+      quiet ||= (suite && suite.quiet?)
 
-    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 ArgumentError, "specify a block and a str, but not both"
-      end
+      job = Job.new({:suite => suite,
+                     :quiet => quiet
+      })
 
-      action = str || blk
-      raise ArgumentError, "no block or string" unless action
+      job_opts = {}
+      job_opts[:time] = time unless time.nil?
+      job_opts[:warmup] = warmup unless warmup.nil?
 
-      @list.push Entry.new(label, action)
-      self
-    end
+      job.config job_opts
 
-    alias_method :report, :item
+      yield job
 
-    # An array of 2-element arrays, consisting of label and block pairs.
-    attr_reader :list
-  end
+      job.load_held_results if job.hold? && job.held_results?
 
-  def ips(time=5, warmup=2)
-    suite = nil
+      job.run
 
-    sync, $stdout.sync = $stdout.sync, true
-
-    if defined? Benchmark::Suite and Suite.current
-      suite = Benchmark::Suite.current
-    end
+      $stdout.sync = sync
+      job.run_comparison
+      job.generate_json
 
-    quiet = suite && !suite.quiet?
+      report = job.full_report
 
-    job = IPSJob.new
-    yield job
-
-    reports = []
-
-    timing = {}
-
-    $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
+      if ENV['SHARE'] || ENV['SHARE_URL']
+        require 'benchmark/ips/share'
+        share = Share.new report, job
+        share.share
       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
+      report
     end
 
-    $stdout.puts "-------------------------------------------------" unless quiet
+    # Set options for running the benchmarks.
+    # :format => [:human, :raw]
+    #    :human format narrows precision and scales results for readability
+    #    :raw format displays 6 places of precision and exact iteration counts
+    def self.options
+      @options ||= {:format => :human}
+    end
 
-    job.list.each do |item|
-      unless quiet
-        if item.label.size > 20
-          $stdout.print "#{item.label}\n#{' ' * 20}"
+    module Helpers
+      def scale(value)
+        scale = (Math.log10(value) / 3).to_i
+        suffix = case scale
+        when 1; 'k'
+        when 2; 'M'
+        when 3; 'B'
+        when 4; 'T'
+        when 5; 'Q'
         else
-          $stdout.print item.label.rjust(20)
+          # < 1000 or > 10^15, no scale or suffix
+          scale = 0
+          ' '
         end
+        "%10.3f#{suffix}" % (value.to_f / (1000 ** scale))
       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
-      end
-
-      measured_us = measurements.inject(0) { |a,i| a + i }
-
-      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
+      module_function :scale
     end
-
-    $stdout.sync = sync
-
-    if job.compare
-      Benchmark.compare(*reports)
-    end
-
-    return reports
   end
 
-
-  module_function :ips
+  extend Benchmark::IPS # make ips available as module-level method
 end