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

graph TB
    subgraph "Go 内存管理架构"
        A[用户程序] --> B[mallocgc 分配入口]
        
        subgraph "分配层次结构"
            B --> C{对象大小判断}
            C -->|< 16B| D[Tiny分配器]
            C -->|16B-32KB| E[小对象分配]
            C -->|> 32KB| F[大对象分配]
            
            D --> G[mcache - P级缓存]
            E --> G
            F --> H[mheap - 全局堆]
            
            G --> I[mcentral - 全局中心缓存]
            I --> H
            
            H --> J[pageAlloc - 页分配器]
            J --> K[操作系统内存]
        end
        
        subgraph "内存组织结构"
            L[mspan - 内存块]
            M[arena - 内存区域]
            N[heapArena - 堆区域]
            
            L --> M
            M --> N
        end
        
        subgraph "辅助系统"
            O[栈分配器 stackalloc]
            P[固定分配器 fixalloc]
            Q[内存统计 mstats]
        end
        
        H --> L
        K --> O
        K --> P
        B --> Q
    end
    
    style A fill:#e1f5fe
    style G fill:#f3e5f5
    style H fill:#e8f5e8
    style J fill:#fff3e0

flowchart TD
    A[内存分配请求] --> B{size == 0?}
    B -->|是| C[返回 zerobase]
    B -->|否| D{size <= maxTinySize?}
    
    D -->|是| E{noscan?}
    E -->|是| F[Tiny分配器]
    E -->|否| G[小对象有指针分配]
    
    D -->|否| H{size <= maxSmallSize?}
    H -->|是| I{noscan?}
    I -->|是| J[小对象无指针分配]
    I -->|否| K[小对象有指针分配]
    
    H -->|否| L[大对象分配]
    
    F --> M[从mcache获取]
    J --> M
    K --> M
    G --> M
    
    M --> N{mcache有空间?}
    N -->|是| O[快速分配]
    N -->|否| P[从mcentral获取]
    
    P --> Q{mcentral有span?}
    Q -->|是| R[获取span到mcache]
    Q -->|否| S[从mheap分配新span]
    
    L --> T[直接从mheap分配]
    
    S --> U[pageAlloc分配页面]
    T --> U
    
    U --> V{有足够页面?}
    V -->|是| W[分配成功]
    V -->|否| X[向OS申请内存]
    
    style F fill:#ffebee
    style J fill:#e8f5e8
    style K fill:#fff3e0
    style L fill:#f3e5f5

sequenceDiagram
    participant USER as 用户代码
    participant MALLOC as mallocgc
    participant MCACHE as mcache
    participant MCENTRAL as mcentral
    participant MHEAP as mheap
    participant PAGEALLOC as pageAlloc
    participant OS as 操作系统

    USER->>MALLOC: 内存分配请求
    MALLOC->>MALLOC: 判断对象大小类型
    
    alt Tiny对象 (< 16B)
        MALLOC->>MCACHE: 检查tiny缓存
        alt tiny缓存足够
            MCACHE->>MALLOC: 返回tiny内存
        else tiny缓存不足
            MALLOC->>MCACHE: 分配新的tiny块
            MCACHE->>MCENTRAL: 请求新span
            MCENTRAL->>MCACHE: 返回span
            MCACHE->>MALLOC: 返回内存
        end
        
    else 小对象 (16B-32KB)
        MALLOC->>MCACHE: 检查对应size class
        alt mcache有空闲
            MCACHE->>MALLOC: 直接分配
        else mcache为空
            MCACHE->>MCENTRAL: cacheSpan()
            alt mcentral有空闲span
                MCENTRAL->>MCACHE: 返回span
            else mcentral为空
                MCENTRAL->>MHEAP: grow()
                MHEAP->>PAGEALLOC: alloc()
                PAGEALLOC->>OS: 系统调用分配
                OS->>PAGEALLOC: 返回内存页
                PAGEALLOC->>MHEAP: 返回页面
                MHEAP->>MCENTRAL: 返回新span
                MCENTRAL->>MCACHE: 返回span
            end
            MCACHE->>MALLOC: 分配内存
        end
        
    else 大对象 (> 32KB)
        MALLOC->>MHEAP: largeAlloc()
        MHEAP->>PAGEALLOC: 直接分配页面
        PAGEALLOC->>OS: 系统调用
        OS->>PAGEALLOC: 返回大内存块
        PAGEALLOC->>MHEAP: 返回内存
        MHEAP->>MALLOC: 返回大对象内存
    end
    
    MALLOC->>USER: 返回分配的内存指针

