1
// 分配一个指定大小的对象。
2
// 小对象从每个 P 的缓存空闲链表中分配。
3
// 大对象（大于 32 kB）直接从堆中分配。
4
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
5
  ...
6

7
  // 剔除了不必要的部分，实际上我们只需要看他是如何分配内存的即可
8
  // 这里实际执行分配操作。
9
  var x unsafe.Pointer
10
  var elemsize uintptr
11
  if size <= maxSmallSize-gc.MallocHeaderSize {
12
    // 如果对象类型为 nil 或不含指针，分配小对象。
13
    if typ == nil || !typ.Pointers() {
14
      if size < maxTinySize {
15
        x, elemsize = mallocgcTiny(size, typ)
16
      } else {
17
        x, elemsize = mallocgcSmallNoscan(size, typ, needzero)
18
      }
19
    } else {
20
      // 如果对象包含指针且不需要零初始化，抛出异常。
21
      if !needzero {
22
        throw("objects with pointers must be zeroed")
23
      }
24
      // 如果该对象是堆段中的一部分，分配扫描小对象。
25
      if heapBitsInSpan(size) {
26
        x, elemsize = mallocgcSmallScanNoHeader(size, typ)
27
      } else {
28
        x, elemsize = mallocgcSmallScanHeader(size, typ)
29
      }
30
    }
31
  } else {
32
    // 分配大对象。
33
    x, elemsize = mallocgcLarge(size, typ, needzero)
34
  }
35
  ...
36
  return x
37
}

1
func mallocgcTiny(size uintptr, typ *_type) (unsafe.Pointer, uintptr) {
2
    mp := acquirem()
3
  ...
4

5
  // Tiny allocator（微小对象分配器）
6
  //
7
  // tiny 分配器会把多个“极小”的分配请求合并到一个内存块里。
8
  // 只有当这个块里的所有子对象都不可达时，这个大块才会被释放。
9
  // 子对象必须是 noscan（不含指针），这样可以保证潜在浪费的内存有上界。
10
  //
11
  // 用于合并的块大小（maxTinySize）是可调的。
12
  // 当前设置 16 字节：对应最坏情况下 2 倍浪费（只剩 1 个子对象可达）。
13
  // 8 字节：几乎不浪费，但可合并机会更少。
14
  // 32 字节：合并机会更多，但最坏可到 4 倍浪费。
15
  // 最佳情况下的收益与块大小无关，最高可减少到 1/8（8x winning）。
16
  //
17
  // 从 tiny 分配器拿到的对象不能被显式 free。
18
  // 因此，如果一个对象将来会被显式 free，会保证它 size >= maxTinySize。
19
  //
20
  // SetFinalizer 对可能来自 tiny 分配器的对象有特殊处理：
21
  // 它允许给“一个大块内部的某个字节”设置 finalizer。
22
  //
23
  // tiny 分配器的主要目标：小字符串、以及单独逃逸到堆上的小变量。
24
  // 在某个 json benchmark 上，它把分配次数减少约 12%，堆大小减少约 20%。
25

26
  // 这里是获取了当前 m 对应的 p 所拥有的 mcache。
27
  c := getMCache(mp)
28
  off := c.tinyoffset
29

30
  ...
31
  // 省略一些字节对齐操作
32

33
  // 这里算是一个比较核心的操作，这个 c.tiny 其实就是当前指向的
34
  // 最后一个 tiny 合并块，如果当前合并块能够放下这块需要分配的小内存，那么就
35
  // 会直接将内存分配到这块地方，如果不够，那么只能向后移动 tiny 合并块，来找到新的足够的待分配内存。
36
  // 值得注意的是，虽然 mcache 在多次分配之后肯定会已经分配了多个 tiny 块，但是此时只会这个 mcache
37
  // 只会指向最后一个块，即便之前的空间够分配，也不会将内存分配到之前的 tiny 合并块上。
38
  if off+size <= maxTinySize && c.tiny != 0 {
39
    // 这个对象能塞进现有的 tiny 块里，直接从现有块切一段出来。
40
    x := unsafe.Pointer(c.tiny + off)
41
    c.tinyoffset = off + size
42
    c.tinyAllocs++
43
    mp.mallocing = 0
44
    releasem(mp)
45
    return x, 0
46
  }
47

48
  // 这里就不能从当前的块找了，得从 span 里面再找一块空闲内存。
49
  checkGCTrigger := false
50
  span := c.alloc[tinySpanClass]
51
  v := nextFreeFast(span)
52
  if v == 0 {
53
    v, span, checkGCTrigger = c.nextFree(tinySpanClass)
54
  }
55
  x := unsafe.Pointer(v)
56

57
  // tiny 块总是按 16 字节（或 maxTinySize）大小分配，这里把它清零（总是零）。
58
  (*[2]uint64)(x)[0] = 0
59
  (*[2]uint64)(x)[1] = 0
60

61
  // 用新分配的 tiny 块替换旧的合并块
62
  if !raceenabled && (size < c.tinyoffset || c.tiny == 0) {
63
    c.tiny = uintptr(x)
64
    c.tinyoffset = size
65
  }
66

67
  ...
68

69
  // 返回：对象指针 x，以及这个分配槽位的大小 span.elemsize
70
  return x, span.elemsize
71
}

