type mspan struct {

	next *mspan     // 指向下一个 mspan

	prev *mspan     // 指向上一个 mspan

	list *mSpanList 

	startAddr uintptr // 起始地址

	npages    uintptr  // 页数

	manualFreeList gclinkptr // 空闲对象列表

	freeindex uint16 

	nelems uint16  //span 链表中元素个数

	// 标识此前的位置都已被占用

	freeIndexForScan uint16 // 

	allocBits  *gcBits // 表示该 span 种所有元素的使用分配情况，位值置为 1 则标识 span 链表中对应位置的 span 已被分配

	gcmarkBits *gcBits // 

	pinnerBits *gcBits 

	sweepgen              uint32

	divMul                uint32        // for divide by elemsize

	allocCount            uint16        // 已分配的对象个数

	spanclass             spanClass     //span 类别

	state                 mSpanStateBox // mSpanInUse etc; accessed atomically (get/set methods)

	needzero              uint8         // needs to be zeroed before allocation

	isUserArenaChunk      bool          // whether or not this span represents a user arena

	allocCountBeforeCache uint16        // a copy of allocCount that is stored just before this span is cached

	elemsize              uintptr       // 能存储的对象大小

	limit                 uintptr       // end of data in span

	speciallock           mutex         // guards specials list and changes to pinnerBits

	specials              *special      // linked list of special records sorted by offset.

	userArenaChunkFree    addrRange     // interval for managing chunk allocation

	largeType             *_type        // malloc header for large objects.

}

type spanClass uint8

const (

	numSpanClasses = _NumSizeClasses << 1

	tinySpanClass  = spanClass(tinySizeClass<<1 | 1)

)

//uint8 类型，高 7 位表示 span 等级，低 1 位表示 noscan

func makeSpanClass(sizeclass uint8, noscan bool) spanClass {

	return spanClass(sizeclass<<1) | spanClass(bool2int(noscan))

}

//go:nosplit

func (sc spanClass) sizeclass() int8 {

	return int8(sc >> 1)

}

//go:nosplit

func (sc spanClass) noscan() bool {

	return sc&1 != 0

}

const numSpanClasses = _NumSizeClasses << 1 = 136

type mcache struct {

	nextSample uintptr // trigger heap sample after allocating this many bytes

	scanAlloc  uintptr // bytes of scannable heap allocated

	// 微对象分配器相关

	tiny       uintptr

	tinyoffset uintptr

	tinyAllocs uintptr

	//mcache 中缓存的 mspan，每种 spanClass 各一个

	alloc [numSpanClasses]*mspan // spans to allocate from, indexed by spanClass

	stackcache [_NumStackOrders]stackfreelist

	flushGen atomic.Uint32

}

type mcentral struct {

	// 对应的 spanClass

	spanclass spanClass

	// 有空位的 mspan 集合，数组长度为 2 适用于抗一轮 GC

	partial [2]spanSet // list of spans with a free object

	// 没有空位的 mspan 集合

	full    [2]spanSet // list of spans with no free objects

}

type mheap struct {

	// 堆的全局锁

	lock mutex

	// 空闲页分配器，底层是多棵基数树组成的索引，每棵树对应 16GB 的空间

	pages pageAlloc // page allocation data structure

	sweepgen uint32 // sweep generation, see comment in mspan; written during STW

	// 记录了所有的 msapn，所有 mspan 都是经由 mheap，使用连续空闲页组装生成的

	allspans []*mspan // all spans out there

	pagesInUse         atomic.Uintptr // pages of spans in stats mSpanInUse

	pagesSwept         atomic.Uint64  // pages swept this cycle

	pagesSweptBasis    atomic.Uint64  // pagesSwept to use as the origin of the sweep ratio

	sweepHeapLiveBasis uint64         // value of gcController.heapLive to use as the origin of sweep ratio; written with lock, read without

	sweepPagesPerByte  float64        // proportional sweep ratio; written with lock, read without

	reclaimIndex atomic.Uint64

	reclaimCredit atomic.Uintptr

	_ cpu.CacheLinePad // prevents false-sharing between arenas and preceding variables

	//heapAreana 数组，64 位系统下，二维数组容量为 [1][2^22]

	// 每个 heapArena 大小 64M，因此理论上，Golang 堆上限为 2^22 * 64M = 256TB

	arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena

	arenasHugePages bool

	heapArenaAlloc linearAlloc

	arenaHints *arenaHint

	arena linearAlloc

	allArenas []arenaIdx

	sweepArenas []arenaIdx

	markArenas []arenaIdx

	curArena struct {

		base, end uintptr

	}

	// 多个 mecntral，总个数为 spanClass 的个数

	central [numSpanClasses]struct {

		mcentral mcentral

		// 用于内存地址对齐

		pad      [(cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize) % cpu.CacheLinePadSize]byte

	}

	spanalloc              fixalloc // allocator for span*

	cachealloc             fixalloc // allocator for mcache*

	specialfinalizeralloc  fixalloc // allocator for specialfinalizer*

	specialprofilealloc    fixalloc // allocator for specialprofile*

	specialReachableAlloc  fixalloc // allocator for specialReachable

	specialPinCounterAlloc fixalloc // allocator for specialPinCounter

	speciallock            mutex    // lock for special record allocators.

	arenaHintAlloc         fixalloc // allocator for arenaHints

	userArena struct {

		arenaHints *arenaHint

		quarantineList mSpanList

		readyList mSpanList

	}

	unused *specialfinalizer

}

