Slab分配器分析

一、Slab分配器概述

1.1 Slab分配器的作用

Slab分配器是Linux内核中用于管理小对象内存分配的高效机制。它主要解决以下问题：

• 频繁分配/释放小对象的性能问题：内核中大量使用固定大小的对象（如task_struct、inode、dentry等），频繁的分配和释放会导致性能下降
• 内存碎片问题：直接使用Buddy分配器分配小对象会造成严重的内部碎片
• 对象初始化开销：通过缓存已构造的对象，避免重复的初始化操作
• 缓存行对齐：提高CPU缓存利用率，减少伪共享

1.2 Slab分配器的设计理念

1. 对象缓存（Object Cache）：为经常使用的数据结构类型创建专用缓存
2. 构造/析构函数：对象可以预先构造，使用后不立即销毁而是放回缓存
3. Per-CPU缓存：减少多处理器系统中的锁竞争
4. 着色（Coloring）：通过偏移量优化CPU缓存利用

1.3 Slab分配器的实现变体

Linux内核中有三种Slab分配器实现：

• SLAB：原始实现，功能完整但较复杂
• SLUB：简化版本，是当前主流实现（默认）
• SLOB：面向小型嵌入式系统的轻量级实现

二、Slab分配器的核心数据结构

2.1 kmem_cache结构

structkmem_cache{structkmem_cache_cpu__percpu*cpu_slab;/* Per-CPU缓存 */unsignedlongflags;/* 分配标志 */unsignedlongmin_partial;/* 部分空闲slab的最小数量 */intsize;/* 对象大小 */intobject_size;/* 实际对象大小（不含元数据） */intoffset;/* 空闲指针的偏移量 */intcpu_partial;/* Per-CPU部分空闲slab数量限制 */structkmem_cache_order_objectsoo;/* 对象和阶数 */structkmem_cache_order_objectsmax;/* 最大对象和阶数 */structkmem_cache_order_objectsmin;/* 最小对象和阶数 */gfp_tallocflags;/* 传递给Buddy系统的分配标志 */intrefcount;/* 引用计数 */void(*ctor)(void*);/* 对象构造函数 */constchar*name;/* 缓存名称 */structlist_headlist;/* 缓存链表 */structkmem_cache_node*node[MAX_NUMNODES];/* NUMA节点 */};

2.2 Slab页结构

structpage{unsignedlongflags;/* 页标志 */union{struct{structlist_headlru;/* 用于链接到各种链表 */structkmem_cache*slab_cache;/* 指向所属的kmem_cache */void*freelist;/* 空闲对象链表 */union{struct{unsignedinuse:16;/* 已使用对象数 */unsignedobjects:15;/* 总对象数 */unsignedfrozen:1;/* 是否冻结（Per-CPU使用） */};atomic_t_refcount;};};};};

2.3 Per-CPU缓存结构

structkmem_cache_cpu{void**freelist;/* 指向下一个可用对象 */unsignedlongtid;/* 事务ID，用于无锁操作 */structpage*page;/* 当前正在使用的slab */structpage*partial;/* 部分空闲的slab链表 */};

三、Slab分配器的工作原理

3.1 三级缓存结构

Slab分配器采用三级缓存架构：

┌─────────────────────────────────────────┐ │ 1. Per-CPU快速路径 │ │ ┌─────────────┐ ┌─────────────┐ │ │ │ CPU 0 Slab │ │ CPU 1 Slab │ │ │ │ freelist │ │ freelist │ │ │ └─────────────┘ └─────────────┘ │ └─────────────────────────────────────────┘ ↓ 缓存未命中 ┌─────────────────────────────────────────┐ │ 2. Per-CPU部分空闲Slab链表 │ │ (cpu_slab->partial) │ └─────────────────────────────────────────┘ ↓ 仍未命中 ┌─────────────────────────────────────────┐ │ 3. Per-Node部分空闲Slab链表 │ │ (kmem_cache_node->partial) │ └─────────────────────────────────────────┘ ↓ 仍未命中 ┌─────────────────────────────────────────┐ │ 4. 从Buddy系统分配新Slab │ └─────────────────────────────────────────┘