1
// nextFreeFast 快速查找并返回下一个可用的空闲对象。
2
// 如果能快速找到，则返回该对象的指针；否则，返回 0。
3
func nextFreeFast(s *mspan) gclinkptr {
4
  // theBit 表示在 allocCache 里面最后一个为 0 的位置，即未分配的区块
5
  // 这里用了一个很高级的算法
6
  theBit := sys.TrailingZeros64(s.allocCache)
7

8
  // 如果 theBit 小于 64，表示在 allocCache 中找到了一个 1，即存在一个快速可用的空闲对象。
9
  if theBit < 64 {
10
    // result 计算出该空闲对象在整个 mspan 中的绝对索引。
11
    // s.freeindex 是当前 allocCache 位图所映射的 64 个对象的起始索引。
12
    // theBit 是该空闲对象在 allocCache 内部的偏移量。
13
    result := s.freeindex + uint16(theBit)
14

15
    // 检查计算出的对象索引是否在 mspan 的有效范围内 (小于总对象数 s.nelems)。
16
    if result < s.nelems {
17
      // freeidx 是分配该对象后，下一个对象的索引。
18
      freeidx := result + 1
19

20
      // 这是一个优化和边界条件处理：
21
      // 如果 freeidx 刚好是 64 的倍数 (即当前 allocCache 对应的 64 个槽位已用完)
22
      // 并且 freeidx 还没有达到 mspan 的末尾 (s.nelems)，
23
      // 那么当前 allocCache 无法再快速提供空闲对象，需要更复杂的分配逻辑（走慢路径）。
24
      // 此时返回 0，表示无法快速分配。
25
      if freeidx%64 == 0 && freeidx != s.nelems {
26
        return 0
27
      }
28

29
      // 将 s.allocCache 右移 (theBit + 1) 位。
30
      // 这会将刚刚分配的对象的位标记为已使用 (从位图中移除)，
31
      // 并将 allocCache 的“窗口”向前推进，以便下次从新的起始位开始查找。
32
      s.allocCache >>= uint(theBit + 1)
33

34
      // 更新 s.freeindex 为下一个可用的起始索引。
35
      s.freeindex = freeidx
36

37
      // 增加 mspan 中已分配对象的计数。
38
      s.allocCount++
39

40
      // 返回新分配对象的内存地址。
41
      // uintptr(result)*s.elemsize 计算对象相对于 mspan 基地址的偏移量。
42
      // s.base() 是 mspan 的起始内存地址。
43
      // gclinkptr 是 Go 运行时中用于表示指向 GC 对象的指针的类型。
44
      return gclinkptr(uintptr(result)*s.elemsize + s.base())
45
    }
46
  }
47
  return 0
48
}

