关于后端:Go源码解析之arenago

3次阅读

共计 12967 个字符，预计需要花费 33 分钟才能阅读完成。

arena.go 文件实现了 Go 语言的堆内存管理器，它提供了跨平台的内存调配和回收服务。目标是治理堆内存区域，以保障高效、可扩大、可配置和牢靠的应用。arena.go 中的代码实现了跨平台内存管理器对应的外围性能，包含内存调配、内存回收、内存对齐、内存复制、内存对齐以及并发的调配和回收操作。

上面介绍 arena.go 中次要的数据结构和函数：

1.arenaAlloc

这个函数的次要作用是分配内存区域，并且在并发操作时能够保障线程平安。在实现上，它通过 arena.alloc_m 和 arena.allocSlow 别离治理内存的调配和回收过程。它应用了一些基于计算机体系结构的技术，如 CAS 指令和锁拆散技术等，以保障内存调配的性能和可靠性。

2.arenaFree

这个函数的次要作用是开释堆内存区域，将其归还给操作系统。与 arenaAlloc 不同，它应用了 spinlock 来实现线程间的同步和互斥，以避免不同线程之间的竞争和抵触。

3.arenaAlloc(向量)

这些函数用于向操作系统申请更多的堆内存区域，并将其与 arena 中的 free list 相结合。这些函数采纳了线程平安的技术来防止内存透露和段谬误等问题。它们还应用了一些高级的技术，如内存对齐和地址映射，以进步内存调配的效率和性能。

4.arenaReclaim

这个函数的次要作用是从新回收内存中的闲暇区域，以防止内存碎片化和资源节约。它应用一种基于自适应调配的算法来优化内存回收过程，并通过多线程技术放慢回收效率。它还实现了垃圾回收机制，用于检测和革除运行时堆中的无用对象和数据结构。

总之，arena.go 文件实现了 Go 语言堆内存管理器的外围性能，是 Go 语言的重要组成部分。它为开发人员提供了高效、可扩大、可配置和牢靠的内存治理服务，能够满足不同环境下的内存需要，并进步计算机系统的运行效率和性能。

arena_newArena 函数是用来调配新的 arena 对象的。arena 对象是存储堆内存的构造体，包含该 arena 的起始地址、完结地址、以后可用地址、该 arena 中的所有 span 等信息。

该函数会先从 p 所在 M 的 central 缓存中获取一个 mspan 对象，如果缓存中没有可用的 mspan 对象，则会调用 mheap 的 alloc manual span 办法，调配一块领有预约义大小的堆内存给该 mspan。而后会设置 mspan 的属性（如对应 arena 的地址、span 的类型等）并将该 mspan 增加到该 arena 的 span 列表中。最初将该 arena 的起始地址和 arena 对象指针返回。

函数定义如下：

func arena_newArena(p *pageAlloc) (h *heapArena) {co := &p.central[0]
    s := co.alloc()
    for s == nil {list := (*[maxTinyIdx + 1]mspan)(atomic.Loadp(unsafe.Pointer(&p.tiny)))
        for i := 0; i < len(list) && s == nil; i++ {s = list[i].pop()}
        if s == nil {s = (*mspan)(p.allocManual(SpanBytes))
            s.init(_PageAlloc, nil, 0, 0, 0)
        }
    }
    // Initialize the arena.
    h = (*heapArena)(s.startAddr)
    h.pageIdx = p.pageIndex(h.startAddr)
    h.end = h.startAddr + _PageSize*_ArenaSize
    h.pageBitmap.init(uintptr(h.startAddr), _ArenaSize)
    h.spans = h.freeSpan[:]
    return
}

参数 p 为指向 pageAlloc 的指针，示意以后的 M 的堆内存分配器。函数首先从 central 缓存中获取一个 mspan，如果获取失败则会从 tiny list 或者手动调配一块新的 mspan。而后将该 mspan 的地址作为 arena 的起始地址，并将该 mspan 增加到该 arena 的 span 列表中。最初返回该 arena 对象的指针。

arena_arena_New函数在 runtime 包中的 arena.go 文件中，用于创立一个新的内存空间 (arena)。这个arena 被用于存储小对象，以缩小内存调配和垃圾回收的开销。

具体而言，arena是一个间断的内存块，由小的堆块 (span) 组成。它提供了几种操作方法，如调配和开释内存，以及获取总内存应用状况等。

