Module: Benchmark

Defined in:
lib/rubysl/benchmark/benchmark.rb

Overview

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

  • Measure the time to construct the string given by the expression "a"*1_000_000:

    require 'benchmark'

puts Benchmark.measure { "a"*1_000_000 }

    On my machine (FreeBSD 3.2 on P5, 100MHz) this generates:

    1.166667   0.050000   1.216667 (  0.571355)

    This report shows the user CPU time, system CPU time, the sum of the user and system CPU times, and the elapsed real time. The unit of time is seconds.

  • Do some experiments sequentially using the #bm method:

    require 'benchmark'

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

    The result:

        user     system      total        real
1.033333   0.016667   1.016667 (  0.492106)
1.483333   0.000000   1.483333 (  0.694605)
1.516667   0.000000   1.516667 (  0.711077)

  • Continuing the previous example, put a label in each report:

    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

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 times for some benchmarks depend on the order in which items are run. These differences are due to the cost of memory allocation and garbage collection. To avoid these discrepancies, the #bmbm method is provided. For example, to compare ways to sort an array of floats:

    require 'benchmark'

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

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

    The result:

    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)

  • Report statistics of sequential experiments with unique labels, using the #benchmark method:

    require 'benchmark'

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

    The result:

                 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)

Defined Under Namespace

Classes: Job, Report, Tms

Constant Summary collapse

BENCHMARK_VERSION =

:nodoc:

"2002-04-25"
CAPTION =

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

Benchmark::Tms::CAPTION
FMTSTR =

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

Benchmark::Tms::FMTSTR

Class Method Summary collapse

Class Method Details

.benchmark(caption = "", label_width = nil, fmtstr = nil, *labels) ⇒ Object

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)

Raises:

  • (ArgumentError) 


170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/rubysl/benchmark/benchmark.rb', line 170

def benchmark(caption="", label_width=nil, fmtstr=nil, *labels) # :yield: report
  raise ArgumentError, "no block" unless block_given?

  # swap
  sync, STDOUT.sync = STDOUT.sync, true

  label_width ||= 0
  fmtstr ||= FMTSTR

  print caption
  results = yield(Report.new(label_width, fmtstr))

  if Array === results
    results.grep(Tms).each do |t|
      lbl = labels.shift || t.label || ""
      print lbl.ljust(label_width), t.format(fmtstr)
    end
  end

  STDOUT.sync = sync
  results
end

.bm(label_width = 0, *labels, &blk) ⇒ Object

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)



214
215
216
 
# File 'lib/rubysl/benchmark/benchmark.rb', line 214

def bm(label_width=0, *labels, &blk) # :yield: report
  benchmark " " * label_width + CAPTION, label_width, FMTSTR, *labels, &blk
end

.bmbm(width = 0) {|job| ... } ⇒ Object

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.

Yields:

  • (job) 


256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/rubysl/benchmark/benchmark.rb', line 256

def bmbm(width=0, &blk) # :yield: job
  job = Job.new(width)
  yield job
  width = job.width

  sync, STDOUT.sync = STDOUT.sync, true

  # rehearsal
  print "Rehearsal "
  puts '-' * (width+CAPTION.length - "Rehearsal ".length)
  list = []
  job.list.each do |label_item|
    label, item = label_item
    print label.ljust(width)
    res = Benchmark.measure(label, &item)
    print res.format
    list.push res
  end
  sum = Tms.new; list.each{ |i| sum += i }
  ets = sum.format("total: %tsec")

  printf "%s %s\n\n", "-"*(width+CAPTION.length-ets.length-1), ets

  # take
  print ' ' * width, CAPTION
  list = []
  ary = []

  job.list.each do |label_item|
    label, item = label_item
    GC.start
    print label.ljust(width)
    res = Benchmark.measure(label, &item)
    print res.format
    ary.push res
    list.push [label, res]
  end

  STDOUT.sync = sync
  ary
end

.measure(label = "") ⇒ Object

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



302
303
304
305
306
307
308
309
310
311
312
 
# File 'lib/rubysl/benchmark/benchmark.rb', line 302

def measure(label="") # :yield:
  t0, r0 = Benchmark.times, Time.now
  yield
  t1, r1 = Benchmark.times, Time.now
  Benchmark::Tms.new(t1.tutime  - t0.tutime,
                     t1.tstime  - t0.tstime,
                     t1.cutime - t0.cutime,
                     t1.cstime - t0.cstime,
                     r1.to_f - r0.to_f,
                     label)
end

.realtime(&blk) ⇒ Object

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



317
318
319
 
# File 'lib/rubysl/benchmark/benchmark.rb', line 317

def realtime(&blk) # :yield:
  Benchmark.measure(&blk).real
end

.times ⇒ Object

:nodoc:



128
129
130
 
# File 'lib/rubysl/benchmark/benchmark.rb', line 128

def Benchmark.times # :nodoc:
  Process.times
end