benchmark-ips 2.3.0 → 2.11.0

data/lib/benchmark/compare.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Benchmark
   # Functionality of performaing comparison between reports.
   #
@@ -24,46 +26,80 @@ module Benchmark
   #   Reduce using to_proc:   247295.4 i/s - 1.13x slower
   #
   # Besides regular Calculating report, this will also indicates which one is slower.
+  #
+  # +x.compare!+ also takes an +order: :baseline+ option.
+  #
+  # Example:
+  #  > Benchmark.ips do |x|
+  #   x.report('Reduce using block')   { [*1..10].reduce { |sum, n| sum + n } }
+  #   x.report('Reduce using tag')     { [*1..10].reduce(:+) }
+  #   x.report('Reduce using to_proc') { [*1..10].reduce(&:+) }
+  #   x.compare!(order: :baseline)
+  # end
+  #
+  # Calculating -------------------------------------
+  #   Reduce using block    886.202k (± 2.2%) i/s -      4.521M in   5.103774s
+  #     Reduce using tag      1.821M (± 1.6%) i/s -      9.111M in   5.004183s
+  # Reduce using to_proc    895.948k (± 1.6%) i/s -      4.528M in   5.055368s
+  #
+  # Comparison:
+  #   Reduce using block:   886202.5 i/s
+  #     Reduce using tag:  1821055.0 i/s - 2.05x  (± 0.00) faster
+  # Reduce using to_proc:   895948.1 i/s - same-ish: difference falls within error
+  #
+  # The first report is considered the baseline against which other reports are compared.
   module Compare
 
     # Compare between reports, prints out facts of each report:
     # runtime, comparative speed difference.
-    # @param reports [Array<Report>] Reports to compare.
-    def compare(*reports)
-      return if reports.size < 2
+    # @param entries [Array<Report::Entry>] Reports to compare.
+    def compare(*entries, order: :fastest)
+      return if entries.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
+      case order
+      when :baseline
+        baseline = entries.shift
+        sorted = entries.sort_by{ |e| e.stats.central_tendency }.reverse
+      when :fastest
+        sorted = entries.sort_by{ |e| e.stats.central_tendency }.reverse
+        baseline = sorted.shift
+      else
+        raise ArgumentError, "Unknwon order: #{order.inspect}"
       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
+      $stdout.printf "%20s: %10.1f i/s\n", baseline.label.to_s, baseline.stats.central_tendency
 
       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
+        $stdout.printf "%20s: %10.1f i/s - ", name, report.stats.central_tendency
+
+        if report.stats.overlaps?(baseline.stats)
+          $stdout.print "same-ish: difference falls within error"
+        elsif report.stats.central_tendency > baseline.stats.central_tendency
+          speedup, error = report.stats.speedup(baseline.stats)
+          $stdout.printf "%.2fx ", speedup
+          if error
+            $stdout.printf " (± %.2f)", error
+          end
+          $stdout.print " faster"
         else
-          x = "%.2f" % (report.ips.to_f / best.ips.to_f)
-          $stdout.puts "#{name.rjust(20)}: #{report.runtime}s - #{x}x slower"
+          slowdown, error = report.stats.slowdown(baseline.stats)
+          $stdout.printf "%.2fx ", slowdown
+          if error
+            $stdout.printf " (± %.2f)", error
+          end
+          $stdout.print " slower"
         end
+
+        $stdout.puts
       end
 
+      footer = baseline.stats.footer
+      $stdout.puts footer.rjust(40) if footer
+
       $stdout.puts
     end
   end

data/lib/benchmark/ips/job/entry.rb

@@ -0,0 +1,95 @@
+module Benchmark
+  module IPS
+    # Benchmark jobs.
+    class Job
+      # Entries in Benchmark Jobs.
+      class Entry
+        # Instantiate the Benchmark::IPS::Job::Entry.
+        # @param label [#to_s] Label of Benchmarked code.
+        # @param action [String, Proc] Code to be benchmarked.
+        # @raise [ArgumentError] Raises when action is not String or not responding to +call+.
+        def initialize(label, action)
+          @label = label
+
+          # We define #call_times on the singleton class of each Entry instance.
+          # That way, there is no polymorphism for `@action.call` inside #call_times.
+
+          if action.kind_of? String
+            compile_string action
+            @action = self
+          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
+              compile_block_with_manual_loop
+            else
+              compile_block
+            end
+          end
+        end
+
+        # The label of benchmarking action.
+        # @return [#to_s] Label of action.
+        attr_reader :label
+
+        # The benchmarking action.
+        # @return [String, Proc] Code to be called, could be String / Proc.
+        attr_reader :action
+
+        # Call action by given times.
+        # @param times [Integer] Times to call +@action+.
+        # @return [Integer] Number of times the +@action+ has been called.
+        def call_times(times)
+          raise '#call_times should be redefined per Benchmark::IPS::Job::Entry instance'
+        end
+
+        def compile_block
+          m = (class << self; self; end)
+          code = <<-CODE
+            def call_times(times)
+              act = @action
+
+              i = 0
+              while i < times
+                act.call
+                i += 1
+              end
+            end
+          CODE
+          m.class_eval code
+        end
+
+        def compile_block_with_manual_loop
+          m = (class << self; self; end)
+          code = <<-CODE
+            def call_times(times)
+              @action.call(times)
+            end
+          CODE
+          m.class_eval code
+        end
+
+        # Compile code into +call_times+ method.
+        # @param str [String] Code to be compiled.
+        # @return [Symbol] :call_times.
+        def compile_string(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
+    end
+  end
+end

data/lib/benchmark/ips/job/noop_report.rb

@@ -0,0 +1,27 @@
+module Benchmark
+  module IPS
+    class Job
+      class NoopReport
+        def start_warming
+        end
+
+        def start_running
+        end
+
+        def footer
+        end
+
+        def warming(a, b)
+        end
+
+        def warmup_stats(a, b)
+        end
+
+        def add_report(a, b)
+        end
+
+        alias_method :running, :warming
+      end
+    end
+  end
+end

data/lib/benchmark/ips/job/stdout_report.rb

@@ -0,0 +1,64 @@
+module Benchmark
+  module IPS
+    class Job
+      class StdoutReport
+        def initialize
+          @last_item = nil
+        end
+
+        def start_warming
+          $stdout.puts "Warming up --------------------------------------"
+        end
+
+        def start_running
+          $stdout.puts "Calculating -------------------------------------"
+        end
+
+        def warming(label, _warmup)
+          $stdout.print rjust(label)
+        end
+
+        def warmup_stats(_warmup_time_us, timing)
+          case format
+          when :human
+            $stdout.printf "%s i/100ms\n", Helpers.scale(timing)
+          else
+            $stdout.printf "%10d i/100ms\n", timing
+          end
+        end
+
+        alias_method :running, :warming
+
+        def add_report(item, caller)
+          $stdout.puts " #{item.body}"
+          @last_item = item
+        end
+
+        def footer
+          return unless @last_item
+          footer = @last_item.stats.footer
+          $stdout.puts footer.rjust(40) if footer
+        end
+
+        private
+
+        # @return [Symbol] format used for benchmarking
+        def format
+          Benchmark::IPS.options[:format]
+        end
+
+        # Add padding to label's right if label's length < 20,
+        # Otherwise add a new line and 20 whitespaces.
+        # @return [String] Right justified label.
+        def rjust(label)
+          label = label.to_s
+          if label.size > 20
+            "#{label}\n#{' ' * 20}"
+          else
+            label.rjust(20)
+          end
+        end
+      end
+    end
+  end
+end