或突然减速，具体取决于阵列大小

Question

我写了一个简单的程序，它OR了一个巨大的go切片中包含的所有值。当我使用大 10 倍的切片时，我预计性能会下降 10 倍。但是，在执行提供的测试时，存在巨大的性能差距。程序输出如下：

oadam@oadam-Latitude-E6510:~/$ go test -bench .
testing: warning: no tests to run
PASS
BenchmarkLittle 2000000000           0.11 ns/op
BenchmarkBig           1    2417869962 ns/op
ok      _/home/oadam/   5.048s

和代码

package main
import (
    "math/rand"
    "testing"
)
const (
    little = 5000000
    big    = 50000000
)
var a = make([]uint32, big)
func benchOR(b *testing.B, l int) {
    for i := 0; i < l; i++ {
        a[i] = rand.Uint32()
    }
    var result uint32
    for i := 0; i < l; i++ {
        result |= a[i]
    }
}
func BenchmarkLittle(b *testing.B) {
    benchOR(b, little)
}
func BenchmarkBig(b *testing.B) {
    benchOR(b, big)
}

编辑：必须是go测试台中的一个错误。使用手动计时我不重现

package main
import (
    "log"
    "math/rand"
    "time"
)
const (
    little = 5000000
    big    = 50000000
)
var a = make([]uint32, big)
func initA(l int) {
    for i := 0; i < l; i++ {
        a[i] = rand.Uint32()
    }
}
func test(l int) uint32 {
    var result uint32
    for i := 0; i < l; i++ {
        result |= a[i]
    }
    return result
}
func main() {
    initA(little)
    var before = time.Now()
    test(little)
    log.Println(time.Since(before))
    initA(big)
    var before2 = time.Now()
    test(big)
    log.Println(time.Since(before2))
}

Answer 1

问题是你没有使用 b.N ，它告诉你运行基准测试的次数。此外，如果您只想对 ORing 进行基准测试，则可能只初始化数组一次，或者至少调用 b.ResetTimer() 这样初始化就不会被计算在内。

这是我最终得到的结果，它给出了预期的结果：

package main
import (
    "math/rand"
    "testing"
)
const (
    little = 5000000
    big    = 50000000
)
var a = make([]uint32, big)
func init() {
    for i := 0; i < big; i++ {
        a[i] = rand.Uint32()
    }
}
func benchOR(b *testing.B, l int) {
    var result uint32
    for _, u := range a[:l] {
        result |= u
    }
}
func BenchmarkLittle(b *testing.B) {
    for i := 0; i < b.N; i++ {
        benchOR(b, little)
    }
}
func BenchmarkBig(b *testing.B) {
    for i := 0; i < b.N; i++ {
        benchOR(b, big)
    }
}

我的结果：

BenchmarkLittle      500       3222064 ns/op
BenchmarkBig          50      32268023 ns/op

Answer 2

我不认为这是一个错误。我稍微修改了你的代码，这就是我得到的：

% go test -bench=.
testing: warning: no tests to run
PASS
BenchmarkLittle 2000000000           0.00 ns/op
BenchmarkBig  2000000000           0.02 ns/op
ok    _/Users/kavu/TMP/becnh_or 12.659s

法典：

    package main
    import (
        "math/rand"
        "testing"
    )
    const (
        little = 5000000
        big    = 50000000
    )
    func benchOR(a []uint32, l int) (result uint32) {
        for i := 0; i < l; i++ {
            result |= a[i]
        }
        return result
    }
    func BenchmarkLittle(b *testing.B) {
        var a = make([]uint32, big)
        for i := 0; i < little; i++ {
            a[i] = rand.Uint32()
        }
        b.ResetTimer()
        benchOR(a, little)
    }
    func BenchmarkBig(b *testing.B) {
        var a = make([]uint32, big)
        for i := 0; i < big; i++ {
            a[i] = rand.Uint32()
        }
        b.ResetTimer()
        benchOR(a, big)
    }

您可以注释掉b.ResetTimer()并benchOR(a, big)事情，看看会发生什么。您也可以尝试big常量。10000000某个地方，即使不重置计时器，它也足够快。因此，用rand.Uint32生成一大块会减慢一切。