Golang内存分布--从源码到分析

一、内存分配器
    程序中的数据和变量都会被分配到程序所在的虚拟内存中，内存才能空间包含两个重要区域: 栈区(Stack)和堆区(Heap)。

    函数调用的参数、返回值以及局部变量大都会被分配到栈上、这部分内存会有编译器进行管理。
    不同编程语言使用不同方法管理堆区的内存，c++、等编程语言会由使用者主动申请和释放内存；
    Go和Java等编程语言会由使用者和编译器共同管理。
    堆中的对象有内存分配器分配并由垃圾收集器回收。
        栈区速度>>堆区速度，堆区分配繁琐，栈区只需要push和pop

    Golang的内存分配器借鉴了tcmalloc的思想，尽量减少在多线程模型下，锁的竞争开销，开提高内存分配的效率。


##  锁的必要性：
        在内存空间中被划分为了多个内存单元格，当两个线程来申请内存空间时，如果不进行加锁，可能会给两个线程划分到一个内存空间，那整个内存空间到底谁使用呢？这就会起冲突。
        所以需要引用锁的概念，在第一个线程申请这块空间后，给这块内存空间上锁，给其他线程分配其他内存空间就能解决这个问题。


二、TCMalloc
    tcmalloc，其实就是thread cache malloc的缩写，线程缓存内存分配机制。
    
    1.tcmalloc的实现：
        tcmalloc内存分配分为了ThreadCache (线程缓存层)、CentralCache (中心缓存)、PageHeap (内存页堆)三个层次。
        
        在一个进程申请到的内存空间上，用PageHeap的概念分成了多个 span ，每一个span都是一个用来管理内存的逻辑概念，我把它理解为单元格单位；
        上一层时CentralCache，里面分为了从8byte到32kb的不同大小 (size class)的一堆链表，每个链表管理着一堆的span。在这一层仍然是被线程共享内存的，所以在这一层上还是需要加锁的；
        再上一层的ThreadCache，每个线程都会独享一个ThreadCache空间，每个空间都会缓存着一些空闲链表，每个线程申请内存空间是只会在ThreadCache中查找。
        因为ThreadCache是独享内存的，所以在这一层上不需要锁竞争，减少了开销。

        ThreadCache是每一个线程的缓存，分配是不需要加锁，速度比较快。ThreadCache中对于每一个size class维护一个单独的FreeList，缓存还没有分配的空闲对象  (占位)。
        CentralCache也同样为每一个size class维护一个Freelist，但是这一层是所有线程公用的，分配时需要加锁。
        CentralCache中内存不足时，会从PageHeap中申请。CentralCache从PageHeap中申请的内存，可能来自于PageHeap的缓存，也可能时PageHeap从操作系统中申请的新的内存。
        PageHeap内部，对于128个Page以内的span，会都用一个链表来缓存，超过了128个page的span，则存储于一个有序的set。

        每一层都可能会出现内存不够用的情况，这时候就会向下一层申请内存空间

    2.tcmalloc的优势：
        · 减少锁的争用
        · 事先一次性向操作系统申请了一大片的内存空间，再由内存分配器进行管理，提高性能。

##  为什么事先申请空间再分配会性能会更好？
        每一次向操作系统申请内存，需要经过系统调用，需要上下文切换，比较耗费性能；
        先申请大量内存再分配，只需要指针的操作就能分配出去。


三、Golang的内存分配器
    Golang语言的内存分配器借鉴了tcmalloc的思想；
    Go语言的内存分配器包含内存管理单元、线程缓存、中心缓存和页堆几个重要组件；
    下面会详细介绍它们对应的数据结构 mspan、 mcache、 mcentral、 mheap以及它们再内存分配器中的作用以及实现。

    每一个处理器 P都会分配一个线程缓存mcache用于处理微对象和小对象的分配，它们会持有内存管理单元mspan；
    每个size class的 mspan都会管理特定大小的对象，当mspan中不存在空闲对象时，它们会从mcentral中获取新的mspan；
    mcentral属于全局的堆结构体 mheap，mheap会从操作系统中申请内存
    mheap中包含多个heap arena，每一个heap arena是一段连续的内存，对应的是操作系统的页page