在 arena_arena_New 函数中，会先通过 mheap_.arenaHint 字段获取一个预留的内存地址，而后调用 sysReserve 函数将该内存地址所在的内存页映射到过程的虚拟地址空间中，并返回这个内存的起始地址。在这个内存的起始地址处，创立一个新的 arena 构造体，并将其返回。

须要留神的是，arena并不是线程平安的，因而在应用它时须要采取一些同步措施。

arena.go 文件中的 arena_arena_Slice 次要用于治理 arena 构造中的 slice 型数据。具体来说，它是 arena 构造的一个内嵌类型，能够通过 arena 构造中的 arena_ arena_Slice 字段调用。

arena_arena_Slice 的作用是在 arena 构造中为 slice 型数据提供内存空间。arena_arena_Slice 实际上是一个蕴含了 slice 的指针和长度信息的构造体指针。它的内存空间位于 arena 构造体中的可变大小区域，也就是所有动态分配的对象都寄存的区域。

具体来说，当程序须要应用 slice 型变量时，会调用 arena_arena_Slice 的 makeSlice() 办法来分配内存。makeSlice() 办法会依据 slice 的长度和元素类型，计算出所需的内存大小，并在 arena 构造体中调配这段内存空间。而后，makeSlice() 办法返回一个指向该内存空间起始地址的 slice 指针。

因为 slice 的长度可能会随着程序运行的变动而发生变化，因而 arena_arena_Slice 还提供了 growSlice() 办法来扩大 slice 的长度。growSlice() 办法会为 slice 调配额定的内存空间，并将扩大后的 slice 拷贝到新的空间中。

总之，arena_arena_Slice 是 Go 语言运行时环境中用于治理内存的重要组成部分，次要用于为 slice 型变量提供内存空间，并提供了相干的操作方法来对其进行扩大和治理。

arena_arena_Free 函数是 Go 语言运行时中的一个函数，用来开释 arena 内存。它的作用是将 arena 内存块返回给内存池。arena 内存块是运行时中用来调配小对象的一块内存，它是按页（通常为 8KB）大小划分的，当一块内存不足时就会从内存池中申请一块新的 arena 内存块来应用，从而防止了频繁申请内存的开销。

arena_arena_Free 函数接管一个 uintptr 类型的参数 arena，它示意须要开释的 arena 内存块的地址。开释 arena 内存块时，该函数会先将 arena 内存块清空，而后再将其返回给内存池。这里所说的清空是指将 arena 内存块中所有调配的对象都进行开释，使其能够被从新应用。

总之，arena_arena_Free 函数的作用是为了内存治理的效率和性能而设计的，它能够回收 arena 内存块，防止了频繁的申请和开释内存的开销，从而进步了程序的运行效率。

arena_heapify 函数是 runtime 中用来对 arena 进行堆化的函数。在 Go 语言中，arena 是一种内存调配策略，它将内存调配划分为若干个区域，每个区域大小为 2 的幂次方。在分配内存时，如果以后 arena 没有足够的空间，就会调配一个新的 arena，并将其退出到链表中。

arena_heapify 函数的作用是对 arena 链表进行堆化操作，行将链表中的 arena 依照大小进行堆排序（小的在前，大的在后），以便在内存调配时可能疾速找到大小适合的 arena。

具体实现过程如下：

查看以后 arena 是否为空，如果是，则返回 nil。
将以后 arena 标记为堆化状态，行将其的 heapified 标记设置为 true。
遍历 arena 链表，找到大小最小的 arena（即从前往后第一个未被堆化的 arena），并将其作为根节点。
遍历残余的 arena，将它们插入到堆中，直到所有的 arena 都被插入到堆中。
对堆进行调整，将所有的 arena 依照大小进行堆排序。
将堆中的 arena 依照大小程序从新组成链表，返回链表的头节点。

arena_heapify 函数通常在分配内存前调用，以保障可能疾速找到大小适合的 arena。在内存调配时，如果以后 arena 没有足够的空间，就会从堆中查找大小适合的 arena，以减速内存调配的过程。

在 Golang 的 runtime 中，arena.go 文件中的 init 函数次要用于初始化 arena 构造体。arena 构造体是用于治理和调配堆空间的数据结构，其外部蕴含多个 span，每个 span 示意一段间断的内存空间，并且 span 的大小是固定的。arena 中的 init 函数会次要实现以下几个工作：

