benchmark_suite 0.8.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2011-04-05
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/benchmark
+lib/benchmark/compare.rb
+lib/benchmark/ips.rb
+lib/benchmark/suite-run.rb
+lib/benchmark/suite.rb
+lib/benchmark/timing.rb
+lib/benchmark_suite.rb
+test/test_benchmark_suite.rb

data/README.txt

@@ -0,0 +1,84 @@
+= benchmark_suite
+
+* http://github.com/evanphx/benchmark_suite
+
+== DESCRIPTION:
+
+A set of enhancements to the standard library benchmark.rb 
+
+== FEATURES/PROBLEMS:
+
+ * benchmark/ips - benchmarks a blocks iterations/second. For short snippits
+   of code, ips automatically figures out how many times to run the code
+   to get interesting data. No more guessing at random iteration counts!
+
+ * benchmark - a cli tool for running multiple benchmarks against
+   multiple rubies.
+
+
+== SYNOPSIS:
+
+require 'benchmark/ips'
+
+Benchmark.ips do
+  # Typical mode, runs the block as many times as it can
+  x.report("addition") { 1 + 2 }
+
+  # To reduce overhead, the number of iterations is passed in
+  # and the block must run the code the specific number of times.
+  # Used for when the workload is very small and any overhead
+  # introduces incorrectable errors.
+  x.report("addition2") do |times|
+    i = 0
+    while i < times
+      1 + 2
+    end
+  end
+
+  # To reduce overhead even more, grafts the code given into
+  # the loop that performs the iterations internally to reduce
+  # overhead. Typically not needed, use the |times| form instead.
+  x.report("addition3", "1 + 2")
+end
+
+== REQUIREMENTS:
+
+* ruby-ffi on MRI
+
+== INSTALL:
+
+* gem install benchmark-suite
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011 Evan Phoenix
+
+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/Rakefile

@@ -0,0 +1,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+Hoe.spec 'benchmark_suite' do
+  developer('Evan Phoenix', 'evan@fallingsnow.net')
+end
+
+# vim: syntax=ruby

