go语言的动态内存

go语言动态内存的申请和释放设计来自于tcmalloc
主要数据结构：
MHeap:the malloc heap,管理page
MCentral:特定类型小对象共享的free list
MCache:线程本地小对象的共享free list

分配小对象

1. 查找MCache相应大小的free list，如果free list非空，从free list中直接获取，
   这种情况下不需要任何锁的开销
2. 如果MCache的free list为空，则从MCentral获取一些free object
3. 如果MCentral的free list为空，则从MHeap申请一些page，然后将page内存加入到相应MCentral的free list
4. 如果MHeap缓存的page不足，则从操作系统申请一些page(至少1M)

分配大对象

大对象直接从MHeap从分配

申请动态内存

// Allocate an object of size bytes.
// Small objects are allocated from the per-P cache's free lists.
// Large objects (> 32 kB) are allocated straight from the heap.
func mallocgc(size uintptr, typ *_type, flags uint32) unsafe.Pointer {
    if size == 0 {
    	return unsafe.Pointer(&zerobase)
    }
    size0 := size
 
    if flags&flagNoScan == 0 && typ == nil {
    	gothrow("malloc missing type")
    }
 
    // This function must be atomic wrt GC, but for performance reasons
    // we don't acquirem/releasem on fast path. The code below does not have
    // split stack checks, so it can't be preempted by GC.
    // Functions like roundup/add are inlined. And onM/racemalloc are nosplit.
    // If debugMalloc = true, these assumptions are checked below.
    if debugMalloc {
    	mp := acquirem()
    	if mp.mallocing != 0 {
    		gothrow("malloc deadlock")
    	}
    	mp.mallocing = 1
    	if mp.curg != nil {
    		mp.curg.stackguard0 = ^uintptr(0xfff) | 0xbad
    	}
    }
 
    c := gomcache()
    var s *mspan
    var x unsafe.Pointer
    if size <= maxSmallSize {
    	if flags&flagNoScan != 0 && size < maxTinySize {
    		// Tiny allocator.
    		//
    		// Tiny allocator combines several tiny allocation requests
    		// into a single memory block. The resulting memory block
    		// is freed when all subobjects are unreachable. The subobjects
    		// must be FlagNoScan (don't have pointers), this ensures that
    		// the amount of potentially wasted memory is bounded.
    		//
    		// Size of the memory block used for combining (maxTinySize) is tunable.
    		// Current setting is 16 bytes, which relates to 2x worst case memory
    		// wastage (when all but one subobjects are unreachable).
    		// 8 bytes would result in no wastage at all, but provides less
    		// opportunities for combining.
    		// 32 bytes provides more opportunities for combining,
    		// but can lead to 4x worst case wastage.
    		// The best case winning is 8x regardless of block size.
    		//
    		// Objects obtained from tiny allocator must not be freed explicitly.
    		// So when an object will be freed explicitly, we ensure that
    		// its size >= maxTinySize.
    		//
    		// SetFinalizer has a special case for objects potentially coming
    		// from tiny allocator, it such case it allows to set finalizers
    		// for an inner byte of a memory block.
    		//
    		// The main targets of tiny allocator are small strings and
    		// standalone escaping variables. On a json benchmark
    		// the allocator reduces number of allocations by ~12% and
    		// reduces heap size by ~20%.
    		tinysize := uintptr(c.tinysize)
    		if size <= tinysize {
    			tiny := unsafe.Pointer(c.tiny)
    			// Align tiny pointer for required (conservative) alignment.
    			if size&7 == 0 {
    				tiny = roundup(tiny, 8)
    			} else if size&3 == 0 {
    				tiny = roundup(tiny, 4)
    			} else if size&1 == 0 {
    				tiny = roundup(tiny, 2)
    			}
    			size1 := size + (uintptr(tiny) - uintptr(unsafe.Pointer(c.tiny)))
    			if size1 <= tinysize {
    				// The object fits into existing tiny block.
    				x = tiny
    				c.tiny = (*byte)(add(x, size))
    				c.tinysize -= uintptr(size1)
    				c.local_tinyallocs++
    				if debugMalloc {
    					mp := acquirem()
    					if mp.mallocing == 0 {
    						gothrow("bad malloc")
    					}
    					mp.mallocing = 0
    					if mp.curg != nil {
    						mp.curg.stackguard0 = mp.curg.stack.lo + _StackGuard
    					}
    					// Note: one releasem for the acquirem just above.
    					// The other for the acquirem at start of malloc.
    					releasem(mp)
    					releasem(mp)
    				}
    				return x
    			}
    		}
    		// Allocate a new maxTinySize block.
    		s = c.alloc[tinySizeClass]
    		v := s.freelist
    		if v == nil {
    			mp := acquirem()
    			mp.scalararg[0] = tinySizeClass
    			onM(mcacheRefill_m)
    			releasem(mp)
    			s = c.alloc[tinySizeClass]
    			v = s.freelist
    		}
    		s.freelist = v.next
    		s.ref++
    		//TODO: prefetch v.next
    		x = unsafe.Pointer(v)
    		(*[2]uint64)(x)[0] = 0
    		(*[2]uint64)(x)[1] = 0
    		// See if we need to replace the existing tiny block with the new one
    		// based on amount of remaining free space.
    		if maxTinySize-size > tinysize {
    			c.tiny = (*byte)(add(x, size))
    			c.tinysize = uintptr(maxTinySize - size)
    		}
    		size = maxTinySize
    	} else {
    		var sizeclass int8
    		if size <= 1024-8 {
    			sizeclass = size_to_class8[(size+7)>>3]
    		} else {
    			sizeclass = size_to_class128[(size-1024+127)>>7]
    		}
    		size = uintptr(class_to_size[sizeclass])
    		s = c.alloc[sizeclass]
    		v := s.freelist
    		if v == nil {
    			mp := acquirem()
    			mp.scalararg[0] = uintptr(sizeclass)
    			onM(mcacheRefill_m)
    			releasem(mp)
    			s = c.alloc[sizeclass]
    			v = s.freelist
    		}
    		s.freelist = v.next
    		s.ref++
    		//TODO: prefetch
    		x = unsafe.Pointer(v)
    		if flags&flagNoZero == 0 {
    			v.next = nil
    			if size > 2*ptrSize && ((*[2]uintptr)(x))[1] != 0 {
    				memclr(unsafe.Pointer(v), size)
    			}
    		}
    	}
    	c.local_cachealloc += intptr(size)
    } else {
    	mp := acquirem()
    	mp.scalararg[0] = uintptr(size)
    	mp.scalararg[1] = uintptr(flags)
    	onM(largeAlloc_m)
    	s = (*mspan)(mp.ptrarg[0])
    	mp.ptrarg[0] = nil
    	releasem(mp)
    	x = unsafe.Pointer(uintptr(s.start << pageShift))
    	size = uintptr(s.elemsize)
    }
 
    if flags&flagNoScan != 0 {
    	// All objects are pre-marked as noscan.
    	goto marked
    }
 
    // If allocating a defer+arg block, now that we've picked a malloc size
    // large enough to hold everything, cut the "asked for" size down to
    // just the defer header, so that the GC bitmap will record the arg block
    // as containing nothing at all (as if it were unused space at the end of
    // a malloc block caused by size rounding).
    // The defer arg areas are scanned as part of scanstack.
    if typ == deferType {
    	size0 = unsafe.Sizeof(_defer{})
    }
 
    // From here till marked label marking the object as allocated
    // and storing type info in the GC bitmap.
    {
    	arena_start := uintptr(unsafe.Pointer(mheap_.arena_start))
    	off := (uintptr(x) - arena_start) / ptrSize
    	xbits := (*uint8)(unsafe.Pointer(arena_start - off/wordsPerBitmapByte - 1))
    	shift := (off % wordsPerBitmapByte) * gcBits
    	if debugMalloc && ((*xbits>>shift)&(bitMask|bitPtrMask)) != bitBoundary {
    		println("runtime: bits =", (*xbits>>shift)&(bitMask|bitPtrMask))
    		gothrow("bad bits in markallocated")
    	}
 
    	var ti, te uintptr
    	var ptrmask *uint8
    	if size == ptrSize {
    		// It's one word and it has pointers, it must be a pointer.
    		*xbits |= (bitsPointer << 2) << shift
    		goto marked
    	}
    	if typ.kind&kindGCProg != 0 {
    		nptr := (uintptr(typ.size) + ptrSize - 1) / ptrSize
    		masksize := nptr
    		if masksize%2 != 0 {
    			masksize *= 2 // repeated
    		}
    		masksize = masksize * pointersPerByte / 8 // 4 bits per word
    		masksize++                                // unroll flag in the beginning
    		if masksize > maxGCMask && typ.gc[1] != 0 {
    			// If the mask is too large, unroll the program directly
    			// into the GC bitmap. It's 7 times slower than copying
    			// from the pre-unrolled mask, but saves 1/16 of type size
    			// memory for the mask.
    			mp := acquirem()
    			mp.ptrarg[0] = x
    			mp.ptrarg[1] = unsafe.Pointer(typ)
    			mp.scalararg[0] = uintptr(size)
    			mp.scalararg[1] = uintptr(size0)
    			onM(unrollgcproginplace_m)
    			releasem(mp)
    			goto marked
    		}
    		ptrmask = (*uint8)(unsafe.Pointer(uintptr(typ.gc[0])))
    		// Check whether the program is already unrolled.
    		if uintptr(atomicloadp(unsafe.Pointer(ptrmask)))&0xff == 0 {
    			mp := acquirem()
    			mp.ptrarg[0] = unsafe.Pointer(typ)
    			onM(unrollgcprog_m)
    			releasem(mp)
    		}
    		ptrmask = (*uint8)(add(unsafe.Pointer(ptrmask), 1)) // skip the unroll flag byte
    	} else {
    		ptrmask = (*uint8)(unsafe.Pointer(typ.gc[0])) // pointer to unrolled mask
    	}
    	if size == 2*ptrSize {
    		*xbits = *ptrmask | bitBoundary
    		goto marked
    	}
    	te = uintptr(typ.size) / ptrSize
    	// If the type occupies odd number of words, its mask is repeated.
    	if te%2 == 0 {
    		te /= 2
    	}
    	// Copy pointer bitmask into the bitmap.
    	for i := uintptr(0); i < size0; i += 2 * ptrSize {
    		v := *(*uint8)(add(unsafe.Pointer(ptrmask), ti))
    		ti++
    		if ti == te {
    			ti = 0
    		}
    		if i == 0 {
    			v |= bitBoundary
    		}
    		if i+ptrSize == size0 {
    			v &^= uint8(bitPtrMask << 4)
    		}
 
    		*xbits = v
    		xbits = (*byte)(add(unsafe.Pointer(xbits), ^uintptr(0)))
    	}
    	if size0%(2*ptrSize) == 0 && size0 < size {
    		// Mark the word after last object's word as bitsDead.
    		*xbits = bitsDead << 2
    	}
    }
marked:
    if raceenabled {
    	racemalloc(x, size)
    }
 
    if debugMalloc {
    	mp := acquirem()
    	if mp.mallocing == 0 {
    		gothrow("bad malloc")
    	}
    	mp.mallocing = 0
    	if mp.curg != nil {
    		mp.curg.stackguard0 = mp.curg.stack.lo + _StackGuard
    	}
    	// Note: one releasem for the acquirem just above.
    	// The other for the acquirem at start of malloc.
    	releasem(mp)
    	releasem(mp)
    }
 
    if debug.allocfreetrace != 0 {
    	tracealloc(x, size, typ)
    }
 
    if rate := MemProfileRate; rate > 0 {
    	if size < uintptr(rate) && int32(size) < c.next_sample {
    		c.next_sample -= int32(size)
    	} else {
    		mp := acquirem()
    		profilealloc(mp, x, size)
    		releasem(mp)
    	}
    }
 
    if memstats.heap_alloc >= memstats.next_gc {
    	gogc(0)
    }
 
    return x
}

