Question

代码：

func MaxSmallSize() {
    a := make([]int64, 8191)
    b := make([]int64, 8192)
    _ = a
    _ = b
}

然后运行go build -gcflags='-m' . 2>&1以检查内存分配详细信息。结果：

./mem.go:10: can inline MaxSmallSize
./mem.go:12: make([]int64, 8192) escapes to heap
./mem.go:11: MaxSmallSize make([]int64, 8191) does not escape

我的问题是为什么a是小对象且b是大对象？

make 64KB将转义为堆，而less将在堆栈中分配。 _MaxSmallSize = 32 << 10是否是原因？

go env

GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/vagrant/gopath"
GORACE=""
GOROOT="/home/vagrant/go"
GOTOOLDIR="/home/vagrant/go/pkg/tool/linux_amd64"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build201775001=/tmp/go-build"
CXX="g++"
CGO_ENABLED="1"

Answer 1

由于语言规范中未提及，因此它是一个实现细节，因此，它可能会根据许多内容（Go版本，目标操作系统，体系结构等）而有所不同。

如果您想了解其当前值或开始挖掘的地方，请查看cmd/compile/internal/gc包裹。

决定在哪里分配变量的escape analysis位于cmd/compile/internal/gc/esc.go。 make切片操作的检查是未导出的函数esc()：

func esc(e *EscState, n *Node, up *Node) {
    // ...

    // Big stuff escapes unconditionally
    // "Big" conditions that were scattered around in walk have been gathered here
    if n.Esc != EscHeap && n.Type != nil &&
        (n.Type.Width > MaxStackVarSize ||
            (n.Op == ONEW || n.Op == OPTRLIT) && n.Type.Elem().Width >= 1<<16 ||
            n.Op == OMAKESLICE && !isSmallMakeSlice(n)) {
        if Debug['m'] > 2 {
            Warnl(n.Lineno, "%v is too large for stack", n)
        }
        n.Esc = EscHeap
        addrescapes(n)
        escassignSinkNilWhy(e, n, n, "too large for stack") // TODO category: tooLarge
    }

    // ...
}

涉及大小的决定在函数isSmallMakeSlice()中，这在文件cmd/compile/internal/gc/walk.go中：

func isSmallMakeSlice(n *Node) bool {
    if n.Op != OMAKESLICE {
        return false
    }
    l := n.Left
    r := n.Right
    if r == nil {
        r = l
    }
    t := n.Type

    return Smallintconst(l) && Smallintconst(r) && (t.Elem().Width == 0 || r.Int64() < (1<<16)/t.Elem().Width)
}

尺寸限制为：

r.Int64() < (1<<16)/t.Elem().Width

r是切片的长度或容量（如果提供了上限），t.Elem().Width是元素类型的字节大小：

NumElem < 65536 / SizeElem

在你的情况下：

NumElem < 65536 / 8 = 8192

因此，如果切片类型为[]uint64，则8192是在堆上（而不是堆栈）分配它的限制，就像您所经历的那样。

Go中关于堆栈分配的什么被认为是“小”对象？

1 个答案: