benchkit 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: de0a1955c6cac87008f7aa70b13796dd35b47431
+  data.tar.gz: 0b04577f70fd7835cdb0b7930d6cf9a9259bf771
+SHA512:
+  metadata.gz: a17a1b3fb5ab065164d17e2a95ad1f001912cf61ccddf6109ddd7ae0917af62dd390e8cb4713a2f3216a767a044a21c6f78f4ff66d2ab5a4af506a2b92c70375
+  data.tar.gz: 2e59277b92fa9bf5689445aef98783da640a754959a57a360b964b1dae174b517097aeb0cfe302b77bcef0a2c15fc0cde14431df5e967b58ed5c411bb800df53

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.travis.yml

@@ -0,0 +1,11 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.4
+script:
+  - bundle exec rake
+
+  # Test some options
+  - bundle exec exe/benchmark_driver ruby_benchmark_set/example_single.yml -e ruby1::ruby -e ruby2::ruby -i
+  - bundle exec exe/benchmark_driver ruby_benchmark_set/example_single.yml -e ruby1::ruby -e ruby2::ruby -i 2

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in benchmark_driver.gemspec
+gemspec
+
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Takashi Kokubun
+
+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/README.md

@@ -0,0 +1,171 @@
+# Benchkit [![Build Status](https://travis-ci.org/k0kubun/benchmark_driver.svg?branch=master)](https://travis-ci.org/k0kubun/benchmark_driver)
+
+Benchmark driver for different Ruby executables
+
+## Installation
+
+    $ gem install benchmark_driver
+
+## Usage
+
+```
+$ exe/benchmark_driver -h
+Usage: benchmark_driver [options] [YAML]
+    -e, --executables [EXECS]        Ruby executables (e1::path1; e2::path2; e3::path3;...)
+    -i, --ips [SECONDS]              Measure IPS in duration seconds (default: 1)
+    -l, --loop-count [COUNT]         Measure execution time with loop count (default: 100000)
+    -v, --verbose
+```
+
+### Running single script
+
+With following `example_single.yml`,
+
+```yml
+prelude: |
+  require 'erb'
+  erb = ERB.new(%q[Hello <%= 'World' %>])
+benchmark: erb.result
+```
+
+you can benchmark the script with multiple ruby executables.
+
+```
+$ exe/benchmark_driver ruby_benchmark_set/example_single.yml -e ruby1::ruby -e ruby2::ruby
+benchmark results:
+Execution time (sec)
+name             ruby1    ruby2
+example_single   0.958    0.972
+
+Speedup ratio: compare with the result of `ruby1' (greater is better)
+name             ruby2
+example_single   0.986
+```
+
+And you can change benchmark output to IPS (iteration per second) by `-i` option.
+
+```
+$ exe/benchmark_driver ruby_benchmark_set/example_single.yml -e ruby1::ruby -e ruby2::ruby -i
+Result -------------------------------------------
+                         ruby1          ruby2
+  example_single   99414.1 i/s    99723.3 i/s
+
+Comparison: example_single
+           ruby2:      99723.3 i/s
+           ruby1:      99414.1 i/s - 1.00x slower
+```
+
+### Running multiple scripts
+
+One YAML file can contain multiple benchmark scripts.
+With following `example_multi.yml`,
+
+```yml
+prelude: |
+  a = 'a' * 100
+  b = 'b' * 100
+benchmarks:
+  - name: join
+    benchmark: |
+      [a, b].join
+  - name: interpolation
+    benchmark: |
+      "#{a}#{b}"
+```
+
+you can benchmark the scripts with multiple ruby executables.
+
+```
+$ exe/benchmark_driver ruby_benchmark_set/example_multi.yml -e ruby1::ruby -e ruby2::ruby
+benchmark results:
+Execution time (sec)
+name             ruby1    ruby2
+join             0.022    0.022
+interpolation    0.026    0.026
+
+Speedup ratio: compare with the result of `ruby1' (greater is better)
+name             ruby2
+join             1.045
+interpolation    1.002
+```
+
+```
+$ exe/benchmark_driver ruby_benchmark_set/example_multi.yml -e ruby1::ruby -e ruby2::ruby -i
+Result -------------------------------------------
+                         ruby1          ruby2
+            join 4701954.3 i/s  4639520.3 i/s
+   interpolation 4263170.0 i/s  4044083.0 i/s
+
+Comparison: join
+           ruby1:    4701954.3 i/s
+           ruby2:    4639520.3 i/s - 1.01x slower
+
+Comparison: interpolation
+           ruby1:    4263170.0 i/s
+           ruby2:    4044083.0 i/s - 1.05x slower
+```
+
+### Configuring modes
+
+There are 2 modes:
+
+- Loop count: Enabled by `-l`. Optionally you can change count to loop by `-l COUNT`.
+- IPS: Enabled by `-i`. Optionally you can change duration by `-i DURATION`.
+
+Specifying both `-l` and `-i` is nonsense.
+
+### YAML syntax
+You can specify `benchmark:` or `benchmarks:`.
+
+#### Single
+```yml
+name: String # optional (default: file name)
+prelude: String # optional
+loop_count: Integer # optional
+benchmark: String # required
+```
+
+#### Multi
+
+```yml
+prelude: String # optional (shared)
+loop_count: Integer # optional (shared)
+benchmarks:
+  - name: String # required
+    prelude: String # optional (benchmark specific)
+    loop_count: Integer # optional (benchmark specific)
+    benchmark: String # required
+```
+
+### Debugging
+
+If you have a trouble like an unexpectedly fast result, you should check benchmark script by `-v`.
+
+```
+$ exe/benchmark_driver ruby_benchmark_set/example_multi.yml -v
+--- Running "join" with "ruby" 957780 times ---
+a = 'a' * 100
+b = 'b' * 100
+
+
+i = 0
+while i < 957780
+  i += 1
+[a, b].join
+
+end
+```
+
+## TODO
+
+- Measure multiple times and use minimum result
+- Retry and reject negative result in ips mode
+- Change not to take long time for iteration count estimation in ips mode
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/k0kubun/benchmark_driver.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/gem_tasks'
+
+desc 'Run benchmarks in ruby_benchmark_set'
+task :ruby_benchmark_set do
+  require 'bundler'
+  require 'shellwords'
+
+  Dir.glob(File.expand_path('./ruby_benchmark_set/**/*.yml', __dir__)).sort.each do |path|
+    Bundler.with_clean_env do
+      sh [File.expand_path('./exe/benchmark_driver', __dir__), path].shelljoin
+    end
+  end
+end
+
+task default: :ruby_benchmark_set

