motion-benchmark-ips 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14cfdbe4568670fda3739ecd7a9837aa0b21a7c7
+  data.tar.gz: 550e6b910b78289a5b525450ed4ad0238e1b2e82
+SHA512:
+  metadata.gz: 9acf976811223997ed734be9570a30e188b5282374fab9215d0028e12034106143464de40d3b1e144cc3bfb55b1f95f912a6d103d1f1181a776c77c118feca01
+  data.tar.gz: d00d71ba9fd3abdfaade152324a6b390099d5e5881be137ce8b856818d66f89edf64bcd10d90f19db13c6da9d14837aec4bda464c81a7e73d3f46857fd5128f6

data/README.md

@@ -0,0 +1,44 @@
+# motion-benchmark-ips
+
+Provides iteration per second benchmarking for RubyMotion.
+The original is https://github.com/evanphx/benchmark-ips.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'motion-benchmark-ips'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motion-benchmark-ips
+
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2014 Watson
+
+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/lib/motion-benchmark-ips.rb

@@ -0,0 +1,8 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "project/**/*.rb")))
+end

data/lib/project/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/project/ips.rb

@@ -0,0 +1,265 @@
+# encoding: utf-8
+# require 'benchmark/timing'
+# require 'benchmark/compare'
+
+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
+      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 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
+
+    # 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
+
+    quiet = suite && !suite.quiet?
+
+    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
+      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
+      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
+    end
+
+    $stdout.sync = sync
+
+    if job.compare
+      Benchmark.compare(*reports)
+    end
+
+    return reports
+  end
+
+
+  module_function :ips
+end

data/lib/project/timing.rb

@@ -0,0 +1,40 @@
+module Benchmark
+  module Timing
+    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

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: motion-benchmark-ips
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Watson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides iteration per second benchmarking for RubyMotion
+email:
+- watson1978@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/motion-benchmark-ips.rb
+- lib/project/compare.rb
+- lib/project/ips.rb
+- lib/project/timing.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Provides iteration per second benchmarking for RubyMotion
+test_files: []