motion-benchmark-ips 1.0 → 1.1

data/lib/project/ips/report.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+module Benchmark
+  module IPS
+
+    # Report contains benchmarking entries.
+    # Perform operations like add new entry, run comparison between entries.
+    class Report
+
+      # Represents benchmarking code data for Report.
+      class Entry
+        # Instantiate the Benchmark::IPS::Report::Entry.
+        # @param [#to_s] label Label of entry.
+        # @param [Integer] us Measured time in microsecond.
+        # @param [Integer] iters Iterations.
+        # @param [Object] stats Statistics.
+        # @param [Integer] cycles Number of Cycles.
+        def initialize(label, us, iters, stats, cycles)
+          @label = label
+          @microseconds = us
+          @iterations = iters
+          @stats = stats
+          @measurement_cycle = cycles
+          @show_total_time = false
+        end
+
+        # Label of entry.
+        # @return [String] the label of entry.
+        attr_reader :label
+
+        # Measured time in microsecond.
+        # @return [Integer] number of microseconds.
+        attr_reader :microseconds
+
+        # Number of Iterations.
+        # @return [Integer] number of iterations.
+        attr_reader :iterations
+
+        # Statistical summary of samples.
+        # @return [Object] statisical summary.
+        attr_reader :stats
+
+        # LEGACY: Iterations per second.
+        # @return [Float] number of iterations per second.
+        def ips
+          @stats.central_tendency
+        end
+
+        # LEGACY: Standard deviation of iteration per second.
+        # @return [Float] standard deviation of iteration per second.
+        def ips_sd
+          @stats.error
+        end
+
+        # Number of Cycles.
+        # @return [Integer] number of cycles.
+        attr_reader :measurement_cycle
+
+        # Control if the total time the job took is reported.
+        # Typically this value is not significant because it's very
+        # close to the expected time, so it's supressed by default.
+        def show_total_time!
+          @show_total_time = true
+        end
+
+        # Return entry's microseconds in seconds.
+        # @return [Float] +@microseconds+ in seconds.
+        def seconds
+          @microseconds.to_f / 1_000_000.0
+        end
+
+        # Return entry's standard deviation of iteration per second in percentage.
+        # @return [Float] +@ips_sd+ in percentage.
+        def error_percentage
+          100.0 * (@stats.error.to_f / @stats.central_tendency)
+        end
+
+        alias_method :runtime, :seconds
+
+        # Return Entry body text with left padding.
+        # Body text contains information of iteration per second with
+        # percentage of standard deviation, iterations in runtime.
+        # @return [String] Left justified body.
+        def body
+          case Benchmark::IPS.options[:format]
+          when :human
+            left = "%s (±%4.1f%%) i/s" % [Helpers.scale(@stats.central_tendency), error_percentage]
+            iters = Helpers.scale(@iterations)
+
+            if @show_total_time
+              left.ljust(20) + (" - %s in %10.6fs" % [iters, runtime])
+            else
+              left.ljust(20) + (" - %s" % iters)
+            end
+          else
+            left = "%10.1f (±%.1f%%) i/s" % [@stats.central_tendency, error_percentage]
+
+            if @show_total_time
+              left.ljust(20) + (" - %10d in %10.6fs" % [@iterations, runtime])
+            else
+              left.ljust(20) + (" - %10d" % @iterations)
+            end
+          end
+        end
+
+        # Return header with padding if +@label+ is < length of 20.
+        # @return [String] Right justified header (+@label+).
+        def header
+          @label.to_s.rjust(20)
+        end
+
+        # Return string repesentation of Entry object.
+        # @return [String] Header and body.
+        def to_s
+          "#{header} #{body}"
+        end
+
+        # Print entry to current standard output ($stdout).
+        def display
+          $stdout.puts to_s
+        end
+      end # End of Entry
+
+      # class Report
+
+      # Entry to represent each benchmarked code in Report.
+      # @return [Array<Report::Entry>] Entries in Report.
+      attr_reader :entries
+
+      # Instantiate the Report.
+      def initialize
+        @entries = []
+        @data = nil
+      end
+
+      # Add entry to report.
+      # @param label [String] Entry label.
+      # @param microseconds [Integer] Measured time in microsecond.
+      # @param iters [Integer] Iterations.
+      # @param stats [Object] Statistical results.
+      # @param measurement_cycle [Integer] Number of cycles.
+      # @return [Report::Entry] Last added entry.
+      def add_entry label, microseconds, iters, stats, measurement_cycle
+        entry = Entry.new(label, microseconds, iters, stats, measurement_cycle)
+        @entries.delete_if { |e| e.label == label }
+        @entries << entry
+        entry
+      end
+
+      # Entries data in array for generate json.
+      # Each entry is a hash, consists of:
+      #   name:   Entry#label
+      #   ips:    Entry#ips
+      #   stddev: Entry#ips_sd
+      #   microseconds: Entry#microseconds
+      #   iterations:   Entry#iterations
+      #   cycles:       Entry#measurement_cycles
+      # @return [Array<Hash<Symbol,String|Float|Integer>] Array of hashes
+      def data
+        @data ||= @entries.collect do |entry|
+          {
+            :name => entry.label,
+            :central_tendency =>  entry.stats.central_tendency,
+            :ips =>  entry.stats.central_tendency, # for backwards compatibility
+            :error => entry.stats.error,
+            :stddev => entry.stats.error, # for backwards compatibility
+            :microseconds => entry.microseconds,
+            :iterations => entry.iterations,
+            :cycles => entry.measurement_cycle,
+          }
+        end
+      end
+
+      # Run comparison of entries.
+      def run_comparison
+        Benchmark.compare(*@entries)
+      end
+
+      # Generate json from Report#data to given path.
+      # @param path [String] path to generate json.
+      def generate_json(path)
+        File.open path, "w" do |f|
+          require "json"
+          f.write JSON.pretty_generate(data)
+        end
+      end
+    end
+  end
+end