sequenceDiagram
    participant P as Processor
    participant MCACHE as mcache
    participant SPAN as mspan
    participant MCENTRAL as mcentral

    P->>MCACHE: 初始化P级缓存
    MCACHE->>MCACHE: 创建alloc数组
    
    loop 为每个size class
        MCACHE->>MCACHE: 初始化alloc[sizeclass]
    end
    
    P->>MCACHE: 分配请求
    MCACHE->>SPAN: 检查当前span
    
    alt span有空闲对象
        SPAN->>MCACHE: nextFreeFast()
        MCACHE->>P: 返回对象
    else span已满
        MCACHE->>MCENTRAL: refill()
        
        alt mcentral有空闲span
            MCENTRAL->>SPAN: 获取新span
            SPAN->>MCACHE: 设置为当前span
            MCACHE->>SPAN: nextFreeFast()
            SPAN->>MCACHE: 返回对象
            MCACHE->>P: 返回对象
        else 需要从mheap分配
            MCENTRAL->>MCENTRAL: grow()
            Note over MCENTRAL: 从mheap获取新页面
            MCENTRAL->>SPAN: 创建新span
            SPAN->>MCACHE: 设置为当前span
            MCACHE->>P: 返回对象
        end
    end

sequenceDiagram
    participant MCACHE as mcache
    participant MCENTRAL as mcentral
    participant PARTIAL as partial链表
    participant FULL as full链表
    participant MHEAP as mheap

    MCACHE->>MCENTRAL: cacheSpan()请求
    MCENTRAL->>MCENTRAL: 加锁保护
    
    MCENTRAL->>PARTIAL: 检查partial链表
    alt partial有空闲span
        PARTIAL->>MCENTRAL: 获取span
        MCENTRAL->>MCENTRAL: 从partial移除
        MCENTRAL->>MCACHE: 返回span
    else partial为空
        MCENTRAL->>FULL: 检查full链表
        alt full有可清扫span
            FULL->>MCENTRAL: 获取span
            MCENTRAL->>MCENTRAL: 清扫span
            alt 清扫后有空闲
                MCENTRAL->>MCACHE: 返回span
            else 清扫后仍满
                MCENTRAL->>FULL: 放回full链表
            end
        else 需要新span
            MCENTRAL->>MHEAP: grow()
            MHEAP->>MHEAP: 分配新页面
            MHEAP->>MCENTRAL: 返回新span
            MCENTRAL->>MCENTRAL: 初始化span
            MCENTRAL->>MCACHE: 返回span
        end
    end
    
    MCENTRAL->>MCENTRAL: 解锁

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的范围
    }
}

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结束地址
}

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
}

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

