3

在学习 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库中？

4

3 回答 3

4

这是一个使用闭包的真实、简单且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
于 2013-06-04T21:36:08.307 回答
4

实际上，这不是在 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) }

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

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

于 2013-06-04T14:51:39.597 回答
1

我不确定这是否可以被视为一种收获：

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("%v\n", testing.Benchmark(bench(func() { f1(42) })))
        fmt.Printf("%v\n", 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$
于 2013-06-04T14:56:09.710 回答