深入Go内存管理：TCMalloc启发的多层次分配器源码解析与实践

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

type mheap struct {
    _ sys.NotInHeap
    
    // 全局锁，保护堆的并发访问
    lock mutex
    
    // 页分配器，管理虚拟地址空间
    pages pageAlloc
    
    // 清扫代数，用于GC清扫
    sweepgen uint32
    
    // 所有span的集合
    allspans []*mspan
    
    // 按页数索引的空闲span列表（已废弃，现在使用pageAlloc）
    // free [_MaxMHeapList]mSpanList
    
    // 比例清扫相关参数
    pagesInUse         atomic.Uintptr // 正在使用的页数
    pagesSwept         atomic.Uint64  // 已清扫的页数
    pagesSweptBasis    atomic.Uint64  // 清扫基准
    sweepHeapLiveBasis uint64         // 堆存活基准
    sweepPagesPerByte  float64        // 每字节清扫页数比例
    
    // 清扫相关状态
    reclaimIndex atomic.Uintptr // 回收索引
    reclaimCredit atomic.Uintptr // 回收信用
    
    // 各种大小类的中心缓存
    central [numSpanClasses]struct {
        mcentral mcentral
        pad      [cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize]byte
    }
    
    // 固定大小对象分配器
    spanalloc             fixalloc // mspan分配器
    cachealloc            fixalloc // mcache分配器
    specialfinalizeralloc fixalloc // specialfinalizer分配器
    specialprofilealloc   fixalloc // specialprofile分配器
    speciallock           mutex    // 特殊对象锁
    
    // arena相关
    arenaHints      *arenaHint   // arena分配提示
    arenaHintAlloc  fixalloc     // arenaHint分配器
    
    // 堆区域管理
    heapArenas []heapArena       // 堆区域数组
    markArenas []heapArena       // 标记时的堆区域快照
    curArena   struct {
        base, end uintptr        // 当前arena的范围
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

type mspan struct {
    _ sys.NotInHeap
    
    next *mspan     // 链表中的下一个span
    prev *mspan     // 链表中的前一个span
    list *mSpanList // 所属链表（用于调试）
    
    startAddr uintptr // span起始地址
    npages    uintptr // span包含的页数
    
    // 手动管理的空闲对象链表
    manualFreeList gclinkptr
    
    // 分配相关字段
    freeindex uint16 // 下一个空闲对象的索引
    nelems    uint16 // span中对象的总数
    freeIndexForScan uint16 // GC扫描用的空闲索引
    
    // 分配位图和GC位图
    allocCache uint64    // 分配缓存，加速查找空闲对象
    allocBits  *gcBits   // 分配位图
    gcmarkBits *gcBits   // GC标记位图
    
    // span状态和属性
    sweepgen    uint32    // 清扫代数
    divMul      uint32    // 除法优化乘数
    allocCount  uint16    // 已分配对象数
    spanclass   spanClass // span类别（大小类+扫描性）
    state       mSpanStateBox // span状态
    needzero    uint8     // 是否需要清零
    elemsize    uintptr   // 对象大小
    
    // 特殊对象链表
    specials *special // 特殊对象（finalizer等）
    
    // GC相关
    sweepgen uint32 // 清扫代数
    
    // 限制相关
    limit uintptr // span结束地址
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

type mcache struct {
    _ sys.NotInHeap
    
    // 内存分析相关
    nextSample  int64   // 下次采样触发点
    memProfRate int     // 内存分析采样率
    scanAlloc   uintptr // 可扫描堆分配字节数
    
    // Tiny分配器
    tiny       uintptr // 当前tiny块指针
    tinyoffset uintptr // tiny块内偏移
    tinyAllocs uintptr // tiny分配计数
    
    // 按大小类索引的span数组
    alloc [numSpanClasses]*mspan
    
    // 栈缓存
    stackcache [_NumStackOrders]stackfreelist
    
    // 刷新代数，用于GC协调
    flushGen atomic.Uint32
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

type mcentral struct {
    _ sys.NotInHeap
    
    spanclass spanClass // 管理的span类别
    
    // 双缓冲区设计：partial和full各有两个spanSet
    // 在每个GC周期中交换角色
    partial [2]spanSet // 部分空闲的span集合
    full    [2]spanSet // 完全分配的span集合
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    // 零大小分配的快速路径
    if size == 0 {
        return unsafe.Pointer(&zerobase)
    }
    
    // 调试钩子
    if debug.malloc {
        if x := preMallocgcDebug(size, typ); x != nil {
            return x
        }
    }
    
    // ASAN支持：添加红区
    var asanRZ uintptr
    if asanenabled {
        asanRZ = redZoneSize(size)
        size += asanRZ
    }
    
    // GC辅助标记
    if gcBlackenEnabled != 0 {
        deductAssistCredit(size)
    }
    
    // 根据大小选择分配策略
    var x unsafe.Pointer
    var elemsize uintptr
    
    if size <= maxSmallSize-gc.MallocHeaderSize {
        if typ == nil || !typ.Pointers() {
            // 无指针对象
            if size < maxTinySize {
                // Tiny分配
                x, elemsize = mallocgcTiny(size, typ)
            } else {
                // 小对象无指针分配
                x, elemsize = mallocgcSmallNoscan(size, typ, needzero)
            }
        } else {
            // 有指针对象
            if !needzero {
                throw("objects with pointers must be zeroed")
            }
            if heapBitsInSpan(size) {
                x, elemsize = mallocgcSmallScanNoHeader(size, typ)
            } else {
                x, elemsize = mallocgcSmallScanHeader(size, typ)
            }
        }
    } else {
        // 大对象分配
        x, elemsize = mallocgcLarge(size, typ, needzero)
    }
    
    // 内存屏障，确保初始化完成后才能被GC观察到
    publicationBarrier()
    
    // GC期间分配的对象直接标记为黑色
    if writeBarrier.enabled {
        gcmarknewobject(uintptr(x), size)
    }
    
    // 内存分析采样
    if rate := MemProfileRate; rate > 0 {
        profilealloc(mp, x, size)
    }
    
    return x
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

func mallocgcTiny(size uintptr, typ *_type) (unsafe.Pointer, uintptr) {
    mp := acquirem()
    if mp.mallocing != 0 {
        throw("malloc deadlock")
    }
    mp.mallocing = 1
    
    c := getMCache(mp)
    
    // Tiny分配器逻辑
    off := c.tinyoffset
    // 对齐到typ的对齐要求
    if typ != nil {
        align := uintptr(typ.Align_)
        if align > 1 {
            off = alignUp(off, align)
        }
    }
    
    if off+size <= maxTinySize && c.tiny != 0 {
        // 当前tiny块有足够空间
        x := unsafe.Pointer(c.tiny + off)
        c.tinyoffset = off + size
        c.tinyAllocs++
        mp.mallocing = 0
        releasem(mp)
        return x, maxTinySize
    }
    
    // 需要新的tiny块
    span := c.alloc[tinySpanClass]
    v := nextFreeFast(span)
    if v == 0 {
        v, span, _ = c.nextFree(tinySpanClass)
    }
    
    x := unsafe.Pointer(v)
    (*[2]uint64)(x)[0] = 0
    (*[2]uint64)(x)[1] = 0
    
    // 设置新的tiny块
    if typ != nil && typ.Pointers() {
        // 如果tiny对象包含指针，不能合并到tiny块中
        c.tiny = 0
        c.tinyoffset = 0
    } else {
        // 更新tiny块状态
        size = alignUp(size, 8)
        c.tiny = uintptr(x)
        c.tinyoffset = size
    }
    
    c.tinyAllocs++
    mp.mallocing = 0
    releasem(mp)
    return x, maxTinySize
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

func mallocgcSmallNoscan(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
    mp := acquirem()
    mp.mallocing = 1
    
    c := getMCache(mp)
    
    // 计算大小类
    var sizeclass uint8
    if size <= gc.SmallSizeMax-8 {
        sizeclass = gc.SizeToSizeClass8[divRoundUp(size, gc.SmallSizeDiv)]
    } else {
        sizeclass = gc.SizeToSizeClass128[divRoundUp(size-gc.SmallSizeMax, gc.LargeSizeDiv)]
    }
    
    size = uintptr(gc.SizeClassToSize[sizeclass])
    spc := makeSpanClass(sizeclass, true) // noscan=true
    span := c.alloc[spc]
    
    // 快速分配路径
    v := nextFreeFast(span)
    if v == 0 {
        // 慢速路径：需要重填span
        v, span, checkGCTrigger := c.nextFree(spc)
        if checkGCTrigger {
            // 可能触发GC
            if t := (gcTrigger{kind: gcTriggerHeap}); t.test() {
                gcStart(t)
            }
        }
    }
    
    x := unsafe.Pointer(v)
    
    // 清零内存（如果需要）
    if needzero && span.needzero != 0 {
        memclrNoHeapPointers(x, size)
    }
    
    // 发布屏障
    publicationBarrier()
    
    mp.mallocing = 0
    releasem(mp)
    return x, span.elemsize
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

func nextFreeFast(s *mspan) gclinkptr {
    theBit := sys.TrailingZeros64(s.allocCache) // 找到第一个0位
    if theBit < 64 {
        result := s.freeindex + uintptr(theBit)
        if result < s.nelems {
            freeidx := result + 1
            if freeidx%64 == 0 && freeidx != s.nelems {
                return 0 // 需要重新填充allocCache
            }
            s.allocCache >>= uint(theBit + 1)
            s.freeindex = freeidx
            s.allocCount++
            return gclinkptr(result*s.elemsize + s.base())
        }
    }
    return 0
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

func mallocgcLarge(size uintptr, typ *_type, needzero bool) (unsafe.Pointer, uintptr) {
    if size+gc.MallocHeaderSize < size {
        throw("size overflow")
    }
    
    // 计算需要的页数
    npages := size >> gc.PageShift
    if size&(gc.PageSize-1) != 0 {
        npages++
    }
    
    // 直接从mheap分配
    var s *mspan
    systemstack(func() {
        s = mheap_.alloc(npages, makeSpanClass(0, typ == nil || !typ.Pointers()))
    })
    
    if s == nil {
        throw("out of memory")
    }
    
    owner := muintptr(unsafe.Pointer(s))
    if typ != nil && typ.Pointers() {
        // 设置GC位图
        scanSize := typ.Size_
        heapBitsSetType(uintptr(s.base()), scanSize, typ)
        if dataSize := typ.Size_ - typ.PtrBytes; dataSize > 0 {
            memclrNoHeapPointers(unsafe.Pointer(uintptr(s.base())+scanSize), dataSize)
        }
    }
    
    // 大对象统计
    atomic.Xadd64(&memstats.nmalloc, 1)
    atomic.Xadd64(&memstats.total_alloc, int64(size))
    
    return unsafe.Pointer(s.base()), s.elemsize
}

1
2
3
4
5
6
7

func (c *mcentral) init(spc spanClass) {
    c.spanclass = spc
    lockInit(&c.partial[0].spineLock, lockRankSpanSetSpine)
    lockInit(&c.partial[1].spineLock, lockRankSpanSetSpine)
    lockInit(&c.full[0].spineLock, lockRankSpanSetSpine)
    lockInit(&c.full[1].spineLock, lockRankSpanSetSpine)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

func (c *mcentral) cacheSpan() *mspan {
    // 扣除清扫信用
    spanBytes := uintptr(gc.SizeClassToNPages[c.spanclass.sizeclass()]) * pageSize
    deductSweepCredit(spanBytes, 0)
    
    // 清扫预算，限制清扫时间
    spanBudget := 100
    
    var s *mspan
    var sl sweepLocker
    
    // 1. 首先尝试已清扫的部分空闲span
    sg := mheap_.sweepgen
    if s = c.partialSwept(sg).pop(); s != nil {
        goto havespan
    }
    
    // 2. 尝试清扫未清扫的span
    sl = sweep.active.begin()
    if sl.valid {
        // 清扫部分空闲的未清扫span
        for ; spanBudget >= 0; spanBudget-- {
            s = c.partialUnswept(sg).pop()
            if s == nil {
                break
            }
            if s, ok := sl.tryAcquire(s); ok {
                s.sweep(true)
                sweep.active.end(sl)
                goto havespan
            }
        }
        
        // 清扫完全分配的未清扫span
        for ; spanBudget >= 0; spanBudget-- {
            s = c.fullUnswept(sg).pop()
            if s == nil {
                break
            }
            if s, ok := sl.tryAcquire(s); ok {
                s.sweep(true)
                freeIndex := s.nextFreeIndex()
                if freeIndex != s.nelems {
                    s.freeindex = freeIndex
                    sweep.active.end(sl)
                    goto havespan
                }
                // 清扫后仍然满，移到已清扫的满span列表
                c.fullSwept(sg).push(s.mspan)
            }
        }
        sweep.active.end(sl)
    }
    
    // 3. 从mheap分配新span
    s = c.grow()
    if s == nil {
        return nil
    }
    
havespan:
    // 验证span状态
    n := int(s.nelems) - int(s.allocCount)
    if n == 0 || s.freeindex == s.nelems || s.allocCount == s.nelems {
        throw("span has no free objects")
    }
    
    // 更新统计信息
    atomic.Xadd64(&c.nmalloc, int64(n))
    usedBytes := uintptr(s.allocCount) * s.elemsize
    atomic.Xadd64(&memstats.heap_live, int64(spanBytes)-int64(usedBytes))
    
    return s
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func (c *mcentral) grow() *mspan {
    npages := uintptr(gc.SizeClassToNPages[c.spanclass.sizeclass()])
    size := uintptr(gc.SizeClassToSize[c.spanclass.sizeclass()])
    
    s := mheap_.alloc(npages, c.spanclass)
    if s == nil {
        return nil
    }
    
    // 初始化span
    n := (npages << gc.PageShift) / size
    s.limit = s.base() + size*n
    heapBitsForAddr(s.base(), size).initSpan(s)
    return s
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

func (p *pageAlloc) alloc(npages uintptr) (addr uintptr, scav uintptr) {
    assertLockHeld(p.mheapLock)
    
    // 检查搜索地址是否超出已知范围
    if chunkIndex(p.searchAddr.addr()) >= p.end {
        return 0, 0
    }
    
    // 快速路径：在当前搜索地址的chunk中查找
    searchAddr := minOffAddr
    if pallocChunkPages-chunkPageIndex(p.searchAddr.addr()) >= uint(npages) {
        i := chunkIndex(p.searchAddr.addr())
        if max := p.summary[len(p.summary)-1][i].max(); max >= uint(npages) {
            j, searchIdx := p.chunkOf(i).find(npages, chunkPageIndex(p.searchAddr.addr()))
            if j != ^uint(0) {
                addr = chunkBase(i) + uintptr(j)*pageSize
                searchAddr = offAddr{chunkBase(i) + uintptr(searchIdx)*pageSize}
                goto Found
            }
        }
    }
    
    // 慢速路径：使用基数树查找
    addr, searchAddr = p.find(npages)
    if addr == 0 {
        if npages == 1 {
            // 连一个页面都分配不了，堆已耗尽
            p.searchAddr = maxSearchAddr()
        }
        return 0, 0
    }
    
Found:
    // 标记页面为已分配
    scav = p.allocRange(addr, npages)
    
    // 更新搜索地址
    p.searchAddr = searchAddr
    
    return addr, scav
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

func (p *pageAlloc) find(npages uintptr) (uintptr, offAddr) {
    // 从根级别开始查找
    i := 0
    for l := 0; l < len(p.summary); l++ {
        // 在当前级别查找足够大的区域
        i, _ = p.findMappedAddr(offAddrOf(chunkBase(i)))
        if i >= len(p.summary[l]) {
            return 0, minOffAddr
        }
        
        // 查找满足条件的summary
        for ; i < len(p.summary[l]); i++ {
            if p.summary[l][i].max() >= uint(npages) {
                break
            }
        }
        
        if i >= len(p.summary[l]) {
            return 0, minOffAddr
        }
        
        // 转换到下一级别的索引
        i <<= levelBits[l]
    }
    
    // 在叶子chunk中查找具体页面
    ci := chunkIdx(i)
    j, _ := p.chunkOf(ci).find(npages, 0)
    if j == ^uint(0) {
        return 0, minOffAddr
    }
    
    addr := chunkBase(ci) + uintptr(j)*pageSize
    return addr, offAddr{addr + uintptr(npages)*pageSize}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

func stackalloc(n uint32) stack {
    thisg := getg()
    if thisg != thisg.m.g0 {
        throw("stackalloc not on scheduler stack")
    }
    if n&(n-1) != 0 {
        throw("stack size not a power of 2")
    }
    
    // 调试模式或系统分配模式
    if debug.efence != 0 || stackFromSystem != 0 {
        n = uint32(alignUp(uintptr(n), physPageSize))
        v := sysAlloc(uintptr(n), &memstats.stacks_sys, "goroutine stack (system)")
        if v == nil {
            throw("out of memory (stackalloc)")
        }
        return stack{uintptr(v), uintptr(v) + uintptr(n)}
    }
    
    // 小栈分配（使用固定大小分配器）
    var v unsafe.Pointer
    if n < fixedStack<<_NumStackOrders && n < _StackCacheSize {
        order := uint8(0)
        n2 := n
        for n2 > fixedStack {
            order++
            n2 >>= 1
        }
        
        var x gclinkptr
        if stackNoCache != 0 || thisg.m.p == 0 || thisg.m.preemptoff != "" {
            // 从全局栈池分配
            lock(&stackpool[order].item.mu)
            x = stackpoolalloc(order)
            unlock(&stackpool[order].item.mu)
        } else {
            // 从P的栈缓存分配
            c := thisg.m.p.ptr().mcache
            x = c.stackcache[order].list
            if x.ptr() == nil {
                // 缓存为空，重新填充
                stackcacherefill(c, order)
                x = c.stackcache[order].list
            }
            c.stackcache[order].list = x.ptr().next
            c.stackcache[order].size -= uintptr(n)
        }
        v = unsafe.Pointer(x)
    } else {
        // 大栈分配
        var s *mspan
        npage := uintptr(n) >> gc.PageShift
        log2npage := stacklog2(npage)
        
        // 尝试从大栈缓存获取
        lock(&stackLarge.lock)
        if !stackLarge.free[log2npage].isEmpty() {
            s = stackLarge.free[log2npage].first
            stackLarge.free[log2npage].remove(s)
        }
        unlock(&stackLarge.lock)
        
        if s == nil {
            // 从堆分配新的栈span
            s = mheap_.allocManual(npage, spanAllocStack)
            if s == nil {
                throw("out of memory")
            }
            osStackAlloc(s)
            s.elemsize = uintptr(n)
        }
        v = unsafe.Pointer(s.base())
    }
    
    return stack{uintptr(v), uintptr(v) + uintptr(n)}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

func stackfree(stk stack) {
    gp := getg()
    v := unsafe.Pointer(stk.lo)
    n := stk.hi - stk.lo
    
    if n&(n-1) != 0 {
        throw("stack not a power of 2")
    }
    
    // 调试模式直接释放给系统
    if debug.efence != 0 || stackFromSystem != 0 {
        if debug.efence != 0 || stackFaultOnFree != 0 {
            sysFault(v, n)
        } else {
            sysFree(v, n, &memstats.stacks_sys)
        }
        return
    }
    
    // 小栈释放到栈池
    if n < fixedStack<<_NumStackOrders && n < _StackCacheSize {
        order := uint8(0)
        n2 := n
        for n2 > fixedStack {
            order++
            n2 >>= 1
        }
        
        x := gclinkptr(uintptr(v))
        if stackNoCache != 0 || gp.m.p == 0 || gp.m.preemptoff != "" {
            lock(&stackpool[order].item.mu)
            stackpoolfree(x, order)
            unlock(&stackpool[order].item.mu)
        } else {
            // 释放到P的栈缓存
            c := gp.m.p.ptr().mcache
            if c.stackcache[order].size >= _StackCacheSize {
                // 缓存已满，刷新到全局池
                stackcacherelease(c, order)
            }
            x.ptr().next = c.stackcache[order].list
            c.stackcache[order].list = x
            c.stackcache[order].size += n
        }
    } else {
        // 大栈释放到大栈缓存
        s := spanOfUnchecked(uintptr(v))
        if s.state.get() != mSpanManual {
            println(hex(s.base()), v)
            throw("bad span state")
        }
        if gcphase == _GCoff {
            // GC未运行时，可以缓存大栈
            log2npage := stacklog2(s.npages)
            lock(&stackLarge.lock)
            stackLarge.free[log2npage].insert(s)
            unlock(&stackLarge.lock)
        } else {
            // GC运行时，直接释放给堆
            s.needzero = 1
            mheap_.freeManual(s, spanAllocStack)
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

type mstats struct {
    // 通用统计
    alloc       uint64 // 当前分配的字节数
    total_alloc uint64 // 累计分配的字节数
    sys         uint64 // 从系统获得的字节数
    nlookup     uint64 // 指针查找次数
    nmalloc     uint64 // 分配次数
    nfree       uint64 // 释放次数
    
    // 堆统计
    heap_alloc    uint64 // 堆中分配的字节数
    heap_sys      uint64 // 堆从系统获得的字节数
    heap_idle     uint64 // 堆中空闲的字节数
    heap_inuse    uint64 // 堆中使用的字节数
    heap_released uint64 // 释放给系统的字节数
    heap_objects  uint64 // 堆中对象数量
    
    // 栈统计
    stack_inuse uint64 // 栈使用的字节数
    stack_sys   uint64 // 栈从系统获得的字节数
    
    // 各种内存区域统计
    mspan_inuse uint64 // mspan使用的字节数
    mspan_sys   uint64 // mspan从系统获得的字节数
    mcache_inuse uint64 // mcache使用的字节数
    mcache_sys   uint64 // mcache从系统获得的字节数
    
    // GC统计
    gc_sys         uint64 // GC元数据使用的字节数
    other_sys      uint64 // 其他系统分配
    next_gc        uint64 // 下次GC的堆大小目标
    last_gc_unix   uint64 // 上次GC的Unix时间戳
    last_gc_nanotime uint64 // 上次GC的纳秒时间戳
    
    // 按大小类的统计
    by_size [_NumSizeClasses]struct {
        size    uint32 // 大小类的字节数
        nmalloc uint64 // 该大小类的分配次数
        nfree   uint64 // 该大小类的释放次数
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 更新分配统计
func (mp *m) incalloc(size uintptr) {
    c := getMCache(mp)
    c.scanAlloc += size
    
    atomic.Xadd64(&memstats.nmalloc, 1)
    atomic.Xadd64(&memstats.total_alloc, int64(size))
    atomic.Xadd64(&memstats.heap_live, int64(size))
}

// 更新释放统计  
func (mp *m) decalloc(size uintptr) {
    atomic.Xadd64(&memstats.nfree, 1)
    atomic.Xadd64(&memstats.heap_live, -int64(size))
}