3.2 对象分配流程

快速路径（Fast Path）

static__always_inlinevoid*slab_alloc(structkmem_cache*s,gfp_tgfpflags){void**object;structkmem_cache_cpu*c;unsignedlongtid;/* 1. 禁用抢占，获取Per-CPU缓存 */c=this_cpu_ptr(s->cpu_slab);tid=c->tid;barrier();/* 2. 快速路径：直接从freelist获取对象 */object=c->freelist;if(unlikely(!object||!node_match(c,node)))gotoslow_path;/* 3. 更新freelist指针 */c->freelist=get_freepointer(s,object);c->tid=next_tid(tid);/* 4. 返回对象 */returnobject;slow_path:return__slab_alloc(s,gfpflags,node,addr,c);}

慢速路径（Slow Path）

staticvoid*__slab_alloc(structkmem_cache*s,gfp_tgfpflags,intnode){void*freelist;structpage*page;/* 1. 尝试从Per-CPU部分空闲链表获取 */page=c->page;if(!page)gotonew_slab;/* 2. 重新加载freelist */freelist=c->freelist;if(freelist)returnfreelist;/* 3. 从Per-CPU partial链表获取 */page=c->partial;if(page){c->page=page;c->freelist=get_freepointer(s,page->freelist);returnpage->freelist;}new_slab:/* 4. 从Per-Node partial链表获取或分配新slab */page=get_partial(s,node);if(!page){/* 5. 从Buddy系统分配新页面 */page=new_slab(s,gfpflags,node);if(!page)returnNULL;}c->page=page;returnpage->freelist;}

3.3 对象释放流程

static__always_inlinevoidslab_free(structkmem_cache*s,structpage*page,void*object){void**object_ptr=object;structkmem_cache_cpu*c;unsignedlongtid;/* 1. 获取Per-CPU缓存 */c=this_cpu_ptr(s->cpu_slab);tid=c->tid;/* 2. 快速路径：将对象插入freelist */if(likely(page==c->page)){set_freepointer(s,object,c->freelist);c->freelist=object;c->tid=next_tid(tid);return;}/* 3. 慢速路径：处理其他情况 */__slab_free(s,page,object);}

3.4 Slab着色技术

着色技术通过在slab中添加偏移量，使不同slab中的对象映射到不同的CPU缓存行：

Slab 1: [偏移0] [对象1][对象2][对象3]... Slab 2: [偏移32][对象1][对象2][对象3]... Slab 3: [偏移64][对象1][对象2][对象3]...

这样可以减少多个slab对象竞争同一缓存行的情况。

四、Slab分配器与Buddy分配器的关系

4.1 层次关系

┌─────────────────────────────────────────────┐ │ 用户空间内存分配请求 │ └─────────────────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────┐ │ 内核内存分配接口 (kmalloc/kfree) │ └─────────────────────────────────────────────┘ ↓ ┌───────────────────────┐ │ 小对象 (<2页) │ └───────────────────────┘ ↓ ┌─────────────────────────────────────────────┐ │ Slab分配器 (kmem_cache) │ │ - 对象缓存管理 │ │ - Per-CPU快速分配 │ │ - 减少碎片 │ └─────────────────────────────────────────────┘ ↓ 需要分配新slab时 ↓ ┌─────────────────────────────────────────────┐ │ Buddy分配器 (alloc_pages) │ │ - 以页为单位分配 │ │ - 2的幂次方大小 │ │ - 管理物理内存页 │ └─────────────────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────┐ │ 物理内存页框 │ └─────────────────────────────────────────────┘

4.2 依赖关系

Slab分配器是建立在Buddy分配器之上的：

1. 页面来源：Slab分配器通过调用alloc_pages()从Buddy系统获取页面
2. 分配单位：通常分配1-2个连续页面作为一个slab
3. 回收机制：当slab完全空闲时，通过__free_pages()归还页面给Buddy系统

