Go 内存模型与分配机制

type mcache struct {  
   _ sys.NotInHeap  // 不会分配到GC堆或者栈上
  
	// 会在每次访问malloc时都会被访问，所以为了更加高效缓存将其按组放在这里
   nextSample uintptr // 分配多少大小的堆时触发堆采样
   scanAlloc  uintptr // 分配的可扫描堆字节数
  
   // 小对象缓存, 当申请对象大小为 `<16KB` 的时候，会使用 `Tiny allocator` 分配器
   tiny       uintptr  
   tinyoffset uintptr  
   tinyAllocs uintptr  
  
  // 下方成员不会在每次 malloc 时被访问
   alloc [numSpanClasses]*mspan  // 当前P的分配规格信息
   stackcache [_NumStackOrders]stackfreelist  
  
   flushGen atomic.Uint32  // 表示上次刷新mcache的sweepgen（清扫生成)
}

type mspan struct {  
   _    sys.NotInHeap
   // 前后节点 ,双向链表
   next *mspan    
   prev *mspan   
	...
  
   startAddr uintptr   
   npages    uintptr // number of pages in span  
  
	// Object n starts at address n*elemsize + (start << pageShift).  
	freeindex uintptr  
	// 最多可以存放多少span
	nelems uintptr
   ...
   
   // 标识 mspan 等级
   spanclass spanClass
   // 标记span中的elem哪些是“被使用”的，哪些是未被使用的；清除后将释放 `allocBits` ，并将 `allocBits` 的值设置为 `gcmarkBits` 
	allocBits  *gcBits  
	gcmarkBits *gcBits
}

type mcentral struct {  
   _         sys.NotInHeap  
   spanclass spanClass  
	// one of swept in-use spans, and one of unswept in-use span 在每轮GC期间都扮演着不同的角色。`mheap_.sweepgen` 在每轮gc期间都会递增2。
   partial [2]spanSet // list of spans with a free object  
   full    [2]spanSet // list of spans with no free objects  
}

type mheap struct {  
   _ sys.NotInHeap  
	// `lock` 全局锁，保证并发，所以尽量避免从`mheap`中分配
   lock mutex  
  
   pages pageAlloc // page allocation data structure  
  
   sweepgen uint32 
   // `allspans` 所有的 spans 都是通过 `mheap_` 申请，所有申请过的 `mspan` 都会记录在 `allspans`，可以随着堆的增长重新分配和移动
   allspans []*mspan
   // 堆arena 映射。它指向整个可用虚拟地址空间的每个 arena 帧的堆元数据,由一个L1级映射和多个L2级映射组成, 当有大量的的 arena 帧时将节省空间
   arenas [1 << arenaL1Bits]*[1 << arenaL2Bits]*heapArena
   ...
   allArenas []arenaIdx
   sweepArenas []arenaIdx
   markArenas []arenaIdx
   ...
   // 每种规格大小的块对应一个 mcentral。pad 是一个字节填充，用来避免伪共享（false sharing）
   central [numSpanClasses]struct {  
	   mcentral mcentral  
	   pad      [(cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize) % cpu.CacheLinePadSize]byte  
	}
	...
}
	

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
	// ...
	assistG := deductAssistCredit(size)
	// 获取m
	mp := acquirem()
	// ... 获取mcache
	c := getMCache(mp)
	// ... mspan
	var span *mspan
	var x unsafe.Pointer
	// 是否为小对象 32kb
	if size <= maxSmallSize {
		// 小于 16 B 且无指针，则视为tiny对象
		if noscan && size < maxTinySize {
			// 1. 分配tiny对象如下
		} else {
			// 2. 分配小对象
		}
	} else {
		// 3. 分配大对象
	}
}

    noscan := typ == nil || typ.ptrdata == 0    
    // ...        
    if noscan && size < maxTinySize {        
      // tiny 内存块中，从 offset 往后有空闲位置          
      off := c.tinyoffset          
      // ...   调整off参数并对齐
      // 如果当前 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 的 span 中尝试获取空间   
		v := nextFreeFast(span)  
		if v == 0 {  
			// 通过mcentral,mheap兜底
			// 同样是获取mcache中的缓存,但是更加耗时
			// 如果mcache中没获取到则获取mcentral中的mspan用于分配(调用refill方法)
			// 如果mcentral也没有则去找mheap.
			// 这里的tinySpanClass,是序号为2的spanClass,即大小为16字节.同时也等于macTinySize
		   v, span, shouldhelpgc = c.nextFree(tinySpanClass)  
		}  
		// ...  
		size = maxTinySize
    // ...
    }

func nextFreeFast(s *mspan) gclinkptr {  
   theBit := sys.TrailingZeros64(s.allocCache) // 在 bit map 上寻找到首个 object 空位
   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)  
         // 偏移
         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]
	// ...    
	// 从 mcache 的 span 中获取 object 空位的偏移量    
	freeIndex := s.nextFreeIndex()
	if freeIndex == s.nelems {
		// ...        
		// 倘若 mcache 中 span 已经没有空位，则调用 refill 方法从 mcentral 或者 mheap 中获取新的 span            
		c.refill(spc)
		// ...        
		// 再次从替换后的 span 中获取 object 空位的偏移量        
		s = c.alloc[spc]
		freeIndex = s.nextFreeIndex()
	}
	// ...    
	v = gclinkptr(freeIndex*s.elemsize + s.base())
	s.allocCount++
	// ...    
	return
}

	// 获取spanclass信息
	var sizeclass uint8  
	if size <= smallSizeMax-8 {  
	   sizeclass = size_to_class8[divRoundUp(size, smallSizeDiv)]  
	} else {  
	   sizeclass = size_to_class128[divRoundUp(size-smallSizeMax, largeSizeDiv)]  
	}  
	// 根据对应的spanclass，分配给每个对象的空间大小
	size = uintptr(class_to_size[sizeclass])  
	spc := makeSpanClass(sizeclass, noscan)  
	span = c.alloc[spc]  
	v := nextFreeFast(span)  
	if v == 0 {  
	   v, span, shouldhelpgc = c.c(spc)  
	}  
	x = unsafe.Pointer(v)  
	if needzero && span.needzero != 0 {  
	   memclrNoHeapPointers(x, size)  
	}

	shouldhelpgc = true  
	// 直接调用mheap进行分配. makeSpanClass(0, noscan)
	span = c.allocLarge(size, noscan)  
	span.freeindex = 1  
	span.allocCount = 1  
	size = span.elemsize  
	x = unsafe.Pointer(span.base())