初始化 arena 构造体，将其外部的各个字段设置为默认值，比方 arena 的大小、已应用的空间等；
创立一些种子 (span)，用于后续调配和治理内存空间，这些种子(span) 具备不同的大小和数量，以适应不同的内存申请需要；
设置一些 arena 构造体的属性，并为其调配肯定数量的内存空间，以便后续对内存空间的调配和治理。

通过这些工作的实现，init 函数为 arena 构造体的失常运行提供了必要的根底设置和资源。在 Golang 的 runtime 中，init 函数是在程序启动时主动执行的，以保障 arena 构造体的失常工作。

newUserArena 是一个函数，它的作用是创立一个新的用户 arena（arena 是指一块间断的内存空间，用于存储对象）。在 Go 的运行时零碎中，每个线程都有本人的 arena，用于调配对象。这个函数次要是为了反对用户自定义的内存分配器。

具体来说，newUserArena 会创立一个新的 arena，并将它与以后线程关联起来。它会应用 Go 的内存分配器来申请一块大小为 size 的内存空间，并将该空间划分成多个大小相等的块，称为 span。这些 span 会被增加到 arena 中作为可用的内存块，用于调配对象。

当线程须要调配对象时，它会应用 arena 中的 span 来分配内存。如果 arena 中的 span 用尽了，线程会向全局的内存池（global pool）申请新的 span。如果全局内存池中也没有可用的 span，那么它会调用用户定义的调配函数来申请新的内存空间。

总之，通过应用 newUserArena 函数，用户能够自定义内存分配器，并将其与线程相关联，进步程序的性能和可扩展性。

在 go 语言中，arena 是一种堆的实现形式。每个 arena 由多个 fixed-size 的调配块（span）组成，而 span 又由多个间断的小块（object）组成。Arena 的次要目标是进步内存调配的效率。

在 arena.go 中的 new 函数是用来调配新的 arena 的。该函数首先会从全局 pool（p.allspans）中查找一个大小与申请匹配的可用的 span（可能须要从堆中调配），而后将该 span 放入到 arena 的列表中，并返回可用空间的地址。

具体过程如下：

首先函数会判断申请的大小是否超过了 maxTinySize (16 bytes)。如果超过该值，则会将申请调配到新的 arena 中。
接下来，函数会在全局 pool(p.allspans)中查找是否存在大小与申请匹配的、调配状态为 _MSpanInUse 的 span。如果找到了，则将该 span 从全局 pool 中删除，并将该 span 退出到刚创立的 arena 的列表中，并返回可用空间的地址。
如果没有找到符合条件的 span，则将该 span 的大小从相应的大小类中的 span 队列中获取，而后将该 span 放入部分 mcache 的 full 列表中，并从新执行 step 2。

总之，new 函数的次要作用是用来调配和治理 arena 中的 span，以及协调全局 pool 中的 span。

在 Go 语言的 runtime 中，arena.go 这个文件是实现了一种小对象内存分配器，它用于解决小内存对象的调配和回收。在这个文件中，slice 是用来示意内存治理的小块内存的缓存区。

具体来说，slice 在 arena.go 中的作用如下：

用于保留已调配但未被应用的小块内存，以便在须要时疾速获取。
用于扩大内存管理器的批量调配大小。
用于在内存分配器的各个 goroutine 之间共享缓存的内存块。
提供一些辅助函数，比方用于挪动内存块、合并相邻的闲暇块等。

总的来说，slice 在 arena.go 中是一个十分重要的数据结构，用于反对高效的小对象内存治理。通过对内存块的缓存和复用，能够大大降低内存调配和回收的开销，进而进步程序的性能。

在 Golang 中，Arena 是一种内存调配的形式，它将内存调配在固定大小的间断块 (chunks) 中。Arena.go 文件中的 free 函数用于将曾经调配的 chunk 所占用的内存开释回 heap，以便可再次调配到其余 chunk。

具体来说，当 goroutine 不再须要一个 chunk 时，它会调用 free 函数。该函数将该 chunk 增加到一个可用 chunk 的链表中，并调用 mheap 对象的 release 函数，通知内存治理模块能够将该 chunk 返回 heap 中。

开释 chunk 的流程能够总结为以下步骤：

通过 chunkheader 获取 chunk 的大小和 next 指针
将该 chunk 增加到可用 chunk 的链表中
调用 mheap.release 函数告诉内存治理模块能够将该 chunk 返回 heap 中