四、内存管理组件 (mspan)
    mspan是一个内存管理单元的基本单元

    每个mspan都对应一个大小等级(67个)，小对象类型的堆对象会根据其大小，分配到相应设定好大小等级的mspan上分配内存
    微对象：(0,16B)     先使用微型分配器，在依次尝试mcache、mcentral、mheap分配内存；
    小对象：[16B,32KB]  依次尝试使用mcache、mcentral、mheap分配内存；
    大对象：(32KB,+∞)   直接再mheap上分配内存。

    mspan: 是Go语言内存管理的基本单元，该结构体包含next和prev两个字段，分别指向了前一个和后一个的mspan；
    串联后形成一个双向链表，mspanlist存储双向链表的头节点和尾节点并再mcache和mcentral中使用。

    span--跨度
        可以理解为一段连续的内存空间
        每个mspan都管理 npages个大小为8KB的页，这里的页不是操作系统中的内存页，它们是操作系统中内存页的整数倍；
        mspan使用 startAddr、npages、freeindex、allocBits、gcmarkBits、allocCache 字段来管理内存页的分配和回收；

        当mspan管理的内存不足时，会以页为单位向mheap申请内存，更改 startAddr和npages ；
        当线程向mspan申请内存时，会使用startAddr和allocCache快速查找空闲对象；
        如果能在内存中找到空闲的内存单元会直接返回，当内存中不包含空闲对象时，mcache会调用 mcache.refill更新mspan以满足内存需求。

    spanclass--跨度类
        用于表示span的对象大小和span类型
        Go语言的一共有67种spanclass，每一个spanclass都标shi存储特定大小的对象并且包含特定数量的页数以及对象；
        所有的数据都会被虚线计算好并存储在runtime.class_to_size和runtime.class_to_allocnpages中。
        
        spanclass所能表示span中对象大小从8btye到32768(32kb)一共67种span
        能标示span的大小、spen的页数、span中对象大小、对象个数等信息
        spanclass为5的span:
            对象大小上限为48byte，页数为1页。
            所以span大小为8*1024byte，最大对象数量为170个，尾部浪费为32byte；
            最小存储对象为33btye，最多会浪费31.52%

        spanclass除了存储类别的id之外，还会存储一个noscan标记位，该标记位表示对象是否包含指针，垃圾回收会对包含指针的mpan进行扫描

        spanclass是一个uint整数，前7位存储class id，最后一位存储noscan标识

    type mspan struct {
	    next *mspan         // list中的下一个span，没有则为nil
	    prev *mspan         // list中的上一个span，没有则为nil
        
	    startAddr uintptr   // 确定span管理页的偏移量
	    npages    uintptr   // 确定span管理的页数
        freeindex uintptr   // 页中空闲对象的索引

        allocBits  *gcBits  // 标记内存的占用情况
	    gcmarkBits *gcBits  // 标记内存的回收情况
        allocCache uint64   // allocBits的补码，用于快速查找内存中未被使用的内存

        spanclass   spanClass   //  用于表示span的类型
        ...
    }


五、线程缓存 (mcache)
    mcache是Go语言中的线程缓存，它会与线程上的处理器(GMP-P)绑定；
    每一个线程分配一个mcache用于处理微对象和小对象的内存分配；
    因为是每个线程独有的，所以不需要加锁。

    mcache刚被初始化的时候是不包含mspan的，只有当用户申请内存时才从上一级组件mcentral获取性的mspan满足内存分配的需求

    mcache会持有tiny相关字段用于微对象内存分配
    mcache会持有mspan用于小对象的内存分配

    alloc：
        用于分配内存的mspan数组；
        数组大小位span类型总数的两倍(67*2)，即每种span类型都有两个mspan，一个表示noscan，一个是scan。
        为了提高GC扫描性能，对于noscan没必要去扫描，而scan则需要GC进行扫描。
    mcache在刚刚被初始化是alloc中mspan是空的占位符emptymspan。当mcache中mspan的空闲内存不足时，会向mcentral组件请求获取mspan。

    · 微分配器 TinyAllocator
        线程缓存中还包括几个分配微对象的字段，tiny、tinyoffset、tinyAllocs三个字段组成了微对象分配器，专门管理16byte以下的对象。
        微分配器只会用于分配非指针类型的内存。

    type mcache struct {
        tiny       uintptr      // 指向堆中的一片内存，即当前偏移量
	    tinyoffset uintptr      // 下一个空闲内存所在的偏移量
        tinyAllocs uintptr      //会记录内存分配器中分配的对象个数
        ...
    }   


