一文搞懂Go1.20内存分配器

// src/runtime/mheap.go
type mspan struct {
	_    sys.NotInHeap
	next *mspan     // 下一个span节点
	prev *mspan     // 上一个span节点 

	startAddr uintptr // span开始地址
	npages    uintptr // span包含的页数
	
	freeindex uintptr  // 空闲对象的索引
	
	nelems uintptr    // span中存放的对象数量

	allocCache uint64    // allocBits 的补码，可以用于快速查找内存中未被使用的内存

	allocBits  *gcBits   // 标记内存的占用
	gcmarkBits *gcBits   // 标记内存的GC回收情况

	spanclass             spanClass     // spanClass规格和是否GC扫描
	state                 mSpanStateBox // 标记mspan的状态，状态可能处于 mSpanDead、mSpanInUse、mSpanManual 和 mSpanFree 四种情况，在空闲堆或被分配或处于GC不同阶段，会有不同状态
}

const (
 ...
 _NumSizeClasses = 68
 ...
)

var class_to_size = [_NumSizeClasses]uint16{0, 8, 16, 24, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256, 288, 320, 352, 384, 416, 448, 480, 512, 576, 640, 704, 768, 896, 1024, 1152, 1280, 1408, 1536, 1792, 2048, 2304, 2688, 3072, 3200, 3456, 4096, 4864, 5376, 6144, 6528, 6784, 6912, 8192, 9472, 9728, 10240, 10880, 12288, 13568, 14336, 16384, 18432, 19072, 20480, 21760, 24576, 27264, 28672, 32768}

var class_to_allocnpages = [_NumSizeClasses]uint8{0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 3, 2, 3, 1, 3, 2, 3, 4, 5, 6, 1, 7, 6, 5, 4, 3, 5, 7, 2, 9, 7, 5, 8, 3, 10, 7, 4}

// src/runtime/mheap.go
type spanClass uint8     // spanClass的个数

const (
        // spanClass的个数是Size Class个数的两倍
	numSpanClasses = _NumSizeClasses << 1
)

// 通过Size Class来得到对应的Span Class，第二个形参noscan表示当前对象是否需要GC扫描
func makeSpanClass(sizeclass uint8, noscan bool) spanClass {
	return spanClass(sizeclass<<1) | spanClass(bool2int(noscan))
}

// src/runtime/sizeclasses.go

// 标题Title解释：
// [class]:  Size Class
// [bytes/obj]:  Object Size，一次对外提供内存Object的大小
// [bytes/span]:  当前Object所对应Span的内存大小
// [objects]:  当前Span一共能存放多少个Object
// [tail waste]:  为当前Span平均分层N份Object，会有多少内存浪费
// [max waste]:  当前Size Class最大可能浪费的空间所占百分比

// class  bytes/obj  bytes/span  objects  tail waste  max waste  min align
//     1          8        8192     1024           0     87.50%          8
//     2         16        8192      512           0     43.75%         16
//     3         24        8192      341           8     29.24%          8
//     4         32        8192      256           0     21.88%         32
//     5         48        8192      170          32     31.52%         16
//     6         64        8192      128           0     23.44%         64
//     7         80        8192      102          32     19.07%         16
//     8         96        8192       85          32     15.95%         32

//    35       1408       16384       11         896     14.00%        128
//    36       1536        8192        5         512     14.00%        512
//    37       1792       16384        9         256     15.57%        256
//    38       2048        8192        4           0     12.45%       2048
...
//    65      27264       81920        3         128     10.00%        128
//    66      28672       57344        2           0      4.91%       4096
//    67      32768       32768        1           0     12.50%       8192

// src/runtime/mcache.go
type mcache struct {
	
        // 分配tiny对象的参数
	tiny       uintptr      // 申请tiny对象的起始地址
	tinyoffset uintptr   // 从tiny地址开始的偏移量 
	tinyAllocs uintptr  // tiny对象分配的数量

	alloc [numSpanClasses]*mspan // 待分配的mspan列表，通过spanClass索引

}

// src/runtime/mcentral.go

//给定Size Class规格的中央缓存mcentral
type mcentral struct {
	// 该mcentral的spanClass规格大小
	spanclass spanClass
	partial [2]spanSet // 维护全部空闲的span集合，partial有两个spanSet集合，其中一个是GC已经扫描的，一个是GC未扫描的
	full    [2]spanSet  //  维护已经被使用的span集合，full也有两个spanSet集合，一个GC已扫描，一个未扫描
}

// src/runtime/mspanset.go