以上就是 arena.go 文件中 free 函数的作用。它是 Golang 内存治理的重要组成部分，通过开释已调配的 chunk，能够防止内存透露，进步内存利用率，从而更无效地利用系统资源。

alloc 函数是 Go 语言运行时零碎中的一个重要函数，它的次要作用是为某个特定的 size 大小的对象分配内存，并返回调配的内存地址。

在 runtime/arena.go 文件中，alloc 是一个外部函数，它用于从 arena 中调配间断的一段内存。arena 是一种非凡的内存池，它由一组间断的内存块组成，每个块大小雷同。

在 alloc 函数中，它会遍历所有的内存块，查找第一个能够包容 size 大小的内存块，并将其标记为已应用。同时，它还会记录曾经应用的内存大小，以便后续再次应用时进行疾速调配。如果没有找到可用的内存块，则会从零碎中申请一个新的内存块，并退出到 arena 中。

从整体上来看，alloc 函数的作用是为 Go 语言程序提供一种疾速分配内存的能力，防止了程序频繁调用零碎 malloc 函数的开销，进步了程序的性能。同时，因为 arena 是一种线程本地内存池，它能够缓解不同线程同时竞争内存调配的问题，防止了锁的开销。

总之，alloc 是 Go 语言运行时零碎中的一个要害函数，它实现了内存的疾速调配，进步了程序的性能，并且解决了多线程竞争内存的问题。

arena.go 文件中的 refill 函数用于从新填充一个锁定的 mcache，以便在须要时调配新的对象。具体来说，refill 函数负责从堆中获取肯定数量的对象（称为 span），而后将这些 span 划分为对象块并增加到 mcache 中。一旦 mcache 中的对象用尽，就会调用 refill 函数来填充新的对象。

在 refill 函数中，首先会查看 mcache 是否为空。如果不为空，则返回，因为咱们曾经有足够的对象能够调配。否则，咱们须要从 heap 中获取新的对象。refill 函数首先会获取一些 heap arenas，而后尝试将它们调配给 mcache。如果调配胜利，则将新的对象增加到 mcache 中。如果没有足够的 heap arenas 可用，则会调用 grow 函数来扩大 heap。

总结一下，refill 函数的作用就是确保 mcache 中始终有足够的对象可用于调配。它从 heap 中获取新的 span，而后将它们调配到 mcache 中。如果没有足够的 heap arenas 可用，则会调用 grow 函数来扩大 heap。

userArenaNextFree 是 runtime 中 arena.go 文件中的一个变量，它的作用是跟踪某个特定 heap arena 闲暇空间的地位。arena 是用来存储 heap 对象的间断内存块，一个 arena 被划分为多个 fixed-size 的 span，每个 span 都能够用来寄存某种大小的对象。userArenaNextFree 指向以后 arena 上还未被应用的第一个空间的地址。

在初始化一个 heap arena 时，该变量被初始化为 arena 起始地址加上一个固定的偏移量，这个偏移量用于保留某个 metadata（元数据）信息。之后每当有对象须要调配空间时，runtime 将会查看以后 arena 是否有足够的空间，如果没有，以后 goroutine 将会尝试去获取一个新的闲暇 arena；如果以后 arena 有足够的空间，就会将须要调配的对象空间从 userArenaNextFree 地址开始调配，并更新 userArenaNextFree 变量为下一个闲暇空间的地址。

须要留神的是，userArenaNextFree 只能被所属 arena 的所属的 goroutine 来批改，这防止了不同 goroutine 之间的竞争条件。同时，因为每个 arena 中的 span 大小是一个固定的值，因而能够通过简略的数学运算疾速地计算出下一个可用的 span 地址（也就是 userArenaNextFree 更新后的值）。

userArenaHeapBitsSetType 是一个未导出的构造体类型，定义在 go/src/runtime/arena.go 中。它的作用是示意 arena（堆区）中的位图，记录了 arena 中每个字节是否被调配或占用的状态。

具体来说，userArenaHeapBitsSetType 蕴含两个字段：data 和 n。其中，data 是一个 uint64 类型的切片，用于存储 arena 中的位图数据；n 示意 arena 的大小，单位是字节，也就是说，位图中有 n * 8 个二进制位，每个二进制位示意 arena 中对应的一个字节的状态。

用户线程能够通过 arenaBitsSetType 类型提供的以下几个办法来治理位图：

