Module: Benchmark
- Defined in:
- lib/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
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
-
.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. -
.bm(label_width = 0, *labels, &blk) ⇒ Object
A simple interface to the #benchmark method, #bm is generates sequential reports with labels.
-
.bmbm(width = 0, &blk) ⇒ Object
Sometimes benchmark results are skewed because code executed earlier encounters different garbage collection overheads than that run later.
-
.measure(label = "") ⇒ Object
Returns the time used to execute the given block as a Benchmark::Tms object.
-
.realtime(&blk) ⇒ Object
Returns the elapsed real time used to execute the given block.
-
.times ⇒ Object
:nodoc:.
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)
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 |
# File 'lib/benchmark.rb', line 170 def benchmark( = "", label_width = nil, fmtstr = nil, *labels) # :yield: report sync = STDOUT.sync STDOUT.sync = true label_width ||= 0 fmtstr ||= FMTSTR raise ArgumentError, "no block" unless iterator? print "\n" print results = yield(Report.new(label_width, fmtstr)) Array === results and results.grep(Tms).each {|t| print((labels.shift || t.label || "").ljust(label_width), t.format(fmtstr)) } STDOUT.sync = sync 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)
207 208 209 |
# File 'lib/benchmark.rb', line 207 def bm(label_width = 0, *labels, &blk) # :yield: report benchmark(" "*label_width + CAPTION, label_width, FMTSTR, *labels, &blk) end |
.bmbm(width = 0, &blk) ⇒ 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.
249 250 251 252 253 254 255 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 |
# File 'lib/benchmark.rb', line 249 def bmbm(width = 0, &blk) # :yield: job job = Job.new(width) yield(job) width = job.width sync = STDOUT.sync STDOUT.sync = true # rehearsal print "\n" print "Rehearsal " puts '-'*(width+CAPTION.length - "Rehearsal ".length) list = [] job.list.each{|label,item| print(label.ljust(width)) res = Benchmark::measure(&item) print res.format() list.push res } 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{|label,item| GC::start print label.ljust(width) res = Benchmark::measure(&item) print res.format() ary.push res list.push [label, res] } ary ensure STDOUT.sync = sync unless sync.nil? end |
.measure(label = "") ⇒ Object
Returns the time used to execute the given block as a Benchmark::Tms object.
294 295 296 297 298 299 300 301 302 303 304 305 306 |
# File 'lib/benchmark.rb', line 294 def measure(label = "") # :yield: t0 = Benchmark.times.retain # FIXME: it seems to me that RubyMotion needs retain r0 = NSDate.date yield t1 = Benchmark.times.retain # FIXME: it seems to me that RubyMotion needs retain r1 = NSDate.date Benchmark::Tms.new(t1.utime - t0.utime, t1.stime - t0.stime, t1.cutime - t0.cutime, t1.cstime - t0.cstime, r1.timeIntervalSinceDate(r0).to_f, label) end |
.realtime(&blk) ⇒ Object
Returns the elapsed real time used to execute the given block.
311 312 313 314 315 316 |
# File 'lib/benchmark.rb', line 311 def realtime(&blk) # :yield: r0 = Time.now yield r1 = Time.now r1.to_f - r0.to_f end |
.times ⇒ Object
:nodoc:
128 129 130 |
# File 'lib/benchmark.rb', line 128 def Benchmark::times() # :nodoc: Process::times() end |