performance - Go 语言指针性能

Question

以下代码显示了两个基准。第一个在每次迭代中按值创建一个结构，而第二个确实使用指向该结构的指针。

为什么后者慢 20 倍？？我知道 GoLang 的 GC 问题，但逃逸分析不应该处理这些情况吗？

我使用的是 go1.4beta1，但 1.3.3 给了我[相同 - 错误]不同的结果。

有什么想法吗？

package main

import "testing"

type Adder struct {
    vals []int
}

func (a *Adder) add() int {
    return a.vals[0] + a.vals[1]
}

func BenchmarkWithoutPointer(b *testing.B) {
    accum := 0
    for i := 0; i < b.N; i++ {
        adder := Adder{[]int{accum, i}}
        accum = adder.add()
    }
    _ = accum
}

func BenchmarkWithPointer(b *testing.B) {
    accum := 0
    for i := 0; i < b.N; i++ {
        adder := &Adder{[]int{accum, i}}
        accum = adder.add()
    }
    _ = accum
}

基准go1.4.1:

 $ go test -bench=.                                                                                                                             

testing: warning: no tests to run
PASS
BenchmarkWithoutPointer 1000000000           2.92 ns/op
BenchmarkWithPointer    30000000            57.8 ns/op
ok      github.com/XXXXXXXXXX/bench/perf    5.010s

基准go1.3.3:

testing: warning: no tests to run
PASS
BenchmarkWithoutPointer 500000000            7.89 ns/op
BenchmarkWithPointer    50000000            37.5 ns/op
ok      

编辑:

结论:

正如 Ainar-G 所说，[]int 在第二个基准测试中确实逃到了堆中。在阅读了更多关于 1.4beta1 的信息后，似乎在访问由新的 GC 计划引起的堆时引入了新的写屏障。但原始执行似乎有所增加。期待 1.5 =)。

Answer 1

使用 -m gcflag 运行基准测试给出了可能的答案:

./main_test.go:16: BenchmarkWithoutPointer []int literal does not escape
(...)
./main_test.go:25: []int literal escapes to heap

第二个示例中的[]int 转义到堆，这比堆栈慢。如果您为参数使用单独的 x 和 y 字段而不是 slice

type Adder struct {
    x, y int
}

func (a *Adder) add() int {
    return a.x + a.y
}

基准显示了预期的行为:

BenchmarkWithoutPointer 1000000000               2.27 ns/op
BenchmarkWithPointer    2000000000               1.98 ns/op