# Benchmark (Module)

In: | benchmark.rb

The Benchmark module provides methods to measure and report the time used to execute Ruby code. Read on for illustrative examples.

## Examples

### Example 1

To 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 P5100MHz) this reported as follows:

          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.

### Example 2

To do some experiments sequentially, the bm method is useful:

          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)

### Example 3

Continuing the previous example, to 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 argument to bm (7) specifies the offset of each report according to the longest label.

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)

### Example 4

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 for 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)

### Example 5

To report statistics of sequential experiments with unique labels, benchmark is available:

          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)

## Methods

benchmark bm bmbm measure realtime

## Constants

BENCHMARK_VERSION | = | "2002-04-25"
| BENCHMARK_VERSION is version string containing the last modification date (YYYY-MM-DD).
CAPTION | = | Benchmark::Tms::CAPTION
| The default caption string (heading above the output times).
FMTSTR | = | Benchmark::Tms::FMTSTR
| The default format string used to display times. See also Benchmark::Tms#format.

## Classes and Modules

Class Benchmark::Job
Class Benchmark::Report
Class Benchmark::Tms

## Public Instance methods

benchmark(caption = "", label_width = nil, fmtstr = nil, *labels) {|report| ...}

Reports the time required to execute one or more blocks of code.

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

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)

The parameters accepted are as follows:

caption: | A string printed once before execution of the given block.
label_width: | An integer used as an offset in each report.
fmtstr: | A string used to format each measurement. See Benchmark::Tms#format.
labels: | The remaining parameters are used as prefix of the format to the value of block; see the example above.

This method yields a Benchmark::Report object.

[Source]

    # File benchmark.rb, line 198
      def benchmark(caption = "", 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 caption
        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) {|report| ...}

A simple interface to benchmark, bm is suitable for sequential reports with labels. For example:

        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 argument to bm (7) specifies the offset of each report according to the longest label.

This reports as follows:

                        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 labels are optional.

[Source]

    # File benchmark.rb, line 239
      def bm(label_width = 0, *labels, &blk) # :yield: report

        benchmark(" "*label_width + CAPTION, label_width, FMTSTR, *labels, &blk)
      end

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

Similar to bm, but designed to prevent memory allocation and garbage collection from influencing the result. It works like this:

1. The rehearsal step runs all items in the job list to allocate enough memory.
2. Before each measurement, invokes GC.start to prevent the influence of previous job.

If the specified label_width is less than the width of the widest label passed as an argument to item, the latter is used. (Because bmbm is a 2-pass procedure, this is possible.) Therefore you do not really need to specify a label width.

For example:

          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)

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

[Source]

    # File benchmark.rb, line 283
      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{|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]
        }

        STDOUT.sync = sync
        ary
      end

measure(label = "") {|| ...}

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

[Source]

    # File benchmark.rb, line 326
      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() {|| ...}

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

[Source]

    # File benchmark.rb, line 341
      def realtime(&blk) # :yield:

        Benchmark::measure(&blk).real
      end

[Validate]