sequenceDiagram
    participant U as 用户程序
    participant M as mallocgc
    participant MC as mcache
    participant MCT as mcentral
    participant MH as mheap
    participant PA as pageAlloc
    participant OS as 操作系统

    Note over U,OS: 内存分配完整流程
    
    U->>M: 请求分配内存
    M->>M: 判断对象大小和类型
    
    alt Tiny对象 (< 16B, noscan)
        M->>MC: 尝试tiny分配
        MC->>MC: 检查tiny块剩余空间
        alt tiny块有足够空间
            MC->>M: 返回tiny块内地址
        else tiny块空间不足
            MC->>MCT: 获取新的tiny span
            MCT->>MH: 请求新span
            MH->>PA: 分配页面
            PA->>OS: 申请物理内存
            OS->>PA: 返回内存页
            PA->>MH: 返回页面地址
            MH->>MCT: 返回新span
            MCT->>MC: 返回span到mcache
            MC->>M: 从新span分配
        end
    else 小对象 (16B-32KB)
        M->>MC: 从对应大小类分配
        MC->>MC: 检查span空闲对象
        alt span有空闲对象
            MC->>MC: 快速分配 nextFreeFast
            MC->>M: 返回对象地址
        else span已满
            MC->>MCT: 请求新span
            MCT->>MCT: 查找部分空闲span
            alt 找到合适span
                MCT->>MC: 返回span
                MC->>M: 从新span分配
            else 无合适span
                MCT->>MH: 请求分配新span
                MH->>PA: 分配连续页面
                PA->>MH: 返回页面
                MH->>MCT: 返回新span
                MCT->>MC: 返回span
                MC->>M: 分配成功
            end
        end
    else 大对象 (> 32KB)
        M->>MH: 直接从堆分配
        MH->>PA: 分配大页面块
        PA->>PA: 查找连续空闲页面
        alt 找到足够页面
            PA->>MH: 返回页面地址
            MH->>M: 返回大对象地址
        else 页面不足
            PA->>OS: 向OS申请更多内存
            OS->>PA: 扩展地址空间
            PA->>MH: 返回新分配页面
            MH->>M: 分配成功
        end
    end
    
    M->>U: 返回分配的内存地址

sequenceDiagram
    participant MC as mcache
    participant MCT as mcentral
    participant MH as mheap
    participant SW as Sweeper

    Note over MC,SW: mcache span重填流程
    
    MC->>MCT: refill(spanClass)
    MCT->>MCT: 尝试从partialSwept获取
    
    alt 有已清扫的部分空闲span
        MCT->>MC: 返回span
    else 无已清扫span
        MCT->>SW: 开始清扫循环
        loop 清扫预算内
            MCT->>MCT: 从partialUnswept获取
            alt 获取到span
                MCT->>SW: 清扫span
                SW->>MCT: 清扫完成
                alt 清扫后有空闲对象
                    MCT->>MC: 返回清扫后的span
                else 清扫后仍满
                    MCT->>MCT: 移到fullSwept
                end
            else 无更多unswept span
                break
            end
        end
        
        alt 仍未获得span
            MCT->>MH: grow() - 请求新span
            MH->>MH: allocSpan()
            MH->>MCT: 返回新分配的span
            MCT->>MC: 返回新span
        end
    end

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
}

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
}

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
}

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
}

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
}

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)
}

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
}

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
}

graph TB
    subgraph "页分配器架构"
        A[pageAlloc] --> B[基数树 Radix Tree]
        A --> C[页面位图 Bitmap]
        A --> D[页面缓存 pageCache]
        
        B --> E[L0 - 16GiB区域]
        B --> F[L1 - 64MiB区域]  
        B --> G[L2 - 2MiB区域]
        B --> H[L3 - 64KiB区域]
        B --> I[L4 - 2KiB区域 Chunk]
        
        C --> J[Chunk位图]
        J --> K[页面状态位]
        
        D --> L[Per-P页面缓存]
        L --> M[64页缓存块]
    end
    
    style A fill:#e1f5fe
    style B fill:#f3e5f5
    style C fill:#e8f5e8
    style D fill:#fff3e0

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
}

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}
}

graph TB
    subgraph "栈内存管理"
        A[stackalloc] --> B{栈大小判断}
        
        B -->|小栈 < 32KB| C[固定大小栈池]
        B -->|大栈 >= 32KB| D[大栈缓存]
        
        C --> E[Per-P栈缓存]
        C --> F[全局栈池]
        
        E --> G[stackcache数组]
        F --> H[stackpool数组]
        
        D --> I[stackLarge]
        I --> J[按大小分类的空闲链表]
        
        G --> K[按order分类 2KB-16KB]
        H --> K
        J --> L[大于32KB的栈]
        
        M[stackfree] --> N{栈大小}
        N -->|小栈| O[返回到栈池]
        N -->|大栈| P[返回到大栈缓存]
    end
    
    style A fill:#e1f5fe
    style C fill:#f3e5f5
    style D fill:#e8f5e8
    style M fill:#fff3e0

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)}
}

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)
        }
    }
}

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 // 该大小类的释放次数
    }
}

// 更新分配统计
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))
}