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

type mspan struct {
    // 前后节点
	next *mspan     // next span in list, or nil if none
	prev *mspan     // previous span in list, or nil if none
    
	list *mSpanList // For debugging. TODO: Remove.
    
    // 起始地址
	startAddr uintptr // address of first byte of span aka s.base()
    // 包含几页，页是连续的
	npages    uintptr // number of pages in span
	manualFreeList gclinkptr // list of free objects in mSpanManual spans
    
    // freeindex之前的位置都被占用了
	freeindex uintptr
    // 最多可以存放多少个object
	nelems uintptr // number of object in the span.
    
    // ☆ allocaCache中每个bit对应一个object块，标识该块是否被占用
	allocCache uint64
	allocBits  *gcBits
    
	gcmarkBits *gcBits
	sweepgen              uint32
	divMul                uint32        // for divide by elemsize
	allocCount            uint16        // number of allocated objects
    
    // 表示mspan对应的那67个等级中的哪一个
	spanclass             spanClass     // size class and noscan (uint8)
    
	state                 mSpanStateBox // mSpanInUse etc; accessed atomically (get/set methods)
	needzero              uint8         // needs to be zeroed before allocation
	allocCountBeforeCache uint16        // a copy of allocCount that is stored just before this span is cached
	elemsize              uintptr       // computed from sizeclass or from npages
	limit                 uintptr       // end of data in span
	speciallock           mutex         // guards specials list
	specials              *special      // linked list of special records sorted by offset.
}

 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

// spanClass 表示 span 的大小类别和无扫描（noscan）属性。
//
// 每个大小类别都有一个 noscan spanClass 和一个 scan spanClass。
// noscan spanClass 仅包含 noscan 对象，这些对象不包含指针，
// 因此不需要由垃圾收集器扫描。
type spanClass uint8


// makeSpanClass 根据大小类别（sizeclass）和无扫描（noscan）属性创建 spanClass。
// sizeclass 是一个表示大小类别的 uint8 值。
// noscan 是一个布尔值，表示该 spanClass 是否为 noscan。
func makeSpanClass(sizeclass uint8, noscan bool) spanClass {
	// 将 sizeclass 左移 1 位，然后将 noscan 转换为整数后做按位或运算，生成最终的 spanClass。
	return spanClass(sizeclass<<1) | spanClass(bool2int(noscan))
}


// 获取当前的等级
func (sc spanClass) sizeclass() int8 {
	return int8(sc >> 1)
}

