实战：手写一个超越 jemalloc 的高性能专用内存分配器（Custom Allocator）

各位同仁、技术爱好者们，大家好！

今天，我们将深入探讨一个既充满挑战又极具吸引力的话题：手写一个超越 jemalloc 的高性能专用内存分配器。这是一个大胆的宣言，因为 jemalloc、tcmalloc 这类通用内存分配器，是业界经过千锤百炼的巨擘，其性能和稳定性在绝大多数场景下都无与伦比。那么，我们为何还要尝试挑战它们？答案在于“专用”二字。

通用分配器为了适应各种复杂的内存请求模式，必须在设计上做出权衡。它们需要处理从几个字节到数兆字节的各种大小的内存块，应对任意频率的分配和释放，以及在多线程环境下的高并发访问。这种通用性带来了巨大的复杂性和一定的开销。而当我们对应用程序的内存使用模式了如指掌时，我们就有可能设计出一种高度特化的分配器，它针对特定模式进行极致优化，从而在特定场景下超越通用分配器。

本次讲座的目标，不仅是展示如何编写代码，更重要的是理解其背后的原理、权衡以及何时何地这种努力是值得的。我们将从内存分配器的基本原理出发，剖析通用分配器的优势与局限，进而识别出适合定制化分配器的场景，并最终通过具体案例，构建一个高性能的专用分配器。

第一章：内存分配器的核心职责与性能考量

在深入定制化之前，我们首先要明确一个内存分配器的基本职能及其衡量性能的关键指标。

1. 内存分配器的基本职能

内存分配器是操作系统与应用程序之间的桥梁。当应用程序需要内存时，它向分配器发出请求；当不再需要时，它将内存归还给分配器。具体来说，分配器需要完成以下任务：

• 从操作系统获取内存： 通常通过 mmap 或 sbrk 系统调用向操作系统请求大块内存（称为“页”或“区域”）。
• 管理已获取的内存： 将这些大块内存细分为更小的、可供应用程序使用的块，并追踪哪些块是空闲的，哪些块已被占用。
• 响应分配请求： 根据应用程序请求的大小，从空闲内存中找到合适的块并返回其地址。
• 处理释放请求： 接收应用程序归还的内存地址，将其标记为空闲，并可能将其与其他空闲块合并。
• 错误处理： 当内存不足时，返回错误（如 NULL）。

2. 关键性能指标

一个优秀的内存分配器通常需要在这几个方面表现出色：

• 速度（Speed）：
  • 分配延迟（Allocation Latency）： 完成一次内存分配操作所需的时间。
  • 释放延迟（Deallocation Latency）： 完成一次内存释放操作所需的时间。
  • 吞吐量（Throughput）： 单位时间内完成分配和释放操作的总次数。
  • 这是我们最直接能感受到的性能指标。
• 内存效率（Memory Efficiency）：
  • 内部碎片（Internal Fragmentation）： 分配器分配给应用程序的内存块，大于应用程序实际请求的大小所造成的浪费。例如，请求 17 字节，但分配器为了管理方便，给了 32 字节。
  • 外部碎片（External Fragmentation）： 尽管总的空闲内存足够大，但由于空闲内存被分割成许多小块，导致无法满足一个较大的连续内存请求。
  • 元数据开销（Metadata Overhead）： 分配器自身用于管理内存块（如大小、状态、链表指针等）所占用的额外内存。
  • 内存效率直接影响程序的内存占用，进而可能影响缓存命中率和整体系统性能。
• 并发性（Concurrency）：
  • 在多线程环境下，多个线程同时请求或释放内存时，分配器如何处理锁竞争、确保数据一致性，并保持高吞吐量。这是现代高性能分配器设计的核心挑战之一。
• 确定性（Determinism）：
  • 在相同条件下，分配和释放操作的性能是否稳定可预测，避免出现偶发的长尾延迟。对于实时系统尤为重要。

第二章：剖析通用内存分配器（以 jemalloc 为例）

要超越，必先理解。我们简要分析一下 jemalloc 这类通用分配器的设计哲学和实现机制，从而找到其在特定场景下的“弱点”。

jemalloc、tcmalloc 等现代通用分配器是极其复杂的工程杰作，它们集成了多种高级技术来应对通用场景的挑战：

1. 核心设计理念

• 线程本地缓存（Thread-Local Caches / Arenas）： 这是解决多线程锁竞争的关键。每个线程维护一个私有的内存池（或称“arena”），当线程需要内存时，优先从自己的本地缓存中获取。只有当本地缓存不足时，才需要从全局共享的内存池中请求，从而大大减少了全局锁的争用。
• 大小分级（Size Classes）： 将内存请求按照大小划分为不同的“大小类”（例如 8 字节、16 字节、32 字节等）。每个大小类都有其独立的空闲链表或管理机制。这样做的好处是：
  • 减少内部碎片：对于小内存请求，可以精确匹配到最近的大小类。
  • 简化管理：不同大小类的内存块可以由不同的算法或数据结构来管理，优化各自的性能。
  • 提高缓存局部性：相同大小的对象倾向于分配在一起。
• 运行/页管理（Run/Page Management）： 从操作系统获取的内存通常是页（4KB、16KB、2MB 等）。分配器会将这些页组织成更大的“运行”（run），然后将运行细分为固定大小的块供不同大小类使用。
• 复杂的空闲块管理数据结构： 对于大块内存或不规则大小的内存，通用分配器会使用如红黑树、B+树、位图、伙伴系统（Buddy System）等复杂数据结构来高效地查找、合并、分割空闲块，以减少外部碎片。

2. jemalloc 的优势

• 高性能： 在大多数通用负载下，其分配和释放速度都非常快。
• 高内存效率： 通过大小分级和复杂的碎片管理算法，能有效控制内部和外部碎片。
• 强大的并发性： 线程本地缓存机制显著降低了锁竞争。
• 成熟稳定： 经过广泛测试和生产环境的验证，可靠性极高。
• 可调优性： 提供了丰富的配置选项，可以针对特定系统或应用进行微调。

3. jemalloc 在特定场景下的“局限性”

请注意，这里所谓的“局限性”并非指 jemalloc 有缺陷，而是指其作为通用分配器，为了适应所有场景而不得不承担的额外开销，这些开销在某些高度特化的场景下是可以被规避的：

• 元数据开销： 无论多小的分配，jemalloc 都需要存储一些元数据（如块大小、所属大小类、状态等）。对于极小且频繁的对象，这些元数据可能相对于对象本身来说比例较大。
• 复杂性带来的固定开销： 即使是简单的分配，也可能需要经过大小类判断、线程本地缓存查找、空闲链表操作等一系列逻辑。这些操作虽然被高度优化，但依然存在固定指令周期开销。
• 通用算法的限制： 例如，伙伴系统在合并和分割时可能会有日志级的复杂度，而简单的自由链表在固定大小块时可以是常数级。
• 内存布局的不可预测性： 虽然 jemalloc 努力提高局部性，但由于其通用性，很难保证应用程序所需的特定内存布局。
• 无法利用应用程序的特定知识： jemalloc 不知道你的应用程序将分配什么、何时分配、何时释放，也无法预知内存总量上限。这些信息正是定制化分配器可以利用的宝藏。

