# class Benchmark::Tms

A data object, representing the times associated with a benchmark measurement.

### Constants

CAPTION

  Default caption, see also Benchmark::CAPTION

FORMAT

  Default format string, see also Benchmark::FORMAT

### Attributes

cstime [R]

System CPU time of children

cutime [R]

User CPU time of children

label [R]

Label

real [R]

Elapsed real time

stime [R]

System CPU time

total [R]

Total time, that is `utime` + `stime` + `cutime` + `cstime`

utime [R]

User CPU time

### Public Class Methods

new (utime = 0.0, stime = 0.0, cutime = 0.0, cstime = 0.0, real = 0.0, label = nil)
Source

    # File lib/benchmark.rb, line 442
    def initialize(utime = 0.0, stime = 0.0, cutime = 0.0, cstime = 0.0, real = 0.0, label = nil)
      @utime, @stime, @cutime, @cstime, @real, @label = utime, stime, cutime, cstime, real, label.to_s
      @total = @utime + @stime + @cutime + @cstime
    end

Returns an initialized `Tms` object which has `utime` as the user CPU time, `stime` as the system CPU time, `cutime` as the children’s user CPU time, `cstime` as the children’s system CPU time, `real` as the elapsed real time and `label` as the label.

### Public Instance Methods

* (x)
Source

    # File lib/benchmark.rb, line 490
    def *(x); memberwise(:*, x) end

Returns a new `Tms` object obtained by memberwise multiplication of the individual times for this `Tms` object by `x`.

+ (other)
Source

    # File lib/benchmark.rb, line 477
    def +(other); memberwise(:+, other) end

Returns a new `Tms` object obtained by memberwise summation of the individual times for this `Tms` object with those of the `other` `Tms` object. This method and `/()` are useful for taking statistics.

- (other)
Source

    # File lib/benchmark.rb, line 484
    def -(other); memberwise(:-, other) end

Returns a new `Tms` object obtained by memberwise subtraction of the individual times for the `other` `Tms` object from those of this `Tms` object.

/ (x)
Source

    # File lib/benchmark.rb, line 497
    def /(x); memberwise(:/, x) end

Returns a new `Tms` object obtained by memberwise division of the individual times for this `Tms` object by `x`. This method and `+()` are useful for taking statistics.

add () { || ... }
Source

    # File lib/benchmark.rb, line 451
    def add(&blk) # :yield:
      self + Benchmark.measure(&blk)
    end

Returns a new `Tms` object whose times are the sum of the times for this `Tms` object, plus the time required to execute the code block (`blk`).

add! (&blk)
Source

    # File lib/benchmark.rb, line 461
    def add!(&blk)
      t = Benchmark.measure(&blk)
      @utime  = utime + t.utime
      @stime  = stime + t.stime
      @cutime = cutime + t.cutime
      @cstime = cstime + t.cstime
      @real   = real + t.real
      self
    end

An in-place version of `add`. Changes the times of this `Tms` object by making it the sum of the times for this `Tms` object, plus the time required to execute the code block (`blk`).

format (format = nil, *args)
Source

    # File lib/benchmark.rb, line 516
    def format(format = nil, *args)
      str = (format || FORMAT).dup
      str.gsub!(/(%[-+.\d]*)n/) { "#{$1}s" % label }
      str.gsub!(/(%[-+.\d]*)u/) { "#{$1}f" % utime }
      str.gsub!(/(%[-+.\d]*)y/) { "#{$1}f" % stime }
      str.gsub!(/(%[-+.\d]*)U/) { "#{$1}f" % cutime }
      str.gsub!(/(%[-+.\d]*)Y/) { "#{$1}f" % cstime }
      str.gsub!(/(%[-+.\d]*)t/) { "#{$1}f" % total }
      str.gsub!(/(%[-+.\d]*)r/) { "(#{$1}f)" % real }
      format ? str % args : str
    end

Returns the contents of this `Tms` object as a formatted string, according to a `format` string like that passed to `Kernel.format`. In addition, `format` accepts the following extensions:

`%u`

  Replaced by the user CPU time, as reported by `Tms#utime`.

`%y`

  Replaced by the system CPU time, as reported by `stime` (Mnemonic: y of “s*y*stem”)

`%U`

  Replaced by the children’s user CPU time, as reported by `Tms#cutime`

`%Y`

  Replaced by the children’s system CPU time, as reported by `Tms#cstime`

`%t`

  Replaced by the total CPU time, as reported by `Tms#total`

`%r`

  Replaced by the elapsed real time, as reported by `Tms#real`

`%n`

  Replaced by the label string, as reported by `Tms#label` (Mnemonic: n of “*n*ame”)

If `format` is not given, `FORMAT` is used as default value, detailing the user, system and real elapsed time.

to_a ()
Source

    # File lib/benchmark.rb, line 541
    def to_a
      [@label, @utime, @stime, @cutime, @cstime, @real]
    end

Returns a new 6-element array, consisting of the label, user CPU time, system CPU time, children’s user CPU time, children’s system CPU time and elapsed real time.

to_h ()
Source

    # File lib/benchmark.rb, line 548
    def to_h
      {
        label:  @label,
        utime:  @utime,
        stime:  @stime,
        cutime: @cutime,
        cstime: @cstime,
        real:   @real
      }
    end

Returns a hash containing the same data as ‘to_a`.

to_s ()
Source

    # File lib/benchmark.rb, line 531
    def to_s
      format
    end

Same as `format`.

### Protected Instance Methods

memberwise (op, x)
Source

    # File lib/benchmark.rb, line 569
    def memberwise(op, x)
      case x
      when Benchmark::Tms
        Benchmark::Tms.new(utime.__send__(op, x.utime),
                           stime.__send__(op, x.stime),
                           cutime.__send__(op, x.cutime),
                           cstime.__send__(op, x.cstime),
                           real.__send__(op, x.real)
                           )
      else
        Benchmark::Tms.new(utime.__send__(op, x),
                           stime.__send__(op, x),
                           cutime.__send__(op, x),
                           cstime.__send__(op, x),
                           real.__send__(op, x)
                           )
      end
    end

Returns a new `Tms` object obtained by memberwise operation `op` of the individual times for this `Tms` object with those of the other `Tms` object (`x`).

`op` can be a mathematical operation such as `+`, `-`, `*`, `/`