data/benchkit.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'benchkit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'benchkit'
+  spec.version       = Benchkit::VERSION
+  spec.authors       = ['Takashi Kokubun']
+  spec.email         = ['takashikkbn@gmail.com']
+
+  spec.summary       = %q{Benchmark driver}
+  spec.description   = %q{Benchmark driver}
+  spec.homepage      = 'https://github.com/k0kubun/benchmark_driver'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "benchmark_driver"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/benchkit

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path('../lib', __dir__)
+
+require 'benchkit'
+require 'optparse'
+require 'yaml'
+
+options = {}
+args = OptionParser.new do |o|
+  o.banner = "Usage: #{File.basename($0, '.*')} [options] [YAML]"
+  o.on('-e', '--executables [EXECS]', 'Ruby executables (e1::path1; e2::path2; e3::path3;...)') do |e|
+    options[:execs] ||= []
+    e.split(/;/).each do |path|
+      options[:execs] << path
+    end
+  end
+  o.on('-i [DURATION]', '--ips [SECONDS]', "Measure IPS in duration seconds (default: #{Benchkit::DEFAULT_IPS_DURATION})") do |i|
+    options[:measure_type] = 'ips'
+    options[:measure_num]  = Integer(i) if i
+  end
+  o.on('-l [COUNT]', '--loop-count [COUNT]', "Measure execution time with loop count (default: #{Benchkit::DEFAULT_LOOP_COUNT})") do |l|
+    options[:measure_type] = 'loop_count'
+    options[:measure_num]  = l if l
+  end
+  o.on('-v', '--verbose') do |v|
+    options[:verbose] = v
+  end
+end.parse!(ARGV)
+abort "No YAML file is specified" if args.empty?
+
+driver = Benchkit.new(options)
+args.each do |yaml|
+  default = { name: File.basename(yaml, '.*') }
+  driver.run(default.merge(YAML.load(File.read(yaml))))
+end

