改善测试.Go的基准

Question

在学习Go时，我看到您可以使用fmt.Println(testing.Benchmark(BenchmarkFunction))对函数进行基准测试，设置以下内容:

func BenchmarkFunction(b *testing.B) {
    n := 42
    for i := 0; i < b.N; i++ {
        _ = Function(n)
    }
}

然而，由于BenchmarkFunction代码将在您这样做的每个方法的每个基准测试中重复(因此就DRY而言，代码气味)，是否有一种方法可以使用闭包(或以其他方式)重写它，以便函数的基准测试可以重写为如下内容:

fmt.println(test.BenchmarkMyFunction(MyFunction(parameters...)))

并添加到我的代码或testing库?

Answer 1

实际上，这不是在Go中做基准测试的正确方法。

实际的标准是将基准测试代码放入名称为BenchmarkXXX的函数中，其中XXX是您喜欢的任何名称。然后在定义这些文件的包上运行go test -bench=.。go test正在为你运行所有的基准测试。

如果您有类似的基准测试，但参数略有不同，您可以编写一个通用的基准测试函数，该函数仅由所有其他基准测试调用:

func genericBenchmarkFoo(b *testing.B, param int) { ... }

然后为每个特定的基准编写一个样板函数:

func BenchmarkFoo1(b *testing.B) { genericBenchmarkFoo(b, 1) }
func BenchmarkFoo2(b *testing.B) { genericBenchmarkFoo(b, 2) }
func BenchmarkFoo3(b *testing.B) { genericBenchmarkFoo(b, 3) }
func BenchmarkFoo4(b *testing.B) { genericBenchmarkFoo(b, 4) }

你可以在我写的这个包里找到一个这种模式的例子。

当然，这并不完全是美丽的，但恐怕没有一个更简单的解决方案。然而，找到一组代表您想要做的事情的基准测试是干净的编码。

Answer 2

这是一个真实的、简单的DRY Go基准测试，它使用了闭包。我想知道各种Substr函数的性能是如何随着子字符串的大小(hi - lo)而变化的。

package main
import (
    "fmt"
    "strings"
    "testing"
)
func Substr1(str string, lo, hi int) string {
    return string([]byte(str[lo:hi]))
}
func Substr2(str string, lo, hi int) string {
    sub := str[lo:hi]
    return (sub + " ")[:len(sub)]
}
func Substr3(str string, lo, hi int) string {
    sub := str[lo:hi]
    if len(sub) == 0 {
        return ""
    }
    return sub[0:1] + sub[1:]
}
var substrFunctions = []struct {
    name     string
    function func(str string, lo, hi int) string
}{
    {"Substr1", Substr1},
    {"Substr2", Substr2},
    {"Substr3", Substr3},
}
var substrBenchmarks = []struct {
    name                 string
    strLen, subLo, subHi int
}{
    {"Zero  ", 1, 1, 1},
    {"Small ", 4, 1, 4},
    {"Medium", 256, 1, 256},
    {"Large ", 4096, 1, 4096},
}
func BenchmarkSubstrSize() {
    fmt.Println("BenchmarkSubstrSize:")
    for _, benchmark := range substrBenchmarks {
        str := strings.Repeat("abc", benchmark.strLen)
        for _, function := range substrFunctions {
            benchmarkFunc := func(b *testing.B) {
                b.ResetTimer()
                for i := 0; i < b.N; i++ {
                    function.function(str, benchmark.subLo, benchmark.subHi)
                }
                b.StopTimer()
            }
            results := testing.Benchmark(benchmarkFunc)
            fmt.Println(benchmark.name, function.name, results)
        }
    }
}
func main() {
    BenchmarkSubstrSize()
}

输出:

BenchmarkSubstrSize:
Zero    Substr1   50000000    54.8 ns/op
Zero    Substr2  100000000    19.6 ns/op
Zero    Substr3  500000000     6.66 ns/op
Small   Substr1   20000000    95.7 ns/op
Small   Substr2   50000000    70.4 ns/op
Small   Substr3   50000000    70.1 ns/op
Medium  Substr1    5000000   380 ns/op
Medium  Substr2   10000000   229 ns/op
Medium  Substr3   10000000   213 ns/op
Large   Substr1     500000  4290 ns/op
Large   Substr2    1000000  2007 ns/op
Large   Substr3    1000000  2275 ns/op

Answer 3

我不确定这是否可以被认为是一个增益:

package main
import (
        "fmt"
        "testing"
)
func f1(n int) (s int) {
        for i := 0; i < n; i++ {
                s += i
        }
        return
}
func f2(n int) (s int) {
        for i := 0; i < n; i++ {
                s += 2 * i
        }
        return
}
func bench(f func()) func(b *testing.B) {
        return func(b *testing.B) {
                for i := 0; i < b.N; i++ {
                        f()
                }
        }
}
func main() {
        fmt.Printf("%vn", testing.Benchmark(bench(func() { f1(42) })))
        fmt.Printf("%vn", testing.Benchmark(bench(func() { f2(24) })))
}

---

输出:

(16:55) jnml@fsc-r550:~/src/tmp/SO/16920669$ go run main.go 
50000000            68.4 ns/op
50000000            35.8 ns/op
(16:55) jnml@fsc-r550:~/src/tmp/SO/16920669$