Go内存分配原理

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

type mheap struct {
    // arenaL1Bits在linux下为0， arenaL2Bits的计算公式为：
    // arenaL2Bits = heapAddrBits - logHeapArenaBytes - arenaL1Bits
    // heapAddrBits就是地址空间所占字节数，在amd64上一般是48，logHeapArenaBytes是每个
    // heapArena管理的内存所占字节数，64M是2^26，所以logHeapArenaBytes为26
    //
    // 最终对于Linux系统来说这里等于定义了arenas [1]*[1 << 22]*heapArena，完美包含48位的地址空间
    arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena

    // 中心缓存，管理mspan双向列表
    central [numSpanClasses]struct {
        mcentral mcentral
        pad      [cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize]byte
    }
}

1
2
3
4
5
6
7
8

type heapArena struct {
    // 表示管理的2^26(64M)内存的占用情况
    // heapArenaBitmapBytes = heapArenaBytes / (sys.PtrSize * 4)
    // 对于64位的linux，bitmap[i]管理32字节的占用情况
    bitmap [heapArenaBitmapBytes]byte
    // 表示这个arena中每个Go内存页对应的管理单元
    spans [pagesPerArena]*mspan
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

type mcentral struct {
	lock      mutex
    spanclass spanClass

    // 没有空闲对象的mspan双向链表
    // 给mcache分配mspan的时候，先从这个链表扫描mspan，
    // 并进行清扫标记，促进未来得及GC的mspan重复利用
    nonempty mSpanList
    // 有空闲对象的mspan双向链表
	empty    mSpanList
}

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

type mspan struct {
    // 管理的起始地址
    startAddr uintptr
    // 本mspan管理多少个Go内存页
    npages    uintptr

    // 跨度类，下面有介绍，表示对象大小等级和是否有指针
    spanclass   spanClass
    // 对象大小等级对应的大小。由于对象大小各异，不利于快速内存分配，
    // 这是一种以空间换时间的方法，做了一个权衡，下面spanclass会详细介绍
    // 具体空间损耗等问题。
    elemsize    uintptr
    // 根据对象大小等级算出的本mspan管理的对象个数
    // nelems = nbytes / elemsize
    nelems uintptr

    // 主要用于runtime.mSpanList，在runtime.mcentral中使用来管理内存
    // 前一个span
    next *mspan
    // 后一个span
    prev *mspan
}

1
2
3
4
5

// 包含了size class，和noscan标识
// size class是指go将对象大小分成67个类别
// noscan是一个标识，代表对象中是否含有指针，含有指针的需要被扫描
// spanClass = sizeclass<<1 | noscan
type spanClass uint8

1
2

# pageSize为8KB
waste=1-(actualElemSize*nelems)/(npages*pageSize)

1
2
3
4
5
6

type mcache struct {
    // numSpanClasses = _NumSizeClasses << 1
    // 也就是线程缓存中，包含67*2个mspan
    // 之所以要乘以2，是因为对象大小等级有67种，是否包含指针(noscan)有两种，所以是67*2
    alloc [numSpanClasses]*mspan
}

 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

// 相关字段展示
type mcache struct {
    // 微内存分配器的内存块起始地址
    tiny             uintptr
    // 微内存分配器用到哪里了
    tinyoffset       uintptr
    // 微分配器分配了多少个还没统计到memstats.tinyallocs的对象
	local_tinyallocs uintptr
}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    ...
    if noscan && size < maxTinySize {
        off := c.tinyoffset
        if off+size <= maxTinySize && c.tiny != 0 {
            // The object fits into existing tiny block.
            x = unsafe.Pointer(c.tiny + off)
            c.tinyoffset = off + size
            c.local_tinyallocs++
            mp.mallocing = 0
            releasem(mp)
            return x
        }
        // Allocate a new maxTinySize block.
        span = c.alloc[tinySpanClass]
        v := nextFreeFast(span)
        if v == 0 {
            v, span, shouldhelpgc = c.nextFree(tinySpanClass)
        }
        x = unsafe.Pointer(v)
        (*[2]uint64)(x)[0] = 0
        (*[2]uint64)(x)[1] = 0
        // See if we need to replace the existing tiny block with the new one
        // based on amount of remaining free space.
        if size < c.tinyoffset || c.tiny == 0 {
            c.tiny = uintptr(x)
            c.tinyoffset = size
        }
        size = maxTinySize
    }
    ...
}