// spanSet是并发安全的存取mspan的集合，本质是个二级数据结构，一级是index字段存储指向spanSetBlock的索引，第二级是spanSetBlock存储指向512个mspan数组的索引
type spanSet struct {
	
	spineLock mutex    // 锁，往spanSet放入push和获取pop mspan需要加锁
	spine     atomicSpanSetSpinePointer // 指向spanSetBlock集合的地址
	spineLen  atomic.Uintptr            // spanSetBlock集合的 length
	spineCap  uintptr                     // spanSetBlock集合的 cap

	index atomicHeadTailIndex   // 指向spanSetBlock集合的头尾指针组成的一个int64位的数字
}

// src/runtime/mheap.go
// 页堆mheap
type mheap struct {
	lock mutex   // mheap的锁

	pages pageAlloc // 页分配数据结构

	allspans []*mspan // 所有的 spans 都是通过 mheap_ 申请，所有申请过的 mspan 都会记录在 allspans，可以随着堆的增长重新分配和移动

        // heapArena二维数组集合
	arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena
        ...
        // arenas的地址集合，用来管理heapArena的增加
	arenaHints *arenaHint
        ...
	// 全部规格的mcental集合，中央缓存MCentral本身也是MHeap的一部分
	central [numSpanClasses]struct {
		mcentral mcentral
		pad      [(cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize) % cpu.CacheLinePadSize]byte
	}
        // 各种分配器
	spanalloc             fixalloc // span* 分配器
	cachealloc            fixalloc // mcache* 分配器
	specialfinalizeralloc fixalloc // specialfinalizer* 分配器
	specialprofilealloc   fixalloc // specialprofile* 分配器
	specialReachableAlloc fixalloc // specialReachable 分配器
	speciallock           mutex    // 特殊记录分配器的锁
	arenaHintAlloc        fixalloc // allocator for arenaHints
        ...
}

const(
     pageSize = 8192  // 1<<13=8K
     heapArenaBytes = 67108864 //一个heapArena是64MB
     heapArenaWords = heapArenaBytes / 8  // 64位的Linux系统，一个heapArena有8M个word，一个word占8个字节
     heapArenaBitmapWords = heapArenaWords /  // 一个heapArena的bitmap占用8M/64=131072，即128K
     pagesPerArena = heapArenaBytes / pageSize  // 一个heapArena包含8192个页
)

type heapArena struct {
	// bitmap 中每个bit标记arena中的一个word
	bitmap [heapArenaBitmapWords]uintptr
        // bitmap的8个比特表示一个字长，这个字长是否包含指针用下面的数组记录
        noMorePtrs [heapArenaBitmapWords / 8]uint8
	// 记录当前arena中每一页对应到哪一个mspan
	spans [pagesPerArena]*mspan
	// 位图类型，标记哪些spans 处于 mSpanInUse 状态
	pageInUse [pagesPerArena / 8]uint8
	// 位图类型，记录哪些 spans 已被标记
	pageMarks [pagesPerArena / 8]uint8
	// 位图类型，指哪些spans有specials (finalizers or other)
	pageSpecials [pagesPerArena / 8]uint8
	// 零基地址，标记arena页中首个未被使用的页的地址
	zeroedBase uintptr
}

// src/runtime/malloc.go
// 堆上所有的对象都会通过调用runtime.newobject函数分配内存，该函数会调用runtime.mallocgc()函数
// 根据对象的大小（字节数）来分配内存，微对象、小对象从每个P的mcache本地缓存分配，大对象从堆分配
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
	......
	// 获取当前G所在的M线程
	mp := acquirem()
	.....
        // 获取M的mcache本地缓存
	c := getMCache(mp)
	if c == nil {
		throw("mallocgc called without a P or outside bootstrapping")
	}
	var span *mspan
	var x unsafe.Pointer
        // noscan变量记录对象是否包含指针，true为不包含
	noscan := typ == nil || typ.ptrdata == 0
	
	if size <= maxSmallSize {   // size是对象的字节数，如果对象小于 32KB
		if noscan && size < maxTinySize {  // 如果对象小于16B且不包含指针
			// 这里有一段注释，说明微分配器 Tiny allocator 的内存空间大小为何是16B.
			// Tiny内存空间越大，如32B，小对象（小字符串、数字、布尔等）组合的可能性越大，浪费也越严重，综合考虑，16B是合适的，

                        // 一组json benchmark测试显示，通过Tiny分配器，可以减少12%的分配次数和20%的堆大小；
			// 获取mcache的变量tinyoffset，表示Tiny空间空闲的位移
			off := c.tinyoffset
			// 内存对齐
			if size&7 == 0 {  // size 在 (0, 16) 范围，如果低三位是0，则跟8位对齐
				off = alignUp(off, 8)
			} else if goarch.PtrSize == 4 && size == 12 {
				// 地址长度是4，字节数是12，也是跟8位对齐
				off = alignUp(off, 8)
			} else if size&3 == 0 { // size低二位是0，跟4位对齐
				off = alignUp(off, 4)
			} else if size&1 == 0 { // size低一位是0，跟2位对齐
				off = alignUp(off, 2)
			}
			if off+size <= maxTinySize && c.tiny != 0 {
				// 如果对象的大小和off偏移量加起来仍然比16B小，且Tiny空间存在，则当前对象可以从已有的Tiny空间分配
                                // 在当前的Tiny空间分配，增加相关变量大小 
				x = unsafe.Pointer(c.tiny + off)
				c.tinyoffset = off + size
				c.tinyAllocs++
				mp.mallocing = 0
				releasem(mp)
				return x    // 分配后直接返回
			}
			// 从当前P的mcache的spanClass为4或5的mspan中，申请一个新的16B Object的 Tiny空间
			span = c.alloc[tinySpanClass]
			v := nextFreeFast(span)
			if v == 0 {
				v, span, shouldhelpgc = c.nextFree(tinySpanClass)
			}
			x = unsafe.Pointer(v)
                        // 将申请的16B内存空间置0，16B由两个长度为uint64地址指向
			(*[2]uint64)(x)[0] = 0
			(*[2]uint64)(x)[1] = 0
			// 非竞态下，如果申请的内存块分配了新对象后，将剩下的给 tiny，用 tinyoffset 记录分配了多少
			if !raceenabled && (size < c.tinyoffset || c.tiny == 0) {
				
				c.tiny = uintptr(x)
				c.tinyoffset = size
			}
			size = maxTinySize
		} else {
			// 小对象分配逻辑
                        .....
		}
	} else {
		// 大对象分配逻辑
                ......
	}
        ......
}