1
// nextFree 函数从当前 mcache 中缓存的 span 中返回下一个空闲对象（如果可用）。
2
// 如果当前 span 已满，它会用一个含有可用对象的新 span 重新填充 mcache 的缓存，
3
// 并返回该对象，同时附带一个标志，表明这是一次“重量级”的内存分配。
4
// 如果是重量级分配，调用者必须判断是否需要启动一个新的 GC 周期，
5
// 或者如果 GC 正在活跃，该 goroutine 是否需要协助 GC。
6
//
7
// 此函数必须在不可抢占的上下文中运行，否则 mcache 'c' 的所有者可能会发生变化（导致并发问题）。
8
func (c *mcache) nextFree(spc spanClass) (v gclinkptr, s *mspan, checkGCTrigger *bool) {
9
  // 获取 mcache 为指定 spanClass (spc) 缓存的当前 mspan。
10
  s = c.alloc[spc]
11
  // 默认情况下，不需要检查 GC 触发器，即不是“重量级”分配。
12
  checkGCTrigger = false
13

14
  // 调用 mspan 的 nextFreeIndex 方法，从 span 里面获取下一个空闲对象的索引。
15
  freeIndex := s.nextFreeIndex()
16

17
  // 如果 freeIndex 等于 s.nelems，表示当前 mspan 已经完全满了，没有空闲对象。
18
  if freeIndex == s.nelems {
19
    // 检查 s.allocCount 是否确实等于 s.nelems。
20
    // 如果不相等，说明计数有问题，抛出运行时错误。
21
    if s.allocCount != s.nelems {
22
      println("runtime: s.allocCount=", s.allocCount, "s.nelems=", s.nelems)
23
      throw("s.allocCount != s.nelems && freeIndex == s.nelems")
24
    }
25

26
    // 当前 span 已满，需要重新填充 mcache。
27
    // c.refill(spc) 会从 mcentral 获取一个新的、有空闲对象的 mspan 来替换当前的。
28
    c.refill(spc)
29

30
    checkGCTrigger = true
31

32
    s = c.alloc[spc]
33
    freeIndex = s.nextFreeIndex()
34
  }
35

36
  ...
37
}

1
// nextFreeIndex returns the index of the next free object in s at
2
// or after s.freeindex.
3
// There are hardware instructions that can be used to make this
4
// faster if profiling warrants it.
5

6
// nextFreeIndex 返回 mspan 's' 中，位于或开始于 s.freeindex 的下一个空闲对象的索引。
7
// 如果性能分析表明有必要，可以使用硬件指令来加速此过程。
8
func (s *mspan) nextFreeIndex() uint16 {
9
  ...
10

11
  // 这里相当于重新走一遍 nextFreeFast 的逻辑
12
  aCache := s.allocCache
13
  bitIndex := sys.TrailingZeros64(aCache)
14

15
  // 如果 bitIndex 等于 64，表示当前的 aCache (64位) 已经全部是 0，没有空闲位了。
16
  // 加载 s.allocBits 中的下一段 64 位位图到 aCache。
17
  for bitIndex == 64 {
18
    // 将 freeindex 移动到下一个 64 位的起始位置。
19
    // (sfreeindex + 64) 向上取整到 64 的倍数。
20
    sfreeindex = (sfreeindex + 64) &^ (64 - 1) // 等同于 (sfreeindex + 63) / 64 * 64
21

22
    // 如果移动后的 sfreeindex 已经超出了 mspan 的总对象数，
23
    // 则说明整个 mspan 已经没有空闲对象了。
24
    if sfreeindex >= snelems {
25
      s.freeindex = snelems // 更新 mspan 的 freeindex 为末尾
26
      return snelems
27
    }
28

29
    // 计算需要从 s.allocBits 数组中加载的字节索引。
30
    // s.allocBits 是一个字节数组，每 8 个字节（64位）存储一个 allocCache。
31
    whichByte := sfreeindex / 8
32

33
    // 从 s.allocBits 中重新填充 s.allocCache。
34
    // 这会加载与 sfreeindex 对应的下一段 64 位空闲位图。
35
    s.refillAllocCache(whichByte)
36
    aCache = s.allocCache
37
    // 再次查找新加载的 aCache 中是否有空闲位。
38
    bitIndex = sys.TrailingZeros64(aCache)
39
    // 如果新的 aCache 仍然没有空闲位，继续循环，尝试加载再下一段。
40
  }
41

42
  // 找到了空闲位。计算该空闲对象在整个 mspan 中的绝对索引。
43
  result := sfreeindex + uint16(bitIndex)
44

45
  // 最终检查 result 是否超出了 mspan 的总对象数。
46
  if result >= snelems {
47
    s.freeindex = snelems
48
    return snelems
49
  }
50

51
  // 将 s.allocCache 右移 (bitIndex + 1) 位。
52
  // 这会“消耗”掉刚刚找到并标记为已使用的空闲位，同时将位图向前推进。
53
  s.allocCache >>= uint(bitIndex + 1)
54

55
  // 更新 sfreeindex 为下一个可能的空闲对象的起始索引。
56
  sfreeindex = result + 1
57

58
  // 如果 sfreeindex 达到了 64 的倍数，并且没有超出 mspan 总对象数，
59
  // 说明当前的 64 位 allocCache 已经用尽。
60
  if sfreeindex%64 == 0 && sfreeindex != snelems {
61
    // 计算需要从 s.allocBits 数组中加载的字节索引，以填充下一个 allocCache。
62
    whichByte := sfreeindex / 8
63
    // 重新填充 s.allocCache，准备处理下一个 64 位的对象块。
64
    s.refillAllocCache(whichByte)
65
  }
66

67
  // 更新 mspan 的 freeindex。
68
  s.freeindex = sfreeindex
69
  // 返回找到的空闲对象的绝对索引。
70
  return result
71
}

