# 7.8 内存统计 Go 运行时对用户提供只读的内存统计信息，通过`runtime.MemStats`支持。 公共方法只有一个：`ReadMemStats`。但调用这个方法的代价非常之大： ``` func ReadMemStats(m *MemStats) { stopTheWorld("read mem stats") systemstack(func() { readmemstats_m(m) }) startTheWorld() } ``` 读取前后需要付出 STW 的成本。对于`readmemstats_m`而言，是将运行时用于内存统计的 变量`memstats`中的值拷贝到用户态的`MemStats`中，不过这样进行`memove`操作 是发生在系统栈上的，因此这部分的内存实际上是 OS 栈上的内存，因此最后还给用户加上`stats.StackInuse`的值来保证完整性： ``` func readmemstats_m(stats *MemStats) { updatememstats() // 将运行时 memstats 变量拷贝到 stats 中 memmove(unsafe.Pointer(stats), unsafe.Pointer(&memstats), sizeof_C_MStats) // 因为 memstats.stacks_sys 是唯一直接映射到 OS 栈的内存。 // 所以这里加上了堆分配的栈内存以供用户使用。 stats.StackSys += stats.StackInuse } ``` 而上方拷贝前的`updatememstats`是为了将 STW 之后未完整统计的内存信息统一更新到`memstats`中： ``` //go:nowritebarrier func updatememstats() { memstats.mcache_inuse = uint64(mheap_.cachealloc.inuse) memstats.mspan_inuse = uint64(mheap_.spanalloc.inuse) memstats.sys = memstats.heap_sys + memstats.stacks_sys + memstats.mspan_sys + memstats.mcache_sys + memstats.buckhash_sys + memstats.gc_sys + memstats.other_sys // 将 stacks_inuse 作为系统内存进行计算 memstats.sys += memstats.stacks_inuse // 计算内存分配器统计信息。 // 在程序执行期间，运行时只计算释放的数量和释放的内存量。 // 堆中当前活动对象的数量和活动堆内存的数量 // 通过扫描所有 span 计算。 // malloc 的总数计算为 frees 数和活动对象数。 // 类似地，分配的内存总量计算为释放的内存量 // 加上活跃堆内存的数量。 memstats.alloc = 0 memstats.total_alloc = 0 memstats.nmalloc = 0 memstats.nfree = 0 for i := 0; i < len(memstats.by_size); i++ { memstats.by_size[i].nmalloc = 0 memstats.by_size[i].nfree = 0 } // Flush mcaches 到 mcentral, TODO: 这个地方不是很明白为什么还要切一次系统栈？ systemstack(flushallmcaches) // 汇总本地统计数据。 cachestats() // 统计分配信息，因为 STW 所以安全 var smallFree, totalAlloc, totalFree uint64 // 搜集每个 span 等级的统计 for spc := range mheap_.central { // mcaches 现在为空，因此 mcentral 统计已经是最新的了 c := &mheap_.central[spc].mcentral memstats.nmalloc += c.nmalloc i := spanClass(spc).sizeclass() memstats.by_size[i].nmalloc += c.nmalloc totalAlloc += c.nmalloc * uint64(class_to_size[i]) } // 收集每个大小等级的信息 for i := 0; i < _NumSizeClasses; i++ { if i == 0 { memstats.nmalloc += mheap_.nlargealloc totalAlloc += mheap_.largealloc totalFree += mheap_.largefree memstats.nfree += mheap_.nlargefree continue } // The mcache stats have been flushed to mheap_. memstats.nfree += mheap_.nsmallfree[i] memstats.by_size[i].nfree = mheap_.nsmallfree[i] smallFree += mheap_.nsmallfree[i] * uint64(class_to_size[i]) } totalFree += smallFree memstats.nfree += memstats.tinyallocs memstats.nmalloc += memstats.tinyallocs // 计算派生数据 memstats.total_alloc = totalAlloc memstats.alloc = totalAlloc - totalFree memstats.heap_alloc = memstats.alloc memstats.heap_objects = memstats.nmalloc - memstats.nfree } ``` ``` //go:nowritebarrier func flushallmcaches() { for i := 0; i < int(gomaxprocs); i++ { flushmcache(i) } } //go:nowritebarrier func flushmcache(i int) { p := allp[i] c := p.mcache if c == nil { return } c.releaseAll() stackcache_clear(c) } //go:systemstack func stackcache_clear(c *mcache) { (...) lock(&stackpoolmu) for order := uint8(0); order < _NumStackOrders; order++ { x := c.stackcache[order].list for x.ptr() != nil { y := x.ptr().next stackpoolfree(x, order) x = y } c.stackcache[order].list = 0 c.stackcache[order].size = 0 } unlock(&stackpoolmu) } ``` ``` //go:nowritebarrier func cachestats() { for _, p := range allp { c := p.mcache if c == nil { continue } purgecachedstats(c) } } //go:nosplit func purgecachedstats(c *mcache) { // Protected by either heap or GC lock. h := &mheap_ memstats.heap_scan += uint64(c.local_scan) c.local_scan = 0 memstats.tinyallocs += uint64(c.local_tinyallocs) c.local_tinyallocs = 0 h.largefree += uint64(c.local_largefree) c.local_largefree = 0 h.nlargefree += uint64(c.local_nlargefree) c.local_nlargefree = 0 for i := 0; i < len(c.local_nsmallfree); i++ { h.nsmallfree[i] += uint64(c.local_nsmallfree[i]) c.local_nsmallfree[i] = 0 } } ``` 这里只是读取时候对全部信息进行的同步，在分配的过程中还有很多直接统计的代码。