Golang笔记-基准测试

时间 2020-05-22

标签 golang 笔记基准测试栏目 Go 繁體版

原文原文链接

上一篇写了些简单的单元测试，这一篇来看看go中的基准测试。在go中基准测试也是开箱即用的。使用testing.B结构对象。linux

须要测试的代码

咱们依然用上一篇的代码结构

│  main.go
│  main_test.go

main.go

func JoinStrUseSprint(a,b string) string {
    return  fmt.Sprintf("%s%s",a,b)
}

func JoinStrUseNor(a,b string) string {
    return  a+b
}

建立一个基准测试

建立普通单元测试咱们使用 TestFunc来定义。建立基准测试咱们须要使用 BenchmarkFunc来定义。

func TestJoinStrUseNor(t *testing.T) {
    s := JoinStrUseNor("aaa","bbb")
    t.Log(s)
}

func TestJoinStrUseSprint(t *testing.T) {
    s := JoinStrUseSprint("aaa","bbb")
    t.Log(s)
}

func BenchmarkJoinStrUseNor(b *testing.B) {
    b.ResetTimer()
    for i:=0; i<b.N; i++{
        JoinStrUseNor("aaa","bbb")
    }

}

func BenchmarkJoinStrUseSprint(b *testing.B) {
    b.ResetTimer()
    for i:=0; i<b.N; i++{
        JoinStrUseSprint("aaa","bbb")
    }
}

执行基础测试

go test -bench=. -benchtime=1s -benchmem -count=1
goos: linux
goarch: amd64
pkg: test
BenchmarkJoinStrUseNor-8        79888155                15.5 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrUseSprint-8      8956500               135 ns/op              40 B/op          3 allocs/op
PASS
ok      test    2.930s

命令参数

-bench=. 表示指定执行测试函数。.表示执行全部，若是修改成go test -bench=BenchmarkJoinStrUseSprint那么只会执行BenchmarkJoinStrUseSprint。
-benchtime=1s指定执行时间为1s
-benchmem显示内存状况
-count=1表示执行一次

响应参数

goos: linux 操做系统
goarch: amd64 系统体系架构
BenchmarkJoinStrUseNor-8 执行的函数名称以及对应的GOMAXPROCS值。
79888155 b.N的值
15.5 ns/op 执行一次函数所花费的时间
0 B/op 执行一次函数分配的内存
0 allocs/op 执行一次函数所分配的内存次数

结果分析

经过上面的响应结果参数，咱们很容易得出拼接两个字符串直接用+号链接，比使用fmt.Sprintf()的性能高。golang

样本分析

有时候由于一些因素的影响，咱们单次测试的结果可能不许备，这个时候咱们就须要进行屡次测试好比go test -bench=BenchmarkJoinStrUseSprint -benchtime=1s -benchmem -count=10将测试的次数定义为10 或者更大，这个时候我就须要去分析这些结果获得相对正确的测试结果。可是这个时候时候若是咱们人工去分析，工做量无疑是很大的，并且很困难。这个时候咱们就能够借助一个工具 benchstat。微信

benchstat是Golang官方推荐的一款命令行工具，能够针对一组或多组样本进行分析，若是同时分析两组样本（好比优化前和优化后），还能够给出性能变化结果。架构

安装

go get golang.org/x/perf/cmd/benchstatide

分析

为了对比咱们增长一个函数

func JoinStrOpt(a,b string) string {
    return  fmt.Sprintf("%s%s",a,b)
}

增长测试

func BenchmarkJoinStrOpt(b *testing.B) {
    b.ResetTimer()
    for i:=0; i<b.N; i++{
        JoinStrOpt("aaa","bbb")
    }
}

执行测试并保存测试结果到before.txt

go test -bench=BenchmarkJoinStrOpt -benchmem -count=10 | tee before.txt
goos: linux
goarch: amd64
pkg: test
BenchmarkJoinStrOpt-8            9143092               131 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9222475               131 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9344643               130 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9127231               131 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9223482               130 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9126334               131 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9364201               129 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9248034               130 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9034518               130 ns/op              40 B/op          3 allocs/op
BenchmarkJoinStrOpt-8            9102846               130 ns/op              40 B/op          3 allocs/op
PASS
ok      test    13.323s

简单分析结果

benchstat before.txt
name          time/op
JoinStrOpt-8  130ns ± 1%

name          alloc/op
JoinStrOpt-8  40.0B ± 0%

name          allocs/op
JoinStrOpt-8   3.00 ± 0%

能够看出benchstrat会给我一个执行10测试的结果分析，平均数值以及波动数值。函数

对比分析

修改代码为直接相加两个字符串既JoinStrUseNor的内容

func JoinStrOpt(a,b string) string {
    return  a+b
}

再次执行测试并保存结果到after.txt

>go test -bench=BenchmarkJoinStrOpt -benchmem -count=10 | tee after.txt
goos: linux
goarch: amd64
pkg: test
BenchmarkJoinStrOpt-8           78033046                15.3 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           77211630                15.3 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           78088903                15.4 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           77907912                15.3 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           73805730                15.3 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           78508854                15.3 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           73493384                15.2 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           78618926                15.2 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           74973290                15.2 ns/op             0 B/op          0 allocs/op
BenchmarkJoinStrOpt-8           79287993                15.4 ns/op             0 B/op          0 allocs/op
PASS
ok      test    11.959s

对比分析

>benchstat before.txt after.txt
name          old time/op    new time/op    delta
JoinStrOpt-8     130ns ± 1%      15ns ± 1%   -88.27%  (p=0.000 n=10+10)

name          old alloc/op   new alloc/op   delta
JoinStrOpt-8     40.0B ± 0%      0.0B       -100.00%  (p=0.000 n=10+10)

name          old allocs/op  new allocs/op  delta
JoinStrOpt-8      3.00 ± 0%      0.00       -100.00%  (p=0.000 n=10+10)

能够看到benchstat会给我直观的展现出优化代码先后的优化差值。工具

对比值括号中的数据含义

p表示结果的可信程度，p 值越大可信程度越低，统计学中一般把p=0.05作为临界值，超过此值说明结果不可信，多是样本过少等缘由。性能

n=10+10表示采用的样本数，，就跟投票同样一般会去掉一个最高分，一个最低分。出于某些缘由(好比数据值反常，过大或太小)，benchstat会舍弃某些样本，本例中优化前,优化后的数据没有舍弃因此是10+10.单元测试

参考资料

[go夜读] https://www.bilibili.com/vide...
[benchstat] https://godoc.org/rsc.io/benc...

期待与您一块儿交流
测试