1
// refill 为 mcache 'c' 获取一个指定 spanClass (spc) 的新 mspan。
2
// 这个新的 mspan 至少会包含一个空闲对象。
3
// 调用此函数时，mcache 中当前对应 spc 的 span 必须是满的。
4
//
5
// 此函数必须在不可抢占的上下文中运行，否则 mcache 'c' 的所有者可能会发生变化（导致并发问题）。
6
func (c *mcache) refill(spc spanClass) {
7
  s := c.alloc[spc] // 获取 mcache 中当前为该 spanClass 缓存的 mspan。
8

9
  ...
10
  // 这里省略一些关于 s 的校验
11

12
  // 如果当前 span 不是一个空的 mspan (emptymspan)，则进行处理。
13
  if s != &emptymspan {
14
    ...
15
    // uncacheSpan 会将其从 mcache 中移除，并放入 mcentral 的相应列表中。
16
    mheap_.central[spc].mcentral.uncacheSpan(s)
17
    ...
18
  }
19

20
  // cacheSpan 会从 mcentral 获取一个新的、有空闲对象的 mspan 来缓存到本地。
21
  s = mheap_.central[spc].mcentral.cacheSpan()
22

23
  ...
24

25
  c.alloc[spc] = s
26
}

1
// 为 mcache 分配一个 span。
2
func (c *mcentral) cacheSpan() *mspan {
3
  // 扣除清扫信用（sweep credit），待会会详细讲。
4
    spanBytes := uintptr(gc.SizeClassToNPages[c.spanclass.sizeclass()]) * pageSize
5
    deductSweepCredit(spanBytes, 0)
6

7
    traceDone := false
8
    trace := traceAcquire()
9
    if trace.ok() {
10
        trace.GCSweepStart()
11
        traceRelease(trace)
12
    }
13

14
    // 如果在尝试了 spanBudget 个 span 后仍然没有找到 free object，
15
    // 就直接从 heap 分配一个新的 span。
16
    // 这样限制了查找时间，并使 sweeping 的成本被摊销。
17
    // 100 这个数字意味着只有 1% 的空间开销。
18
    spanBudget := 100
19

20
    var s *mspan
21
    var sl sweepLocker
22

23
    // 首先看看 “部分空闲”（部分清扫）的 mspan 集合里面有没有可用的 mspan
24
    // 它表示的是有空闲对象，且已经经过 gc 扫描回收过的 mspan
25
    sg := mheap_.sweepgen
26
    if s = c.partialSwept(sg).pop(); s != nil {
27
        goto havespan
28
    }
29

30
    // 如果上面的集合里面找不到，那么就会从部分未清扫的集合里面找，
31
    // 它表示的是还没有经过 gc 扫描回收，但是有一定的空闲空间的 mspan。
32
    sl = sweep.active.begin()
33
    if sl.valid {
34
        for ; spanBudget >= 0; spanBudget-- {
35
            s = c.partialUnswept(sg).pop()
36
            if s == nil {
37
                break
38
            }
39
            if s, ok := sl.tryAcquire(s); ok {
40
                // 成功获得这个 span 的所有权，执行 sweeping。
41
                s.sweep(true)
42
                sweep.active.end(sl)
43
                goto havespan
44
            }
45
        }
46

47
        // 实在找不到空闲的区域了，可以从全满但是还没有清扫的 mspan 集合中获取，
48
        // 因为经过清扫之后，可能会有空闲的空间。
49
        for ; spanBudget >= 0; spanBudget-- {
50
            s = c.fullUnswept(sg).pop()
51
            if s == nil {
52
                break
53
            }
54
            if s, ok := sl.tryAcquire(s); ok {
55
                // 成功获得该 span，进行 sweeping。
56
                s.sweep(true)
57
                // 检查 sweeping 后是否有 free slot。
58
                freeIndex := s.nextFreeIndex()
59
                if freeIndex != s.nelems {
60
                    s.freeindex = freeIndex
61
                    sweep.active.end(sl)
62
                    goto havespan
63
                }
64
                // sweeping 后仍无空位，将其放回 fullSwept 列表。
65
                c.fullSwept(sg).push(s.mspan)
66
            }
67
            // 同上，若无法获取 ownership，跳过。
68
        }
69
        sweep.active.end(sl)
70
    }
71

72
    // 真的一滴都不剩了，只能从堆里面分配了。
73
    trace = traceAcquire()
74
    if trace.ok() {
75
        trace.GCSweepDone()
76
        traceDone = true
77
        traceRelease(trace)
78
    }
79

80
    s = c.grow()
81
    if s == nil {
82
        return nil
83
    }
84

85
    // 至此一定有可用 span。
86
havespan:
87
  ...
88
  // 一些处理
89

90
    return s
91
}