data/bin/benchmark

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'tempfile'
+
+lib_path = File.expand_path("../../lib", __FILE__)
+
+$:.unshift lib_path
+
+require 'benchmark/suite'
+require 'benchmark/ips'
+
+targets = []
+extra = []
+at_end = false
+save = false
+
+compare_targets = []
+
+opt = OptionParser.new do |o|
+  o.on("-t", "--target TARGET", String,
+          "Use TARGET to compare against: r:ruby|r19:ruby19|x:rbx|j:jruby") do |t|
+    case t
+    when 'r', 'ruby'
+      targets << 'ruby'
+    when 'r19', 'ruby19'
+      targets << 'ruby19'
+    when 'x', 'rbx', 'rubinius'
+      targets << 'rbx'
+    when 'j', 'jruby'
+      targets << 'jruby'
+    else
+      # + disambiguates execution vs using a file
+      if t[0,1] == "+"
+        targets << t[1..-1]
+      elsif File.exists?(t)
+        begin
+          data = Marshal.load(File.read(t))
+          compare_targets << [t, data]
+        rescue TypeError
+          targets << t
+        end
+      else
+        targets << t
+      end
+    end
+  end
+
+  o.on("-p", "--profile", "Profile code while benchmarking (rbx only)") do
+    extra << "-Xprofile"
+  end
+
+  o.on("-e", "--end", "Report all stats after all suitse have run") do
+    at_end = true
+  end
+
+  o.on("-T OPTION", String, "Add more arguments to each target") do |t|
+    extra << t
+  end
+
+  o.on("-s", "--save PATH", String, "Save the results to a file") do |t|
+    save = t
+  end
+end
+
+opt.parse!
+
+if targets.empty?
+  targets << "ruby"
+end
+
+if save and targets.size > 1
+  STDOUT.puts "Save mode only available with one target."
+  exit 1
+end
+
+opts = []
+
+if at_end
+  opts << "--quiet"
+end
+
+results = targets.map do |t|
+  tf = Tempfile.new "benchmark"
+  tf.close
+  STDOUT.puts "=== #{t} ===" unless at_end
+
+  args = extra + ["-I#{lib_path}", "#{lib_path}/benchmark/suite-run.rb"]
+
+  args += opts
+  args << tf.path
+  args += ARGV
+
+  cmd, *rest = t.split(/\s+/)
+  args.unshift *rest
+
+  system cmd, *args
+
+  if $?.exitstatus != 0
+    puts "Error executing: #{cmd}"
+    nil
+  else
+    tf.open
+    [t, Marshal.load(tf.read)]
+  end
+end
+
+results.compact!
+
+if save
+  name, data = results.last
+
+  File.open save, "w" do |f|
+    f << Marshal.dump(data)
+  end
+
+  STDOUT.puts "[Saved results to '#{save}']"
+end
+
+if at_end
+  results.each do |name, suite|
+    STDOUT.puts "=== #{name} ==="
+    suite.display
+  end
+end
+
+results += compare_targets
+
+if results.size > 1
+  compared = Hash.new { |h,k| h[k] = [] }
+
+  results.each do |target, suite|
+    suite.reports.each do |name, reports|
+      reports.each do |rep|
+        compared["#{name}:#{rep.label}"] << [target, rep]
+      end
+    end
+  end
+
+  STDOUT.puts
+
+  compared.each do |name, reports|
+    if reports.size > 1
+      STDOUT.puts "Comparing #{name}:"
+
+      iter = false
+      sorted = reports.sort do |a,b|
+        if a[1].respond_to? :ips
+          iter = true
+          b[1].ips <=> a[1].ips
+        else
+          a[1].runtime <=> b[1].runtime
+        end
+      end
+
+      best_name, best_report = sorted.shift
+
+
+      if iter
+        STDOUT.printf "%20s: %10d i/s\n", best_name, best_report.ips
+      else
+        STDOUT.puts "#{best_name.rjust(20)}: #{best_report.runtime}s"
+      end
+
+      sorted.each do |entry|
+        name, report = entry
+        if iter
+          x = (best_report.ips.to_f / report.ips.to_f)
+          STDOUT.printf "%20s: %10d i/s - %.2fx slower\n", name, report.ips, x
+        else
+          x = "%.2f" % (report.ips.to_f / best_report.ips.to_f)
+          STDOUT.puts "#{name.rjust(20)}: #{report.runtime}s - #{x}x slower"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+# encoding: utf-8
+require 'benchmark/timing'
+require 'benchmark/compare'
+
+module Benchmark
+
+  class IPSReport
+    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 (cycle=%d)" % 
+                          [@iterations, runtime, @measurement_cycle])
+    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 ArgmentError, "specify a block and a str, but not both"
+      end
+
+      action = str || blk
+      raise ArgmentError, "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
+
+    job = IPSJob.new
+    yield job
+
+    start = Timing::TimeVal.new
+    cur = Timing::TimeVal.new
+
+    before = Timing::TimeVal.new
+    after = Timing::TimeVal.new
+
+    reports = []
+
+    job.list.each do |item|
+      suite.warming item.label, warmup if suite
+
+      Timing.clean_env
+
+      if !suite or !suite.quiet?
+        if item.label.size > 20
+          STDOUT.print "#{item.label}\n#{' ' * 20}"
+        else
+          STDOUT.print item.label.rjust(20)
+        end
+      end
+
+      before.update!
+      start.update!
+      cur.update!
+
+      warmup_iter = 0
+
+      until start.elapsed?(cur, warmup)
+        item.call_times(1)
+        warmup_iter += 1
+        cur.update!
+      end
+
+      after.update!
+
+      warmup_time = before.diff(after)
+
+      # calculate the time to run approx 100ms
+      
+      cycles_per_100ms = ((100_000 / warmup_time.to_f) * warmup_iter).to_i
+      cycles_per_100ms = 1 if cycles_per_100ms <= 0
+
+      suite.warmup_stats warmup_time, cycles_per_100ms if suite
+
+      Timing.clean_env
+
+      suite.running item.label, time if suite
+
+      iter = 0
+      start.update!
+      cur.update!
+
+      measurements = []
+
+      until start.elapsed?(cur, time)
+        before.update!
+        item.call_times cycles_per_100ms
+        after.update!
+
+        iter += cycles_per_100ms
+        cur.update!
+
+        measurements << before.diff(after)
+      end
+
+      measured_us = measurements.inject(0) { |a,i| a + i }
+
+      seconds = measured_us.to_f / 1_000_000.0
+
+      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}" if !suite or !suite.quiet?
+
+      suite.add_report rep, caller(1).first if suite
+
+      STDOUT.sync = sync
+
+      reports << rep
+    end
+
+    if job.compare
+      Benchmark.compare *reports
+    end
+  end
+
+
+  module_function :ips
+end

data/lib/benchmark/suite-run.rb

@@ -0,0 +1,31 @@
+require 'benchmark/suite'
+require 'optparse'
+
+quiet = false
+
+opts = OptionParser.new do |o|
+  o.on "-q", "--quiet" do
+    quiet = true
+  end
+end
+
+opts.parse!
+
+results = ARGV.shift
+
+suite = Benchmark::Suite.create do |s|
+  s.quiet! if quiet
+
+  ARGV.each do |f|
+    if File.directory?(f)
+      more = Dir["#{f}/**/{bench,bm}_*.rb"]
+      more.each do |x|
+        s.run x
+      end
+    else
+      s.run f
+    end
+  end
+end
+
+File.open(results, "w") { |f| f << Marshal.dump(suite) }

data/lib/benchmark/suite.rb

