Linux内存管理章节十九：超越kmalloc：自定义内存分配器开发实战 - 教程

引言

通用内存分配器（如SLUB）设计用于处理各种大小和生命周期的内存请求，其泛用性必然伴随着性能开销：锁竞争、缓存行 bouncing、以及复杂的元数据管理。在对性能有极致要求的内核子系统（如网络栈、文件系统）或特定驱动中，我们往往需要一种更专注、更高效的解决方案。开发自定义内存分配器允许我们针对特定工作负载进行深度优化。本文将指导你实现一个简单的内存池、创建专用对象缓存，并进行性能测试与优化。

一、 实现简单的内存池（Memory Pool）

内存池的核心思想是：预先分配一大块内存，并将其划分为多个固定大小的对象或缓冲区，后续的分配和释放都在这个池内进行。

设计与实现

1. 数据结构：

   #include <linux/slab.h>
     #include <linux/spinlock.h>
       struct mempool {
       void *pool_base;
       // 池的起始虚拟地址
       dma_addr_t pool_dma;
       // 池的起始DMA地址（如果用于DMA）
       size_t obj_size;
       // 每个对象的大小
       int num_objs;
       // 对象总数
       void **free_list;
       // 空闲对象链表栈
       int free_count;
       // 当前空闲对象数量
       spinlock_t lock;
       // 保护池的锁
       };

2. 初始化（mypool_init）：

   int mypool_init(struct mempool *pool, size_t obj_size, int num_objs, bool needs_dma)
   {
   int i;
   void *obj;
   // 1. 预分配整个内存池
   if (needs_dma) {
   pool->pool_base = dma_alloc_coherent(NULL, obj_size * num_objs,
   &pool->pool_dma, GFP_KERNEL);
   } else {
   pool->pool_base = kmalloc(obj_size * num_objs, GFP_KERNEL);
   }
   if (!pool->pool_base) return -ENOMEM;
   // 2. 初始化元数据
   pool->obj_size = obj_size;
   pool->num_objs = num_objs;
   pool->free_count = num_objs;
   spin_lock_init(&pool->lock);
   // 3. 构建初始空闲链表（后进先出栈）
   pool->free_list = kmalloc_array(num_objs, sizeof(void*), GFP_KERNEL);
   if (!pool->free_list) goto err_free_pool;
   for (i = 0; i < num_objs; i++) {
   obj = pool->pool_base + (i * obj_size);
   pool->free_list[i] = obj;
   }
   return 0;
   err_free_pool:
   if (needs_dma) dma_free_coherent(...);
   else kfree(pool->pool_base);
   return -ENOMEM;
   }

3. 分配对象（mypool_alloc）：

   void *mypool_alloc(struct mempool *pool)
   {
   unsigned long flags;
   void *obj = NULL;
   spin_lock_irqsave(&pool->lock, flags);
   if (pool->free_count >
   0) {
   pool->free_count--;
   obj = pool->free_list[pool->free_count];
   // 从栈顶弹出
   }
   spin_unlock_irqrestore(&pool->lock, flags);
   // 可选：分配失败处理（返回NULL或等待）
   return obj;
   }

4. 释放对象（mypool_free）：

   void mypool_free(struct mempool *pool, void *obj)
   {
   unsigned long flags;
   spin_lock_irqsave(&pool->lock, flags);
   if (pool->free_count < pool->num_objs) {
     pool->free_list[pool->free_count] = obj;
     // 压入栈顶
     pool->free_count++;
     } else {
     // 不应发生：释放次数多于分配次数
     WARN_ON(1);
     }
     spin_unlock_irqrestore(&pool->lock, flags);
     }

优势：

• 极速分配/释放：操作仅为操作栈和整数，复杂度O(1)。
• 确定性：无锁争用或搜索开销，执行时间恒定。
• 防止碎片：所有对象大小固定，且生命周期集中。
• DMA友好：可预先分配物理连续的内存供DMA使用。

适用场景：中断处理程序、网络包缓冲区（skbuff）、频繁分配/释放的固定大小对象。

二、 专用对象缓存创建