func (b *userArenaHeapBitsSetType) init(n uintptr, ptrSize uintptr)：初始化一个长度为 n 的位图，ptrSize 示意指针的大小，在位于 arena 底部的 GC 元数据对象中应用。
func (b userArenaHeapBitsSetType) isMarked(offset uintptr) bool：返回位图中偏移为 offset 8 处的二进制位是否被标记为已调配或已占用。
func (b userArenaHeapBitsSetType) mark(offset uintptr)：将位图中偏移为 offset 8 处的二进制位标记为已调配或已占用。
func (b userArenaHeapBitsSetType) clear(offset uintptr)：将位图中偏移为 offset 8 处的二进制位标记为未调配或未占用。

这些办法在治理 arena 中内存调配时十分重要，能够帮忙用户线程在操作 heap 时更加高效、精确。

userArenaHeapBitsSetSliceType 是一个 slice 类型，用于在 arena.go 文件中示意堆空间的位图标记信息。堆空间能够被分为一系列固定大小的 chunk，每个 chunk 有一个对应的位图标记示意该 chunk 是否正在被应用。用户程序能够通过设置和查问这些位图标记来治理堆空间的调配和开释。

在 userArenaHeapBitsSetSliceType 中，每个元素示意一个 chunk 的位图标记信息，应用一个 64 位的整数来存储。具体来说，元素的第 i 位示意 chunk 中第 i 个 bit 的状态。如果位图标记被设置为 1 示意该 bit 曾经被调配，如果设置为 0 示意该 bit 为闲暇。

这个 slice 类型的作用是让用户程序能够不便地拜访和治理堆空间的位图标记信息，尤其是在并发环境下。因为 chunk 是固定大小的，用户程序能够间接通过计算偏移量来获取对应的位图标记信息。而通过应用 userArenaHeapBitsSetSliceType，用户程序能够间接通过索引来拜访和批改位图标记信息，而无需手动计算偏移量，进步了代码的可读性和可维护性。

newUserArenaChunk是在 Go 语言运行时零碎的 runtime 包中的 arena.go 文件中定义的一个函数。该函数的作用是为堆分配器调配新的内存块，从而将内存可用空间扩大到新的内存区域。

在 Go 语言程序运行时，须要为运行时零碎调配可用的内存。为此，Go 语言运行时将堆分为多个段，每个段都有一个根底地址和一组字节数。每个段又被分成多个块。在堆中，内存块的大小从几个字节到几个千字节不等。

newUserArenaChunk函数的次要作用是治理这些堆空间。每次调用该函数都会为堆分配器创立一个新的内存块，为新的对象分配内存。

在堆内存治理过程中，如果以后堆的内存使用率（即已应用的内存块与总内存块的比率）有余肯定比例，就须要调用 newUserArenaChunk 来减少可用的内存。在新的内存块中，堆分配器能够为新调配的对象提供底层内存。这样，程序就能够在新的内存块中创立更多的对象。

总的来说，newUserArenaChunk函数是 Go 语言运行时零碎中的一部分，是用于治理堆内存的工具之一。它的作用是为堆分配器提供新的内存块，从而管理程序的内存应用状况，确保 Go 语言程序能够高效地运行。

在 Go 语言的运行时零碎中，堆空间治理应用了一种叫做 Arena 的技术。Arena 是一个内存区域，其中蕴含了多个 chunk，每个 chunk 有固定大小（个别为 8KB），别离用于存储不同大小的内存块。当程序须要分配内存时，零碎会在对应的 chunk 中寻找可用内存块，如果找不到，则会调配新的 chunk 进行扩大。

isUnusedUserArenaChunk 函数是 arena.go 文件中的一个函数，其作用是查看指定的 chunk 是否能够开释。一个 chunk 是否能够开释的条件是：

这个 chunk 是属于用户的（不是零碎保留的）。
这个 chunk 没有调配过任何内存块，也就是说，整个 chunk 都是闲暇的。

具体的实现过程如下：

首先，通过 chunkIndex 函数，计算出 chunk 在 arena 中的索引。
判断 chunk 是否为零碎保留的 chunk，如果是，则返回 false。
判断 chunk 是否曾经调配过内存，如果是，则返回 false。
如果以上两个条件都不满足，则返回 true，示意这个 chunk 能够被开释。