data/lib/benchkit/version.rb

@@ -0,0 +1,3 @@
+class Benchkit
+  VERSION = '0.2.0'
+end

data/lib/benchkit.rb

@@ -0,0 +1,273 @@
+require 'benchkit/version'
+require 'benchmark'
+require 'tempfile'
+
+class Benchkit
+  MEASURE_TYPES = %w[loop_count ips]
+  DEFAULT_LOOP_COUNT = 100_000
+  DEFAULT_IPS_DURATION = 1
+
+  # @param [String] measure_type - "loop_count"|"ips"
+  # @param [Integer,nil] measure_num - Loop count for "loop_type", duration seconds for "ips"
+  # @param [Array<String>] execs - ["path1", "path2"] or `["ruby1::path1", "ruby2::path2"]`
+  # @param [Boolean] verbose
+  def initialize(measure_type: 'loop_count', measure_num: nil, execs: ['ruby'], verbose: false)
+    unless MEASURE_TYPES.include?(measure_type)
+      abort "unsupported measure type: #{measure_type.dump}"
+    end
+    @measure_type = measure_type
+    @measure_num = measure_num
+    @execs = execs.map do |exec|
+      name, path = exec.split('::', 2)
+      Executable.new(name, path || name)
+    end
+    @verbose = verbose
+  end
+
+  # @param [Hash] root_hash
+  def run(root_hash)
+    root = BenchmarkRoot.new(Hash[root_hash.map { |k, v| [k.to_sym, v] }])
+
+    results = root.benchmarks.map do |benchmark|
+      metrics_by_exec = {}
+      iterations = calc_iterations(@execs.first, benchmark)
+      @execs.each do |exec|
+        if @verbose
+          puts "--- Running #{benchmark.name.dump} with #{exec.name.dump} #{iterations} times ---"
+          puts "#{benchmark.benchmark_script(iterations)}\n"
+        end
+        elapsed_time = run_benchmark(exec, benchmark, iterations)
+        metrics_by_exec[exec] = BenchmarkMetrics.new(iterations, elapsed_time)
+      end
+      BenchmarkResult.new(benchmark.name, metrics_by_exec)
+    end
+    puts if @verbose
+
+    case @measure_type
+    when 'loop_count'
+      LoopCountReporter.report(@execs, results)
+    when 'ips'
+      IpsReporter.report(@execs, results)
+    else
+      raise "unexpected measure type: #{@measure_type.dump}"
+    end
+  end
+
+  private
+
+  # Estimate iterations to finish benchmark within `@duration`.
+  def calc_iterations(exec, benchmark)
+    case @measure_type
+    when 'loop_count'
+      @measure_num || benchmark.loop_count || DEFAULT_LOOP_COUNT
+    when 'ips'
+      # TODO: Change to try from 1, 10, 100 ...
+      base = 1000
+      time = run_benchmark(exec, benchmark, base)
+      duration = @measure_num || DEFAULT_IPS_DURATION
+      (duration / time * base).to_i
+    else
+      raise "unexpected measure type: #{@measure_type.dump}"
+    end
+  end
+
+  def run_benchmark(exec, benchmark, iterations)
+    # TODO: raise error if negative
+    measure_script(exec.path, benchmark.benchmark_script(iterations)) -
+      measure_script(exec.path, benchmark.overhead_script(iterations))
+  end
+
+  def measure_script(ruby, script)
+    Tempfile.create(File.basename(__FILE__)) do |f|
+      f.write(script)
+      f.close
+
+      cmd = "#{ruby} #{f.path}"
+      Benchmark.measure { system(cmd, out: File::NULL) }.real
+    end
+  end
+
+  class BenchmarkRoot
+    # @param [String] name
+    # @param [String] prelude
+    # @param [Integer,nil] loop_count
+    # @param [String,nil]  benchmark  - For running single instant benchmark
+    # @param [Array<Hash>] benchmarks - For running multiple benchmarks
+    def initialize(name:, prelude: '', loop_count: nil, benchmark: nil, benchmarks: [])
+      if benchmark
+        unless benchmarks.empty?
+          raise ArgumentError.new("Only either :benchmark or :benchmarks can be specified")
+        end
+        @benchmarks = [BenchmarkScript.new(name: name, prelude: prelude, benchmark: benchmark)]
+      else
+        @benchmarks = benchmarks.map do |hash|
+          BenchmarkScript.new(Hash[hash.map { |k, v| [k.to_sym, v] }]).tap do |b|
+            b.inherit_root(prelude: prelude, loop_count: loop_count)
+          end
+        end
+      end
+    end
+
+    # @return [Array<BenchmarkScript>]
+    attr_reader :benchmarks
+  end
+
+  class BenchmarkScript
+    # @param [String] name
+    # @param [String] prelude
+    # @param [String] benchmark
+    def initialize(name:, prelude: '', loop_count: nil, benchmark:)
+      @name = name
+      @prelude = prelude
+      @loop_count = loop_count
+      @benchmark = benchmark
+    end
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Integer]
+    attr_reader :loop_count
+
+    def inherit_root(prelude:, loop_count:)
+      @prelude = "#{prelude}\n#{@prelude}"
+      if @loop_count.nil? && loop_count
+        @loop_count = loop_count
+      end
+    end
+
+    def overhead_script(iterations)
+      <<-RUBY
+#{@prelude}
+i = 0
+while i < #{iterations}
+  i += 1
+end
+      RUBY
+    end
+
+    def benchmark_script(iterations)
+      <<-RUBY
+#{@prelude}
+i = 0
+while i < #{iterations}
+  i += 1
+#{@benchmark}
+end
+      RUBY
+    end
+  end
+
+  class BenchmarkResult < Struct.new(
+    :name,            # @param [String]
+    :metrics_by_exec, # @param [Hash{ Executable => BenchmarkMetrics }]
+  )
+    def iterations_of(exec)
+      metrics_by_exec.fetch(exec).iterations
+    end
+
+    def elapsed_time_of(exec)
+      metrics_by_exec.fetch(exec).elapsed_time
+    end
+
+    def ips_of(exec)
+      iterations_of(exec) / elapsed_time_of(exec)
+    end
+  end
+
+  class BenchmarkMetrics < Struct.new(
+    :iterations,   # @param [Integer]
+    :elapsed_time, # @param [Float] - Elapsed time in seconds
+  )
+  end
+
+  class Executable < Struct.new(
+    :name, # @param [String]
+    :path, # @param [String]
+  )
+  end
+
+  module LoopCountReporter
+    class << self
+      # @param [Array<Executable>] execs
+      # @param [Array<BenchmarkResult>] results
+      def report(execs, results)
+        puts "benchmark results:"
+        puts "Execution time (sec)"
+        puts "#{'%-16s' % 'name'} #{execs.map { |e| "%-8s" % e.name }.join(' ')}"
+
+        results.each do |result|
+          print '%-16s ' % result.name
+          puts execs.map { |exec|
+            "%-8s" % ("%.3f" % result.elapsed_time_of(exec))
+          }.join(' ')
+        end
+        puts
+
+        if execs.size > 1
+          report_speedup(execs, results)
+        end
+      end
+
+      private
+
+      def report_speedup(execs, results)
+        compared = execs.first
+        rest = execs - [compared]
+
+        puts "Speedup ratio: compare with the result of `#{compared.name}' (greater is better)"
+        puts "#{'%-16s' % 'name'} #{rest.map { |e| "%-8s" % e.name }.join(' ')}"
+        results.each do |result|
+          print '%-16s ' % result.name
+          puts rest.map { |exec|
+            "%-8s" % ("%.3f" % (result.ips_of(exec) / result.ips_of(compared)))
+          }.join(' ')
+        end
+        puts
+      end
+    end
+  end
+
+  module IpsReporter
+    class << self
+      # @param [Array<Executable>] execs
+      # @param [Array<BenchmarkResult>] results
+      def report(execs, results)
+        puts "Result -------------------------------------------"
+        puts "#{' ' * 16} #{execs.map { |e| "%13s" % e.name }.join('  ')}"
+
+        results.each do |result|
+          print '%16s ' % result.name
+          puts execs.map { |exec|
+            "%13s" % ("%.1f i/s" % result.ips_of(exec))
+          }.join('  ')
+        end
+        puts
+
+        if execs.size > 1
+          compare(execs, results)
+        end
+      end
+
+      private
+
+      def compare(execs, results)
+        results.each do |result|
+          puts "Comparison: #{result.name}"
+
+          sorted = execs.sort_by { |e| -result.ips_of(e) }
+          first = sorted.first
+
+          sorted.each do |exec|
+            if exec == first
+              puts "%16s: %12s i/s" % [first.name, "%.1f" % result.ips_of(first)]
+            else
+              puts "%16s: %12s i/s - %.2fx slower" % [exec.name, "%.1f" % result.ips_of(exec), result.ips_of(first) / result.ips_of(exec)]
+            end
+          end
+          puts
+        end
+      end
+    end
+  end
+end