六、中心缓存 (mcentral)
    mcentral时内存分配器的中心缓存，与线程缓存不同，访问中心缓存中的mspan需要使用互斥锁

    每个mcentral都会管理某个spanclass的内存管理单元；
    他会持有两个runtime.spanSet，分别存储包含空闲对象和不包含空闲对象的mspan。

    partial：有空闲空间的span列表
    full：没有空闲空间的span列表

    与mcache不同，mcentral是公共资源，会有多个线程的mcache向mcentral申请mspan，依次访问mcentral中的mspan时需要使用互斥锁。
    mcache会通过mcentra的cacheSpan方法获取mspan，并更新mcache的alloc字段中相应span class对应的mspan

    从mcentral中申请资源的时候，会优先向有空闲空间的span列表申请mspan，再向无空闲空间的span列表申请mspan，如果获取失败，会再从mheap中申请mspan。

##  为什么再向mheap中申请span之前还要先尝试向full列表申请呢？
        因为再向mheap申请之前会进行一次GC，会把一些已经满的但是不使用的mspan的空间回收掉，可能会出现一些空的mspan

    如果申请到了mspan，会更新mspan中的 allocBits和allocCache字段。
    runtime.refill会为线程缓存获取一个指定span class的mspan；
    被替换的(old)mspan不能包含空闲的内存空间，而获取的mspan中需要至少包含一个空闲对象。  (旧的一定要非常旧，新的不一定要非常新)

    type mcentral struct {
	spanclass spanClass
    partial [2]spanSet 
	full    [2]spanSet 
    }


七、页堆 (mheap)
    内存分配的核心组件，包含mcentral和heapArena，堆上所有mspan都是mheap结构分配来的

    allspans：  已经分配的所有mspan
    arenas：    heapArena数组，用于管理一个个内存块
    central：   mcentral数组，用于管理对应spanClass的mspan

    heapArena：
        Go 1.11后采用稀疏内存管理。堆区的内存可以不连续，将堆区内存分成一个个内存块(arena)，通过heapArena管理
    在mheap中维护一个heapArena数组，记录所有内存块：
        bitmap：标记heapArena内存中没饿过地址空间的使用情况
        spans：记录page id映射到的mspan
        pageInUse、pageMarks：标记状态为mSpanInUse或在GC扫描中被标记的page，用于加速内存回收
        zeroedBase：标记此arena中尚未使用的第一个page的首地址

    mcentral从mheap中申请新的mspan时：
        1. 从heap的pages中获取内存，并生成mspan
        2. heap中无法获取到mspan时，需要对堆增长，调用sysAlloc从操作系统中申请的内存
        3. 从已经保留的heapArena中获取内存
        4. 无法获取到合适的内存时，会向操作系统申请，并进行heapArena初始化，将heapArena加入到arena列表中


