go通过benchmark对代码进行性能测试详解
作者:octobershen
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代码性能测试的资料请关注脚本之家其它相关文章!