Linux内核 Slab块分配器深度剖析

最新推荐文章于 2025-08-08 20:58:41 发布

原创最新推荐文章于 2025-08-08 20:58:41 发布 · 926 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#linux #运维 #服务器

Linux 专栏收录该内容

31 篇文章

订阅专栏

Linux内核 Slab块分配器深度剖析

作者：
时间：2024年6月
关键词：Linux内核、内存管理、Slab分配器、源码分析、架构演进、调优技巧

一、引言

在Linux内核管理内存的众多机制中，Slab分配器（Slab Allocator）以其高效的对象分配与缓存复用能力，成为内核对象分配的核心。本文将从架构设计、源码实现、流程细节、调优实践等多个维度，系统性剖析Slab分配器的工作原理，并给出调试优化建议及实际业务应用举例。

二、背景与设计动机

2.1 内存碎片问题

传统的伙伴系统（Buddy System）适合分配大块内存，但面对频繁的小对象分配/释放时，易产生内存碎片（Memory Fragmentation）。Slab分配器应运而生，专为高频小对象分配而设计。

2.2 设计思想

对象缓存（Object Caching）：将相同类型对象预先分配并缓存起来。
分层管理：通过slab、cache、kmem_cache三层结构，实现高效复用。
批量分配/释放：减少锁竞争，提升并发性能。
对象构造/析构钩子：支持定制初始化与销毁操作。

三、主流程环节与设计技巧

3.1 Slab分配器结构

3.1.1 主要数据结构

struct kmem_cache {
    unsigned int size;                 // 单个对象大小
    unsigned int align;                // 对齐方式
    unsigned int object_in_slab;       // 一个slab中对象数量
    struct list_head slabs_full;       // 满slab链表
    struct list_head slabs_partial;    // 部分满slab链表
    struct list_head slabs_free;       // 空slab链表
    // ... 省略部分成员
};

口诀：“三链分管，缓存分层，对象复用，性能优先。”

3.1.2 工作流程图

3.2 主流程分解

3.2.1 对象分配（kmem_cache_alloc）

检查slabs_partial链表，优先复用已有slab。
无可用slab则从slabs_free分配，若仍无则新建slab。
若slab耗尽，则通过伙伴系统分配新物理页。

核心源码片段（kernel/slab.c）：

void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
{
    struct slab *slabp;
    void *objp;

    /* 1. 优先从部分满slab分配 */
    slabp = list_first_entry_or_null(&cachep->slabs_partial, struct slab, list);
    if (slabp) {
        objp = slab_alloc_obj(slabp, cachep);
        if (objp)
            return objp;
    }

    /* 2. 尝试从空slab分配 */
    slabp = list_first_entry_or_null(&cachep->slabs_free, struct slab, list);
    if (!slabp) {
        /* 3. 分配新slab */
        slabp = alloc_new_slab(cachep, flags);
        if (!slabp)
            return NULL;
    }
    objp = slab_alloc_obj(slabp, cachep);
    return objp;
}

逐行注释：

优先查找部分满slab，提高空间利用率。
若无则查找空slab，避免频繁分配新slab。
若仍无则通过伙伴系统分配新页，构建新slab。

3.2.2 对象释放（kmem_cache_free）

释放对象回slab。
若slab全空，则可回收物理页。

核心源码片段：

void kmem_cache_free(struct kmem_cache *cachep, void *objp)
{
    struct slab *slabp = virt_to_slab(objp);

    /* 1. 回收对象到slab */
    slab_free_obj(slabp, objp, cachep);

    /* 2. 判断slab是否全空，若是则回收 */
    if (slab_is_empty(slabp))
        free_slab(slabp, cachep);
}

口诀：“用时分配，用完即还，空则释放，节省空间。”

四、源码行级剖析与深层次逻辑

4.1 slab对象分配实现

slab_alloc_obj（简化版）：

static void *slab_alloc_obj(struct slab *slabp, struct kmem_cache *cachep)
{
    unsigned long *bitmap = slabp->bitmap;
    int obj_idx = find_first_zero_bit(bitmap, cachep->object_in_slab);

    if (obj_idx < cachep->object_in_slab) {
        __set_bit(obj_idx, bitmap);
        return slabp->s_mem + obj_idx * cachep->size;
    }
    return NULL;
}

find_first_zero_bit：查找第一个空闲对象。
__set_bit：标记为已分配。
s_mem：slab内存起始指针。

4.2 slab对象释放实现

slab_free_obj（简化版）：

static void slab_free_obj(struct slab *slabp, void *objp, struct kmem_cache *cachep)
{
    int obj_idx = (objp - slabp->s_mem) / cachep->size;
    __clear_bit(obj_idx, slabp->bitmap);
}

__clear_bit：标记为未分配。

五、优缺点分析

优点	缺点
1. 高速对象分配/释放	1. 内存利用率低于SLUB/SLAB v2
2. 支持对象构造/析构钩子	2. 结构复杂，维护难度较大
3. 降低碎片化	3. 多线程场景下锁粒度较大
4. 批量管理提升并发	4. 适合定长、频繁分配释放场景