硬件到软件

Go语言每次申请64MB的虚拟内存，称为heapArena

最多可以有2的20次幂个

Go语言mheap内存是由许多heapArena组成

Runtime/mheap.go

type heapArena struct {
    bitmap [heapArenaBitmapBytes]byte

    spans [pagesPerArena]*mspan

    pageInUse [pagesPerArena / 8]uint8

    pageMarks [pagesPerArena / 8]uint8

    pageSpecials [pagesPerArena / 8]uint8

    checkmarks *checkmarksMap

    zeroedBase uintptr
}

type mheap struct {
    ...
    arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena
    ...
}

上面图，我们可以看到，来1个人，可以吃，来多个人也可以吃，当然1个人占用1个包间，确实浪费空间，那就放到2人的餐桌吃饭，最多浪费1个位置，来3个人，就做4人餐位置，以此类推。 Go语言也使用了这样的思路，管理内存中的对象。

mspan内存管理单元。是由多个相同的内存单元组成。

runtime/mheap.go

type mspan struct {
    next *mspan     
    prev *mspan     
    list *mSpanList
    startAddr uintptr 
    npages    uintptr
    manualFreeList gclinkptr 
    nelems uintptr
    allocCache uint64
    allocBits  *gcBits
    gcmarkBits *gcBits
    sweepgen              uint32
    divMul                uint32        
    allocCount            uint16        
    spanclass             spanClass     
    state                 mSpanStateBox
    needzero              uint8         
    allocCountBeforeCache uint16        
    elemsize              uintptr       
    limit                 uintptr       
    speciallock           mutex         
    specials              *special      
}

heapArena存储的是元数据。heapArena被存储在Go堆之外，并通过mheap_.arenas索引进行访问。
type heapArena struct {
    ...
    spans [pagesPerArena]*mspan
    ...
}

runtime/sizeclasses.go

go-36-003

源代码中有1-67个级别，这里只截取了1-18级

每个heapArena（64M）里不一定包含全部的内存等级小块(mspan)，Go语言会根据需要进行分配的。

Go语言如何快速找到合适的mspan

runtime/mcentral.go

给定大小的可用对象的中央列表。
type mcentral struct {
    spanclass spanClass
    partial [2]spanSet 
    full    [2]spanSet
}

runtime/mheap.go

mheap 不能被堆分配，因为它包含 mSpanLists.
type mheap struct {
    central [numSpanClasses]struct {
        mcentral mcentral
        pad      [cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize]byte
	}
}
numSpanClasses = _NumSizeClasses << 1
_NumSizeClasses = 68

runtime/mcache.go


它是每个线程中小对象的缓存。它包括小型对象缓存和本地分配统计信息。无需锁定，因为它是每个线程的。
mcaches 是从非 GC'd 内存中分配的，因此任何堆指针，必须特别处理。
type mcache struct {
    nextSample uintptr 
    scanAlloc  uintptr
    tiny       uintptr
    tinyoffset uintptr
    tinyAllocs uintptr
    alloc [numSpanClasses]*mspan // spans to allocate from, indexed by spanClass
    stackcache [_NumStackOrders]stackfreelist
    flushGen uint32
}

GMP中的P
type p struct {
    ...
    mcache      *mcache
    ...
}

numSpanClasses就是136,每一个mcentral都对应一个spanClass。上图的mcentral可以看到也就类似一个大市场，如果大家都来读数据，没问题，但是有人读，有人写，这自然就是并发问题，要解决就要加锁，这样的话，性能就很低，基于前面的GMP模型思想，GO语言给每个P有一个mcache，先操作这个mcache，如果写满了，那么本地的mcache再和中央mcentral的进行交换，如果中央的还是满的，那么就再开一个heapArena。

Go语言对象都多大

0 < Tiny对象<16B

16B<=Small对象<=32KB

Large对象>32KB

1-67级存放 <=32KB大小的对象（Tiny对象、Small对象），可以进行多个对象进行压缩，放在一起，节省更多的空间和开销。

Large对象就是按自身大小决定，没有固定的等级。

Go语言如何对象分配

小对象是从每 P 缓存的空闲列表中分配的。
大型对象（> 32 kB）直接从堆中分配。

runtime/malloc.go

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    if size <= maxSmallSize { // maxSmallSize (32k)
        if noscan && size < maxTinySize {// maxTinySize 16字节
            // Tiny allocator.
            ...
            // Allocate a new maxTinySize block.
            span = c.alloc[tinySpanClass]
            v := nextFreeFast(span)
            if v == 0 {
                v, span, shouldhelpgc = c.nextFree(tinySpanClass)
            }
            ...
        }else{
            var sizeclass uint8
            if size <= smallSizeMax-8 {
                sizeclass = size_to_class8[divRoundUp(size, smallSizeDiv)]
            } else {
                sizeclass = size_to_class128[divRoundUp(size-smallSizeMax, largeSizeDiv)]
            }
            size = uintptr(class_to_size[sizeclass])
            spc := makeSpanClass(sizeclass, noscan)
            span = c.alloc[spc]
            v := nextFreeFast(span)
            if v == 0 {
                v, span, shouldhelpgc = c.nextFree(spc)
            }
        }
    }else{
        ...
        span = c.allocLarge(size, noscan)
    }
}
func (c *mcache) allocLarge(size uintptr, noscan bool) *mspan {
    ...
    spc := makeSpanClass(0, noscan)
    s := mheap_.alloc(npages, spc)
    ...
}