八、内存分配
    堆上所有的对象都会通过调用 rentime.newobject 函数分配内存；
    该函数会调用 runtime.mallocgc 分配指定大小的内存空间，这也是程序向堆上申请内存空间的必经函数。

    func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
        mp := acquirem()
        mp.mallocing = 1

        c := gomcache()
        var x unsafe.Pointer
        noscan := typ == nil || typ.ptrdata == 0
        if size <= maxSmallSize {
                if noscan && size < maxTinySize {
                        // 微对象分配
                } else {
                        // 小对象分配
                }
        } else {
                // 大对象分配
        }

        publicationBarrier()
        mp.mallocing = 0
        releasem(mp)

        return x
    }
    
    上述代码使用runtime.gomcache 获取线程缓存并判断申请内存的类型是否为指针。
    而且还可以看出runtime.mallocgc 会根据对象的大小执行不同的分配逻辑，在前面也提到过根据对象大小将他们分成微对象、小对象、大对象

    · 微对象：(0，16byte) 先使用微型分配器，在依次尝试mcache、mcentral、mheap分配内存；
        会使用微型分配器提高微对象分配性能，我们主要使用它来分配较小的字符串和逃逸的临时变量；
        微分配器可以将多个较小的内存分配请求何如同一个内存块中，只有当内存块中的所有对象都需要被回收时，整片内存才可能被回收。

        微分配器管理的对象不可以是指针类型，管理多个对象的内存块大小 maxTinySize是可以调整的，默认情况是16字节。
        maxTinySize越大，组合多个对象的可能性就越高，内存浪费就越严重；
        maxTinySize越小，内存浪费越少，但是提供了越少的组合可能；
        最好的方案是8的倍数

        还记得微分配器的结构吗？
            tiny       uintptr      // 指向推中的一片内存，即当前偏移量
	        tinyoffset uintptr      // 下一个空闲内存所在的偏移量
        假设tiny标记的16byte的微分配器已经被分配了12byte，tinyoffset标记了12byte之后；
        如果下一个待分配对象小于16-12=4byte，他会直接使用这个内存块的剩余部分，减少内存碎片；
        不过该内存块只有所有对象都被标记为垃圾时，才会回收。
        代码：
            mcache中的tiny字段指向了maxTinySize大小的块；
            如果当前块中还包含大小合适的空闲内存，运行时会通过这tiny和tinyoffset直接获取并返回这块内存
        func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
            ...
            if size <= maxSmallSize {
                if noscan && size < maxTinySize {
                        off := c.tinyoffset
                        if off+size <= maxTinySize && c.tiny != 0 {
                                x = unsafe.Pointer(c.tiny + off)
                                c.tinyoffset = off + size
                                c.local_tinyallocs++
                                releasem(mp)
                                return x
                        }
                        ...
                }
                ...
            }   
            ...
        }

        
        如果内存块的空闲内存不够时，会先从mcache中找到跨度对应的mspan，，调用runtime.nextFreeFast获取空闲的内存；
        当不存在空闲内存时，调用runtime.mcache.nextFree从mcentral或mheap中获取可分配的内存块
        代码：
            func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                ...
                if size <= maxSmallSize {
                    if noscan && size < maxTinySize {
                        ...
                        span := c.alloc[tinySpanClass]
                        v := nextFreeFast(span)
                        if v == 0 {
                                v, _, _ = c.nextFree(tinySpanClass)
                        }
                        x = unsafe.Pointer(v)
                        (*[2]uint64)(x)[0] = 0
                        (*[2]uint64)(x)[1] = 0
                        if size < c.tinyoffset || c.tiny == 0 {
                                c.tiny = uintptr(x)
                                c.tinyoffset = size
                        }
                        size = maxTinySize
                    }
                    ...
                }
                ...
                return x
            }
        获取新的空闲内存块之后，上述代码会清空空闲内存中的数据、更新构成微对象分配器的几个字段并返回空闲内存


    · 小对象：
        大小为16byte到32kb的对象以及所有小于16byte的指针对象，小对象的分配可以分为三个步骤：
                1. 确定分配对象的大小以及spanclass
                2. 从mcache、mcentral、mheap中获取mspan并从mspan中找到空闲的内存空间
                3. 调用 runtime.memclrNoHeapPointers 清空空闲内存中的所有数据
        
        确定待分配对象的大小以及spanclass需要使用预先计算好的size_to_class8、size_to_class128、class_to_divmagic字典，这些常量能帮助快速获取对应的值并构建。
            func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                ...
                if size <= maxSmallSize {
                    ...
                    } else {
                            var sizeclass uint8
                            if size <= smallSizeMax-8 {
                                    sizeclass = size_to_class8[(size+smallSizeDiv-1)/smallSizeDiv]
                            } else {
                                    sizeclass = size_to_class128[(size-smallSizeMax+largeSizeDiv-1)/largeSizeDiv]
                            }
                            size = uintptr(class_to_size[sizeclass])
                            spc := makeSpanClass(sizeclass, noscan)
                            span := c.alloc[spc]
                            v := nextFreeFast(span)
                            if v == 0 {
                                    v, span, _ = c.nextFree(spc)
                            }
                            x = unsafe.Pointer(v)
                            if needzero && span.needzero != 0 {
                                    memclrNoHeapPointers(unsafe.Pointer(v), size)
                            }
                        }
                } else {
                        ...
                }
                ...
                return x
            }

        重点分析两个方法的实现原理，它们分别是 runtime.nextFreeFast和runtime.mcache.nextFree，这两个方法会帮助我们获取空闲的内存空间。
        runtime.nextFreeFast会利用mspan中的allocCache字段 (占用位图的补码)，快速找到该字段为1的位数，
        找到了空闲对象后，我们就可以更新mspan的allocCache、freeindex等字段并返回该片内存
        代码：    
            func nextFreeFast(s *mspan) gclinkptr {
                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)
                        s.freeindex = freeidx
                        s.allocCount++
                        return gclinkptr(result*s.elemsize + s.base())
                    }
                }
                return 0
            }
        
        如果通过runtime.nextFreeFast没有找到空闲的内存，会通过runtime.mcache.nextFree找到新的内存管理单元
        代码：
            func (c *mcache) nextFree(spc spanClass) (v gclinkptr, s *mspan, shouldhelpgc bool) {
                    s = c.alloc[spc]
                freeIndex := s.nextFreeIndex()
                if freeIndex == s.nelems {
                        c.refill(spc)
                        s = c.alloc[spc]
                        freeIndex = s.nextFreeIndex()
                }

                v = gclinkptr(freeIndex*s.elemsize + s.base())
                s.allocCount++
                return
            }
        
        如果在mcache中没有找到可用的mspan，会通过前面介绍的mcache.refill使用mcentral中的mspan替换已经不存在可用对象的数据；
        该方法会调用新结构体的mspan.nextFreeIndex获取空闲的内存并返回


    · 大对象：
        运行时对于大于32KB的大对象会单独处理，我们不会从mcache或者mcentral中获取mspan而是直接调用mcache.allocLarge：
            func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
                ...
                if size <= maxSmallSize {
                    ...
                } else {
                        var s *mspan
                        span = c.allocLarge(size, needzero, noscan)
                        span.freeindex = 1
                        span.allocCount = 1
                        x = unsafe.Pointer(span.base())
                        size = span.elemsize
                }

                publicationBarrier()
                mp.mallocing = 0
                releasem(mp)

                return x
            }       

        mcache.allocLarge会计算分配给该对象所需要的页数，它按照8KB的背书在堆上申请内存。
        申请内存时会创建一个spanclass为0的特殊spancalss并调用mheap.alloc分配一个管理对应内存的mspan
        代码：
            func (c *mcache) allocLarge(size uintptr, needzero bool, noscan bool) *mspan {
                    npages := size >> _PageShift
                    if size&_PageMask != 0 {
                            npages++
                    }
                    ...
                    s := mheap_.alloc(npages, spc, needzero)
                    mheap_.central[spc].mcentral.fullSwept(mheap_.sweepgen).push(s)
                    s.limit = s.base() + size
                    heapBitsForAddr(s.base()).initSpan(s)
                    return s
            }