第三章：识别适合定制化分配器的场景

要超越 jemalloc，我们必须找到那些 jemalloc 因其通用性而无法极致优化的“利基市场”。这些场景通常具有以下特征：

1. 固定大小对象（Fixed-Size Objects）： 应用程序频繁地分配和释放大量相同大小的对象。例如，链表节点、树节点、消息结构体、自定义的类实例等。这是定制化分配器最容易取得成功的场景。
2. 短生命周期对象（Short-Lived Objects）： 内存对象在很短的时间内被分配，并在不久后被全部释放。例如，处理一次网络请求时创建的所有临时数据结构，在请求处理完毕后即可全部清理。
3. 批量分配与释放（Burst Allocations & Deallocations）： 应用程序在某个时间段内集中进行大量分配，然后在另一个时间段内集中释放。
4. 已知最大内存用量（Known Max Memory Usage）： 如果我们知道应用程序在某个阶段或总体的最大内存需求，就可以预先分配一块大内存，避免频繁的操作系统调用。
5. 对内存局部性有极端要求（Extreme Locality Requirements）： 某些算法或数据结构对内存访问的局部性有非常高的要求，希望相关数据尽可能地连续存储，以最大化缓存命中率。
6. 避免操作系统调用（Avoid OS Calls）： mmap/munmap 等系统调用开销相对较大。如果能通过自定义分配器减少这些调用，也能提升性能。

第四章：定制化分配器的设计原则

一旦我们确定了目标场景，就可以遵循以下原则来设计高性能的专用分配器：

1. 极致简化（Extreme Simplicity）： 移除所有不必要的通用逻辑和元数据。如果只处理固定大小，就不需要大小分级。如果只批量释放，就不需要单个对象释放逻辑。
2. 局部性优先（Locality First）： 尽可能将相关数据放置在连续的内存区域，以利用 CPU 缓存。线程本地缓存是实现这一目标的关键。
3. 无锁或最小化锁（Lock-Free or Minimal Locking）： 锁是并发性能的头号杀手。尽可能使用线程本地数据、原子操作（Atomic Operations）或无锁数据结构来避免或减少锁竞争。
4. 批量操作（Batching Operations）： 无论是向操作系统请求内存，还是在线程间传递内存块，都尽量以批处理方式进行，分摊操作开销。
5. 预分配（Pre-allocation）： 在程序启动时或空闲时预先分配一部分内存，避免在关键路径上进行昂贵的操作系统调用。
6. 针对性数据结构（Targeted Data Structures）： 根据使用模式选择最简单、最高效的数据结构。例如，对于固定大小块，一个简单的单向链表（Free List）通常比红黑树快得多。

第五章：案例一：高性能固定大小对象分配器（Slab/Object Pool）

这是最常见且最有效的定制化分配器模式。它非常适合那些频繁创建和销毁相同类型对象的场景，例如游戏中的实体、网络服务器中的请求对象、各种数据结构节点等。

基本思想：

1. 从操作系统一次性申请一大块内存（称为“Slab”）。
2. 将这个 Slab 划分为许多个固定大小的内存块。
3. 维护一个空闲块链表（Free List）。
4. 分配时，从空闲链表中取出一个块。
5. 释放时，将块添加到空闲链表头部。

优点：

• 极快的分配和释放速度（通常是 O(1) 操作）。
• 几乎没有内部碎片（如果对象大小与块大小完全匹配）。
• 极高的缓存局部性。

缺点：

• 只能处理固定大小的对象。
• 如果有少量外部碎片，但由于块大小固定，通常不是大问题。

A. 单线程 Slab 分配器

我们先从最简单的单线程版本开始。

#include <stddef.h> // For size_t
#include <stdbool.h> // For bool
#include <stdio.h> // For printf, NULL
#include <stdlib.h> // For exit
#include <sys/mman.h> // For mmap, munmap
#include <unistd.h> // For sysconf (page size)

// 定义一个 Slab 的大小，通常是 OS 页的倍数
// 比如 4KB * 16 = 64KB
#define SLAB_SIZE (sysconf(_SC_PAGE_SIZE) * 16) 

// SlabAllocator 结构体，管理一个固定大小的内存池
typedef struct SlabAllocator {
    size_t object_size;       // 每个对象的大小
    size_t objects_per_slab;  // 每个 Slab 能容纳的对象数量
    void*  current_slab;      // 当前正在使用的 Slab 的起始地址
    void*  next_free;         // 指向下一个空闲块的指针 (作为链表头)
    size_t allocated_in_current_slab; // 当前 Slab 已分配的对象数量

    // Slab 链表，用于管理多个 Slab
    struct SlabNode {
        void* slab_start;
        struct SlabNode* next;
    } *slab_list_head;

} SlabAllocator;

// 初始化 Slab 分配器
// object_size: 要分配的对象大小
bool init_slab_allocator(SlabAllocator* alloc, size_t object_size) {
    if (object_size == 0) {
        fprintf(stderr, "Error: Object size cannot be zero.n");
        return false;
    }

    // 确保 object_size 至少足够存储一个指针，用于构建空闲链表
    // 这样，释放后的内存块就可以直接用作下一个空闲块的指针
    alloc->object_size = (object_size < sizeof(void*)) ? sizeof(void*) : object_size;

    // 计算每个 Slab 能容纳的对象数量
    alloc->objects_per_slab = SLAB_SIZE / alloc->object_size;
    if (alloc->objects_per_slab == 0) {
        fprintf(stderr, "Error: Object size (%zu) is too large for SLAB_SIZE (%zu).n", alloc->object_size, (size_t)SLAB_SIZE);
        return false;
    }

    alloc->current_slab = NULL;
    alloc->next_free = NULL;
    alloc->allocated_in_current_slab = 0;
    alloc->slab_list_head = NULL;

    printf("SlabAllocator initialized: object_size=%zu, objects_per_slab=%zu, SLAB_SIZE=%zun", 
           alloc->object_size, alloc->objects_per_slab, (size_t)SLAB_SIZE);
    return true;
}