1
// allocLarge 为一个大对象分配一个内存块（span）。
2
// 这是 mcache 的一个方法，mcache 是每个处理器（P）本地的缓存，但大对象分配不经过 mcache，而是直接走向主堆 mheap。
3
func (c *mcache) allocLarge(size uintptr, noscan bool) *mspan {
4

5
  ...
6
  // 计算 npages，就是 size 所需的页数量。
7

8
  // 扣除清扫信用（sweep credit），待会会详细讲。
9
  deductSweepCredit(npages*pageSize, npages)
10

11
  spc := makeSpanClass(0, noscan)
12

13
  // 从主堆（mheap）分配 npages 数量的连续内存页。
14
  s := mheap_.alloc(npages, spc)
15
  if s == nil {
16
    // 如果 mheap 返回 nil，说明物理内存不足。
17
    throw("out of memory") // 抛出内存溢出异常
18
  }
19

20
  ...
21
  // 省略一些对我们来说不太重要的东西
22

23
  // 将这个新分配的大对象 span 放入 mcentral 的 "fullSwept" 列表中。
24
  // mcentral 是集中管理某种规格 span 的地方。
25
  // 这样做是为了让后台清扫器（background sweeper）能够看到并管理这个 span。
26
  mheap_.central[spc].mcentral.fullSwept(mheap_.sweepgen).push(s)
27

28
  ...
29

30
  return s
31
}