九、内存分配总结：
    Go的内存分配器在给对象分配内存时，根据对象的大小，分成三类微对象(0,16btye]、小对象(16btye,32KB]、大对象(32KB,+∞)。
    大体上的分配流程：
        1. 大对象直接从mheap上分配；
        2. 微对象使用mcache上的tiny分配器分配；
        3. 小对象首先计算对象的规格大小，然后使用mcache中相应规格大小的mspan分配；
        4.如果mcache没有相应规格大小的mspan，指向mcentral申请；
        4.如果mcentral没有相应规格大小的mspan，指向mheap申请；
        4.如果mheap没有相应规格大小的mspan，指向操作系统申请；


十、逃逸分析：
    逃逸分析是一种静态分析，在编译阶段执行。
    每当函数中申请新对象，编译器会根据该对象是否被函数外部引用来分析，决定变量应该在栈上非，还是在堆上分配。

    · 两个不变性：
        1. 指向栈对象的指针不能存在于堆中
        2. 指向栈对象的指针不能在栈对象收回后存活
    
    · 主要策略：
        1. 如果函数外部没有引用，则优先放到栈中；
        2. 如果函数外部存在引用，则必定放到堆中；
    
    · 场景：
        1. 函数返回局部变量，则会引起内存逃逸
        2. 动态类型引起的逃逸
        3. 栈空间不足导致逃逸
        4. 闭包函数中没有定义变量i的，而是引用了他所在函数f中的变量i，变量i发生逃逸


十一、如何利用逃逸分析提升性能
    传值 VS 传指针：
        传值会拷贝整个对象，而传指针只会拷贝指针地址，指向的对象是同一个。
        传指针可以减少值的拷贝，但是导致内存逃逸到堆中，增加垃圾回收(GC)的负担。
        在对象频繁创建和删除的场景下，传递指针导致的GC开销可能会严重影响性能。

        一般情况下，对于需要修改原对象值，或占用内存比较大的结构体，选择传指针。
        对于只读的占用内存比较小的结构体，直接传值能够获得更好的性能。