// 是否是noscan
func (sc spanClass) noscan() bool {
	return sc&1 != 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
38
39
40
41
42
43
44
45
46
47

const (
    // 136
	numSpanClasses = _NumSizeClasses << 1
	tinySpanClass  = spanClass(tinySizeClass<<1 | 1)
)


// 每个线程（在 Go 中，每个 P）的缓存用于小对象。
// 包含一个小对象缓存和本地分配统计。
// 由于它是每个线程（每个 P）的，所以不需要锁定。
//
// mcaches 是从非 GC 管理的内存中分配的，因此任何堆指针必须特别处理。
//
//go:notinheap
type mcache struct {
	// 以下成员在每次 malloc 时都会被访问，
	// 因此将它们放在一起以便更好地缓存。
	nextSample uintptr // 在分配了这么多字节之后触发堆采样
	scanAlloc  uintptr // 分配的可扫描堆的字节数

	// 【没有指针的小对象】的分配器缓存。
	// 请参见 malloc.go 中的 "Tiny allocator" 注释。

	// tiny 指向当前 tiny 块的开头，
	// 如果没有当前 tiny 块，则为 nil。
	//
	// tiny 是一个堆指针。由于 mcache 位于非 GC 管理的内存中，
	// 我们通过在标记终止期间在 releaseAll 中清除它来处理它。
	//
	// tinyAllocs 是拥有此 mcache 的 P 执行的 tiny 分配的次数。
    // 指向堆中的一片内存
	tiny       uintptr
    // 下一个空闲内存所在的偏移量
	tinyoffset uintptr
    // 分配的次数
	tinyAllocs uintptr

	// 其余部分在每次 malloc 时不会被访问。
	alloc [numSpanClasses]*mspan // 根据 spanClass 索引分配用的 span

	stackcache [_NumStackOrders]stackfreelist // 用于缓存栈的空闲列表

	// flushGen 表示上次刷新此 mcache 的 sweepgen。
	// 如果 flushGen != mheap_.sweepgen，则此 mcache 中的 span 是陈旧的，
	// 需要刷新以便可以被清扫。这在 acquirep 中完成。
	flushGen uint32
}

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

// 给定大小的空闲对象的中央列表。
//
//go:notinheap
type mcentral struct {
	spanclass spanClass

	// partial 和 full 包含两组 mspan 集合：一组是已经清扫的在使用的 span，
	// 另一组是尚未清扫的在使用的 span。这两组在每个 GC 周期中交换角色。
	// 未清扫集合在每个 GC 周期中要么通过分配要么通过后台清扫器被清空，
	// 因此只需要两组。
	//
	// sweepgen 在每个 GC 周期中增加 2，因此清扫过的 span 位于
	// partial[sweepgen/2%2] 中，而未清扫的 span 位于
	// partial[1-sweepgen/2%2] 中。清扫会从未清扫集合中弹出 span，
	// 并将仍在使用的 span 推入清扫过的集合。同样，分配一个在使用的 span
	// 会将其推入清扫过的集合。
	//
	// 清扫器的某些部分可以清扫任意 span，因此不能从未清扫集合中移除它们，
	// 但会将 span 添加到适当的清扫列表中。因此，从未清扫列表中消耗的
	// 清扫器和 mcentral 部分可能会遇到清扫过的 span，这些应被忽略。
	partial [2]spanSet // 有空位的mspan集合，数组长度为2是为了抗一轮GC
	full    [2]spanSet // 没有空位的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
 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
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

// 主堆分配器。
// 堆本身是 "free" 和 "scav" treaps，但所有其他全局数据也在这里。
//
// mheap 不能堆分配，因为它包含 mSpanLists，这些不能堆分配。
//
//go:notinheap
type mheap struct {
	// lock 只能在系统栈上获取，否则如果 g 的栈在持有锁时增长，可能会自死锁。
	lock mutex

	_ uint32 // 8字节对齐 pages，以使其与测试对齐。

    // 空闲页分配器，底层是多个基数树组成的索引，每棵树对应的空间为16GB
	pages pageAlloc // 页分配数据结构

	sweepgen uint32 // 清扫代，见 mspan 中的注释；在 STW（stop-the-world）期间写入

	// allspans 是所有曾经创建的 mspan 的切片。每个 mspan 只出现一次。
	//
	// allspans 的内存是手动管理的，并且可以随着堆的增长重新分配和移动。
	//
	// 通常，allspans 由 mheap_.lock 保护，这可以防止并发访问和释放底层存储。
	// 在 STW 期间的访问可能不会持有锁，但必须确保在访问时不能发生分配
	// （因为这可能会释放底层存储）。
    // 记录了所有的 mspan. 需要知道，所有 mspan 都是经由 mheap，使用连续空闲页组装生成的
	allspans []*mspan // 所有的 span

	// Proportional sweep（比例清扫）
	//
	// 这些参数表示一个从 gcController.heapLive 到页面清扫计数的线性函数。
	// 比例清扫系统通过保持当前页面清扫计数高于当前 gcController.heapLive
	// 时的这条线来维持在黑色。
	//
	// 该线的斜率为 sweepPagesPerByte，并且通过一个基点 (sweepHeapLiveBasis,
	// pagesSweptBasis)。系统在任何给定时间点处于 (gcController.heapLive,
	// pagesSwept)。
	//
	// 重要的是，线必须通过我们控制的点，而不仅仅是从 0,0 原点开始，
	// 因为这让我们可以在任何时候调整清扫节奏，同时考虑当前进度。如果我们只能
	// 调整斜率，那么如果已经取得了一些进展，会在债务上产生不连续性。
	pagesInUse         atomic.Uint64 // 在 mSpanInUse 中统计的 span 页数
	pagesSwept         atomic.Uint64 // 本周期清扫的页数
	pagesSweptBasis    atomic.Uint64 // 用作清扫比率原点的 pagesSwept 值
	sweepHeapLiveBasis uint64        // 用作清扫比率原点的 gcController.heapLive 值；带锁写入，不带锁读取
	sweepPagesPerByte  float64       // 比例清扫比率；带锁写入，不带锁读取
	// TODO(austin): pagesInUse 应该是 uintptr，但 386 编译器不能 8 字节对齐字段。

	// 页面回收状态

	// reclaimIndex 是 allArenas 中下一个要回收的页面索引。
	// 具体来说，它指的是 allArenas[i / pagesPerArena] 中的第 (i %
	// pagesPerArena) 页。
	//
	// 如果此值 >= 1<<63，页面回收器已完成扫描页面标记。
	reclaimIndex atomic.Uint64

	// reclaimCredit 是多余清扫页面的备用积分。由于页面回收器以大块工作，
	// 它可能回收比请求更多的页面。任何释放的备用页面都会进入这个积分池。
	reclaimCredit atomic.Uintptr

	// arenas 是堆 arena 映射。它指向整个可用虚拟地址空间中每个 arena 帧的元数据。
	//
	// 使用 arenaIndex 计算该数组的索引。
	//
	// 对于未由 Go 堆支持的地址空间区域，arena 映射包含 nil。
	//
	// 修改由 mheap_.lock 保护。读取可以不加锁进行；但是，当未持有锁时，
	// 给定条目可能随时从 nil 变为非 nil。（条目不会变回 nil。）
	//
	// 通常，这是一个两级映射，包括一个 L1 映射和可能的多个 L2 映射。
	// 当有大量 arena 帧时，这节省了空间。然而，在许多平台上（即使是 64 位），
	// arenaL1Bits 为 0，这使得它实际上是单级映射。在这种情况下，arenas[0]
	// 永远不会是 nil。
	arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena

	// heapArenaAlloc 是用于分配 heapArena 对象的预留空间。这仅在 32 位上使用，
	// 我们预留此空间以避免与堆本身交错。
	heapArenaAlloc linearAlloc

	// arenaHints 是一个列表，包含尝试添加更多堆 arena 的地址。最初用一组
	// 通用提示地址填充，并随着实际堆 arena 范围的边界增长。
	arenaHints *arenaHint

	// arena 是用于分配堆 arena（实际的 arena）的预留空间。这仅在 32 位上使用。
	arena linearAlloc

	// allArenas 是所有映射的 arena 的 arenaIndex。可以用它遍历地址空间。
	//
	// 访问由 mheap_.lock 保护。然而，由于这是追加的，旧的底层数组永远不会被释放，
	// 所以可以安全地获取 mheap_.lock，复制切片头，然后释放 mheap_.lock。
	allArenas []arenaIdx

	// sweepArenas 是在清扫周期开始时拍摄的 allArenas 快照。只需阻止 GC
	// （通过禁用抢占）即可安全读取。
	sweepArenas []arenaIdx

	// markArenas 是在标记周期开始时拍摄的 allArenas 快照。由于 allArenas
	// 仅追加，因此在标记期间此切片及其内容不会更改，因此可以安全读取。
	markArenas []arenaIdx

	// curArena 是堆当前正在扩展的 arena。应始终是 physPageSize 对齐的。
	curArena struct {
		base, end uintptr
	}

	_ uint32 // 确保 central 的 64 位对齐

	// 小尺寸类别的中央空闲列表。
	// padding 确保 mcentral 被 CacheLinePadSize 字节隔开，
	// 以便每个 mcentral.lock 拥有自己的缓存行。
	// central 由 spanClass 索引。    numSpanClasses=136
	central [numSpanClasses]struct {
		mcentral mcentral
        
        // 用于内存对齐
		pad      [cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize]byte
	}

	spanalloc             fixalloc // span* 的分配器
	cachealloc            fixalloc // mcache* 的分配器
	specialfinalizeralloc fixalloc // specialfinalizer* 的分配器
	specialprofilealloc   fixalloc // specialprofile* 的分配器
	specialReachableAlloc fixalloc // specialReachable 的分配器
	speciallock           mutex    // special 记录分配器的锁。
	arenaHintAlloc        fixalloc // arenaHints 的分配器

	unused *specialfinalizer // 从未设置，仅此处以强制将 specialfinalizer 类型放入 DWARF
}

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

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
}

 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

type pallocSum uint64

// packPallocSum takes a start, max, and end value and produces a pallocSum.
func packPallocSum(start, max, end uint) pallocSum {
	if max == maxPackedValue {
		return pallocSum(uint64(1 << 63))
	}
	return pallocSum((uint64(start) & (maxPackedValue - 1)) |
		((uint64(max) & (maxPackedValue - 1)) << logMaxPackedValue) |
		((uint64(end) & (maxPackedValue - 1)) << (2 * logMaxPackedValue)))
}

// start extracts the start value from a packed sum.
func (p pallocSum) start() uint {
	if uint64(p)&uint64(1<<63) != 0 {
		return maxPackedValue
	}
	return uint(uint64(p) & (maxPackedValue - 1))
}

// max extracts the max value from a packed sum.
func (p pallocSum) max() uint {
	if uint64(p)&uint64(1<<63) != 0 {
		return maxPackedValue
	}
	return uint((uint64(p) >> logMaxPackedValue) & (maxPackedValue - 1))
}

// end extracts the end value from a packed sum.
func (p pallocSum) end() uint {
	if uint64(p)&uint64(1<<63) != 0 {
		return maxPackedValue
	}
	return uint((uint64(p) >> (2 * logMaxPackedValue)) & (maxPackedValue - 1))
}

// unpack unpacks all three values from the summary.
func (p pallocSum) unpack() (uint, uint, uint) {
	if uint64(p)&uint64(1<<63) != 0 {
		return maxPackedValue, maxPackedValue, maxPackedValue
	}
	return uint(uint64(p) & (maxPackedValue - 1)),
		uint((uint64(p) >> logMaxPackedValue) & (maxPackedValue - 1)),
		uint((uint64(p) >> (2 * logMaxPackedValue)) & (maxPackedValue - 1))
}

 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
77
78
79
80
81
82
83
84
85
86
87
88
89
90

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    // ...    
    // 获取 m
    mp := acquirem()
    // 获取当前 p 对应的 mcache
    c := getMCache(mp)
    var span *mspan
    var x unsafe.Pointer
    // 根据当前对象是否包含指针，标识 gc 时是否需要展开扫描
    noscan := typ == nil || typ.ptrdata == 0
    
    // 是否是小于 32KB 的微、小对象
    if size <= maxSmallSize {
    	// 小于 16 B 且无指针，则视为微对象
        if noscan && size < maxTinySize {
          // tiny 内存块中，从 offset 往后有空闲位置
          off := c.tinyoffset
          // 如果大小为 5 ~ 8 B，size 会被调整为 8 B，此时 8 & 7 == 0，会走进此分支
          if size&7 == 0 {
                // 将 offset 补齐到 8 B 倍数的位置
                off = alignUp(off, 8)
                // 如果大小为 3 ~ 4 B，size 会被调整为 4 B，此时 4 & 3 == 0，会走进此分支  
           } else if size&3 == 0 {
           		// 将 offset 补齐到 4 B 倍数的位置
                off = alignUp(off, 4)
                // 如果大小为 1 ~ 2 B，size 会被调整为 2 B，此时 2 & 1 == 0，会走进此分支  
           } else if size&1 == 0 {
            	// 将 offset 补齐到 2 B 倍数的位置
                off = alignUp(off, 2)
           }
			// 如果当前 tiny 内存块空间还够用，则直接分配并返回
            if off+size <= maxTinySize && c.tiny != 0 {
            	// 分配空间
                x = unsafe.Pointer(c.tiny + off)
                c.tinyoffset = off + size
                c.tinyAllocs++
                mp.mallocing = 0
                releasem(mp)  
                return x
            } 
            // 分配一个新的 tiny 内存块
            span = c.alloc[tinySpanClass]    
            // 从 mCache 中获取
            v := nextFreeFast(span)        
            if v == 0 {
            // 从 mCache 中获取失败，则从 mCentral 或者 mHeap 中获取进行兜底
                v, span, shouldhelpgc = c.nextFree(tinySpanClass)
            }   
			// 分配空间      
            x = unsafe.Pointer(v)
            (*[2]uint64)(x)[0] = 0
            (*[2]uint64)(x)[1] = 0
            size = maxTinySize
        } else {
          // 根据对象大小，映射到其所属的 span 的等级(0~66）
          var sizeclass uint8
          if size <= smallSizeMax-8 {
              sizeclass = size_to_class8[divRoundUp(size, smallSizeDiv)]
          } else {
              sizeclass = size_to_class128[divRoundUp(size-smallSizeMax, largeSizeDiv)]
          }        
          // 对应 span 等级下，分配给每个对象的空间大小(0~32KB)
          size = uintptr(class_to_size[sizeclass])
          // 创建 spanClass 标识，其中前 7 位对应为 span 的等级(0~66)，最后标识表示了这个对象 gc 时是否需要扫描
          spc := makeSpanClass(sizeclass, noscan) 
          // 获取 mcache 中的 span
          span = c.alloc[spc]  
          // 从 mcache 的 span 中尝试获取空间        
          v := nextFreeFast(span)
          if v == 0 {
          // mcache 分配空间失败，则通过 mcentral、mheap 兜底            
             v, span, shouldhelpgc = c.nextFree(spc)
          }     
          // 分配空间  
          x = unsafe.Pointer(v)
          // ...
       }      
       // 大于 32KB 的大对象      
   } else {
       // 从 mheap 中获取 0 号 span
       span = c.allocLarge(size, noscan)
       span.freeindex = 1
       span.allocCount = 1
       size = span.elemsize         
       // 分配空间   
        x = unsafe.Pointer(span.base())
   }  
   // ...
   return x
}