vendor/github.com/go-check/check/benchmark.go

   1 // Copyright (c) 2012 The Go Authors. All rights reserved.
   2 //
   3 // Redistribution and use in source and binary forms, with or without
   4 // modification, are permitted provided that the following conditions are
   5 // met:
   6 //
   7 //    * Redistributions of source code must retain the above copyright
   8 // notice, this list of conditions and the following disclaimer.
   9 //    * Redistributions in binary form must reproduce the above
  10 // copyright notice, this list of conditions and the following disclaimer
  11 // in the documentation and/or other materials provided with the
  12 // distribution.
  13 //    * Neither the name of Google Inc. nor the names of its
  14 // contributors may be used to endorse or promote products derived from
  15 // this software without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 package check
  30
  31 import (
  32         "fmt"
  33         "runtime"
  34         "time"
  35 )
  36
  37 var memStats runtime.MemStats
  38
  39 // testingB is a type passed to Benchmark functions to manage benchmark
  40 // timing and to specify the number of iterations to run.
  41 type timer struct {
  42         start     time.Time // Time test or benchmark started
  43         duration  time.Duration
  44         N         int
  45         bytes     int64
  46         timerOn   bool
  47         benchTime time.Duration
  48         // The initial states of memStats.Mallocs and memStats.TotalAlloc.
  49         startAllocs uint64
  50         startBytes  uint64
  51         // The net total of this test after being run.
  52         netAllocs uint64
  53         netBytes  uint64
  54 }
  55
  56 // StartTimer starts timing a test. This function is called automatically
  57 // before a benchmark starts, but it can also used to resume timing after
  58 // a call to StopTimer.
  59 func (c *C) StartTimer() {
  60         if !c.timerOn {
  61                 c.start = time.Now()
  62                 c.timerOn = true
  63
  64                 runtime.ReadMemStats(&memStats)
  65                 c.startAllocs = memStats.Mallocs
  66                 c.startBytes = memStats.TotalAlloc
  67         }
  68 }
  69
  70 // StopTimer stops timing a test. This can be used to pause the timer
  71 // while performing complex initialization that you don't
  72 // want to measure.
  73 func (c *C) StopTimer() {
  74         if c.timerOn {
  75                 c.duration += time.Now().Sub(c.start)
  76                 c.timerOn = false
  77                 runtime.ReadMemStats(&memStats)
  78                 c.netAllocs += memStats.Mallocs - c.startAllocs
  79                 c.netBytes += memStats.TotalAlloc - c.startBytes
  80         }
  81 }
  82
  83 // ResetTimer sets the elapsed benchmark time to zero.
  84 // It does not affect whether the timer is running.
  85 func (c *C) ResetTimer() {
  86         if c.timerOn {
  87                 c.start = time.Now()
  88                 runtime.ReadMemStats(&memStats)
  89                 c.startAllocs = memStats.Mallocs
  90                 c.startBytes = memStats.TotalAlloc
  91         }
  92         c.duration = 0
  93         c.netAllocs = 0
  94         c.netBytes = 0
  95 }
  96
  97 // SetBytes informs the number of bytes that the benchmark processes
  98 // on each iteration. If this is called in a benchmark it will also
  99 // report MB/s.
 100 func (c *C) SetBytes(n int64) {
 101         c.bytes = n
 102 }
 103
 104 func (c *C) nsPerOp() int64 {
 105         if c.N <= 0 {
 106                 return 0
 107         }
 108         return c.duration.Nanoseconds() / int64(c.N)
 109 }
 110
 111 func (c *C) mbPerSec() float64 {
 112         if c.bytes <= 0 || c.duration <= 0 || c.N <= 0 {
 113                 return 0
 114         }
 115         return (float64(c.bytes) * float64(c.N) / 1e6) / c.duration.Seconds()
 116 }
 117
 118 func (c *C) timerString() string {
 119         if c.N <= 0 {
 120                 return fmt.Sprintf("%3.3fs", float64(c.duration.Nanoseconds())/1e9)
 121         }
 122         mbs := c.mbPerSec()
 123         mb := ""
 124         if mbs != 0 {
 125                 mb = fmt.Sprintf("\t%7.2f MB/s", mbs)
 126         }
 127         nsop := c.nsPerOp()
 128         ns := fmt.Sprintf("%10d ns/op", nsop)
 129         if c.N > 0 && nsop < 100 {
 130                 // The format specifiers here make sure that
 131                 // the ones digits line up for all three possible formats.
 132                 if nsop < 10 {
 133                         ns = fmt.Sprintf("%13.2f ns/op", float64(c.duration.Nanoseconds())/float64(c.N))
 134                 } else {
 135                         ns = fmt.Sprintf("%12.1f ns/op", float64(c.duration.Nanoseconds())/float64(c.N))
 136                 }
 137         }
 138         memStats := ""
 139         if c.benchMem {
 140                 allocedBytes := fmt.Sprintf("%8d B/op", int64(c.netBytes)/int64(c.N))
 141                 allocs := fmt.Sprintf("%8d allocs/op", int64(c.netAllocs)/int64(c.N))
 142                 memStats = fmt.Sprintf("\t%s\t%s", allocedBytes, allocs)
 143         }
 144         return fmt.Sprintf("%8d\t%s%s%s", c.N, ns, mb, memStats)
 145 }
 146
 147 func min(x, y int) int {
 148         if x > y {
 149                 return y
 150         }
 151         return x
 152 }
 153
 154 func max(x, y int) int {
 155         if x < y {
 156                 return y
 157         }
 158         return x
 159 }
 160
 161 // roundDown10 rounds a number down to the nearest power of 10.
 162 func roundDown10(n int) int {
 163         var tens = 0
 164         // tens = floor(log_10(n))
 165         for n > 10 {
 166                 n = n / 10
 167                 tens++
 168         }
 169         // result = 10^tens
 170         result := 1
 171         for i := 0; i < tens; i++ {
 172                 result *= 10
 173         }
 174         return result
 175 }
 176
 177 // roundUp rounds x up to a number of the form [1eX, 2eX, 5eX].
 178 func roundUp(n int) int {
 179         base := roundDown10(n)
 180         if n < (2 * base) {
 181                 return 2 * base
 182         }
 183         if n < (5 * base) {
 184                 return 5 * base
 185         }
 186         return 10 * base
 187 }