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代码性能测试的资料请关注脚本之家其它相关文章！
相关文章
这篇文章主要给大家介绍了Golang token的生成和解析,文中通过代码示例给大家介绍的非常详细,对大家的学习或工作有一定的帮助,需要的朋友可以参考下2024-02-02
在使用Go语言开发应用程序时,有个非常方便的地方就是编译得到的可执行文件可以不依赖任何动态链接库、并且不需要任何运行环境即可运行,本文给大家介绍Go编译时为exe添加图标和属性信息的方法,需要的朋友可以参考下2023-09-09
今天小编就为大家分享一篇关于Golang数组的传递详解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧2019-03-03
如果你是一个开发人员，或多或少对树型结构都有一定的认识。二叉树作为树的一种,是一种重要的数据结构,也是面试官经常考的东西。本文为大家总结了一些二叉树必会知识点，需要的可以参考一下2022-08-08
下面小编就为大家带来一篇golang之log rotate详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-06-06
son格式可以算我们日常最常用的序列化格式之一了，下面这篇文章主要给大家介绍了关于golang如何自定义json序列化应用的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面来一起看看吧2018-08-08
这篇文章主要为大家介绍了详解Go 依赖管理 go mod tidy，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-10-10
Range是go语言中很独特的一个关键词，也相当好用。下面就跟着小编来再聊聊这个Range关键字，有需要的朋友们可以参考借鉴。2016-09-09
在 Go 语言开发中,大家为了方便,通常会选择使用 ORM 操作数据库,比如使用 XORM 或 GORM 操作 MySQL,本文我们来介绍一下使用 XORM[3] 操作 MySQL 可能会遇到的陷阱2023-11-11
本篇文章主要介绍了golang常用手册之切片(Slice)原理，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2017-12-12
最新评论