benchmark_driver 0.8.6 → 0.9.0

data/lib/benchmark/driver/bundle_installer.rb

@@ -1,45 +0,0 @@
-require 'pathname'
-
-# TODO: Support Windows... This depends on availability of which(1)
-module Benchmark::Driver::BundleInstaller
-  class << self
-    # @param [Benchmark::Driver::Configuration::Executable] executable
-    def bundle_install_for(executable)
-      ruby_path = IO.popen(['which', executable.command.first], &:read).rstrip
-      unless $?.success?
-        abort "#{executable.command.first.dump} command was not found to execute `bundle install`"
-      end
-
-      bundler_path = Pathname.new(ruby_path).dirname.join('bundle')
-      unless bundler_path.executable?
-        abort "#{bundler_path.to_s.dump} was not a bundler executable, whose path was guessed from #{ruby_path.dump}"
-      end
-      bundle = bundler_path.to_s
-
-      Bundler.with_clean_env do
-        bundle_check(bundle, ruby: executable.name) || bundle_install(bundle)
-      end
-    end
-
-    private
-
-    # @param [String] bundle - full path to bundle(1)
-    # @param [String] ruby - name of ruby
-    # @return [TrueClass,FalseClass] - true if success
-    def bundle_check(bundle, ruby:)
-      output = IO.popen([bundle, 'check'], &:read)
-      $?.success?.tap do |success|
-        unless success
-          $stderr.puts("For #{ruby}:")
-          $stderr.print(output)
-        end
-      end
-    end
-
-    # @param [String] bundle - full path to bundle(1)
-    def bundle_install(bundle)
-      pid = Process.spawn(bundle, 'install', '-j', ENV.fetch('BUNDLE_JOBS', '4'))
-      Process.wait(pid)
-    end
-  end
-end

data/lib/benchmark/driver/bundler.rb

@@ -1,12 +0,0 @@
-# This module can be transparently run even if Bundler is not installed
-module Benchmark::Driver::Bundler
-  def self.with_clean_env(&block)
-    begin
-      require 'bundler'
-    rescue LoadError
-      block.call # probably bundler is not used
-    else
-      ::Bundler.with_clean_env { block.call }
-    end
-  end
-end

data/lib/benchmark/driver/configuration.rb

@@ -1,77 +0,0 @@
-# @param [Array<Benchmark::Driver::Configuration::Job>] jobs
-# @param [Benchmark::Driver::Configuration::RunnerOptions] runner_options
-# @param [Benchmark::Driver::Configuration::OutputOptions] output_options
-class Benchmark::Driver::Configuration < Struct.new(:jobs, :runner_options, :output_options)
-  # @param [String,nil] name
-  # @param [String,Proc] sctipt
-  # @param [String,nil] prelude
-  # @param [Integer,nil] loop_count - If this is nil, loop count is automatically estimated by warmup.
-  Job = Struct.new(:name, :script, :prelude, :loop_count) do
-    # @param [Integer,nil] guessed_count - Set by runner only when loop_count is nil. This is not configuration.
-    attr_accessor :guessed_count
-
-    def warmup_needed?
-      # This needs to check original configuration
-      self[:loop_count].nil?
-    end
-
-    def loop_count
-      self[:loop_count] || guessed_count
-    end
-  end
-
-  # @param [String] name
-  # @param [Array<String>] command - ["ruby", "-w", ...]. First element should be path to ruby command
-  Executable = Struct.new(:name, :command) do
-    def self.parse(name_path)
-      name, path = name_path.split('::', 2)
-      Benchmark::Driver::Configuration::Executable.new(name, path ? path.split(',') : [name])
-    end
-
-    def self.parse_rbenv(spec)
-      version, *args = spec.split(',')
-      path = `RBENV_VERSION='#{version}' rbenv which ruby`.rstrip
-      abort "Failed to execute 'rbenv which ruby'" unless $?.success?
-      Benchmark::Driver::Configuration::Executable.new(version, [path, *args])
-    end
-  end
-
-  DEFAULT_EXECUTABLES = [Executable.new(RUBY_VERSION, [RbConfig.ruby])]
-
-  # @param [Symbol] type - Type of runner
-  # @param [Array<Benchmark::Driver::Configuration::Executable>] executables
-  # @param [Integer,nil] repeat_count - Times to repeat benchmarks. When this is not nil, benchmark_driver will use the best result.
-  RunnerOptions = Struct.new(:type, :executables, :repeat_count, :bundler) do
-    def initialize(*)
-      super
-      self.executables ||= DEFAULT_EXECUTABLES
-    end
-
-    def executables_specified?
-      executables != DEFAULT_EXECUTABLES
-    end
-  end
-
-  # @param [Symbol] type - Type of output
-  # @param [TrueClass,FalseClass] compare
-  OutputOptions = Struct.new(:type, :compare)
-
-  # @param [Object] config
-  def self.symbolize_keys!(config)
-    case config
-    when Hash
-      config.keys.each do |key|
-        config[key.to_sym] = symbolize_keys!(config.delete(key))
-      end
-    when Array
-      config.map! { |c| symbolize_keys!(c) }
-    end
-    config
-  end
-
-  # @param [String] str
-  def self.camelize(str)
-    return str if str !~ /_/ && str =~ /[A-Z]+.*/
-    str.split('_').map { |e| e.capitalize }.join
-  end
-end