// Allocate an object of size bytes.
// Small objects are allocated from the per-P cache's free lists.
// Large objects (> 32 kB) are allocated straight from the heap.
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
	......
	// 获取线程M
	mp := acquirem()
	.....
        // 获取G所在P的mcache
	c := getMCache(mp)
	......
        // 对象是否包含指针
	noscan := typ == nil || typ.ptrdata == 0
	......
	if size <= maxSmallSize {   // 对象小于32KB
		if noscan && size < maxTinySize {    // 对象小于16B
			......
		} else {     // 对象在(16B, 32KB)，进入小对象分配流程
			var sizeclass uint8
                        // 根据对象大小获取对象所属的Size Class
			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])
                        // 根据Size Class和对象是否包含指针，获取所属的spanClass
			spc := makeSpanClass(sizeclass, noscan)
                        // 从mcache中获取对应spanClass的mspan
			span = c.alloc[spc]
                        // 从mpsan分配一个空闲的Object
			v := nextFreeFast(span)
			if v == 0 {
                                // mcache没有空闲的Object，则从mcentral申请可用的mspan给到mcache
				v, span, shouldhelpgc = c.nextFree(spc)
			}
                        // 这时，mcache中有了空闲的Object空间，获取并返回
			x = unsafe.Pointer(v)
			if needzero && span.needzero != 0 {
				memclrNoHeapPointers(x, size)
			}
		}
	} else { // 大对象分配流程
		......
	}
        ......
	return x
}

// src/runtime/malloc.go
// 从当前的mspan获取下一个空闲的Object空间，如果没有则从mcentral获取，否则从mheap获取
func (c *mcache) nextFree(spc spanClass) (v gclinkptr, s *mspan, shouldhelpgc bool) {
	s = c.alloc[spc]
	shouldhelpgc = false
        // 当前mspan找到空闲的Object空间的index索引
	freeIndex := s.nextFreeIndex()
	if freeIndex == s.nelems {  // 如果mspan已满
		// The span is full.
		if uintptr(s.allocCount) != s.nelems {
			println("runtime: s.allocCount=", s.allocCount, "s.nelems=", s.nelems)
			throw("s.allocCount != s.nelems && freeIndex == s.nelems")
		}
                // 从mcentral获取可用的mspan，并替换当前的mcache的mspan
		c.refill(spc)
		shouldhelpgc = true
		s = c.alloc[spc]
                // 再次到新的mspan里查找空闲的Object索引
		freeIndex = s.nextFreeIndex()
	}

	if freeIndex >= s.nelems {
		throw("freeIndex is not valid")
	}
        // 计算要使用的Object内存块在mspan中的地址，并返回该mspan
	v = gclinkptr(freeIndex*s.elemsize + s.base())
	s.allocCount++
	if uintptr(s.allocCount) > s.nelems {
		println("s.allocCount=", s.allocCount, "s.nelems=", s.nelems)
		throw("s.allocCount > s.nelems")
	}
	return
}

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
	......
	// 获取当前mcache
	c := getMCache(mp)
	......
        // 对象是否包含指针
	noscan := typ == nil || typ.ptrdata == 0
	......
	if size <= maxSmallSize {   // 对象小于32KB
		if noscan && size < maxTinySize {
			......
		} else {
			......
		}
	} else {  // 大对象内存分配逻辑
		shouldhelpgc = true
		// 调用mcache.allocLarge()根据对象的大小size和是否包含指针分配大内存mspan
		span = c.allocLarge(size, noscan)
		span.freeindex = 1
		span.allocCount = 1
		size = span.elemsize
		x = unsafe.Pointer(span.base())
		......
	}
        ......
}