在 Go 语言的运行时零碎中，arena 是由多个 chunk 组成，每个 chunk 都是固定大小的。isUnusedUserArenaChunk 函数用于判断指定的 chunk 是否能够被开释，以便在堆空间中腾出更多的空间。

setUserArenaChunkToFault 是 Go 语言中 runtime 的一个函数，它的作用是将指定的用户内存区域设置为不可用。

在 Go 语言中，arena 是一种用于调配小内存块的机制，通常采纳 mmap 或 VirtualAlloc 等零碎调用在运行时依据须要动静地将物理内存映射到虚拟内存中的一组间断段，这些段被称为 Chunk。而 setUserArenaChunkToFault 函数的作用就是将某个 chunk 标记为不可用，这意味着对应的内存区域不能再被应用了。

具体来说，这个函数会将 chunk 对应的虚拟内存区域的映射关系移除，同时将这个区域的爱护位设置为无法访问（PAGE_NOACCESS 或 PROT_NONE）。这么做的目标是避免程序误拜访曾经被开释的内存，从而防止了内存透露和应用曾经开释的内存的潜在危险。

在应用 setUserArenaChunkToFault 函数时，必须保障这个 chunk 内曾经没有调配进来的小块，否则会导致拜访这些小块时产生内存拜访异样。因而，在调用这个函数之前，须要首先对这个 chunk 进行闲暇块的回收，确保其中没有正在被应用的内存块。

在 Go 语言运行时中，arena.go 文件中的 inUserArenaChunk 函数的作用是查看给定的内存块是否位于以后 goroutine 的用户内存池中。

用户内存池是一个用于调配小块内存的自定义内存池。这是为了防止因为屡次小内存调配而导致的内存碎片化，从而进步内存应用效率。在 goroutine 启动时，默认创立一个用户内存池。每个用户内存池是由多个 arena chunk 形成的，每个 arena chunk 都是一个固定大小的内存块，它们在须要时动静增长。当用户分配内存时，程序会从此内存池中获取内存。

当 inUserArenaChunk 函数被调用时，它会查看给定的内存块是否位于以后 goroutine 的用户内存池中。如果是，则返回 true，否则返回 false。这个函数通常用于跟踪内存应用状况，帮忙诊断内存相干问题。

freeUserArenaChunk 函数是 Go 语言中运行时零碎中的一个函数，它的作用是开释由用户申请的 arena chunk 占用的内存。arena chunk 是一种在 Go 语言中用于调配堆上内存的数据结构。

在 Go 语言的运行时零碎中，arena chunk 是一种蕴含从堆上调配的内存的数据结构。这些数据结构被存储在 arena 中，arena 是一种能够从新应用的内存池。如果一个 arena chunk 不再被应用，它能够通过 freeUserArenaChunk 函数开释，这样它所占用的内存就能够被重新分配给其余的 arena chunk。

当用户申请一个 arena chunk 时，运行时零碎就会在 arena 中查找可用的 chunk，而后将其中一部分内存调配给用户，将另一部分留给后续须要分配内存的应用程序。一旦这个 arena chunk 被开释，运行时零碎会将其中的所有内存返回给 arena，应用 freeUserArenaChunk 函数实现。

在实现过程中，freeUserArenaChunk 函数会将 arena chunk 放回 arena 中，以便其余应用程序能够应用它。具体来说，它会将 arena chunk 的状态设置为可用状态，并将其与相邻的闲暇 arena chunk 合并，以便更大的间断内存块能够被重复使用。

总的来说，freeUserArenaChunk 函数是 Go 语言运行时零碎中的一个重要函数，它能够回收由用户申请的 arena chunk 占用的内存，以便这些内存能够被从新利用。

allocUserArenaChunk 函数定义于 go/src/runtime/arena.go 文件中，用于在操作系统中调配新的内存块，并为全局内存池中的用户线程调配一块指定大小的内存区域。该函数是 runtime 包中一些内存调配算法的根底。

在 Go 的运行时零碎中，内存是依照“页面”（Page）来治理的。每个页面的大小通常是 4KB，一块内存由多个页面组成。Go 内存管理器对于任意的用户线程，都会保护一个 page 分配器，在这个 page 分配器中，Go 内存管理器会为每个线程分配内存区域。在应用程序中，均匀每个线程会常常申请和开释这些内存块。