data/lib/benchmark/driver/duration_runner.rb

@@ -1,24 +0,0 @@
-class Benchmark::Driver::DurationRunner
-  # @param [Benchmark::Driver::Configuration::Job] job
-  def initialize(job)
-    @job = job
-  end
-
-  # @param [Integer,Float] seconds
-  # @param [Integer] unit_iters
-  # @param [Proc] runner - should take (job, unit_iters) and return duration.
-  # @return [Benchmark::Driver::BenchmarkResult]
-  def run(seconds:, unit_iters:, runner:)
-    real_time  = 0.0
-    iterations = 0
-    unit_iters = unit_iters.to_i
-
-    benchmark_until = Benchmark::Driver::Time.now + seconds
-    while Benchmark::Driver::Time.now < benchmark_until
-      real_time  += runner.call(@job, unit_iters)
-      iterations += unit_iters
-    end
-
-    Benchmark::Driver::BenchmarkResult.new(@job, iterations, real_time)
-  end
-end

data/lib/benchmark/driver/error.rb

@@ -1,16 +0,0 @@
-module Benchmark::Driver
-  class Error < StandardError
-  end
-
-  class ExecutionTimeTooShort < Error
-    def initialize(job, iterations)
-      @job = job
-      @iterations = iterations
-    end
-
-    def message
-      "Execution time of job #{@job.name.dump} was too short in #{@iterations} executions;\n  "\
-        'Please retry, try slower script or increase loop_count.'
-    end
-  end
-end

data/lib/benchmark/driver/repeatable_runner.rb

@@ -1,18 +0,0 @@
-class Benchmark::Driver::RepeatableRunner
-  # @param [Benchmark::Driver::Configuration::Job] job
-  def initialize(job)
-    @job = job
-  end
-
-  # @param [Integer] repeat_count
-  # @param [Proc] runner - should take (job, unit_iters) and return duration.
-  # @return [Benchmark::Driver::BenchmarkResult]
-  def run(repeat_count:, runner:)
-    real_times = (repeat_count || 1).times.map do
-      runner.call(@job, @job.loop_count)
-    end
-    Benchmark::Driver::BenchmarkResult.new(@job).tap do |result|
-      result.real = real_times.select { |d| d > 0 }.min || real_times.max
-    end
-  end
-end

data/lib/benchmark/driver/ruby_dsl_parser.rb

@@ -1,78 +0,0 @@
-require 'benchmark/driver/configuration'
-
-class Benchmark::Driver::RubyDslParser
-  # @param [Symbol,nil] runner - If this is nil, this is automatically decided by Benchmark::Driver#runner_type_for
-  # @param [Symbol] output
-  def initialize(runner: nil, output: :ips)
-    @prelude = nil
-    @loop_count = nil
-    @jobs = []
-    @runner = runner
-    @execs = nil
-    @bundler = false
-    @output = output
-    @compare = false
-  end
-
-  # API to fetch configuration parsed from DSL
-  # @return [Benchmark::Driver::Configuration]
-  def configuration
-    @jobs.each do |job|
-      job.prelude = @prelude
-      job.loop_count = @loop_count
-    end
-    Benchmark::Driver::Configuration.new(@jobs).tap do |c|
-      c.runner_options = Benchmark::Driver::Configuration::RunnerOptions.new(@runner, @execs, nil, @bundler)
-      c.output_options = Benchmark::Driver::Configuration::OutputOptions.new(@output, @compare)
-    end
-  end
-
-  # @param [String] prelude_script - Script required for benchmark whose execution time is not measured.
-  def prelude(prelude_script)
-    unless prelude_script.is_a?(String)
-      raise ArgumentError.new("prelude must be String but got #{prelude_script.inspect}")
-    end
-    unless @prelude.nil?
-      raise ArgumentError.new("prelude is already set:\n#{@prelude}")
-    end
-
-    @prelude = prelude_script
-  end
-
-  # @param [Array<String>] specs
-  def rbenv(*specs)
-    @execs ||= []
-    specs.each do |spec|
-      @execs << Benchmark::Driver::Configuration::Executable.parse_rbenv(spec)
-    end
-  end
-
-  def bundler
-    @bundler = true
-  end
-
-  # @param [String,nil] name   - Name shown on result output. This must be provided if block is given.
-  # @param [String,nil] script - Benchmarked script in String. Only either of script or block must be provided.
-  # @param [Proc,nil]   block  - Benchmarked Proc object.
-  def report(name = nil, script = nil, &block)
-    if !script.nil? && block_given?
-      raise ArgumentError.new('script and block cannot be specified at the same time')
-    elsif name.nil? && block_given?
-      raise ArgumentError.new('name must be specified if block is given')
-    elsif !name.nil? && !name.is_a?(String)
-      raise ArgumentError.new("name must be String but got #{name.inspect}")
-    elsif !script.nil? && !script.is_a?(String)
-      raise ArgumentError.new("script must be String but got #{script.inspect}")
-    end
-
-    @jobs << Benchmark::Driver::Configuration::Job.new(name, script || block || name)
-  end
-
-  def compare!
-    @compare = true
-  end
-
-  def loop_count(count)
-    @loop_count = count
-  end
-end