// 内部函数：获取一个新的 Slab
static bool get_new_slab(SlabAllocator* alloc) {
    void* new_slab = mmap(NULL, SLAB_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (new_slab == MAP_FAILED) {
        perror("mmap failed");
        return false;
    }

    // 将新 Slab 加入到 Slab 链表中
    struct SlabNode* new_node = (struct SlabNode*)malloc(sizeof(struct SlabNode));
    if (!new_node) {
        munmap(new_slab, SLAB_SIZE);
        perror("malloc slab node failed");
        return false;
    }
    new_node->slab_start = new_slab;
    new_node->next = alloc->slab_list_head;
    alloc->slab_list_head = new_node;

    // 初始化新 Slab 的空闲链表
    alloc->current_slab = new_slab;
    alloc->allocated_in_current_slab = 0;
    alloc->next_free = NULL; // 清空当前的 free list, 重新构建

    // 将新 Slab 中的所有块加入到空闲链表
    for (size_t i = 0; i < alloc->objects_per_slab; ++i) {
        void* block_addr = (char*)new_slab + i * alloc->object_size;
        // 将当前块的地址作为下一个空闲块的指针写入到当前块中
        *(void**)block_addr = alloc->next_free;
        alloc->next_free = block_addr;
    }

    printf("Acquired new slab at %pn", new_slab);
    return true;
}

// 分配内存
void* slab_alloc(SlabAllocator* alloc) {
    // 如果空闲链表为空，说明当前 Slab 已满或还未初始化
    if (alloc->next_free == NULL) {
        if (!get_new_slab(alloc)) {
            return NULL; // 获取新 Slab 失败
        }
    }

    // 从空闲链表头部取出块
    void* block = alloc->next_free;
    alloc->next_free = *(void**)block; // 更新空闲链表头指针

    alloc->allocated_in_current_slab++; // 只是一个大致统计，多 Slab 模式下不准确，但可以用于判断是否需要新的 Slab
    return block;
}

// 释放内存
void slab_free(SlabAllocator* alloc, void* ptr) {
    if (ptr == NULL) return;

    // 将释放的块添加到空闲链表头部
    // 注意：这里没有检查 ptr 是否属于当前分配器或是否被双重释放，生产环境需要更健壮的检查
    *(void**)ptr = alloc->next_free;
    alloc->next_free = ptr;

    // alloc->allocated_in_current_slab--; // 在多 Slab 且 free list 混合的情况下，这个统计会变得复杂且不准确
}

// 销毁 Slab 分配器，释放所有内存
void destroy_slab_allocator(SlabAllocator* alloc) {
    struct SlabNode* current = alloc->slab_list_head;
    while (current) {
        struct SlabNode* next = current->next;
        if (munmap(current->slab_start, SLAB_SIZE) == -1) {
            perror("munmap failed");
        }
        free(current); // 释放 SlabNode 结构体本身
        printf("Released slab at %pn", current->slab_start);
        current = next;
    }
    alloc->slab_list_head = NULL;
    alloc->current_slab = NULL;
    alloc->next_free = NULL;
    alloc->allocated_in_current_slab = 0;
    printf("SlabAllocator destroyed.n");
}

// ------------------- 示例用法 -------------------
typedef struct MyObject {
    int id;
    double value;
    char name[16];
} MyObject;

int main() {
    SlabAllocator my_allocator;
    if (!init_slab_allocator(&my_allocator, sizeof(MyObject))) {
        return 1;
    }

    MyObject* objects[100]; // 假设我们分配 100 个对象

    printf("n--- Allocating objects ---n");
    for (int i = 0; i < 100; ++i) {
        objects[i] = (MyObject*)slab_alloc(&my_allocator);
        if (objects[i]) {
            objects[i]->id = i;
            objects[i]->value = (double)i / 10.0;
            snprintf(objects[i]->name, sizeof(objects[i]->name), "Obj%d", i);
            // printf("Allocated object %d at %pn", i, objects[i]);
        } else {
            fprintf(stderr, "Failed to allocate object %dn", i);
            break;
        }
    }

    printf("n--- Freeing objects (out of order to demonstrate free list) ---n");
    // 随机释放一部分，模拟实际应用
    for (int i = 0; i < 50; i += 2) { // 释放偶数索引对象
        if (objects[i]) {
            // printf("Freeing object %d at %pn", i, objects[i]);
            slab_free(&my_allocator, objects[i]);
            objects[i] = NULL;
        }
    }

    // 再次分配，应该会复用之前释放的内存
    printf("n--- Re-allocating objects ---n");
    for (int i = 0; i < 50; i += 2) {
        objects[i] = (MyObject*)slab_alloc(&my_allocator);
        if (objects[i]) {
            objects[i]->id = 100 + i; // 新 ID
            // printf("Re-allocated object %d at %pn", i, objects[i]);
        }
    }

    // 释放所有对象
    printf("n--- Freeing all remaining objects ---n");
    for (int i = 0; i < 100; ++i) {
        if (objects[i]) {
            slab_free(&my_allocator, objects[i]);
        }
    }

    destroy_slab_allocator(&my_allocator);

    return 0;
}

代码解释：

• SlabAllocator 结构体：维护对象大小、每个 Slab 的对象数量、当前空闲链表头指针 next_free 等。slab_list_head 维护了所有已获取的 Slab。
• init_slab_allocator：初始化分配器，计算 object_size 和 objects_per_slab。关键一点是，如果 object_size 小于 sizeof(void*)，我们会将其提升到 sizeof(void*)，因为我们需要在释放的块内部存储一个指针来构建空闲链表。
• get_new_slab：当空闲链表为空时，通过 mmap 向操作系统请求一个 SLAB_SIZE 大小的内存块。然后，它将这个新 Slab 分割成许多固定大小的块，并将它们串联成一个单向链表，作为 next_free。
• slab_alloc：从 next_free 指向的空闲块中取出内存，并将 next_free 更新为取出的块内部存储的下一个空闲块的地址。这是一个 O(1) 操作。
• slab_free：将释放的块重新添加到 next_free 的头部。同样是 O(1) 操作。
• destroy_slab_allocator：遍历所有已获取的 Slab，并使用 munmap 将它们归还给操作系统。

这个单线程版本在固定大小对象的分配和释放上，性能将远超 malloc/free，因为它消除了复杂的查找、合并、分割逻辑，以及多线程同步的开销。

B. 增强并发性：线程本地 Slab 分配器

单线程分配器性能再高，在多线程环境下也无济于事，因为 next_free 会成为争用点。为了支持并发，我们引入线程本地缓存的概念，这是 jemalloc 等通用分配器的核心思想。

基本思想：

1. 每个线程维护一个私有的 SlabAllocator 实例（或一个小的 Slab 块集合）。
2. 线程优先从自己的本地分配器中进行分配和释放。
3. 当线程本地分配器用尽时，它会向一个全局的 SlabManager 请求一个新的 Slab。
4. 当线程本地分配器有大量空闲块时，它可以将一部分块归还给全局 SlabManager。

这样，大部分操作都在线程本地进行，无需加锁，只有在本地缓存不足或溢出时才需要与全局管理器交互，此时才需要加锁，但频率大大降低。

#include <stddef.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <pthread.h> // For thread-local storage and mutex
#include <stdatomic.h> // For atomic operations (optional, could use mutex)

// 假设我们使用 64K 的 Slab
#define SLAB_SIZE (sysconf(_SC_PAGE_SIZE) * 16) 
// 线程本地缓存中允许的最大空闲块数量，超过则归还给全局
#define THREAD_LOCAL_CACHE_MAX_FREE_BLOCKS 1024 

// 前向声明
typedef struct GlobalSlabManager GlobalSlabManager;

// SlabAllocator 结构体，现在是线程本地的
typedef struct SlabAllocator {
    size_t object_size;       
    size_t objects_per_slab;  
    void*  next_free;         // 指向下一个空闲块的指针 (作为链表头)
    size_t free_count;        // 当前本地空闲块数量

    // 指向全局管理器的指针，用于在本地缓存不足时获取新的Slab
    GlobalSlabManager* global_manager; 

    // 本地已获取的 Slab 列表 (可以简化为只持有当前活动Slab，或通过GlobalManager统一管理)
    // 为了简化，我们假定本地只有 next_free 管理的块，获取新块时从 GlobalManager 拿，用完还给 GlobalManager
    // 或者，更进一步，每个本地分配器也可以维护一个小的 Slab 列表
    // struct SlabNode { void* slab_start; struct SlabNode* next; } *local_slab_list_head;

} SlabAllocator;

// 全局 Slab 管理器
typedef struct GlobalSlabManager {
    size_t object_size;
    size_t objects_per_slab;

    pthread_mutex_t mutex; // 保护全局 free_slabs 链表

    // 全局空闲 Slab 列表，每个节点代表一个完整的 Slab，其中包含许多空闲块
    struct GlobalSlabNode {
        void* slab_start;
        // 也可以在这里维护该 Slab 内部的空闲块链表，或直接将整个 Slab 标记为可用
        // 简化起见，这里假设它只是一个指向 Slab 内存的指针
        struct GlobalSlabNode* next;
    } *free_slabs_head;

    // 全局已分配但可能未完全使用的 Slab 列表，用于归还和再分配
    struct GlobalSlabNode *partial_slabs_head;

    // 为了简化，我们还可以用一个全局的空闲块链表来代替 free_slabs_head 和 partial_slabs_head
    // 但那样会失去 Slab 的概念，更像是全局的自由链表。
    // 更常见的做法是，GlobalManager管理的是"页"或"运行"，然后将这些页/运行分配给线程本地分配器。
    // 在这里，我们让 GlobalManager 维护的是完整的 Slab，当线程本地需要时，GlobalManager 分配一个完整的 Slab 给它
    // 或者，当线程本地需要时，GlobalManager可以提供一个块，这个块可能来自一个被线程归还的 Slab。

} GlobalSlabManager;

// 全局管理器实例
static GlobalSlabManager global_manager_instance;

// 初始化全局 Slab 管理器
bool init_global_slab_manager(size_t object_size) {
    if (object_size == 0) return false;

    global_manager_instance.object_size = (object_size < sizeof(void*)) ? sizeof(void*) : object_size;
    global_manager_instance.objects_per_slab = SLAB_SIZE / global_manager_instance.object_size;
    if (global_manager_instance.objects_per_slab == 0) return false;

    pthread_mutex_init(&global_manager_instance.mutex, NULL);
    global_manager_instance.free_slabs_head = NULL;
    global_manager_instance.partial_slabs_head = NULL;

    printf("GlobalSlabManager initialized: object_size=%zu, objects_per_slab=%zu, SLAB_SIZE=%zun", 
           global_manager_instance.object_size, global_manager_instance.objects_per_slab, (size_t)SLAB_SIZE);
    return true;
}

// 销毁全局 Slab 管理器
void destroy_global_slab_manager() {
    pthread_mutex_lock(&global_manager_instance.mutex);

    // 释放所有 free_slabs
    struct GlobalSlabNode* current = global_manager_instance.free_slabs_head;
    while (current) {
        struct GlobalSlabNode* next = current->next;
        if (munmap(current->slab_start, SLAB_SIZE) == -1) {
            perror("munmap failed on free_slabs");
        }
        free(current);
        current = next;
    }
    global_manager_instance.free_slabs_head = NULL;

    // 释放所有 partial_slabs (注意：这些可能还有部分被线程使用，但这里是强制清理)
    current = global_manager_instance.partial_slabs_head;
    while (current) {
        struct GlobalSlabNode* next = current->next;
        if (munmap(current->slab_start, SLAB_SIZE) == -1) {
            perror("munmap failed on partial_slabs");
        }
        free(current);
        current = next;
    }
    global_manager_instance.partial_slabs_head = NULL;

    pthread_mutex_unlock(&global_manager_instance.mutex);
    pthread_mutex_destroy(&global_manager_instance.mutex);
    printf("GlobalSlabManager destroyed.n");
}

// 全局函数：从操作系统获取一个新的 Slab 并初始化其空闲链表
static void* global_get_new_slab_memory(GlobalSlabManager* gm) {
    void* new_slab = mmap(NULL, SLAB_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (new_slab == MAP_FAILED) {
        perror("mmap failed in global_get_new_slab_memory");
        return NULL;
    }
    printf("[Global] Acquired raw slab at %pn", new_slab);
    return new_slab;
}

// 全局函数：向 GlobalManager 请求一个 Slab 块列表
// 为了简化，这里我们让 GlobalManager 直接提供一个初始化好的 Slab 的所有块
// 更复杂的实现会从 partial_slabs_head 中找，或者仅提供部分块
void* global_get_blocks_from_manager(GlobalSlabManager* gm, size_t* num_blocks) {
    pthread_mutex_lock(&gm->mutex);

    // 优先从全局的 free_slabs_head 中取出一个 Slab
    if (gm->free_slabs_head) {
        struct GlobalSlabNode* node = gm->free_slabs_head;
        gm->free_slabs_head = node->next;
        pthread_mutex_unlock(&gm->mutex);

        void* slab_start = node->slab_start;
        free(node); // 释放管理节点本身

        // 初始化这个 Slab 的空闲链表并返回其头指针
        void* first_block = slab_start;
        void* current_free_ptr = NULL;
        for (size_t i = 0; i < gm->objects_per_slab; ++i) {
            void* block_addr = (char*)slab_start + i * gm->object_size;
            *(void**)block_addr = current_free_ptr;
            current_free_ptr = block_addr;
        }
        *num_blocks = gm->objects_per_slab;
        printf("[Global] Providing a full slab from free_slabs_head to thread. Blocks: %zun", *num_blocks);
        return current_free_ptr; // 返回初始化好的空闲链表头
    }

    // 如果没有现成的空闲 Slab，则从操作系统获取一个新的
    void* new_slab_mem = global_get_new_slab_memory(gm);
    if (!new_slab_mem) {
        pthread_mutex_unlock(&gm->mutex);
        return NULL;
    }

    // 初始化新 Slab 的空闲链表并返回其头指针
    void* current_free_ptr = NULL;
    for (size_t i = 0; i < gm->objects_per_slab; ++i) {
        void* block_addr = (char*)new_slab_mem + i * gm->object_size;
        *(void**)block_addr = current_free_ptr;
        current_free_ptr = block_addr;
    }
    *num_blocks = gm->objects_per_slab;
    printf("[Global] Providing a newly mmap'd slab to thread. Blocks: %zun", *num_blocks);

    // 将这个 Slab 记录到 partial_slabs_head，因为现在它被线程使用了
    struct GlobalSlabNode* new_node = (struct GlobalSlabNode*)malloc(sizeof(struct GlobalSlabNode));
    if (!new_node) {
        munmap(new_slab_mem, SLAB_SIZE); // 失败回滚
        pthread_mutex_unlock(&gm->mutex);
        return NULL;
    }
    new_node->slab_start = new_slab_mem;
    new_node->next = gm->partial_slabs_head;
    gm->partial_slabs_head = new_node;

    pthread_mutex_unlock(&gm->mutex);
    return current_free_ptr; // 返回初始化好的空闲链表头
}

// 全局函数：线程将空闲块归还给 GlobalManager
// 为了简化，这里我们假设线程归还的是一个完整的 Slab 的所有块
// 实际中可能需要归还零散的块，这就需要 GlobalManager 维护更复杂的机制来合并和跟踪
void global_return_blocks_to_manager(GlobalSlabManager* gm, void* block_list_head, size_t num_blocks) {
    if (!block_list_head || num_blocks == 0) return;

    // 在实际场景中，这里需要找到这些块所属的 Slab，并判断该 Slab 是否完全空闲。
    // 如果一个 Slab 的所有块都被归还，那么可以将整个 Slab 移动到 free_slabs_head。
    // 为了简化，我们假设归还的就是一个完整的 Slab 的所有块，并且可以识别其起始地址。
    // 这里的简化：我们只是简单地将这些块的首地址作为 Slab 的起始，并加入到 free_slabs_head。
    // 这是一个非常大的简化，实际实现需要一个机制来从 `block_list_head` 逆向推断其所属的 Slab 的起始地址。
    // 例如，所有 Slab 都会被页对齐，可以根据地址找到页起始。

    // 假设我们能找到这个 block_list_head 对应的 Slab 的起始地址
    // 并且假设 num_blocks 正好是一个 Slab 的大小。
    void* slab_start_guess = block_list_head; // 极度简化，实际需要计算
    // 更好的做法是，GlobalManager 在分发 Slab 时，给每个 Slab 一个唯一ID，或在其中记录元数据，
    // 线程在归还时也附带上这些信息。

    pthread_mutex_lock(&gm->mutex);

    struct GlobalSlabNode* new_node = (struct GlobalSlabNode*)malloc(sizeof(struct GlobalSlabNode));
    if (!new_node) {
        // 如果分配节点失败，这些块就可能丢失，这是个问题。
        // 生产环境需要更健壮的错误处理，例如尝试将块重新添加到线程本地缓存。
        perror("malloc global slab node failed on return");
        pthread_mutex_unlock(&gm->mutex);
        return;
    }

    // 这里的 slab_start_guess 应该通过更可靠的方式获取
    new_node->slab_start = slab_start_guess; // 这是一个非常粗略的假设！
    new_node->next = gm->free_slabs_head;
    gm->free_slabs_head = new_node;
    printf("[Global] Returned a full slab to free_slabs_head from thread. Blocks: %zun", num_blocks);

    // 实际还需要从 partial_slabs_head 中移除这个 Slab
    // 这需要遍历 partial_slabs_head 链表并删除对应的节点，这里省略

    pthread_mutex_unlock(&gm->mutex);
}

// 线程本地 Slab 分配器初始化
bool init_thread_slab_allocator(SlabAllocator* alloc, GlobalSlabManager* gm) {
    alloc->global_manager = gm;
    alloc->object_size = gm->object_size;
    alloc->objects_per_slab = gm->objects_per_slab;
    alloc->next_free = NULL;
    alloc->free_count = 0;
    return true;
}

// 线程本地分配器销毁 (将所有空闲块归还给全局管理器)
void destroy_thread_slab_allocator(SlabAllocator* alloc) {
    // 这里的 free_count 统计的是本地链表中的空闲块，不代表完整的 Slab
    // 实际中，线程本地可能持有多个 Slab 的部分空闲块。
    // 更准确的做法是，每个线程本地分配器也维护一个其所持有的 Slab 列表。
    // 当销毁时，遍历这些 Slab，如果 Slab 完全空闲，则归还整个 Slab 给 GlobalManager。
    // 如果 Slab 部分空闲，则将其所有空闲块归还给 GlobalManager，GlobalManager 会尝试合并。

    // 简化处理：假设 next_free 链表中的块来自一个或多个 Slab，我们将其全部归还
    // 但这无法告诉 GlobalManager 它们来自哪个 Slab，无法高效合并。
    // 这是一个需要进一步完善的地方。
    // global_return_blocks_to_manager(alloc->global_manager, alloc->next_free, alloc->free_count);

    alloc->next_free = NULL;
    alloc->free_count = 0;
    printf("[Thread] SlabAllocator destroyed.n");
}

// 线程本地分配内存
void* thread_slab_alloc(SlabAllocator* alloc) {
    if (alloc->next_free == NULL) {
        size_t num_blocks_fetched = 0;
        void* new_blocks_head = global_get_blocks_from_manager(alloc->global_manager, &num_blocks_fetched);
        if (!new_blocks_head) {
            return NULL;
        }
        alloc->next_free = new_blocks_head;
        alloc->free_count += num_blocks_fetched;
        printf("[Thread] Refilled local cache with %zu blocks.n", num_blocks_fetched);
    }

    void* block = alloc->next_free;
    alloc->next_free = *(void**)block;
    alloc->free_count--;
    return block;
}

// 线程本地释放内存
void thread_slab_free(SlabAllocator* alloc, void* ptr) {
    if (ptr == NULL) return;

    *(void**)ptr = alloc->next_free;
    alloc->next_free = ptr;
    alloc->free_count++;

    // 如果本地空闲块过多，可以考虑将其一部分归还给全局管理器
    // 这需要更复杂的逻辑来判断哪些块可以作为一个 Slab 归还
    // 例如，当 free_count 超过某个阈值且这些块能组成一个完整的 Slab 时
    // 暂时省略这个复杂的归还逻辑
    // if (alloc->free_count > THREAD_LOCAL_CACHE_MAX_FREE_BLOCKS && can_form_a_slab_from_next_free_list(alloc)) {
    //     void* slab_to_return = extract_a_full_slab_from_next_free_list(alloc);
    //     global_return_blocks_to_manager(alloc->global_manager, slab_to_return, alloc->objects_per_slab);
    // }
}

// ------------------- 示例用法（多线程） -------------------

// 线程本地存储分配器实例
static thread_local SlabAllocator* my_thread_allocator = NULL;

// 线程工作函数
void* thread_func(void* arg) {
    // 确保每个线程只初始化一次
    if (my_thread_allocator == NULL) {
        my_thread_allocator = (SlabAllocator*)malloc(sizeof(SlabAllocator));
        if (!init_thread_slab_allocator(my_thread_allocator, &global_manager_instance)) {
            fprintf(stderr, "Thread %lu: Failed to init thread local allocator.n", pthread_self());
            return NULL;
        }
        printf("Thread %lu: Initialized local allocator.n", pthread_self());
    }

    MyObject* objects[50];
    printf("Thread %lu: Allocating objects...n", pthread_self());
    for (int i = 0; i < 50; ++i) {
        objects[i] = (MyObject*)thread_slab_alloc(my_thread_allocator);
        if (objects[i]) {
            objects[i]->id = (int)pthread_self() * 1000 + i;
            // printf("Thread %lu: Allocated object %d at %pn", pthread_self(), i, objects[i]);
        } else {
            fprintf(stderr, "Thread %lu: Failed to allocate object %dn", pthread_self(), i);
            break;
        }
    }

    printf("Thread %lu: Freeing objects...n", pthread_self());
    for (int i = 0; i < 50; ++i) {
        if (objects[i]) {
            thread_slab_free(my_thread_allocator, objects[i]);
        }
    }

    // 模拟长时间运行后，清理本地分配器
    destroy_thread_slab_allocator(my_thread_allocator);
    free(my_thread_allocator); // 释放分配器结构体本身
    my_thread_allocator = NULL;

    return NULL;
}

int main() {
    // 1. 初始化全局管理器
    if (!init_global_slab_manager(sizeof(MyObject))) {
        return 1;
    }

    // 2. 创建多个线程
    pthread_t threads[4];
    for (int i = 0; i < 4; ++i) {
        pthread_create(&threads[i], NULL, thread_func, NULL);
    }

    // 3. 等待线程完成
    for (int i = 0; i < 4; ++i) {
        pthread_join(threads[i], NULL);
    }

    // 4. 销毁全局管理器
    destroy_global_slab_manager();

    return 0;
}

代码解释与改进点：

• GlobalSlabManager：负责从 OS 获取真正的内存 Slab，并维护一个全局的空闲 Slab 链表 (free_slabs_head)。当线程本地缓存不足时，线程会向它请求一个 Slab。
• pthread_mutex_t mutex：保护 GlobalSlabManager 的内部状态，确保对 free_slabs_head 等共享资源的访问是线程安全的。
• thread_local SlabAllocator* my_thread_allocator：这是 C++11 引入的 thread_local 关键字，在 C 语言中可以使用 __thread 或 pthread_key_create/pthread_getspecific 实现。它确保每个线程都有一个独立的 SlabAllocator 实例。
• global_get_blocks_from_manager：这是线程与全局管理器交互的关键函数。它会尝试从 free_slabs_head 中取出一个完整的 Slab。如果全局也没有空闲 Slab，则 mmap 一个新的。它返回的是一个初始化好的空闲块链表的头指针，以及这个链表中包含的块数量。
• global_return_blocks_to_manager：当线程退出或其本地缓存中积累了大量空闲块时，可以将其归还给全局管理器。注意：这个函数在当前简化实现中存在很大问题。 实际应用中，线程归还的往往是散乱的块，全局管理器需要更复杂的机制来追踪每个 Slab 的使用情况（例如，通过位图或引用计数），只有当一个 Slab 的所有块都被归还后，才能将整个 Slab 重新放入 free_slabs_head。如果仅仅归还一个链表头，全局管理器很难知道这些块来自哪个 Slab，也无法判断整个 Slab 是否空闲。
• thread_slab_alloc 和 thread_slab_free：大部分时间，它们操作的是线程本地的 next_free 链表，无需加锁，速度极快。只有当 next_free 为空时，才需要通过 global_get_blocks_from_manager 向全局管理器请求一批新的块。

这个多线程版本的 Slab 分配器，通过线程本地缓存机制，将大部分内存操作变成了无锁的 O(1) 操作，大大降低了锁竞争，从而在多核环境下提供卓越的性能。其性能瓶颈将主要集中在线程本地缓存的填充/耗尽以及向全局管理器请求/归还 Slab 的频率上。

C. 进一步优化思路

1. 分级 Slab 分配： 可以有多个 SlabAllocator 实例，每个实例管理不同大小的对象，形成类似 jemalloc 的大小分级。
2. 更智能的归还策略： 线程本地分配器不应在每次释放时都考虑归还。应该在积累到一定数量的空闲块，或者在线程退出时，才将部分或全部空闲块归还给全局管理器。归还时，需要提供足够的信息（如块所属的 Slab 地址），以便全局管理器能够正确合并。
3. 使用位图管理 Slab 内部空闲块： 对于非常小的对象，如果 object_size 小于 sizeof(void*)，那么将 next_free 指针存储在对象内部会造成浪费（我们不得不将 object_size 扩大到 sizeof(void*)）。此时，可以使用一个位图来标记 Slab 内部哪些块是空闲的，分配时扫描位图找第一个空闲位，释放时设置对应的位。这可以进一步减少内存开销。
4. NUMA-aware 分配： 在 NUMA 架构下，可以尝试在靠近当前 CPU 的内存节点上分配 Slab，减少跨节点内存访问延迟。这需要使用 mmap 的 MAP_HUGETLB 和 mbind 等更底层的系统调用。
5. 内存对齐： 确保分配的内存块满足特定对齐要求（例如，为了 SIMD 指令或某些数据结构）。mmap 返回的地址通常是页对齐的，但如果我们在 Slab 内部进一步细分，则需要确保每个块也满足对齐要求。

第六章：案例二：Arena 分配器（Bump Allocator）

Arena 分配器（也常被称为 Bump Allocator）是另一种极度简化的专用分配器，适用于短生命周期、批量分配且无需单独释放的场景。

基本思想：

1. 从操作系统申请一大块连续内存作为“Arena”。
2. 维护一个指向 Arena 当前空闲位置的指针 current_ptr。
3. 分配时，直接返回 current_ptr，然后将 current_ptr 向前移动请求的大小。
4. 不提供单个对象的释放功能。
5. 当 Arena 耗尽时，可以获取新的 Arena，或者在整个任务完成后，一次性释放整个 Arena。

优点：

• 分配速度极快： 仅仅是简单的指针加法操作，通常比 Slab Allocator 更快。
• 极佳的缓存局部性： 所有分配的对象都连续存储。
• 零碎片： 内部碎片可以忽略不计（仅最后一个对象可能浪费一点点空间以对齐），没有外部碎片。
• 没有释放开销： 因为不单独释放。

缺点：

• 不能单独释放对象： 一旦分配，直到整个 Arena 被重置或销毁才能回收内存。
• 不适合长期存在的对象： 除非对象生命周期与 Arena 相同。
• 可能浪费内存： 如果 Arena 中有少量对象长期存活，但大部分是短生命周期对象，那么整个 Arena 都无法被释放，导致内存占用较高。

典型应用场景：

• 编译器中的 AST (抽象语法树) 构建。
• 解析器中的临时数据结构。
• 网络请求处理：所有请求相关的临时内存都在一个 Arena 中分配，请求处理完毕后整个 Arena 重置或释放。
• 游戏引擎中的帧级内存分配。

#include <stddef.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <string.h> // For memset

// 定义 Arena 的大小，通常是 OS 页的倍数
#define ARENA_DEFAULT_SIZE (sysconf(_SC_PAGE_SIZE) * 256) // 1MB 示例

typedef struct Arena {
    char* buffer_start; // 内存块起始地址
    char* buffer_end;   // 内存块结束地址
    char* current_ptr;  // 当前分配指针

    // 链表，用于管理多个 Arena 块（如果一个 Arena 耗尽，可以获取新的）
    struct Arena* next_arena; 
} Arena;

// 初始化 Arena 分配器
// initial_size: 首次分配的 Arena 大小
bool init_arena(Arena* arena, size_t initial_size) {
    if (initial_size == 0) initial_size = ARENA_DEFAULT_SIZE;

    arena->buffer_start = (char*)mmap(NULL, initial_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (arena->buffer_start == MAP_FAILED) {
        perror("mmap failed for arena");
        return false;
    }
    arena->buffer_end = arena->buffer_start + initial_size;
    arena->current_ptr = arena->buffer_start;
    arena->next_arena = NULL; // 初始时没有下一个 Arena

    printf("Arena initialized at %p, size %zu bytes.n", arena->buffer_start, initial_size);
    return true;
}

// 辅助函数：根据对齐要求调整指针
static inline char* align_ptr(char* ptr, size_t alignment) {
    return (char*)(((uintptr_t)ptr + alignment - 1) & ~(alignment - 1));
}

// 从 Arena 分配内存
void* arena_alloc(Arena** current_arena_ptr, size_t size, size_t alignment) {
    Arena* arena = *current_arena_ptr;
    if (size == 0) return NULL;

    // 处理对齐
    char* aligned_ptr = align_ptr(arena->current_ptr, alignment);

    // 检查是否有足够的空间
    if (aligned_ptr + size > arena->buffer_end) {
        // 当前 Arena 耗尽，尝试获取下一个 Arena
        if (arena->next_arena == NULL) {
            // 如果没有下一个 Arena，则创建一个新的
            size_t new_arena_size = ARENA_DEFAULT_SIZE; // 可以根据需求动态调整新 Arena 的大小
            Arena* new_arena = (Arena*)malloc(sizeof(Arena)); // 分配 Arena 结构体本身
            if (!new_arena || !init_arena(new_arena, new_arena_size)) {
                free(new_arena);
                fprintf(stderr, "Failed to get new arena.n");
                return NULL;
            }
            arena->next_arena = new_arena; // 将新 Arena 链接到当前 Arena 的后面
        }
        // 切换到下一个 Arena 进行分配
        *current_arena_ptr = arena->next_arena;
        return arena_alloc(current_arena_ptr, size, alignment); // 递归调用，在新 Arena 中分配
    }

    // 分配成功，更新 current_ptr
    arena->current_ptr = aligned_ptr + size;
    return aligned_ptr;
}

// 重置 Arena (不释放内存，只是将 current_ptr 归位，以便重用)
// 这只会重置当前 Arena，并不会重置链表中所有 Arena
void reset_arena(Arena* arena) {
    if (arena) {
        arena->current_ptr = arena->buffer_start;
        printf("Arena at %p reset.n", arena->buffer_start);
    }
}

// 销毁 Arena 分配器 (释放所有链表中的 Arena 内存)
void destroy_arena(Arena* head_arena) {
    Arena* current = head_arena;
    while (current) {
        Arena* next = current->next_arena;
        if (munmap(current->buffer_start, current->buffer_end - current->buffer_start) == -1) {
            perror("munmap failed for arena");
        }
        printf("Arena at %p destroyed.n", current->buffer_start);
        if (current != head_arena) { // head_arena 结构体可能不是动态分配的
            free(current); // 释放 Arena 结构体本身
        }
        current = next;
    }
}

// ------------------- 示例用法 -------------------
typedef struct DataNode {
    int id;
    char name[20];
    double values[2];
} DataNode;

int main() {
    Arena my_head_arena; // 头部的 Arena 可以是栈上的
    Arena* current_arena = &my_head_arena; // 分配时总是使用这个指针

    if (!init_arena(&my_head_arena, ARENA_DEFAULT_SIZE)) {
        return 1;
    }

    printf("n--- Allocating objects in arena ---n");
    // 第一次分配，使用 head arena
    DataNode* node1 = (DataNode*)arena_alloc(&current_arena, sizeof(DataNode), _Alignof(DataNode));
    if (node1) {
        node1->id = 1; strcpy(node1->name, "Node One");
        printf("Allocated node1 at %p (from arena %p)n", node1, current_arena->buffer_start);
    }

    // 分配一些 char 数组，模拟不同大小对象
    char* str1 = (char*)arena_alloc(&current_arena, 30, _Alignof(char));
    if (str1) {
        strcpy(str1, "Hello Arena World!");
        printf("Allocated str1 at %p (from arena %p)n", str1, current_arena->buffer_start);
    }

    // 假设 Arena 很快耗尽，会分配新的 Arena
    // 为了模拟，我们可以分配一个很大的块，强制当前 Arena 耗尽
    size_t large_block_size = ARENA_DEFAULT_SIZE - (current_arena->current_ptr - current_arena->buffer_start) + 100;
    void* large_block = arena_alloc(&current_arena, large_block_size, 1);
    if (large_block) {
        printf("Allocated large_block at %p (from arena %p), size %zun", large_block, current_arena->buffer_start, large_block_size);
    }

    // 再次分配，应该会在新的 Arena 中
    DataNode* node2 = (DataNode*)arena_alloc(&current_arena, sizeof(DataNode), _Alignof(DataNode));
    if (node2) {
        node2->id = 2; strcpy(node2->name, "Node Two");
        printf("Allocated node2 at %p (from arena %p)n", node2, current_arena->buffer_start);
    }

    // 注意：我们无法单独释放 node1, str1, node2

    printf("n--- Resetting the head arena (only head is reset) ---n");
    reset_arena(&my_head_arena); // 只有第一个 Arena 被重置

    // 再次分配，会从被重置的 head arena 开始
    DataNode* node3 = (DataNode*)arena_alloc(&current_arena, sizeof(DataNode), _Alignof(DataNode));
    if (node3) {
        node3->id = 3; strcpy(node3->name, "Node Three");
        printf("Allocated node3 at %p (from arena %p)n", node3, current_arena->buffer_start);
    }

    // 销毁所有 Arena
    printf("n--- Destroying all arenas ---n");
    destroy_arena(&my_head_arena);

    return 0;
}

代码解释：

• Arena 结构体：包含 buffer_start (Arena 内存块的起始)、buffer_end (结束)、current_ptr (下一个可用内存的起始) 和 next_arena (当当前 Arena 耗尽时指向下一个 Arena)。
• init_arena：使用 mmap 获取一个指定大小的内存块作为 Arena。
• arena_alloc：这是核心函数。它首先根据 alignment 调整 current_ptr，然后检查是否有足够空间。
  • 如果有空间，它就直接返回 aligned_ptr，并更新 current_ptr。
  • 如果没有空间，它会检查 next_arena。如果存在，就切换到下一个 Arena；如果不存在，就创建一个新的 Arena，并将其链接到当前 Arena 的后面，然后在新 Arena 中继续分配。注意 current_arena_ptr 是一个指向 Arena 指针的指针，这样我们才能在 arena_alloc 内部修改 main 函数中的 current_arena 变量，使其指向新的活动 Arena。
• reset_arena：将 current_ptr 简单地重置回 buffer_start。这意味着 Arena 中的所有已分配对象都被“逻辑上”释放了，但内存内容不变。这非常适合循环使用 Arena 的场景。注意，这里只重置了传入的 Arena，不会重置链表中的其他 Arena。
• destroy_arena：遍历整个 Arena 链表，使用 munmap 释放所有内存块。

Arena 分配器是极致性能的典范，尤其适用于那些“分配后一次性清理”的场景。

第七章：性能测量与基准测试

编写定制化分配器后，最关键的一步是测量其性能并与通用分配器进行比较。没有数据支撑，任何性能提升都只是猜测。

1. 测量工具：

• Linux perf： 功能强大的性能分析工具，可以测量 CPU 周期、缓存命中/未命中、TLB 命中/未命中、系统调用次数等，找出性能瓶颈。
• valgrind --tool=massif： 堆内存分析器，可以查看内存分配模式、峰值内存使用和碎片情况。
• 自定义基准测试程序： 编写模拟实际工作负载的程序，精确测量分配/释放的延迟和吞吐量。

2. 基准测试方法论：

• 模拟真实工作负载： 这是最重要的。你的基准测试应该尽可能地模仿你的应用程序实际的内存分配大小、频率、生命周期和并发模式。
• 预热阶段（Warm-up Phase）： 在正式测量前，运行一段时间，让系统和分配器进入稳定状态，填充缓存，避免首次分配的冷启动开销影响测量结果。
• 多次重复测试： 运行基准测试多次，取平均值、中位数，并分析标准差，以消除系统噪声和偶发性波动。
• 测量关键指标：
  • 吞吐量： 每秒钟完成的分配/释放操作次数。
  • 延迟： 单次分配/释放操作的平均、P90、P99、P99.9 分位延迟。长尾延迟对于实时系统至关重要。
  • 内存占用： 峰值内存使用量，内部/外部碎片。
  • CPU 使用率： 尤其是在多线程环境下。
• 对比基准： 始终与 malloc/free（通常链接到 jemalloc/tcmalloc）进行对比。如果可以，明确链接到 jemalloc 或 tcmalloc 的最新版本进行对比。
• 控制变量： 确保基准测试环境稳定，减少其他程序干扰。在专用机器上运行，禁用不必要的服务。
• 关注缓存效应： 内存分配器的性能受 CPU 缓存影响巨大。设计基准测试时要考虑缓存命中率，例如，通过在分配后立即访问内存来模拟实际使用。

一个简单的基准测试框架可能如下：

// 伪代码：基准测试框架
#include <time.h> // for clock_gettime
#include <sys/time.h> // for gettimeofday

// ... 你的 SlabAllocator/ArenaAllocator 定义 ...

// 计时函数
static inline long long get_nanoseconds() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return (long long)ts.tv_sec * 1000000000LL + ts.tv_nsec;
}

void run_benchmark(const char* name, void* (*alloc_func)(size_t, size_t), void (*free_func)(void*), size_t object_size, int num_iterations) {
    long long start_time, end_time;
    void** ptrs = (void**)malloc(sizeof(void*) * num_iterations);

    printf("--- Benchmarking %s for object size %zu, iterations %d ---n", name, object_size, num_iterations);

    // 分配阶段
    start_time = get_nanoseconds();
    for (int i = 0; i < num_iterations; ++i) {
        ptrs[i] = alloc_func(object_size, 1); // 假设对齐是1
        // 实际使用：memset(ptrs[i], 0, object_size); // 模拟写入，触发缓存加载
    }
    end_time = get_nanoseconds();
    printf("Allocation time: %.3f ms (Avg: %.3f ns/op)n", 
           (end_time - start_time) / 1000000.0, 
           (double)(end_time - start_time) / num_iterations);

    // 释放阶段
    start_time = get_nanoseconds();
    for (int i = 0; i < num_iterations; ++i) {
        free_func(ptrs[i]);
    }
    end_time = get_nanoseconds();
    printf("Deallocation time: %.3f ms (Avg: %.3f ns/op)n", 
           (end_time - start_time) / 1000000.0, 
           (double)(end_time - start_time) / num_iterations);

    free(ptrs);
    printf("n");
}

// 主函数中调用
// int main() {
//     // 准备你的自定义分配器
//     SlabAllocator my_slab_allocator;
//     init_slab_allocator(&my_slab_allocator, sizeof(MyObject));
//     
//     // 包装函数以匹配 run_benchmark 签名
//     void* my_slab_alloc_wrapper(size_t s, size_t align) { return slab_alloc(&my_slab_allocator); }
//     void my_slab_free_wrapper(void* p) { slab_free(&my_slab_allocator, p); }
//
//     // 运行基准测试
//     run_benchmark("Custom Slab Allocator", my_slab_alloc_wrapper, my_slab_free_wrapper, sizeof(MyObject), 1000000);
//     run_benchmark("System malloc/free", malloc, free, sizeof(MyObject), 1000000);
//
//     destroy_slab_allocator(&my_slab_allocator);
//     return 0;
// }

第八章：何时不应编写定制化分配器

尽管定制化分配器在特定场景下能带来显著性能提升，但它们并非万灵药。以下情况，您应该慎重考虑，甚至避免编写自定义分配器：

• 通用场景： 如果你的应用程序的内存分配模式是多样化的，既有小对象也有大对象，生命周期各异，那么 jemalloc/tcmalloc 等通用分配器几乎总是更好的选择。它们在这些场景下经过了极致优化。
• 不了解工作负载： 如果你不清楚应用程序的内存使用模式，那么定制化分配器很可能“优化”错误的方向，反而可能不如通用分配器。
• 分配不是瓶颈： 在进行任何优化之前，始终要进行性能分析。如果内存分配只占总运行时间的很小一部分，那么优化分配器是舍本逐末。你应该将精力放在真正的瓶颈上，例如 I/O、算法复杂度、数据库查询等。
• 开发和维护成本： 编写、调试和维护一个自定义分配器需要投入大量时间和专业知识。它增加了代码的复杂性，并且容易引入难以发现的内存错误（如 UAF、double free 等），而这些错误可能无法被 Valgrind 等标准工具检测到。
• 小的性能收益： 如果经过评估，定制化分配器带来的性能提升微乎其微，不足以抵消其带来的额外复杂性和维护成本，那么就应该坚持使用标准库。

第九章：高级考量与未来方向

如果您已经掌握了基础定制化分配器的知识，并成功在特定场景下超越了通用分配器，那么可以进一步探索以下高级主题：

• 大页（Huge Pages）： 使用操作系统提供的大页内存（如 Linux 2MB 或 1GB 页面），可以减少 TLB (Translation Lookaside Buffer) 未命中，从而提高内存访问性能。mmap 的 MAP_HUGETLB 标志可以用于此目的。
• NUMA 架构优化： 在非均匀内存访问（NUMA）系统上，内存访问延迟取决于内存与 CPU 的距离。可以设计 NUMA-aware 的分配器，在当前线程运行的 CPU 所在的内存节点上分配内存，以最小化跨节点访问。
• 内存保护与调试： 在开发阶段，可以为分配的内存添加额外的保护机制，如在内存块前后添加“哨兵区域”（canaries）或使用页保护（mprotect）来检测缓冲区溢出、越界访问和双重释放。
• 集成到语言运行时： 某些语言（如 Go、Rust）允许用户自定义全局内存分配器。这为在更高级别的应用程序中集成定制化分配器提供了接口。
• 垃圾回收（Garbage Collection）集成： 对于需要 GC 的语言，定制化分配器可以与 GC 协同工作，例如，提供更适合 GC 扫描的内存布局。

结语

定制化内存分配器是优化高性能系统的一把双刃剑。它要求开发者对内存管理、操作系统原理和应用程序的工作负载有深刻的理解。只有当标准分配器成为明确的瓶颈，并且应用程序的内存模式高度可预测时，投入精力设计和实现一个专用分配器才可能带来显著的性能收益。这是一个充满挑战但回报丰厚的领域，它将您的系统性能推向新的极限。