Question

与 mcentral 类似，有个全局 stackpool 负责平衡，为 mcache.stackcache 提供后备内存。

// stack.go

// Global pool of spans that have free stacks.
// Stacks are assigned an order according to size.
//     order = log_2(size/FixedStack)
// There is a free list for each order.

var stackpool [_NumStackOrders]struct {
	item stackpoolItem
}

type stackpoolItem struct {
	mu   mutex
	span mSpanList
}

// mheap.go

// mSpanList heads a linked list of spans.
type mSpanList struct {
	first *mspan
	last  *mspan
}

type mspan struct {
    manualFreeList gclinkptr // list of free objects in mSpanManual spans    
}

• stackpoolItem.span: 多个 mspan 构成的链表。
• mspan.manualFreeList: 切分好可供复用的栈内存。

本地缓存不足，从 stackpool 扩容。

// stack.go

// stackcacherefill/stackcacherelease implement a global pool of stack segments.
// The pool is required to prevent unlimited growth of per-thread caches.

func stackcacherefill(c *mcache, order uint8) {
    
	// Grab some stacks from the global cache.
	// Grab half of the allowed capacity (to prevent thrashing).
    
	var list gclinkptr
	var size uintptr
	lock(&stackpool[order].item.mu)
    
	for size < _StackCacheSize/2 {
		x := stackpoolalloc(order)
		x.ptr().next = list
		list = x
		size += _FixedStack << order
	}
    
	unlock(&stackpool[order].item.mu)
	c.stackcache[order].list = list
	c.stackcache[order].size = size
}

// Allocates a stack from the free pool. Must be called with
// stackpool[order].item.mu held.

func stackpoolalloc(order uint8) gclinkptr {
    
    // 从链表提取 span。
	list := &stackpool[order].item.span
	s := list.first

    // 如 span 为空。
	if s == nil {
        
		// 从堆获取新内存块。
		s = mheap_.allocManual(_StackCacheSize>>_PageShift, spanAllocStack)
		osStackAlloc(s)
        
        // 切分，串成链表。
		s.elemsize = _FixedStack << order
		for i := uintptr(0); i < _StackCacheSize; i += s.elemsize {
			x := gclinkptr(s.base() + i)
			x.ptr().next = s.manualFreeList
			s.manualFreeList = x
		}
        
        // 插入 span 链表。
		list.insert(s)
	}
    
    // 提取内存块。
	x := s.manualFreeList
	s.manualFreeList = x.ptr().next
	s.allocCount++
    
    // 该 span 没有剩余内存，从链表移除。
	if s.manualFreeList.ptr() == nil {
		// all stacks in s are allocated.
		list.remove(s)
	}
    
	return x
}

而当本地数量过多时，则归还部分给全局池。

// stack.go

func stackcacherelease(c *mcache, order uint8) {
	
    x := c.stackcache[order].list
	size := c.stackcache[order].size
	lock(&stackpool[order].item.mu)
    
	for size > _StackCacheSize/2 {
		y := x.ptr().next
		stackpoolfree(x, order)
		x = y
		size -= _FixedStack << order
	}
    
	unlock(&stackpool[order].item.mu)
	c.stackcache[order].list = x
	c.stackcache[order].size = size
}

// Adds stack x to the free pool. 
// Must be called with stackpool[order].item.mu held.

func stackpoolfree(x gclinkptr, order uint8) {

    // 所在 span。
    s := spanOfUnchecked(uintptr(x))
    
    // 如该 span 内存块链表为空，直接放回。
	if s.manualFreeList.ptr() == nil {
		// s will now have a free stack
		stackpool[order].item.span.insert(s)
	}
    
    // 放回 span 内存块链表。
	x.ptr().next = s.manualFreeList
	s.manualFreeList = x
	s.allocCount--
    
    // 如果该 span 内存被全部收回，则将其归还给堆。
	if gcphase == _GCoff && s.allocCount == 0 {
        
		// Span is completely free. Return it to the heap
		// immediately if we're sweeping.
        
		stackpool[order].item.span.remove(s)
		s.manualFreeList = 0
        
		osStackFree(s)
		mheap_.freeManual(s, spanAllocStack)
	}
}