data/lib/benchmark/driver/time.rb

@@ -1,12 +0,0 @@
-module Benchmark::Driver::Time
-  if defined?(Process::CLOCK_MONOTONIC)
-    def self.now
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-  else
-    $stderr.puts "Process::CLOCK_MONOTONIC was unavailable. Using Time."
-    def self.now
-      ::Time.now
-    end
-  end
-end

data/lib/benchmark/driver/version.rb

@@ -1,5 +0,0 @@
-module Benchmark
-  module Driver
-    VERSION = '0.8.6'
-  end
-end

data/lib/benchmark/driver/yaml_parser.rb

@@ -1,55 +0,0 @@
-module Benchmark::Driver::YamlParser
-  class << self
-    # @param [String] prelude
-    # @param [Integer,nil] loop_count
-    # @param [String,Array<String,Hash{ Symbol => String }>,Hash{ Symbol => String }] benchmark
-    # @return [Array<Benchmark::Driver::Configuration::Job>]
-    def parse(prelude: '', loop_count: nil, benchmark:)
-      jobs = parse_benchmark(benchmark)
-      jobs.each do |job|
-        job.prelude = prelude
-        job.loop_count ||= loop_count
-      end
-    end
-
-    private
-
-    # Parse "benchmark" declarative. This may have multiple benchmarks.
-    # @param [String,Array<String,Hash{ Symbol => String }>,Hash{ Symbol => String }] benchmark
-    def parse_benchmark(benchmark)
-      case benchmark
-      when String
-        [parse_each_benchmark(benchmark)]
-      when Array
-        benchmark.map { |b| parse_each_benchmark(b) }
-      when Hash
-        benchmark.map do |key, value|
-          Benchmark::Driver::Configuration::Job.new(key.to_s, value)
-        end
-      else
-        raise ArgumentError.new("benchmark must be String, Array or Hash, but got: #{benchmark.inspect}")
-      end
-    end
-
-    # Parse one benchmark specified in "benchmark" declarative.
-    # @param [String,Hash{ Symbol => String }>] job
-    def parse_each_benchmark(benchmark)
-      case benchmark
-      when String
-        Benchmark::Driver::Configuration::Job.new(benchmark, benchmark)
-      when Hash
-        parse_job(benchmark)
-      else
-        raise ArgumentError.new("Expected String or Hash in element of benchmark, but got: #{benchmark.inspect}")
-      end
-    end
-
-    # @param [String,nil] name
-    # @param [String] script
-    # TODO: support benchmark-specific prelude
-    def parse_job(name: nil, script:)
-      name = script if name.nil?
-      Benchmark::Driver::Configuration::Job.new(name, script)
-    end
-  end
-end

data/lib/benchmark/output.rb

@@ -1,20 +0,0 @@
-module Benchmark::Output
-  class << self
-    # Benchmark::Output is pluggable.
-    # Create `Benchmark::Output::FooBar` as benchmark-output-foo_bar.gem and specify `output: foo_bar`.
-    #
-    # @param [Symbol] name
-    def find(name)
-      class_name = Benchmark::Driver::Configuration.camelize(name.to_s)
-      unless Benchmark::Output.const_defined?("#{class_name}::REQUIRED_FIELDS")
-        require "benchmark/output/#{name}"
-      end
-      Benchmark::Output.const_get(class_name, false)
-    end
-  end
-end
-
-require 'benchmark/output/ips'
-require 'benchmark/output/markdown'
-require 'benchmark/output/memory'
-require 'benchmark/output/time'

