go通过benchmark对代码进行性能测试详解

func randomStr(length int) string {
  mathRand.Seed(time.Now().UnixNano())
  letters := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
  b := make([]byte, length)
  for i := range b {
    b[i] = letters[mathRand.Intn(len(letters))]
  }
  return string(b)
}

func BenchmarkRandomStr(b *testing.B) {
  for i := 0; i < b.N; i++ {
    randomStr(10000)
  }
}

$  go test -bench='Str$'
goos: darwin
goarch: amd64
pkg: learn/learn_test
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRandomStr-12               6692            181262 ns/op
PASS
ok      learn/learn_test        2.142s
​

$  go test -bench='Str$' -cpu=2,4,8 .
goos: darwin
goarch: amd64
pkg: learn/learn_test
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRandomStr-2        6715            181197 ns/op
BenchmarkRandomStr-4        6471            180249 ns/op
BenchmarkRandomStr-8        6616            179510 ns/op
PASS
ok      learn/learn_test        4.516s
​

$  go test -bench='Str$' -benchtime=3s .
goos: darwin
goarch: amd64
pkg: learn/learn_test
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRandomStr-12              19988            177572 ns/op
PASS
ok      learn/learn_test        5.384s
​
$ go test -bench='Str$' -benchtime=10000x .
goos: darwin
goarch: amd64
pkg: learn/learn_test
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRandomStr-12              10000            184832 ns/op
PASS
ok      learn/learn_test        1.870s
​
$ go test -bench='Str$' -count=2 . 
goos: darwin
goarch: amd64
pkg: learn/learn_test
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRandomStr-12               6702            177048 ns/op
BenchmarkRandomStr-12               6482            177861 ns/op
PASS
ok      learn/learn_test        3.269s
​
​

func BenchmarkRandomStr(b *testing.B) {
  time.Sleep(time.Second * 2) // 模拟耗时操作
  for i := 0; i < b.N; i++ {
    randomStr(10000)
  }
}
​

$ go test -bench='Str$' .
goos: darwin
goarch: amd64
pkg: learn/learn_test
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRandomStr-12                  1        2001588866 ns/op
PASS
ok      learn/learn_test        2.009s
​

func BenchmarkRandomStr(b *testing.B) {
  time.Sleep(time.Second * 2) // 模拟耗时操作
  b.ResetTimer() 
  for i := 0; i < b.N; i++ {
    randomStr(10000)
  }
}

$ go test -bench='Str$' .
goos: darwin
goarch: amd64
pkg: learn/learn_test
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRandomStr-12               6506            183098 ns/op
PASS
ok      learn/learn_test        10.030s
​

func getIntArr(n int) []int {
  rand.Seed(uint64(time.Now().UnixNano()))
  arr := make([]int, 0)
  for i := 0; i < n; i++ {
    arr = append(arr, rand.Int())
  }
​
  return arr
}
​
func getIntArrWithCap(n int) []int {
  rand.Seed(uint64(time.Now().UnixNano()))
  arr := make([]int, 0, n)
  for i := 0; i < n; i++ {
    arr = append(arr, rand.Int())
  }
​
  return arr
}
//------------------------------------------
// 基准测试代码
//------------------------------------------
func BenchmarkGetIntArr(b *testing.B) {
  for i := 0; i < b.N; i++ {
    getIntArr(100000)
  }
}
​
func BenchmarkGetIntArrWithCap(b *testing.B) {
  for i := 0; i < b.N; i++ {
    getIntArrWithCap(100000)
  }
}
​

$ go test -bench='Arr' -benchmem .
goos: darwin
goarch: amd64
pkg: learn/learn_test
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkGetIntArr-12                        598           1928991 ns/op         4101389 B/op         28 allocs/op
BenchmarkGetIntArrWithCap-12                 742           1556204 ns/op          802817 B/op          1 allocs/op
PASS
ok      learn/learn_test        2.688s
​

type B struct {
  common
  importPath       string
  context          *benchContext
  N                int // 这个就是要搞懂的N，代表要执行的次数
  previousN        int          
  previousDuration time.Duration 
  benchFunc        func(b *B) // 测试函数
  benchTime        durationOrCountFlag // 执行时间，默认是1s 可以通过-benchtime指定
  bytes            int64 
  missingBytes     bool 
  timerOn          bool 
  showAllocResult  bool
  result           BenchmarkResult
  parallelism      int 
  
  startAllocs uint64 
  startBytes  uint64 
  
  netAllocs uint64 
  netBytes  uint64 
  
  extra map[string]float64
}

// Run benchmarks f as a subbenchmark with the given name. It reports
// whether there were any failures.
//
// A subbenchmark is like any other benchmark. A benchmark that calls Run at
// least once will not be measured itself and will be called once with N=1.
func (b *B) Run(name string, f func(b *B)) bool {
  // ...省略部分代码
  // Run()方法是基准测试的启动方法，会新建一个子测试
  sub := &B{
    common: common{
      signal:  make(chan bool),
      name:    benchName,
      parent:  &b.common,
      level:   b.level + 1,
      creator: pc[:n],
      w:       b.w,
      chatty:  b.chatty,
      bench:   true,
    },
    importPath: b.importPath,
    benchFunc:  f,
    benchTime:  b.benchTime,
    context:    b.context,
  }
// ...省略部分代码
  if sub.run1() { // 执行一次子测试，如果不出错执行run()
    sub.run() //最终调用 launch()方法，决定需要执行多少次runN()
  }
  b.add(sub.result)
  return !sub.failed
}
​
// runN runs a single benchmark for the specified number of iterations.
func (b *B) runN(n int) {
	// ....省略部分代码
	b.N = n //指定N
	// ...
}

// launch launches the benchmark function. It gradually increases the number
// of benchmark iterations until the benchmark runs for the requested benchtime.
// launch is run by the doBench function as a separate goroutine.
// run1 must have been called on b.
func (b *B) launch() {
  // ....省略部分代码
    d := b.benchTime.d
  // 最少执行时间为1s,最多执行次数为1e9次
    for n := int64(1); !b.failed && b.duration < d && n < 1e9; {
      last := n
      // 预测所需要的迭代次数
      goalns := d.Nanoseconds()
      prevIters := int64(b.N)
      prevns := b.duration.Nanoseconds()
      if prevns <= 0 {
        //四舍五入，预防除0
        prevns = 1
      }
      n = goalns * prevIters / prevns
      // 避免增长的太快，先按1.2倍增长，最少增加一次
      n += n / 5
      n = min(n, 100*last)
      n = max(n, last+1)
      // 最多执行1e9次
      n = min(n, 1e9)
      b.runN(int(n))
}
​