Module: Benchmark (Ruby 2.5.2) (original) (raw)

benchmark(caption = "", label_width = nil, format = 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 format to format each line. Returns an array of Benchmark::Tms objects.

If the block returns an array of Benchmark::Tms objects, these will be used to format additional lines of output. If labels parameter 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

n = 5000000 Benchmark.benchmark(CAPTION, 7, FORMAT, ">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: 0.970000 0.000000 0.970000 ( 0.970493) times: 0.990000 0.000000 0.990000 ( 0.989542) upto: 0.970000 0.000000 0.970000 ( 0.972854)

total: 2.930000 0.000000 2.930000 ( 2.932889) avg: 0.976667 0.000000 0.976667 ( 0.977630)

def benchmark(caption = "", label_width = nil, format = nil, *labels) sync = STDOUT.sync STDOUT.sync = true label_width ||= 0 label_width += 1 format ||= FORMAT print ' '*label_width + caption unless caption.empty? report = Report.new(label_width, format) results = yield(report) Array === results and results.grep(Tms).each {|t| print((labels.shift || t.label || "").ljust(label_width), t.format(format)) } report.list ensure STDOUT.sync = sync unless sync.nil? end

bm(label_width = 0, *labels) click to toggle source

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

require 'benchmark'

n = 5000000 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: 0.960000 0.000000 0.960000 ( 0.957966) times: 0.960000 0.000000 0.960000 ( 0.960423) upto: 0.950000 0.000000 0.950000 ( 0.954864)

def bm(label_width = 0, *labels, &blk) benchmark(CAPTION, label_width, FORMAT, *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! 1.440000 0.010000 1.450000 ( 1.446833) sort 1.440000 0.000000 1.440000 ( 1.448257) -------------------------------- total: 2.890000sec

        user     system      total        real

sort! 1.460000 0.000000 1.460000 ( 1.458065) sort 1.450000 0.000000 1.450000 ( 1.455963)

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

def bmbm(width = 0) job = Job.new(width) yield(job) width = job.width + 1 sync = STDOUT.sync STDOUT.sync = true

puts 'Rehearsal '.ljust(width+CAPTION.length,'-') ets = job.list.inject(Tms.new) { |sum,(label,item)| print label.ljust(width) res = Benchmark.measure(&item) print res.format sum + res }.format("total: %tsec") print " #{ets}\n\n".rjust(width+CAPTION.length+2,'-')

print ' '*width + CAPTION job.list.map { |label,item| GC.start print label.ljust(width) Benchmark.measure(label, &item).tap { |res| print res } } ensure STDOUT.sync = sync unless sync.nil? end

measure(label = "") click to toggle source

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

require 'benchmark'

n = 1000000

time = Benchmark.measure do n.times { a = "1" } end puts time

Generates:

0.220000 0.000000 0.220000 ( 0.227313)

def measure(label = "") t0, r0 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC) yield t1, r1 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC) Benchmark::Tms.new(t1.utime - t0.utime, t1.stime - t0.stime, t1.cutime - t0.cutime, t1.cstime - t0.cstime, r1 - r0, label) end

realtime() click to toggle source

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

def realtime r0 = Process.clock_gettime(Process::CLOCK_MONOTONIC) yield Process.clock_gettime(Process::CLOCK_MONOTONIC) - r0 end