@@ -0,0 +1,125 @@
+require 'benchmark'
+
+module Benchmark
+  class Suite
+    def self.current
+      @current
+    end
+
+    def self.create
+      if block_given?
+        old = @current
+
+        begin
+          s = new
+          @current = s
+          yield s
+          return s
+        ensure
+          @current = old
+        end
+      else
+        @current = new
+      end
+    end
+
+    class SimpleReport
+      def initialize
+        @start = nil
+        @end = nil
+      end
+
+      attr_reader :start, :end
+    end
+
+    def initialize
+      @report = nil
+      @reports = {}
+      @order = []
+      @quiet = false
+    end
+
+    attr_reader :reports
+
+    def quiet!
+      @quiet = true
+    end
+
+    def quiet?
+      @quiet
+    end
+
+    def warming(label, sec)
+      return unless @verbose
+      STDOUT.print "#{label.rjust(20)} warmup: #{sec}s"
+    end
+
+    def warmup_stats(time, cycles)
+      return unless @verbose
+      STDOUT.print " time=#{time}us, cycles=#{cycles}."
+    end
+
+    def running(label, sec)
+      return unless @verbose
+      STDOUT.puts " running: #{sec}s..."
+    end
+
+    def add_report(rep, location)
+      if @report
+        @report << rep
+      else
+        @report = [rep]
+      end
+
+      @report_location = location
+    end
+
+    def run(file)
+      start = Time.now
+
+      begin
+        load file
+      rescue Exception => e
+        STDOUT.puts "\nError in #{file}:"
+        if e.respond_to? :render
+          e.render(STDERR)
+        else
+          STDOUT.puts e.backtrace
+        end
+        return
+      end
+
+      fin = Time.now
+
+      if @report
+        @reports[file] = @report
+        @report = nil
+      else
+        @reports[file] = SimpleReport.new(start, fin)
+      end
+
+      @order << file
+    end
+
+    def display
+      if @report
+        file = @report_location ? @report_location.split(":").first : "<unknown.rb>"
+        @order << file
+        @reports[file] = [@report]
+      end
+
+      @order.each do |file|
+        STDOUT.puts "#{file}:"
+        reports = @reports[file]
+
+        if reports.empty?
+          STDOUT.puts "  NO REPORTS FOUND"
+        else
+          reports.each do |rep|
+            STDOUT.puts "  #{rep}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/benchmark/timing.rb

@@ -0,0 +1,137 @@
+if !defined?(RUBY_ENGINE) or RUBY_ENGINE != "rbx"
+  require 'rubygems'
+end
+
+require 'ffi'
+
+module Benchmark
+  module Timing
+    extend FFI::Library
+
+    ffi_lib FFI::Library::LIBC
+
+    attach_function :gettimeofday, [:pointer, :pointer], :int
+
+    class TimeVal < FFI::Struct
+      layout :tv_sec, :time_t, :tv_usec, :suseconds_t
+
+      def sec
+        self[:tv_sec]
+      end
+
+      def usec
+        self[:tv_usec]
+      end
+
+      def update!
+        Timing.gettimeofday to_ptr, nil
+      end
+
+      def to_time
+        Time.at sec, usec
+      end
+
+      def <(tv)
+        return true if sec < tv.sec
+        return true if usec < tv.usec
+        return false
+      end
+
+      def ==(tv)
+        if sec == tv.sec and usec == tv.usec
+          return true
+        end
+        return false
+      end
+
+      def diff(tv)
+        if tv.sec == sec
+          return tv.usec - usec
+        end
+
+        sec_diff = tv.sec - sec
+
+        usec_diff = tv.usec - usec
+        if usec_diff < 0
+          sec_diff -= 1
+          usec_diff += 1_000_000
+        end
+
+        (sec_diff * 1_000_000) + usec_diff
+      end
+
+      def >(tv)
+        tv < self
+      end
+
+      def elapsed?(tv, second)
+        target = sec + second
+        cur_tv = tv.sec
+
+        return true if target < cur_tv
+        return true if target == cur_tv and usec < tv.usec
+
+        return false
+      end
+
+    end
+
+    def self.resolution
+      samples = []
+
+      t1 = TimeVal.new
+      t2 = TimeVal.new
+
+      30.times do
+        t1.update!
+
+        while true
+          t2.update!
+          break if t2 != t1
+        end
+
+        samples << t1.diff(t2)
+      end
+
+      sum = samples.inject(0) { |acc, i| acc + i }
+      sum / 30
+    end
+
+    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

data/lib/benchmark_suite.rb

@@ -0,0 +1,3 @@
+class BenchmarkSuite
+  VERSION = '0.8.0'
+end

data/test/test_benchmark_suite.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "benchmark_suite"
+
+class TestBenchmarkSuite < Test::Unit::TestCase
+  def test_sanity
+    flunk "write tests or I will kneecap you"
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: benchmark_suite
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: 
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Evan Phoenix
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-05 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 2
+        - 9
+        - 1
+        version: 2.9.1
+  type: :development
+  version_requirements: *id001
+description: A set of enhancements to the standard library benchmark.rb
+email: 
+- evan@fallingsnow.net
+executables: 
+- benchmark
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/benchmark
+- lib/benchmark/compare.rb
+- lib/benchmark/ips.rb
+- lib/benchmark/suite-run.rb
+- lib/benchmark/suite.rb
+- lib/benchmark/timing.rb
+- lib/benchmark_suite.rb
+- test/test_benchmark_suite.rb
+- .gemtest
+has_rdoc: true
+homepage: http://github.com/evanphx/benchmark_suite
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: benchmark_suite
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A set of enhancements to the standard library benchmark.rb
+test_files: 
+- test/test_benchmark_suite.rb