go - 为什么指向局部变量的指针会逃逸到堆中？

Question

这是我的go环境:

[lorneli@localhost GoTest]$ go version
go version go1.9 linux/amd64

这是我的程序:

package main

type request struct {
    ID string
    size uint32
    off uint64
}

func main() {
    r := request{}
    iter := interface{}(&r) // &r escapes to heap
    iters := make([]interface{}, 0)
    iters = append(iters, iter)
}

我分配了一个 request 实例并将它的指针转换为 interface{}。但是当用标志 -gcflags "-m" 分析时，我发现实例逃逸了转换时堆。为什么会这样？

分析结果如下:

[lorneli@localhost GoTest]$ go build -gcflags "-m"
# _/mnt/hgfs/vmfolder/workspace/GoTest
./main.go:9:6: can inline main
./main.go:11:21: (interface {})(&r) escapes to heap
./main.go:11:22: &r escapes to heap
./main.go:10:15: moved to heap: r
./main.go:12:15: main make([]interface {}, 0) does not escape

我认为这个案例与 "Go Escape Analysis Flaws" 上列出的任何案例都不匹配.

Answer 1

简化您的示例。使用 -gcflags='-m -m' 进行分析。

示例 1:

package main

func main() {
    var v int
    s := make([]*int, 0)
    s = append(s, &v) // &v escapes to heap
}

输出:

$ go version
go version devel +df8c2b905b Tue Mar 6 06:13:17 2018 +0000 linux/amd64
$ go run -gcflags='-m -m' esc.go
# command-line-arguments
./esc.go:3:6: can inline main as: func() { var v int; v = <N>; s := make([]*int, 0); s = append(s, &v) }
./esc.go:6:16: &v escapes to heap
./esc.go:6:16:  from append(s, &v) (appended to slice) at ./esc.go:6:12
./esc.go:4:6: moved to heap: v
./esc.go:5:11: main make([]*int, 0) does not escape
$ 

---

逃逸分析确定对值的任何引用是否逃逸了声明该值的函数。对函数 main 中声明的变量 v 的引用作为函数 append 的参数转义:&v 从 append 转义到堆(s, &v), 移动到堆:v。

---

示例 2:

package main

func main() {
    var v int
    lc := 1
    s := make([]*int, lc)
    s[0] = &v
}

$ go run -gcflags='-m -m' esc2.go
./esc2.go:3:6: can inline main as: func() { var v int; v = <N>; lc := 1; s := make([]*int, lc); s[0] = &v }
./esc2.go:6:11: make([]*int, lc) escapes to heap
./esc2.go:6:11:     from make([]*int, lc) (too large for stack) at ./esc2.go:6:11
./esc2.go:7:9: &v escapes to heap
./esc2.go:7:9:  from s[0] (slice-element-equals) at ./esc2.go:7:7
./esc2.go:4:6: moved to heap: v
$ 

---

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

slice 的

make 返回一个 slice 描述符 struct(指向底层数组、长度和容量的指针)并分配一个底层 slice 元素数组。底层数组一般分配在堆上:make([]*int, lc) 从 make([]*int, lc) 转义到堆。

s[0] = &v 在堆上的底层数组中存储对变量v (&v) 的引用:&v 从 s[0] (slice-element-equals) 逃逸到堆，移动到堆:v。引用保留在堆上，在函数结束并且它的堆栈被回收之后，直到底层数组被垃圾回收。

如果 make slice 容量是一个小的(编译时)常量，make([]*int, 1) 在您的示例中，可能会分配底层数组在堆栈上。然而，逃逸分析没有考虑到这一点。