golang内存管理

 

解释定义：

mheap：用于管理整个堆内存，mheap 管理多个arena，arena管理多个span，一个span由多个page组成，一个arena有8192个page，page由内存块组成

mspan：一个span对应一个mspan

mcentral：mheap里有一个全局的mspan管理中心包含mcentral数组，0-135 mcentral，一个mcentral(管理对应类型的span)

 

spanclass高7为是大小编号，最后一位0代表是指针，1代表不是指针

另外分已用尽full和未用尽partial，里面又分已清扫的spanSet和未清扫的spanSet，spanSet是并发安全的。如果所有人都来mcentral要内存，那加锁太频繁了，那么自然而然每个P都有本地的小对象缓存

mcache：每个P内部的小对象缓存。alloc 0-135 *mspan，先在本地找，不够了去mcentral拿一个到本地，用完的放到mcentral的fullset中，tiny 16B，tinyoffset记录这段内存已经用到哪里了，剩下空间还够就继续分配，不够就拿16B大小的内存块过来用，本地缓存的用完了就从mcentral中拿一个新的mspan过来

heapArena：arena 对应一个heapArena 管理者

    type heapArena struct {
        bitmap [heapArenaBitmapBytes]byte 

        spans [pagesPerArena]*mspan  pagesPerArena = 8192 用于定位一个page对应的mspan在哪
        pageInUse [pagesPerArena / 8]uint8  
        pageMarks [pagesPerArena / 8]uint8   
        pageSpecials [pagesPerArena / 8]uint8
        checkmarks *checkmarksMap
        zeroedBase uintptr 标记此 arena 中尚未使用的第一个page的首地址
    }

 

bitmap最后的byte代表一字节分高4位代表终止扫描，低4位代表标量指针。



假设分配一个slice，包含指针，长度，容量。pageInUse 只标记处于使用状态的span的第一个page，例如arena的span 0-1 2-4都使用了，那么第0号元素的pageInUse 第0位标记为1 第2位标记为1

 pageMarks 同pageInUse，只标记哪些span中存在被标记的对象，在gc的时候通过这个位图来释放不含标记对象的span

spans 用于定位一个page对应的mspan在哪

 

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 is the slot index between 0 and nelems at which to begin scanning
	// for the next free object in this span.
	// Each allocation scans allocBits starting at freeindex until it encounters a 0
	// indicating a free object. freeindex is then adjusted so that subsequent scans begin
	// just past the newly discovered free object.
	//
	// If freeindex == nelem, this span has no free objects.
	//
	// allocBits is a bitmap of objects in this span.
	// If n >= freeindex and allocBits[n/8] & (1<<(n%8)) is 0
	// then object n is free;
	// otherwise, object n is allocated. Bits starting at nelem are
	// undefined and should never be referenced.
	//
	// Object n starts at address n*elemsize + (start << pageShift).
	freeindex uintptr
	// TODO: Look up nelems from sizeclass and remove this field if it
	// helps performance.
	nelems uintptr // number of object in the span.

	// Cache of the allocBits at freeindex. allocCache is shifted
	// such that the lowest bit corresponds to the bit freeindex.
	// allocCache holds the complement of allocBits, thus allowing
	// ctz (count trailing zero) to use it directly.
	// allocCache may contain bits beyond s.nelems; the caller must ignore
	// these.
	allocCache uint64

	// allocBits and gcmarkBits hold pointers to a span's mark and
	// allocation bits. The pointers are 8 byte aligned.
	// There are three arenas where this data is held.
	// free: Dirty arenas that are no longer accessed
	//       and can be reused.
	// next: Holds information to be used in the next GC cycle.
	// current: Information being used during this GC cycle.
	// previous: Information being used during the last GC cycle.
	// A new GC cycle starts with the call to finishsweep_m.
	// finishsweep_m moves the previous arena to the free arena,
	// the current arena to the previous arena, and
	// the next arena to the current arena.
	// The next arena is populated as the spans request
	// memory to hold gcmarkBits for the next GC cycle as well
	// as allocBits for newly allocated spans.
	//
	// The pointer arithmetic is done "by hand" instead of using
	// arrays to avoid bounds checks along critical performance
	// paths.
	// The sweep will free the old allocBits and set allocBits to the
	// gcmarkBits. The gcmarkBits are replaced with a fresh zeroed
	// out memory.
	allocBits  *gcBits
	gcmarkBits *gcBits

	// sweep generation:
	// if sweepgen == h->sweepgen - 2, the span needs sweeping
	// if sweepgen == h->sweepgen - 1, the span is currently being swept
	// if sweepgen == h->sweepgen, the span is swept and ready to use
	// if sweepgen == h->sweepgen + 1, the span was cached before sweep began and is still cached, and needs sweeping
	// if sweepgen == h->sweepgen + 3, the span was swept and then cached and is still cached
	// h->sweepgen is incremented by 2 after every GC

	sweepgen              uint32
	divMul                uint32        // for divide by elemsize
	allocCount            uint16        // number of allocated objects
	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.

	// freeIndexForScan is like freeindex, except that freeindex is
	// used by the allocator whereas freeIndexForScan is used by the
	// GC scanner. They are two fields so that the GC sees the object
	// is allocated only when the object and the heap bits are
	// initialized (see also the assignment of freeIndexForScan in
	// mallocgc, and issue 54596).
	freeIndexForScan uintptr
}

 

spanclass 跟mcentral一样记录着划分好的内存块规格

nelem 记录当前span共划分成了多少个内存块

freeIndex 记录着下个空闲内存块的索引

allocBits *gcBits 用于标记哪些内存块已经被分配了

gcmarkBits *gcBits 当前span的标记位图，一个二进制位对应span的一个内存块，gc清扫的时候释放allocBits，然后把gcmarkBits用作allocBits，未被gc标记的内存块就能回收利用了

 

申请内存的步骤：

1.辅助gc
至少扫描64KB，多干的部分会存在银行。全局gccontroller有足够多的信用，窃取了也不用进行辅助gc
2.空间分配
<16B noscan tiny
>=16B <=32KB noscan scannable
>32KB 大块内存分配器 需要多少字节就分配一个对应大小的新的span
3.位图标记

*heapArena放到一个数组里，并用arena编号作为索引定位heapArena windows/linux架构arena大小不同，所以有二维数组的说法，计算出arenaidx
amd64 windows第一维64，占6bit，第二维数组长度为1M=2^20，arenaidx中低20位用作第二维的索引
amd64 linux第一维一个元素，第二维4M=2^22，arenaidx中低22位用作第二维的索引
每个arena中有pagesPerArena个page，每个page大小是pageSize，一个内存块的page编号=(p/pageSize)%pagesPerArena，最终能在heapArena数组中找到mspan地址了
4.收尾工作

当前处于gc标记阶段，需要对新分配的对象进行gc标记，这次内存分配达到了触发gc的条件，还会触发新一轮的gc