type pageAlloc struct {

	// 共有五层基数树，第一层有 2^14 个节点，因此共用 2^14 棵基数树

	// 总空间大小为 2^14 * 16GB = 256TB

	// 接下来每层的节点数为上层的 8 倍

	summary [summaryLevels][]pallocSum

	summaries and

	chunks [1 << pallocChunksL1Bits]*[1 << pallocChunksL2Bits]pallocData

	searchAddr offAddr

	// start and end represent the chunk indices

	// which pageAlloc knows about. It assumes

	// chunks in the range [start, end) are

	// currently ready to use.

	start, end chunkIdx

	// inUse is a slice of ranges of address space which are

	// known by the page allocator to be currently in-use (passed

	// to grow).

	//

	// We care much more about having a contiguous heap in these cases

	// and take additional measures to ensure that, so in nearly all

	// cases this should have just 1 element.

	//

	// All access is protected by the mheapLock.

	inUse addrRanges

	// scav stores the scavenger state.

	scav struct {

		// index is an efficient index of chunks that have pages available to

		// scavenge.

		index scavengeIndex

		// releasedBg is the amount of memory released in the background this

		// scavenge cycle.

		releasedBg atomic.Uintptr

		// releasedEager is the amount of memory released eagerly this scavenge

		// cycle.

		releasedEager atomic.Uintptr

	}

	// mheap_.lock. This level of indirection makes it possible

	// to test pageAlloc independently of the runtime allocator.

	mheapLock *mutex

	// sysStat is the runtime memstat to update when new system

	// memory is committed by the pageAlloc for allocation metadata.

	sysStat *sysMemStat

	// summaryMappedReady is the number of bytes mapped in the Ready state

	// in the summary structure. Used only for testing currently.

	//

	// Protected by mheapLock.

	summaryMappedReady uintptr

	// chunkHugePages indicates whether page bitmap chunks should be backed

	// by huge pages.

	chunkHugePages bool

	// Whether or not this struct is being used in tests.

	test bool

}

const(

    logMaxPackedValue = 21

    maxPackedValue    = 1 << logMaxPackedValue

)

type pallocSum uint64

//  基于 start、max、end 组装成一个基数树节点 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))

}

type heapArena struct {

	heapArenaPtrScalar

	// 实现 page 到 mspan 的映射

	spans [pagesPerArena]*mspan

	pageInUse [pagesPerArena / 8]uint8

	// pageMarks is a bitmap that indicates which spans have any

	// marked objects on them. Like pageInUse, only the bit

	// corresponding to the first page in each span is used.

	//

	// Writes are done atomically during marking. Reads are

	// non-atomic and lock-free since they only occur during

	// sweeping (and hence never race with writes).

	//

	// This is used to quickly find whole spans that can be freed.

	//

	// TODO(austin): It would be nice if this was uint64 for

	// faster scanning, but we don't have 64-bit atomic bit

	// operations.

	pageMarks [pagesPerArena / 8]uint8

	// pageSpecials is a bitmap that indicates which spans have

	// specials (finalizers or other). Like pageInUse, only the bit

	// corresponding to the first page in each span is used.

	//

	// Writes are done atomically whenever a special is added to

	// a span and whenever the last special is removed from a span.

	// Reads are done atomically to find spans containing specials

	// during marking.

	pageSpecials [pagesPerArena / 8]uint8

	// checkmarks stores the debug.gccheckmark state. It is only

	// used if debug.gccheckmark > 0.

	checkmarks *checkmarksMap

	// zeroedBase marks the first byte of the first page in this

	// arena which hasn't been used yet and is therefore already

	// zero. zeroedBase is relative to the arena base.

	// Increases monotonically until it hits heapArenaBytes.

	//

	// This field is sufficient to determine if an allocation

	// needs to be zeroed because the page allocator follows an

	// address-ordered first-fit policy.

	//

	// Read atomically and written with an atomic CAS.

	zeroedBase uintptr

}

noscan := typ == nil || typ.ptrdata == 0

// ...

if noscan && size < maxTinySize {

//tiny 内存块中，从 offset 往后有空闲位置

	off := c.tinyoffset

	// ...

	// 如果当前 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

	}

	// ...

}

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)

}

x = unsafe.Pointer(v)

func nextFreeFast(s *mspan) gclinkptr {

    // 通过 ctz64 算法，在 bit map 上寻找到首个 object 空位

    theBit := sys.Ctz64(s.allocCache) 

    if theBit < 64 {

        result := s.freeindex + uintptr(theBit)

        if result < s.nelems {

            freeidx := result + 1

            if freeidx%64 == 0 && freeidx != s.nelems {

                return 0

            }

            s.allocCache >>= uint(theBit + 1)

            // 偏移 freeindex 

            s.freeindex = freeidx

            s.allocCount++

            // 返回获取 object 空位的内存地址 

            return gclinkptr(result*s.elemsize + s.base())

        }

    }

    return 0

}