allocUserArenaChunk 函数的具体作用是为每个用户线程（goroutines）调配新的用户内存池。每个用户内存池是固定大小的，并由多个大小雷同的内存块组成。相邻的内存块之间是严密相连的，它们的大小都是 4KB 的页（在 POSIX 零碎中）或 8KB（在 Windows 零碎中）。一个新的内存块能够在不与其它用户内存池重叠的状况下增加到现有的用户内存池中。这些内存块的调配不然而线程专用的，还和物理内存的页面调配相关联，这使得内存调配更高效。

当一个用户线程首次拜访它的用户内存池时，allocUserArenaChunk 函数会被调用，以便为这个线程调配一个新的用户内存块。在函数执行的过程中，零碎会为该线程调配一块虚拟内存区域，而后将这块虚拟内存区域与零碎中的物理内存页面绝对应。尔后，Go 程序能够在该线程的用户内存块中进行内存调配和治理操作了。

在 Go 语言的 runtime 源代码中，arena.go 文件定义了 userArena 类型，次要用于治理堆（heap）中的内存块。具体来说，它是一个构造体，蕴含了以下字段：

ptr：指向调配的内存块的指针；
end：指向调配的内存块的完结地位的指针；
next：指向下一个可用的 userArena 的指针；
freeindex：自在内存块的索引数组的下一个可用存储地位的索引。

其中，ptr 和 end 指针用于跟踪堆中以后 arena 内存块的应用状况。next 指针用于存储下一个可用的 userArena 实例，以便在须要时疾速进行调配。freeindex 索引数组用于存储内存块的索引以及如何复原闲暇列表的索引。

在 Go 语言中，线程的堆空间是由一些称为 arena 的内存块组成的。每个线程都有一个 heapArena 的构造体，用于治理和操作堆内存。当须要分配内存时，runtime 会先搜寻以后 arena 数据块是否还有残余空间，如果没有，则会从 heapArena 中的自在列表（freeindex）中调配一个新的 arena 数据块，并将其与以后 arena 数据块连贯在一起，而后再进行调配。当一个 arena 数据块被应用结束时，它将被增加到 heapArena 的自在列表中，以便稍后进行反复利用。

因而，userArena 的作用是治理 heapArena 中的内存块，以便在须要时为创立堆空间的线程提供已调配的内存块。它容许 Go 运行时系统管理大量的内存操作，进步了内存操作的效率和性能，并缩小了内存透露的可能性。

liveUserArenaChunk 函数在 runtime 包中的 arena.go 文件中，是用来找到以后正在应用的 arena 中最初一个被调配的 chunk 块的函数。

arena 是 Go 语言中内存分配器的一个概念，其作用是治理内存分配情况，为堆上分配内存提供反对。arena 是由若干个大小相等的 chunk 组成的，每个 chunk 蕴含大小相等的字节块，并且每个字节块大小都是固定的。

通过调用 liveUserArenaChunk 函数能够获取到最初一个被调配的 chunk 块，该函数会遍历 arena 中的所有 chunk，找到最初一个被调配的 chunk，并返回该 chunk 的地址。

具体实现过程如下：

遍历所有的 arena，对于每个 arena：
计算以后 arena 中的 chunk 数量
如果以后 arena 中的 chunk 数量为 0，那么持续遍历下一个 arena
如果以后 arena 中存在 chunk，那么找到该 arena 中最初一个被调配的 chunk，并返回该 chunk 的地址

这样，咱们能够通过 liveUserArenaChunk 函数获取到以后正在应用中的最初一个 chunk，以不便咱们进行内存调配治理和监控。

本文由 mdnice 多平台公布

正文完

后端

发表至：后端

2023-06-27

0

关于后端:Activiti入门学习

关于后端:Go121-速览过了一年半slicesmaps-泛型库终于要加入标准库

关于后端:干货三句话搞懂-Redis-缓存穿透击穿雪崩

关于后端:PolarDB-Btree-并发控制优化

关于后端:Go源码解析之formatgo

关于后端:Go源码解析之arenago

File: arena.go

Functions:

arena_newArena

arena_arena_New

arena_arena_Slice

arena_arena_Free

arena_heapify

init

newUserArena

new

slice

free

alloc

refill

userArenaNextFree

userArenaHeapBitsSetType

userArenaHeapBitsSetSliceType

newUserArenaChunk

isUnusedUserArenaChunk

setUserArenaChunkToFault

inUserArenaChunk

freeUserArenaChunk

allocUserArenaChunk

Structs:

userArena

liveUserArenaChunk

站内搜索