data/lib/project/ips/stats/bootstrap.rb

@@ -0,0 +1,51 @@
+module Benchmark
+  module IPS
+    module Stats
+
+      class Bootstrap
+
+        attr_reader :data
+
+        def initialize(samples, confidence)
+          dependencies
+          @iterations = 10_000
+          @confidence = (confidence / 100.0).to_s
+          @data = Kalibera::Data.new({[0] => samples}, [1, samples.size])
+          interval = @data.bootstrap_confidence_interval(@iterations, @confidence)
+          @median = interval.median
+          @error = interval.error
+        end
+
+        def central_tendency
+          @median
+        end
+
+        def error
+          @error
+        end
+
+        def slowdown(baseline)
+          low, slowdown, high = baseline.data.bootstrap_quotient(@data, @iterations, @confidence)
+          error = Timing.mean([slowdown - low, high - slowdown])
+          [slowdown, error]
+        end
+
+        def footer
+          "with #{(@confidence.to_f * 100).round(1)}% confidence"
+        end
+
+        def dependencies
+          require 'kalibera'
+        rescue LoadError
+          puts
+          puts "Can't load the kalibera gem - this is required to use the :bootstrap stats options."
+          puts "It's optional, so we don't formally depend on it and it isn't installed along with benchmark-ips."
+          puts "You probably want to do something like 'gem install kalibera' to fix this."
+          abort
+        end
+
+      end
+
+    end
+  end
+end

data/lib/project/ips/stats/sd.rb

@@ -0,0 +1,33 @@
+module Benchmark
+  module IPS
+    module Stats
+
+      class SD
+
+        def initialize(samples)
+          @mean = Timing.mean(samples)
+          @error = Timing.stddev(samples, @mean).round
+        end
+
+        def central_tendency
+          @mean
+        end
+
+        def error
+          @error
+        end
+
+        def slowdown(baseline)
+          slowdown = baseline.central_tendency.to_f / central_tendency
+          [slowdown, nil]
+        end
+
+        def footer
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/project/timing.rb

@@ -1,10 +1,20 @@
 module Benchmark
+  # Perform caclulations on Timing results.
   module Timing
+    # Microseconds per second.
+    MICROSECONDS_PER_SECOND = 1_000_000
+
+    # Calculate (arithmetic) mean of given samples.
+    # @param [Array] samples Samples to calculate mean.
+    # @return [Float] Mean of given samples.
     def self.mean(samples)
-      sum = samples.inject(0) { |acc, i| acc + i }
+      sum = samples.inject(:+)
       sum / samples.size
     end
 
+    # Calculate variance of given samples.
+    # @param [Float] m Optional mean (Expected value).
+    # @return [Float] Variance of given samples.
     def self.variance(samples, m=nil)
       m ||= mean(samples)
 
@@ -13,21 +23,15 @@ module Benchmark
       total / samples.size
     end
 
+    # Calculate standard deviation of given samples.
+    # @param [Array] samples Samples to calculate standard deviation.
+    # @param [Float] m Optional mean (Expected value).
+    # @return [Float] standard deviation of given samples.
     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
-
+    # Recycle used objects by starting Garbage Collector.
     def self.clean_env
       # rbx
       if GC.respond_to? :run
@@ -36,5 +40,41 @@ module Benchmark
         GC.start
       end
     end
+
+    # Use a monotonic clock if available, otherwise use Time
+    begin
+    ## RubyMotion has not supported Process.clock_gettime
+    #   Process.clock_gettime Process::CLOCK_MONOTONIC, :float_microsecond
+
+    #   # Get an object that represents now and can be converted to microseconds
+    #   def self.now
+    #     Process.clock_gettime Process::CLOCK_MONOTONIC, :float_microsecond
+    #   end
+
+    #   # Add one second to the time represenetation
+    #   def self.add_second(t, s)
+    #     t + (s * MICROSECONDS_PER_SECOND)
+    #   end
+
+    #   # Return the number of microseconds between the 2 moments
+    #   def self.time_us(before, after)
+    #     after - before
+    #   end
+    # rescue NameError
+      # Get an object that represents now and can be converted to microseconds
+      def self.now
+        Time.now
+      end
+
+      # Add one second to the time represenetation
+      def self.add_second(t, s)
+        t + s
+      end
+
+      # Return the number of microseconds between the 2 moments
+      def self.time_us(before, after)
+        (after.to_f - before.to_f) * MICROSECONDS_PER_SECOND
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motion-benchmark-ips
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: '1.1'
 platform: ruby
 authors:
 - Watson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-24 00:00:00.000000000 Z
+date: 2017-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -35,8 +35,14 @@ files:
 - lib/motion-benchmark-ips.rb
 - lib/project/compare.rb
 - lib/project/ips.rb
+- lib/project/ips/job.rb
+- lib/project/ips/job/entry.rb
+- lib/project/ips/job/stdout_report.rb
+- lib/project/ips/report.rb
+- lib/project/ips/stats/bootstrap.rb
+- lib/project/ips/stats/sd.rb
 - lib/project/timing.rb
-homepage: ''
+homepage: https://github.com/Watson1978/motion-benchmark-ips
 licenses:
 - MIT
 metadata: {}
@@ -56,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Provides iteration per second benchmarking for RubyMotion