释放动态内存

go不存在类似C中的free函数，动态内存的释放是由GC进行的，每次释放不是单独一个对象，而是一个span中n个对象

// Free n objects from a span s back into the central free list c.
// Called during sweep.
// Returns true if the span was returned to heap.  Sets sweepgen to
// the latest generation.
// If preserve=true, don't return the span to heap nor relink in MCentral lists;
// caller takes care of it.
bool
runtime·MCentral_FreeSpan(MCentral *c, MSpan *s, int32 n, MLink *start, MLink *end, bool preserve)
{
    bool wasempty;
 
    if(s->incache)
    	runtime·throw("freespan into cached span");
 
    // Add the objects back to s's free list.
    wasempty = s->freelist == nil;
    end->next = s->freelist;
    s->freelist = start;
    s->ref -= n;
 
    if(preserve) {
    	// preserve is set only when called from MCentral_CacheSpan above,
    	// the span must be in the empty list.
    	if(s->next == nil)
    		runtime·throw("can't preserve unlinked span");
    	runtime·atomicstore(&s->sweepgen, runtime·mheap.sweepgen);
    	return false;
    }
 
    runtime·lock(&c->lock);
 
    // Move to nonempty if necessary.
    if(wasempty) {
    	runtime·MSpanList_Remove(s);
    	runtime·MSpanList_Insert(&c->nonempty, s);
    }
 
    // delay updating sweepgen until here.  This is the signal that
    // the span may be used in an MCache, so it must come after the
    // linked list operations above (actually, just after the
    // lock of c above.)
    runtime·atomicstore(&s->sweepgen, runtime·mheap.sweepgen);
 
    if(s->ref != 0) {
    	runtime·unlock(&c->lock);
    	return false;
    }
 
    // s is completely freed, return it to the heap.
    runtime·MSpanList_Remove(s);
    s->needzero = 1;
    s->freelist = nil;
    runtime·unlock(&c->lock);
    runtime·unmarkspan((byte*)(s->start<<PageShift), s->npages<<PageShift);
    runtime·MHeap_Free(&runtime·mheap, s, 0);
    return true;
}