mirror of https://go.googlesource.com/go
349 lines
11 KiB
Go
349 lines
11 KiB
Go
// Copyright 2018 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Garbage collector: stack objects and stack tracing
|
|
// See the design doc at https://docs.google.com/document/d/1un-Jn47yByHL7I0aVIP_uVCMxjdM5mpelJhiKlIqxkE/edit?usp=sharing
|
|
// Also see issue 22350.
|
|
|
|
// Stack tracing solves the problem of determining which parts of the
|
|
// stack are live and should be scanned. It runs as part of scanning
|
|
// a single goroutine stack.
|
|
//
|
|
// Normally determining which parts of the stack are live is easy to
|
|
// do statically, as user code has explicit references (reads and
|
|
// writes) to stack variables. The compiler can do a simple dataflow
|
|
// analysis to determine liveness of stack variables at every point in
|
|
// the code. See cmd/compile/internal/gc/plive.go for that analysis.
|
|
//
|
|
// However, when we take the address of a stack variable, determining
|
|
// whether that variable is still live is less clear. We can still
|
|
// look for static accesses, but accesses through a pointer to the
|
|
// variable are difficult in general to track statically. That pointer
|
|
// can be passed among functions on the stack, conditionally retained,
|
|
// etc.
|
|
//
|
|
// Instead, we will track pointers to stack variables dynamically.
|
|
// All pointers to stack-allocated variables will themselves be on the
|
|
// stack somewhere (or in associated locations, like defer records), so
|
|
// we can find them all efficiently.
|
|
//
|
|
// Stack tracing is organized as a mini garbage collection tracing
|
|
// pass. The objects in this garbage collection are all the variables
|
|
// on the stack whose address is taken, and which themselves contain a
|
|
// pointer. We call these variables "stack objects".
|
|
//
|
|
// We begin by determining all the stack objects on the stack and all
|
|
// the statically live pointers that may point into the stack. We then
|
|
// process each pointer to see if it points to a stack object. If it
|
|
// does, we scan that stack object. It may contain pointers into the
|
|
// heap, in which case those pointers are passed to the main garbage
|
|
// collection. It may also contain pointers into the stack, in which
|
|
// case we add them to our set of stack pointers.
|
|
//
|
|
// Once we're done processing all the pointers (including the ones we
|
|
// added during processing), we've found all the stack objects that
|
|
// are live. Any dead stack objects are not scanned and their contents
|
|
// will not keep heap objects live. Unlike the main garbage
|
|
// collection, we can't sweep the dead stack objects; they live on in
|
|
// a moribund state until the stack frame that contains them is
|
|
// popped.
|
|
//
|
|
// A stack can look like this:
|
|
//
|
|
// +----------+
|
|
// | foo() |
|
|
// | +------+ |
|
|
// | | A | | <---\
|
|
// | +------+ | |
|
|
// | | |
|
|
// | +------+ | |
|
|
// | | B | | |
|
|
// | +------+ | |
|
|
// | | |
|
|
// +----------+ |
|
|
// | bar() | |
|
|
// | +------+ | |
|
|
// | | C | | <-\ |
|
|
// | +----|-+ | | |
|
|
// | | | | |
|
|
// | +----v-+ | | |
|
|
// | | D ---------/
|
|
// | +------+ | |
|
|
// | | |
|
|
// +----------+ |
|
|
// | baz() | |
|
|
// | +------+ | |
|
|
// | | E -------/
|
|
// | +------+ |
|
|
// | ^ |
|
|
// | F: --/ |
|
|
// | |
|
|
// +----------+
|
|
//
|
|
// foo() calls bar() calls baz(). Each has a frame on the stack.
|
|
// foo() has stack objects A and B.
|
|
// bar() has stack objects C and D, with C pointing to D and D pointing to A.
|
|
// baz() has a stack object E pointing to C, and a local variable F pointing to E.
|
|
//
|
|
// Starting from the pointer in local variable F, we will eventually
|
|
// scan all of E, C, D, and A (in that order). B is never scanned
|
|
// because there is no live pointer to it. If B is also statically
|
|
// dead (meaning that foo() never accesses B again after it calls
|
|
// bar()), then B's pointers into the heap are not considered live.
|
|
|
|
package runtime
|
|
|
|
import (
|
|
"internal/goarch"
|
|
"runtime/internal/sys"
|
|
"unsafe"
|
|
)
|
|
|
|
const stackTraceDebug = false
|
|
|
|
// Buffer for pointers found during stack tracing.
|
|
// Must be smaller than or equal to workbuf.
|
|
type stackWorkBuf struct {
|
|
_ sys.NotInHeap
|
|
stackWorkBufHdr
|
|
obj [(_WorkbufSize - unsafe.Sizeof(stackWorkBufHdr{})) / goarch.PtrSize]uintptr
|
|
}
|
|
|
|
// Header declaration must come after the buf declaration above, because of issue #14620.
|
|
type stackWorkBufHdr struct {
|
|
_ sys.NotInHeap
|
|
workbufhdr
|
|
next *stackWorkBuf // linked list of workbufs
|
|
// Note: we could theoretically repurpose lfnode.next as this next pointer.
|
|
// It would save 1 word, but that probably isn't worth busting open
|
|
// the lfnode API.
|
|
}
|
|
|
|
// Buffer for stack objects found on a goroutine stack.
|
|
// Must be smaller than or equal to workbuf.
|
|
type stackObjectBuf struct {
|
|
_ sys.NotInHeap
|
|
stackObjectBufHdr
|
|
obj [(_WorkbufSize - unsafe.Sizeof(stackObjectBufHdr{})) / unsafe.Sizeof(stackObject{})]stackObject
|
|
}
|
|
|
|
type stackObjectBufHdr struct {
|
|
_ sys.NotInHeap
|
|
workbufhdr
|
|
next *stackObjectBuf
|
|
}
|
|
|
|
func init() {
|
|
if unsafe.Sizeof(stackWorkBuf{}) > unsafe.Sizeof(workbuf{}) {
|
|
panic("stackWorkBuf too big")
|
|
}
|
|
if unsafe.Sizeof(stackObjectBuf{}) > unsafe.Sizeof(workbuf{}) {
|
|
panic("stackObjectBuf too big")
|
|
}
|
|
}
|
|
|
|
// A stackObject represents a variable on the stack that has had
|
|
// its address taken.
|
|
type stackObject struct {
|
|
_ sys.NotInHeap
|
|
off uint32 // offset above stack.lo
|
|
size uint32 // size of object
|
|
r *stackObjectRecord // info of the object (for ptr/nonptr bits). nil if object has been scanned.
|
|
left *stackObject // objects with lower addresses
|
|
right *stackObject // objects with higher addresses
|
|
}
|
|
|
|
// obj.r = r, but with no write barrier.
|
|
//
|
|
//go:nowritebarrier
|
|
func (obj *stackObject) setRecord(r *stackObjectRecord) {
|
|
// Types of stack objects are always in read-only memory, not the heap.
|
|
// So not using a write barrier is ok.
|
|
*(*uintptr)(unsafe.Pointer(&obj.r)) = uintptr(unsafe.Pointer(r))
|
|
}
|
|
|
|
// A stackScanState keeps track of the state used during the GC walk
|
|
// of a goroutine.
|
|
type stackScanState struct {
|
|
// stack limits
|
|
stack stack
|
|
|
|
// conservative indicates that the next frame must be scanned conservatively.
|
|
// This applies only to the innermost frame at an async safe-point.
|
|
conservative bool
|
|
|
|
// buf contains the set of possible pointers to stack objects.
|
|
// Organized as a LIFO linked list of buffers.
|
|
// All buffers except possibly the head buffer are full.
|
|
buf *stackWorkBuf
|
|
freeBuf *stackWorkBuf // keep around one free buffer for allocation hysteresis
|
|
|
|
// cbuf contains conservative pointers to stack objects. If
|
|
// all pointers to a stack object are obtained via
|
|
// conservative scanning, then the stack object may be dead
|
|
// and may contain dead pointers, so it must be scanned
|
|
// defensively.
|
|
cbuf *stackWorkBuf
|
|
|
|
// list of stack objects
|
|
// Objects are in increasing address order.
|
|
head *stackObjectBuf
|
|
tail *stackObjectBuf
|
|
nobjs int
|
|
|
|
// root of binary tree for fast object lookup by address
|
|
// Initialized by buildIndex.
|
|
root *stackObject
|
|
}
|
|
|
|
// Add p as a potential pointer to a stack object.
|
|
// p must be a stack address.
|
|
func (s *stackScanState) putPtr(p uintptr, conservative bool) {
|
|
if p < s.stack.lo || p >= s.stack.hi {
|
|
throw("address not a stack address")
|
|
}
|
|
head := &s.buf
|
|
if conservative {
|
|
head = &s.cbuf
|
|
}
|
|
buf := *head
|
|
if buf == nil {
|
|
// Initial setup.
|
|
buf = (*stackWorkBuf)(unsafe.Pointer(getempty()))
|
|
buf.nobj = 0
|
|
buf.next = nil
|
|
*head = buf
|
|
} else if buf.nobj == len(buf.obj) {
|
|
if s.freeBuf != nil {
|
|
buf = s.freeBuf
|
|
s.freeBuf = nil
|
|
} else {
|
|
buf = (*stackWorkBuf)(unsafe.Pointer(getempty()))
|
|
}
|
|
buf.nobj = 0
|
|
buf.next = *head
|
|
*head = buf
|
|
}
|
|
buf.obj[buf.nobj] = p
|
|
buf.nobj++
|
|
}
|
|
|
|
// Remove and return a potential pointer to a stack object.
|
|
// Returns 0 if there are no more pointers available.
|
|
//
|
|
// This prefers non-conservative pointers so we scan stack objects
|
|
// precisely if there are any non-conservative pointers to them.
|
|
func (s *stackScanState) getPtr() (p uintptr, conservative bool) {
|
|
for _, head := range []**stackWorkBuf{&s.buf, &s.cbuf} {
|
|
buf := *head
|
|
if buf == nil {
|
|
// Never had any data.
|
|
continue
|
|
}
|
|
if buf.nobj == 0 {
|
|
if s.freeBuf != nil {
|
|
// Free old freeBuf.
|
|
putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
|
|
}
|
|
// Move buf to the freeBuf.
|
|
s.freeBuf = buf
|
|
buf = buf.next
|
|
*head = buf
|
|
if buf == nil {
|
|
// No more data in this list.
|
|
continue
|
|
}
|
|
}
|
|
buf.nobj--
|
|
return buf.obj[buf.nobj], head == &s.cbuf
|
|
}
|
|
// No more data in either list.
|
|
if s.freeBuf != nil {
|
|
putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
|
|
s.freeBuf = nil
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
// addObject adds a stack object at addr of type typ to the set of stack objects.
|
|
func (s *stackScanState) addObject(addr uintptr, r *stackObjectRecord) {
|
|
x := s.tail
|
|
if x == nil {
|
|
// initial setup
|
|
x = (*stackObjectBuf)(unsafe.Pointer(getempty()))
|
|
x.next = nil
|
|
s.head = x
|
|
s.tail = x
|
|
}
|
|
if x.nobj > 0 && uint32(addr-s.stack.lo) < x.obj[x.nobj-1].off+x.obj[x.nobj-1].size {
|
|
throw("objects added out of order or overlapping")
|
|
}
|
|
if x.nobj == len(x.obj) {
|
|
// full buffer - allocate a new buffer, add to end of linked list
|
|
y := (*stackObjectBuf)(unsafe.Pointer(getempty()))
|
|
y.next = nil
|
|
x.next = y
|
|
s.tail = y
|
|
x = y
|
|
}
|
|
obj := &x.obj[x.nobj]
|
|
x.nobj++
|
|
obj.off = uint32(addr - s.stack.lo)
|
|
obj.size = uint32(r.size)
|
|
obj.setRecord(r)
|
|
// obj.left and obj.right will be initialized by buildIndex before use.
|
|
s.nobjs++
|
|
}
|
|
|
|
// buildIndex initializes s.root to a binary search tree.
|
|
// It should be called after all addObject calls but before
|
|
// any call of findObject.
|
|
func (s *stackScanState) buildIndex() {
|
|
s.root, _, _ = binarySearchTree(s.head, 0, s.nobjs)
|
|
}
|
|
|
|
// Build a binary search tree with the n objects in the list
|
|
// x.obj[idx], x.obj[idx+1], ..., x.next.obj[0], ...
|
|
// Returns the root of that tree, and the buf+idx of the nth object after x.obj[idx].
|
|
// (The first object that was not included in the binary search tree.)
|
|
// If n == 0, returns nil, x.
|
|
func binarySearchTree(x *stackObjectBuf, idx int, n int) (root *stackObject, restBuf *stackObjectBuf, restIdx int) {
|
|
if n == 0 {
|
|
return nil, x, idx
|
|
}
|
|
var left, right *stackObject
|
|
left, x, idx = binarySearchTree(x, idx, n/2)
|
|
root = &x.obj[idx]
|
|
idx++
|
|
if idx == len(x.obj) {
|
|
x = x.next
|
|
idx = 0
|
|
}
|
|
right, x, idx = binarySearchTree(x, idx, n-n/2-1)
|
|
root.left = left
|
|
root.right = right
|
|
return root, x, idx
|
|
}
|
|
|
|
// findObject returns the stack object containing address a, if any.
|
|
// Must have called buildIndex previously.
|
|
func (s *stackScanState) findObject(a uintptr) *stackObject {
|
|
off := uint32(a - s.stack.lo)
|
|
obj := s.root
|
|
for {
|
|
if obj == nil {
|
|
return nil
|
|
}
|
|
if off < obj.off {
|
|
obj = obj.left
|
|
continue
|
|
}
|
|
if off >= obj.off+obj.size {
|
|
obj = obj.right
|
|
continue
|
|
}
|
|
return obj
|
|
}
|
|
}
|