data/ruby_benchmark_set/core/array.yml

@@ -0,0 +1,4 @@
+benchmarks:
+  - name: bm_vm2_array
+    benchmark: a = [1,2,3,4,5,6,7,8,9,10]
+    loop_count: 6000000

data/ruby_benchmark_set/example_multi.yml

@@ -0,0 +1,10 @@
+prelude: |
+  a = 'a' * 100
+  b = 'b' * 100
+benchmarks:
+  - name: join
+    benchmark: |
+      [a, b].join
+  - name: interpolation
+    benchmark: |
+      "#{a}#{b}"

data/ruby_benchmark_set/example_single.yml

@@ -0,0 +1,4 @@
+prelude: |
+  require 'erb'
+  erb = ERB.new(%q[Hello <%= 'World' %>])
+benchmark: erb.result

data/ruby_benchmark_set/lib/erb.yml

@@ -0,0 +1,30 @@
+prelude: |
+  require 'erb'
+
+  template = <<EOS
+  <html>
+    <head> <%= title %> </head>
+    <body>
+      <h1> <%= title %> </h1>
+      <p>
+        <%= content %>
+      </p>
+    </body>
+  </html>
+  EOS
+
+  title = "hello world!"
+  content = "hello world!\n" * 10
+
+benchmarks:
+  - name: ERB compiling
+    benchmark: ERB.new(template)
+    loop_count: 10000
+
+  - name: ERB rendering
+    prelude: |
+      src = "def self.render(title, content); #{ERB.new(template).src}; end"
+      mod = Module.new
+      mod.instance_eval(src, "(ERB)")
+    benchmark: mod.render(title, content)
+    loop_count: 100000

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: benchkit
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Takashi Kokubun
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !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: Benchmark driver
+email:
+- takashikkbn@gmail.com
+executables:
+- benchkit
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchkit.gemspec
+- bin/console
+- bin/setup
+- exe/benchkit
+- lib/benchkit.rb
+- lib/benchkit/version.rb
+- ruby_benchmark_set/core/array.yml
+- ruby_benchmark_set/example_multi.yml
+- ruby_benchmark_set/example_single.yml
+- ruby_benchmark_set/lib/erb.yml
+homepage: https://github.com/k0kubun/benchmark_driver
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Benchmark driver
+test_files: []