1
// deductSweepCredit 函数为分配一个大小为 spanBytes 的 span（内存块）扣除清扫信用。
2
// 这个操作必须在 span 被真正分配 *之前* 执行，以确保系统有足够的信用。
3
// 如果信用不足，它会强制执行清扫操作以避免进入“债务”状态。如果调用者自己也会
4
// 清扫一些页面（例如，在进行一次大内存分配时），它可以传递一个非零的 callerSweepPages
5
// 参数，这样函数会少计算这部分页面的清扫任务。
6
//
7
// deductSweepCredit 做了一个最坏情况的假设：即最终分配的 spanBytes 字节
8
// 将全部用于对象分配。
9
//
10
// deductSweepCredit 是“按比例清扫”（proportional sweep）系统的核心。
11
// 它利用垃圾收集器收集的统计数据来执行足够的清扫工作，以确保在两次 GC 周期
12
// 之间的并发清扫阶段，所有的内存页都能被清扫完毕。
13
//
14
// 调用此函数时，mheap_（内存堆）不能被锁定。
15
func deductSweepCredit(spanBytes uintptr, callerSweepPages uintptr) {
16
  ...
17
retry:
18
  // 获取当前的清扫基准。这个基准是在上一次调整清扫步调时记录的已清扫页面数。
19
  sweptBasis := mheap_.pagesSweptBasis.Load()
20
  // 获取当前的堆上存活对象大小。
21
  live := gcController.heapLive.Load()
22
  // 获取计算清扫步调时使用的堆上存活对象大小的基准值。
23
  liveBasis := mheap_.sweepHeapLiveBasis
24

25
  // 估算新的堆大小。初始值是即将分配的 spanBytes。
26
  newHeapLive := spanBytes
27
  // 如果当前的存活对象大小 `live` 大于设置步调时的基准 `liveBasis`，
28
  // 说明在步调设置之后，又有新的对象被分配了。
29
  // 这部分增量也需要计入清扫任务。
30
  if liveBasis < live {
31
    // 加上这个增量 `live - liveBasis`。
32
    // 这里的代码是有意设计成有竞争条件的，在极少数情况下（例如并发调整GC参数），
33
    // `live` 可能小于 `liveBasis` 导致溢出。注释中提到，这是为了防止计算出一个
34
    // 巨大的 pagesTarget，从而卡在清扫循环里。如果发生这种情况，newHeapLive
35
    // 会是一个较小的值，本次清扫可能会被跳过，等待状态恢复正常。
36
    newHeapLive += uintptr(live - liveBasis)
37
  }
38

39
  // 计算目标需要清扫的页面数。
40
  // `mheap_.sweepPagesPerByte` 是一个比率，代表“每分配一字节内存，需要清扫多少页”。
41
  // `newHeapLive` 是估算的新增内存，乘以这个比率，就得到了需要完成的清扫页数。
42
  // `callerSweepPages` 是调用者承诺自己会清扫的页数，所以可以从目标中减去。
43
  pagesTarget := int64(mheap_.sweepPagesPerByte*float64(newHeapLive)) - int64(callerSweepPages)
44

45
  // 循环清扫，直到达到要求
46
  for pagesTarget > int64(mheap_.pagesSweEpt.Load()-sweptBasis) {
47
    // 调用 sweepone() 来清扫一个 span（通常包含多个页）。
48
    // 如果 sweepone() 返回 ^uintptr(0)，表示所有可清扫的 span 都已清扫完毕。
49
    if sweepone() == ^uintptr(0) {
50
      // 既然没东西可扫了，就将 sweepPagesPerByte 设为 0，禁用按比例清扫。
51
      mheap_.sweepPagesPerByte = 0
52
      // 跳出循环。
53
      break
54
    }
55

56
    // 在清扫过程中，GC 的步调可能会被其他 goroutine 改变（例如，通过 `runtime.GC()`）。
57
    // 如果 `pagesSweptBasis` 发生了变化，说明清扫的基准和目标已经过时。
58
    if mheap_.pagesSweptBasis.Load() != sweptBasis {
59
      // 必须重新计算债务。通过 goto retry 跳转回循环的开始。
60
      goto retry
61
    }
62
  }
63

64
  ...
65
}