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

各位用户为了找寻关于go通过benchmark对代码进行性能测试详解的资料费劲了很多周折。这里教程网为您整理了关于go通过benchmark对代码进行性能测试详解的相关资料，仅供查阅，以下为您介绍关于go通过benchmark对代码进行性能测试详解的详细内容

目录

benchmark的使用

在开发中我们要想编写高性能的代码，或者优化代码的性能时，你首先得知道当前代码的性能，在go中可以使用testing包的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) }

要对上面的代码做基准测试，首先我们要新建一个测试文件，比如main_test.go，然后新建一个基准测试方法BenchmarkRandomStr，与普通的测试函数Test 开头，参数为t *testing.T类似，基准测试函数要以Benchmark开头，参数为b *testing.B，代码中的b.N代表的是该用例的运行次数，这个值是会变的，对于每个用例都不一样，这个值会从1开始增加，具体的实现我会在下面的实现原理里进行介绍。

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

运行Benchmark

我们可以使用 go test -bench .命令直接运行当前目录下的所有基准测试用例，-bench后面也可以跟正则或者是字符串来匹配对应的用例

$ 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 ​

对上面的一些关键指标我们要了解一下，首先BenchmarkRandomStr-12后面的-12代表的是GOMAXPROCS这个跟你机器CPU的逻辑核数有关，在基准测试中可以通过-cpu参数指定需要以几核的cpu来运行测试用例

$ 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 ​

6715和181197 ns/op代表用例执行了6715次，每次花费的时间约为0.0001812s，总耗时约为1.2s（ns:s的换算为1000000000:1）

指定测试时长或测试次数

-benchtime=3s 指定时长

-benchtime=100000x 指定次数

-coun=3 指定轮数

$ 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 ​

发现只执行了一次，时间变成了2s多，这显然不符合我们的预期，这个时候需要调用b.ResetTime()来重置时间

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 ​

运行次数和单次执行时间已经恢复到之前测试的情况了。基准测试还有b.StopTimer()和b.StartTimer()方法也是同样的道理，在影响耗时的操作之前停止计时，完成之后再开始计时。

查看内存使用情况

我们再评估代码的性能时，除了时间的快慢，还有一个重要的指标就是内存使用率，基准测试中可以通过 -benchmem 来显示内存使用情况。下面我们用一组指定cap和不指定cap的返回int切片方法来看一下内存的使用情况

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 ​

可以看到指定了cap的方法执行的速度大约快20%，而内存的使用少了80%左右, 802817 B/op 代表每次的内存使用情况，1 allocs/op表示每次操作分配内存的次数

testing.B的底层实现

在写基准测试的时候，最让我搞不懂的是b.N的机制，如何根据不同的用例来自动调整执行的次数，然后我在源码中找到了一些蛛丝马迹。首先，先看一下基准测试的底层数据结构

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 }

通过结构体中的N字段，可以找到几个关键的方法，runN():每一次执行都会调用的方法，设置N的值。run1():第一次迭代，根据它的结果决定是否需要运行更多的基准测试。run(): run1()执行的结果为true的情况会调用，这个方法里调用doBench()函数从而调用launch()函数，这个是最终决定执行次数的函数

// 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)) } ​

总结

1.基准测试方法要以Benchmark开头

2.执行基准测试用go test -bench .命令执行该目录下所有的基准测试，-bench后面可以跟正则表达式，来执行符合条件的测试

3.-cpu参数可以指定运行测试的cpu核心数

4.-benchtime参数可以指定运行测试的时间和次数

5.-count参数可以指定运行测试的轮数

6.b.ResetTimer()、b.StopTimer()、b.StartTimer()可以重置或暂停计时，来消除一些耗时操作的影响

以上就是go通过benchmark对代码进行性能测试详解的详细内容，更多关于go benchmark代码性能测试的资料请关注其它相关文章！