/* Slab分配器向Buddy系统请求页面 */staticstructpage*allocate_slab(structkmem_cache*s,gfp_tflags,intnode){structpage*page;intorder;/* 计算需要的页面阶数 */order=oo_order(s->oo);/* 从Buddy系统分配连续页面 */page=alloc_pages_node(node,flags|__GFP_COMP,order);if(!page)returnNULL;/* 初始化slab页面 */__SetPageSlab(page);page->slab_cache=s;returnpage;}

4.3 性能优势对比

4.4 协作机制

/* 示例：kmalloc的实现 */void*kmalloc(size_tsize,gfp_tflags){/* 1. 小于2页的分配走Slab */if(size<=KMALLOC_MAX_CACHE_SIZE){structkmem_cache*s=kmalloc_slab(size,flags);returnkmem_cache_alloc(s,flags);// 使用Slab}/* 2. 大于2页的分配直接走Buddy */returnkmalloc_large(size,flags);// 使用Buddy}/* 大对象直接使用Buddy分配器 */void*kmalloc_large(size_tsize,gfp_tflags){unsignedintorder=get_order(size);structpage*page=alloc_pages(flags,order);// 直接调用Buddyreturnpage?page_address(page):NULL;}

五、Slab分配器与不连续页分配器（vmalloc）的关系

5.1 内存区域划分

内核地址空间布局（x86-64）： ┌────────────────────────────────────┐ 0xFFFFFFFF FFFFFFFF │ 内核代码段 & 数据段 │ ├────────────────────────────────────┤ │ 直接映射区（线性映射） │ <- Slab和Buddy在此区域 │ - 物理内存连续映射 │ │ - 虚拟地址连续 = 物理地址连续 │ ├────────────────────────────────────┤ VMALLOC_START │ vmalloc区域（非连续映射） │ <- vmalloc在此区域 │ - 物理内存不连续 │ │ - 虚拟地址连续 ≠ 物理地址连续 │ ├────────────────────────────────────┤ VMALLOC_END │ 其他内核区域 │ └────────────────────────────────────┘

5.2 核心区别

5.3 vmalloc的实现原理

void*vmalloc(unsignedlongsize){/* 1. 在vmalloc区域分配虚拟地址空间 */structvm_struct*area=get_vm_area(size,VM_ALLOC);if(!area)returnNULL;/* 2. 逐页从Buddy系统分配物理页面（不要求连续） */for(i=0;i<nr_pages;i++){page=alloc_page(GFP_KERNEL);// 从Buddy分配单页if(!page)gotofail;pages[i]=page;}/* 3. 建立虚拟地址到物理页面的映射（修改页表） */if(map_vm_area(area,PAGE_KERNEL,pages))gotofail;returnarea->addr;}

5.4 三者的协作关系

┌──────────────────────────────────────────────┐ │ 内核内存分配需求 │ └──────────────────────────────────────────────┘ ↓ ┌───────────┴───────────┬──────────────┐ ↓ ↓ ↓ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ 小对象 │ │ 中等对象 │ │ 大对象 │ │ <2KB │ │ 2KB-128KB │ │ >128KB │ └──────────────┘ └──────────────┘ └──────────────┘ ↓ ↓ ↓ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ Slab分配器 │ │ Slab/Buddy │ │ vmalloc │ │ - 对象缓存 │ │ - 直接分配 │ │ - 不连续页 │ │ - Per-CPU │ │ │ │ - 页表映射 │ └──────────────┘ └──────────────┘ └──────────────┘ ↓ ↓ ↓ └───────────┬───────┴──────────────────┘ ↓ ┌───────────────────────┐ │ Buddy分配器 │ │ - 提供物理页面 │ └───────────────────────┘ ↓ ┌───────────────────────┐ │ 物理内存 │ └───────────────────────┘

5.5 使用场景对比

Slab分配器适用于：

• 频繁分配/释放的小对象（如task_struct、inode）
• 需要高性能的场景
• 需要DMA的场景
• 对象大小固定或变化不大

vmalloc分配器适用于：

• 大块内存分配（>128KB）
• 不需要物理连续的场景
• 模块加载（内核模块代码段）
• 不关心性能的临时缓冲区
• 物理内存碎片严重时

5.6 性能影响分析

/* 测试示例：分配1MB内存的性能对比 *//* 方式1：使用kmalloc（通过Buddy，要求物理连续） */void*buf1=kmalloc(1024*1024,GFP_KERNEL);// 优点：访问快（TLB友好，可能使用大页）// 缺点：可能因内存碎片而失败/* 方式2：使用vmalloc（物理不连续） */void*buf2=vmalloc(1024*1024);// 优点：不易失败（物理内存不需要连续）// 缺点：访问慢（TLB miss多，页表遍历）

六、通用缓存（kmalloc）的实现

6.1 kmalloc缓存层次

内核预先创建了一系列大小递增的Slab缓存：

staticstructkmem_cache*kmalloc_caches[KMALLOC_SHIFT_HIGH+1];/* 缓存大小： */// kmalloc-8, kmalloc-16, kmalloc-32, kmalloc-64,// kmalloc-96, kmalloc-128, kmalloc-192, kmalloc-256,// kmalloc-512, kmalloc-1024, kmalloc-2048, kmalloc-4096, kmalloc-8192

6.2 大小选择算法

static__always_inlinestructkmem_cache*kmalloc_slab(size_tsize,gfp_tflags){unsignedintindex;if(size<=192)index=size_index[size_index_elem(size)];elseindex=fls(size-1);// 找到最高位returnkmalloc_caches[index];}

七、Slab分配器的调试与统计

7.1 查看slab信息

# 查看所有slab缓存的统计信息cat/proc/slabinfo# 示例输出：# slabinfo - version: 2.1# name <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab># task_struct 256 280 4352 1 1# mm_struct 180 200 1024 4 1# dentry 32000 32500 192 42 2

7.2 sysfs接口

# 查看特定缓存的详细信息ls/sys/kernel/slab/kmalloc-1024/# 输出包括：# - objects: 对象总数# - object_size: 对象大小# - slabs: slab数量# - cpu_slabs: Per-CPU slab数量# - partial: 部分空闲slab数量

7.3 内存泄漏检测

启用CONFIG_DEBUG_SLAB或CONFIG_SLUB_DEBUG可以跟踪对象分配：

/* 启用调试后可以使用 */echo1>/sys/kernel/slab/<cache_name>/trace

八、总结

8.1 三种分配器的关系总结

内核内存管理层次结构 ┌─────────────────────────────────────────────┐ │ 高层接口（API） │ │ kmalloc/kfree | vmalloc/vfree │ └─────────────────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────┐ │ 中间层（对象管理） │ │ │ │ ┌─────────────┐ ┌──────────────┐ │ │ │ Slab分配器 │ │ vmalloc管理 │ │ │ │ - 对象缓存 │ │ - 虚拟区域 │ │ │ │ - Per-CPU │ │ - 页表映射 │ │ │ └─────────────┘ └──────────────┘ │ └─────────────────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────┐ │ 底层（页框管理） │ │ Buddy分配器 │ │ - 伙伴系统算法 │ │ - 以页为单位 │ │ - 2的幂次方分配 │ └─────────────────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────┐ │ 物理内存（RAM） │ └─────────────────────────────────────────────┘

8.2 选择建议

• 小对象（<2KB）：使用kmalloc（底层Slab）
• 中等对象（2KB-128KB）：使用kmalloc（底层Buddy）
• 大对象（>128KB）或可接受不连续：使用vmalloc
• 特定类型对象频繁分配：创建专用kmem_cache
• 需要DMA：必须使用kmalloc或直接使用Buddy（保证物理连续）

8.3 关键要点

1. Slab是Buddy的上层：Slab通过Buddy获取页面，在页面上实现对象级管理
2. vmalloc与Slab并列：两者都使用Buddy，但服务不同场景
3. 性能排序：Slab > Buddy > vmalloc
4. 连续性要求：Slab和Buddy保证物理连续，vmalloc不保证
5. 适用场景不同：根据对象大小、频率、连续性需求选择合适的分配器