func (c *mcache) nextFree(spc spanClass) (v gclinkptr, s *mspan, shouldhelpgc bool) {

	s = c.alloc[spc]

	shouldhelpgc = false

	freeIndex := s.nextFreeIndex()

	if freeIndex == s.nelems {

		// The span is full.

		if s.allocCount != s.nelems {

			println("runtime: s.allocCount=", s.allocCount, "s.nelems=", s.nelems)

			throw("s.allocCount != s.nelems && freeIndex == s.nelems")

		}

		c.refill(spc)

		shouldhelpgc = true

		s = c.alloc[spc]

		freeIndex = s.nextFreeIndex()

	}

	if freeIndex >= s.nelems {

		throw("freeIndex is not valid")

	}

	v = gclinkptr(uintptr(freeIndex)*s.elemsize + s.base())

	s.allocCount++

	if s.allocCount > s.nelems {

		println("s.allocCount=", s.allocCount, "s.nelems=", s.nelems)

		throw("s.allocCount > s.nelems")

	}

	return

}

func (c *mcache) refill(spc spanClass) {  

    s := c.alloc[spc]

    // ...

    // 从 mcentral 当中获取对应等级的 span

    s = mheap_.central[spc].mcentral.cacheSpan()

    // ...

    // 将新的 span 添加到 mcahe 当中

    c.alloc[spc] = s

}

func (c *mcentral) cacheSpan() *mspan {

    // ...

    var sl sweepLocker    

    // ...

    sl = sweep.active.begin()

    if sl.valid {

        for ; spanBudget >= 0; spanBudget-- {

            s = c.partialUnswept(sg).pop()

            // ...

            if s, ok := sl.tryAcquire(s); ok {

                // ...

                sweep.active.end(sl)

                goto havespan

            }

        // 通过 sweepLock，加锁尝试从 mcentral 的非空链表 full 中获取 mspan

        for ; spanBudget >= 0; spanBudget-- {

            s = c.fullUnswept(sg).pop()

           // ...

            if s, ok := sl.tryAcquire(s); ok {

                // ...

                sweep.active.end(sl)

                goto havespan

                }

                // ...

            }

        }

        // ...

    }

    // ...

    // 执行到此处时，s 已经指向一个存在 object 空位的 mspan 了

havespan:

    // ...

    return

}

func (c *mcentral) cacheSpan() *mspan {

    // ...

    //mcentral 中也没有可用的 mspan 了，则需要从 mheap 中获取，最终会调用 mheap_.alloc 方法

    s = c.grow()

   // ...

    // 执行到此处时，s 已经指向一个存在 object 空位的 mspan 了

havespan:

    // ...

    return

}

func (c *mcentral) grow() *mspan {

    npages := uintptr(class_to_allocnpages[c.spanclass.sizeclass()])

    size := uintptr(class_to_size[c.spanclass.sizeclass()])

    s := mheap_.alloc(npages, c.spanclass)

    // ...

    // ...

    return s

}

func (h *mheap) alloc(npages uintptr, spanclass spanClass) *mspan {

    var s *mspan

    systemstack(func() {

        // ...

        s = h.allocSpan(npages, spanAllocHeap, spanclass)

    })

    return s

}

func (h *mheap) allocSpan(npages uintptr, typ spanAllocType, spanclass spanClass) (s *mspan) {

    gp := getg()

    base, scav := uintptr(0), uintptr(0)

    //... 此处实际上还有一阶缓存，是从每个 P 的页缓存 pageCache 中获取空闲页组装 mspan，此处先略去了...

    // 加上堆全局锁

    lock(&h.lock)

    if base == 0 {

        // 通过基数树索引快速寻找满足条件的连续空闲页

        base, scav = h.pages.alloc(npages)

        // ...

    }

    // ...

    unlock(&h.lock)

HaveSpan:

    // 把空闲页组装成 mspan

    s.init(base, npages)

    // 将这批页添加到 heapArena 中，建立由页指向 mspan 的映射

    h.setSpans(s.base(), npages, s)

    // ...

    return s

}

func (h *mheap) grow(npage uintptr) (uintptr, bool) {

    av, asize := h.sysAlloc(ask)

}

func (h *mheap) sysAlloc(n uintptr) (v unsafe.Pointer, size uintptr) {

       v = sysReserve(unsafe.Pointer(p), n)

}

func sysReserve(v unsafe.Pointer, n uintptr) unsafe.Pointer {

    return sysReserveOS(v, n)

}

func sysReserveOS(v unsafe.Pointer, n uintptr) unsafe.Pointer {

    p, err := mmap(v, n, _PROT_NONE, _MAP_ANON|_MAP_PRIVATE, -1, 0)

    if err != 0 {

        return nil

    }

    return p

}