go - benchmem 的输出

Question

使用内存分析器运行基准测试时，我看到以下输出

SomeFunc             100      17768876 ns/op         111 B/op          0 allocs/op

我不明白输出 - 0 allocs/op 但分配了 111 B？知道这是什么意思吗？我的函数是否在堆上分配内存？

Answer 1

基准测试结果收集在 testing.BenchmarkResult 类型的值中:

type BenchmarkResult struct {
        N         int           // The number of iterations.
        T         time.Duration // The total time taken.
        Bytes     int64         // Bytes processed in one iteration.
        MemAllocs uint64        // The total number of memory allocations; added in Go 1.1
        MemBytes  uint64        // The total number of bytes allocated; added in Go 1.1
}

您看到的已分配内存和每个操作分配的值由 BencharkResult.AllocedBytesPerOp() 返回和 BenchmarkResult.AllocsPerOp() .他们记录返回值是:

AllocedBytesPerOp returns r.MemBytes / r.N.

AllocsPerOp returns r.MemAllocs / r.N.

所以结果是整数除法。这意味着如果一个基准函数在不同的调用中执行不同数量的分配，结果可能不是整数，但小数部分会被丢弃(这就是整数除法的工作原理)。

因此，如果一个函数平均执行少于 1 次分配，您将看到 0 allocs/op，但如果平均每次调用至少 1 字节，则分配的内存可能大于 0。

让我们看一个例子:

var (
    counter   int
    falseCond bool // Always false at runtime
)

func AvgHalfAllocs() {
    counter++
    if counter%2 == 0 {
        return
    }
    buf := make([]byte, 128)
    if falseCond {
        fmt.Println(buf)
    }
}

func AvgOneAndHalfAllocs() {
    for i := 0; i < 3; i++ {
        AvgHalfAllocs()
    }
}

此处 AvgHalfAllocs() 平均每次调用进行一半分配，它通过从一半调用返回而不分配任何东西，并在另一半调用中恰好进行 1 次分配来实现。

AvgOneAndHalfAllocs() 平均每次调用执行 1.5 次分配，因为它调用 AvgHalfAllocs() 3 次。

^{falseCond 变量和 fmt.Println() 调用的目的只是让编译器不会优化我们的分配，但是 fmt.Println() 永远不会被调用，因此它不会干扰分配。}

像这样对上述 2 个函数进行基准测试:

func BenchmarkAvgHalfAllocs(b *testing.B) {
    for i := 0; i < b.N; i++ {
        AvgHalfAllocs()
    }
}

func BenchmarkAvgOneAndHalfAllocs(b *testing.B) {
    for i := 0; i < b.N; i++ {
        AvgOneAndHalfAllocs()
    }
}

结果是:

BenchmarkAvgHalfAllocs-4          50000000    29.2 ns/op    64 B/op   0 allocs/op
BenchmarkAvgOneAndHalfAllocs-4    20000000    92.0 ns/op   192 B/op   1 allocs/op

如您所见，在 AvgHalfAllocs() 的情况下，每次调用 0.5 的分配被截断为 0，在 AvgOneAndHalfAllocs 的情况下，1.5 被截断为 1 ()。

AvgHalfAllocs() 的平均分配内存为 0.5 * 128 字节 = 64 字节。

AvgOneAndHalfAllocs() 的平均分配内存为 1.5 * 128 字节 = 192 字节。