// src/runtime/mcache.go
// allocLarge()函数为大对象申请一个mspan
func (c *mcache) allocLarge(size uintptr, noscan bool) *mspan {
        // Linux 64位系统下_PageSize为8K，如果对象太大发生溢出，甩出错误
	if size+_PageSize < size {
		throw("out of memory")
	}
        // _PageShift=13，2的13次方是8192，用对象大小size/8192得到需要分配的页数npages
	npages := size >> _PageShift
        // 页数npages不是整数，多出来一些小数，加1
	if size&_PageMask != 0 {
		npages++
	}
        ......
	// 从mheap页堆上分配npages页Size Class为0的mspan，spanClass根据对象是否包含指针为0或1
	spc := makeSpanClass(0, noscan)
	s := mheap_.alloc(npages, spc)
	if s == nil {
		throw("out of memory")
	}
        ......
	return s
}

// src/runtime/mheap.go
// alloc()函数从GC的堆上分配npages页的mspan
func (h *mheap) alloc(npages uintptr, spanclass spanClass) *mspan {
	var s *mspan
	systemstack(func() {
		// 为了阻止额外的堆增长，如果GC扫描未结束，在分配前需要先回收npages个页的内存
		if !isSweepDone() {
			h.reclaim(npages)
		}
                // 调用mheap.allocSpan()获取具体的npages页mspan
		s = h.allocSpan(npages, spanAllocHeap, spanclass)
	})
	return s
}

// src/runtime/mheap.go
func (h *mheap) allocSpan(npages uintptr, typ spanAllocType, spanclass spanClass) (s *mspan) {
	// 获取当前G
	gp := getg()
	base, scav := uintptr(0), uintptr(0)
	growth := uintptr(0)

	// 在某些平台上，需要进行物理页对齐
	needPhysPageAlign := physPageAlignedStacks && typ == spanAllocStack && pageSize < physPageSize

	// 当对象足够小，且无需进行物理页对齐，优先从本地P的缓存分配内存
	pp := gp.m.p.ptr()
	if !needPhysPageAlign && pp != nil && npages < pageCachePages/4 {
		c := &pp.pcache     

		// 本地P的缓存为空，从mheap分配缓存pageCache给它
		if c.empty() {
			lock(&h.lock)
			*c = h.pages.allocToCache()
			unlock(&h.lock)
		}

		// 从本地P的缓存pageCache获取npages页内存
		base, scav = c.alloc(npages)
		if base != 0 {
			s = h.tryAllocMSpan()
			if s != nil {   // 获取到了内存，调整到HaveSpan位置
				goto HaveSpan
			}
		}
	}

	lock(&h.lock)

	if needPhysPageAlign {  // 需要物理页对齐
		// 进行物理页对齐需要增加的额外页数
		extraPages := physPageSize / pageSize

               // 从mheap页堆的pages页分配数据结构中查找所需物理对齐后的页数
		base, _ = h.pages.find(npages + extraPages)
		if base == 0 {    // 如果没有获取到，调用mheap.grow()函数增长页堆
			var ok bool
			growth, ok = h.grow(npages + extraPages)
			if !ok {
				unlock(&h.lock)
				return nil
			}
			base, _ = h.pages.find(npages + extraPages)
			if base == 0 {
				throw("grew heap, but no adequate free space found")
			}
		}
               // 将获取的内存地址base进行物理页对齐，并获取内存大小scav
		base = alignUp(base, physPageSize)
		scav = h.pages.allocRange(base, npages)
	}

	if base == 0 {   // 如果在上面两种情况下，依然没有获取到所需内存页
		// 从mheap的pages页分配数据结构中获取
		base, scav = h.pages.alloc(npages)
		if base == 0 { // 内存不够，调用mheap.grow()扩容
			var ok bool
			growth, ok = h.grow(npages)
			if !ok {
				unlock(&h.lock)
				return nil
			}
                        // 重新从mheap的pages页分配数据结构中获取内存
			base, scav = h.pages.alloc(npages)
                        // 内存还是不足，则抛出异常
			if base == 0 {
				throw("grew heap, but no adequate free space found")
			}
		}
	}
	if s == nil {
		// 分配一个mspan对象
		s = h.allocMSpanLocked()
	}
	unlock(&h.lock)

HaveSpan:
        .....
	// 初始化得到的 mspan，并将其与mheap关联起来
	h.initSpan(s, typ, spanclass, base, npages)
        .....
	return s
}