Namespace

Benchmark

The Benchmark module provides methods to measure and report the time used to execute Ruby code.

The result:

             user     system      total        real
for:     1.050000   0.000000   1.050000 (  0.503462)
times:   1.533333   0.016667   1.550000 (  0.735473)
upto:    1.500000   0.016667   1.516667 (  0.711239)

The Benchmark module provides methods to measure and report the time used to execute Ruby code.

The result:

             user     system      total        real
for:     1.050000   0.000000   1.050000 (  0.503462)
times:   1.533333   0.016667   1.550000 (  0.735473)
upto:    1.500000   0.016667   1.516667 (  0.711239)

Constants

BENCHMARK_VERSION
CAPTION

The default caption string (heading above the output times).

FMTSTR

The default format string used to display times. See also Benchmark::Tms#format.

OUTPUT
SYNC

Public Class Methods

benchmark(caption = "", label_width = nil, fmtstr = nil, *labels) click to toggle source

Invokes the block with a Benchmark::Report object, which may be used to collect and report on the results of individual benchmark tests. Reserves label_width leading spaces for labels on each line. Prints caption at the top of the report, and uses fmt to format each line. If the block returns an array of Benchmark::Tms objects, these will be used to format additional lines of output. If label parameters are given, these are used to label these extra lines.

Note: Other methods provide a simpler interface to this one, and are suitable for nearly all benchmarking requirements. See the examples in Benchmark, and the bm and bmbm methods.

Example:

require 'benchmark'
include Benchmark          # we need the CAPTION and FMTSTR constants 

n = 50000
Benchmark.benchmark(" "*7 + CAPTION, 7, FMTSTR, ">total:", ">avg:") do |x|
  tf = x.report("for:")   { for i in 1..n; a = "1"; end }
  tt = x.report("times:") { n.times do   ; a = "1"; end }
  tu = x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
  [tf+tt+tu, (tf+tt+tu)/3]
end

Generates:

             user     system      total        real
for:     1.016667   0.016667   1.033333 (  0.485749)
times:   1.450000   0.016667   1.466667 (  0.681367)
upto:    1.533333   0.000000   1.533333 (  0.722166)
>total:  4.000000   0.033333   4.033333 (  1.889282)
>avg:    1.333333   0.011111   1.344444 (  0.629761)
# File lib/railsbench/benchmark.rb, line 173
def benchmark(caption = "", label_width = nil, fmtstr = nil, *labels) # :yield: report
  if SYNC
    sync = OUTPUT.sync
    OUTPUT.sync = true
  end
  label_width ||= 0
  fmtstr ||= FMTSTR
  raise ArgumentError, "no block" unless iterator?
  OUTPUT.print caption
  results = yield(Report.new(label_width, fmtstr))
  Array === results and results.grep(Tms).each {|t|
    OUTPUT.print((labels.shift || t.label || "").ljust(label_width), 
                 t.format(fmtstr))
  }
  OUTPUT.sync = sync if SYNC
end
bm(label_width = 0, *labels) click to toggle source

A simple interface to the benchmark method, bm is generates sequential reports with labels. The parameters have the same meaning as for benchmark.

require 'benchmark'

n = 50000
Benchmark.bm(7) do |x|
  x.report("for:")   { for i in 1..n; a = "1"; end }
  x.report("times:") { n.times do   ; a = "1"; end }
  x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
end

Generates:

             user     system      total        real
for:     1.050000   0.000000   1.050000 (  0.503462)
times:   1.533333   0.016667   1.550000 (  0.735473)
upto:    1.500000   0.016667   1.516667 (  0.711239)
# File lib/railsbench/benchmark.rb, line 211
def bm(label_width = 0, *labels, &blk) # :yield: report
  benchmark(" "*label_width + CAPTION, label_width, FMTSTR, *labels, &blk)
end
bmbm(width = 0) click to toggle source

Sometimes benchmark results are skewed because code executed earlier encounters different garbage collection overheads than that run later. bmbm attempts to minimize this effect by running the tests twice, the first time as a rehearsal in order to get the runtime environment stable, the second time for real. GC.start is executed before the start of each of the real timings; the cost of this is not included in the timings. In reality, though, there's only so much that bmbm can do, and the results are not guaranteed to be isolated from garbage collection and other effects.

Because bmbm takes two passes through the tests, it can calculate the required label width.

require 'benchmark'

array = (1..1000000).map { rand }

Benchmark.bmbm do |x|
  x.report("sort!") { array.dup.sort! }
  x.report("sort")  { array.dup.sort  }
end

Generates:

Rehearsal -----------------------------------------
sort!  11.928000   0.010000  11.938000 ( 12.756000)
sort   13.048000   0.020000  13.068000 ( 13.857000)
------------------------------- total: 25.006000sec

            user     system      total        real
sort!  12.959000   0.010000  12.969000 ( 13.793000)
sort   12.007000   0.000000  12.007000 ( 12.791000)

bmbm yields a Benchmark::Job object and returns an array of Benchmark::Tms objects.

# File lib/railsbench/benchmark.rb, line 253
def bmbm(width = 0, &blk) # :yield: job
  job = Job.new(width)
  yield(job)
  width = job.width
  if SYNC
    sync = OUTPUT.sync
    OUTPUT.sync = true
  end

  # rehearsal
  OUTPUT.print "Rehearsal "
  puts '-'*(width+CAPTION.length - "Rehearsal ".length)
  list = []
  job.list.each{|label,item|
    OUTPUT.print(label.ljust(width))
    res = Benchmark::measure(&item)
    OUTPUT.print res.format()
    list.push res
  }
  sum = Tms.new; list.each{|i| sum += i}
  ets = sum.format("total: %tsec")
  OUTPUT.printf("%s %s\n\n",
                "-"*(width+CAPTION.length-ets.length-1), ets)
  
  # take
  OUTPUT.print ' '*width, CAPTION
  list = []
  ary = []
  job.list.each{|label,item|
    GC::start
    OUTPUT.print label.ljust(width)
    res = Benchmark::measure(&item)
    OUTPUT.print res.format()
    ary.push res
    list.push [label, res]
  }

  OUTPUT.sync = sync if SYNC
  ary
end
measure(label = "") click to toggle source

Returns the time used to execute the given block as a Benchmark::Tms object.

# File lib/railsbench/benchmark.rb, line 298
def measure(label = "") # :yield:
  t0, r0 = Benchmark.times, Time.now
  yield
  t1, r1 = Benchmark.times, Time.now
  Benchmark::Tms.new(t1.utime  - t0.utime, 
                     t1.stime  - t0.stime, 
                     t1.cutime - t0.cutime, 
                     t1.cstime - t0.cstime, 
                     r1.to_f - r0.to_f,
                     label)
end
realtime() click to toggle source

Returns the elapsed real time used to execute the given block.

# File lib/railsbench/benchmark.rb, line 313
def realtime(&blk) # :yield:
  Benchmark::measure(&blk).real
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.