如果你需要频繁分配某种特定内核结构体，可以为其创建一个专用缓存。这本质上是让SLUB分配器为你创建一个专属的“精品店”，而不是去“综合商场”（通用缓存）里找。

使用 kmem_cache_create

#include <linux/slab.h>
  struct kmem_cache *my_cache;
  // 1. 创建缓存
  my_cache = kmem_cache_create("my_struct_cache", // 缓存名称（出现在/proc/slabinfo）
  sizeof(struct my_struct), // 对象大小
  0, // 对齐偏移（通常为0）
  SLAB_HWCACHE_ALIGN | SLAB_PANIC, // 标志位
  NULL);
  // 构造函数（通常为NULL）
  if (!my_cache) {
  // 错误处理，但SLAB_PANIC会使创建失败时直接panic
  }
  // 2. 从专用缓存分配对象
  struct my_struct *obj = kmem_cache_alloc(my_cache, GFP_KERNEL);
  // 3. 释放对象回专用缓存
  kmem_cache_free(my_cache, obj);
  // 4. 销毁缓存（通常在模块退出时）
  kmem_cache_destroy(my_cache);

关键标志位：

• SLAB_HWCACHE_ALIGN：让SLUB确保每个对象与缓存行（Cache Line） 对齐，防止伪共享（False Sharing），这是非常重要的性能优化。
• SLAB_POISON：投毒，用于调试use-after-free。
• SLAB_RED_ZONE：在对象前后插入红区，用于检测缓冲区溢出。

优势：

• 性能提升：避免了通用SLAB中的元数据搜索开销。
• 缓存友好：通过SLAB_HWCACHE_ALIGN优化，减少了缓存失效。
• 内存利用率：为特定对象量身定做，减少了内部碎片。
• 调试支持：可以方便地为整个缓存开启调试功能。

适用场景：频繁分配的内核核心数据结构（如task_struct, inode, file等本身就是这样管理的）。

三、 性能测试与优化

没有测量，就没有优化。自定义分配器必须通过性能测试来证明其价值。

1. 测试方法

• 基准测试：编写一个内核模块，使用ktime_get_ns()高精度计时器。
  • 循环执行大量（如100万次）alloc和free操作。
  • 分别测试通用分配器（kmalloc/kfree）和你的自定义分配器。
  • 计算平均耗时、最大耗时、最小耗时。自定义分配器应该表现出更稳定、更低的延迟。
• 压力测试：在并发环境下（使用内核线程）测试分配器，评估其可扩展性和锁竞争程度。
• 真实负载测试：将自定义分配器集成到目标子系统中（如网络驱动），在真实流量下观察性能指标（如包转发速率、CPU使用率）。

2. 优化方向

• 减少锁竞争：
  • ** per-CPU 缓存**：为每个CPU核心创建一个本地的空闲链表。分配和释放优先在本地CPU上进行，仅在本地为空或满时才操作全局链表。这几乎是高性能分配器的标配优化。
  • 无锁设计：尝试使用无锁算法（如CAS）管理空闲链表，但内核中的无锁编程非常复杂，需谨慎。
• 缓存预热：在系统启动或初始化阶段就完成主要的内存分配，避免在关键路径上分配。
• 批量操作：一次分配/释放多个对象，分摊锁和元数据操作的开销。
• NUMA优化：保证分配的内存对正在运行的CPU是本地的，减少远程访问延迟。

总结

开发自定义内存分配器是一项高级技能，其本质是在通用性、性能和开发复杂度之间做出权衡。

• 内存池提供了极致的速度和确定性，适用于固定大小、生命周期短、分配频繁的对象。
• 专用缓存在享受SLUB成熟功能的同时，通过专一化获得了性能提升，适用于特定内核结构体。
• 性能测试是证明其价值的唯一标准，而per-CPU缓存是应对多核扩展性的关键优化。

在决定“造轮子”之前，首先问自己：标准的kmalloc或专用缓存kmem_cache_create是否真的成为了性能瓶颈？只有当答案明确为“是”时，投入精力开发自定义分配器才是值得的。否则，你应该相信并充分利用内核社区已经优化了数十年的通用分配器。