data/lib/benchmark/output/ips.rb

@@ -1,143 +0,0 @@
-class Benchmark::Output::Ips
-  # This class requires runner to measure following fields in `Benchmark::Driver::BenchmarkResult` to show output.
-  REQUIRED_FIELDS = [:real]
-
-  NAME_LENGTH = 20
-
-  # @param [Array<Benchmark::Driver::Configuration::Job>] jobs
-  # @param [Array<Benchmark::Driver::Configuration::Executable>] executables
-  # @param [Benchmark::Driver::Configuration::OutputOptions] options
-  def initialize(jobs:, executables:, options:)
-    @jobs        = jobs
-    @executables = executables
-    @options     = options
-    @results     = []
-    @name_by_result = {}
-  end
-
-  def start_warming
-    $stdout.puts 'Warming up --------------------------------------'
-  end
-
-  # @param [String] name
-  def warming(name)
-    if name.length > NAME_LENGTH
-      $stdout.puts(name)
-    else
-      $stdout.print("%#{NAME_LENGTH}s" % name)
-    end
-  end
-
-  # @param [Benchmark::Driver::BenchmarkResult] result
-  def warmup_stats(result)
-    $stdout.puts "#{humanize(result.ip100ms)} i/100ms"
-  end
-
-  def start_running
-    $stdout.puts 'Calculating -------------------------------------'
-    if @executables.size > 1
-      $stdout.print(' ' * NAME_LENGTH)
-      @executables.each do |executable|
-        $stdout.print(" %10s " % executable.name)
-      end
-      $stdout.puts
-    end
-  end
-
-  def running(name)
-    warming(name)
-    @row_results = []
-  end
-
-  # @param [Benchmark::Driver::BenchmarkResult] result
-  def benchmark_stats(result)
-    executable = @executables[@row_results.size]
-    $stdout.print("#{humanize(result.ips, [10, executable.name.length].max)} ")
-
-    @results << result
-    @row_results << result
-    if @row_results.size == @executables.size
-      $stdout.print("i/s - #{humanize(result.iterations)} in")
-      @row_results.each do |r|
-        $stdout.print(" %3.6fs" % r.real)
-      end
-      if @row_results.size == 1
-        sec = @row_results[0].real
-        iter = result.iterations
-        if File.exist?('/proc/cpuinfo') && (clks = estimate_clock(sec, iter)) < 1_000
-          $stdout.print(" (#{pretty_sec(sec, iter)}/i, #{clks}clocks/i)")
-        else
-          $stdout.print(" (#{pretty_sec(sec, iter)}/i)")
-        end
-      end
-      $stdout.puts
-    end
-
-    @name_by_result[result] = executable.name
-  end
-
-  def finish
-    if @results.size > 1 && @options.compare
-      compare
-    end
-  end
-
-  private
-
-  def humanize(value, width = 10)
-    scale = (Math.log10(value) / 3).to_i
-    suffix =
-      case scale
-      when 1; 'k'
-      when 2; 'M'
-      when 3; 'G'
-      when 4; 'T'
-      when 5; 'Q'
-      else # < 1000 or > 10^15, no scale or suffix
-        scale = 0
-        ' '
-      end
-    "%#{width}.3f#{suffix}" % (value.to_f / (1000 ** scale))
-  end
-
-  def pretty_sec sec, iter
-    r = Rational(sec, iter)
-    case
-    when r >= 1
-      "#{'%3.2f' % r.to_f}s"
-    when r >= 1/1000r
-      "#{'%3.2f' % (r * 1_000).to_f}ms"
-    when r >= 1/1000_000r
-      "#{'%3.2f' % (r * 1_000_000).to_f}us"
-    else
-      "#{'%3.2f' % (r * 1_000_000_000).to_f}ns"
-    end
-  end
-
-  def estimate_clock sec, iter
-    hz = File.read('/proc/cpuinfo').scan(/cpu MHz\s+:\s+([\d\.]+)/){|(f)| break hz = Rational(f.to_f) * 1_000_000}
-    r = Rational(sec, iter)
-    Integer(r/(1/hz))
-  end
-
-  def compare
-    $stdout.puts("\nComparison:")
-    results = @results.sort_by { |r| -r.ips }
-    first   = results.first
-
-    results.each do |result|
-      if result == first
-        slower = ''
-      else
-        slower = '- %.2fx  slower' % (first.ips / result.ips)
-      end
-
-      name = result.job.name
-      if @executables.size > 1
-        name = "#{name} (#{@name_by_result.fetch(result)})"
-      end
-      $stdout.puts("%#{NAME_LENGTH}s: %11.1f i/s #{slower}" % [name, result.ips])
-    end
-    $stdout.puts
-  end
-end