跳至主要內容

内存池

学习阁2026/7/16大约 18 分钟内核组件内核内存管理内存池

内存池

📚 本节导读

学习时长: 约 25 分钟
难度级别: ⭐⭐⭐☆☆
前置知识: 4.4 内存管理、C 语言链表

内存池（Memory Pool）是 OneOS 提供的另一种内存管理机制。与堆内存不同，内存池预先分配固定大小的内存块，分配和释放操作具有确定性时间，且无碎片问题。它特别适合高频、固定大小的对象分配场景，如网络数据包缓冲区、传感器数据缓存等。

🎯 学习目标

  • 理解内存池与堆内存的区别和适用场景
  • 掌握内存池的创建、分配、释放 API
  • 了解内存池大小计算方法
  • 掌握内存池溢出检测机制
  • 能够使用 Shell 命令查看内存池状态

一、内存池概念

1.1 什么是内存池

内存池是一块预先分配好的内存区域，被划分为若干个大小相同的块（block）。分配和释放操作都在这些固定大小的块上进行。

1.2 内存池 vs 堆内存

特性内存池堆内存
分配大小固定可变
分配时间确定性 O(1)非确定性
碎片无有
超时等待支持不支持
并发保护自旋锁信号量
适用场景高频固定大小分配通用动态分配

1.3 使用场景与选型边界

一句话核心：当你需要反复分配/释放相同大小的对象、且对分配时间确定性要求高时，用内存池；当大小不确定、需要灵活伸缩时，用堆。

典型场景：

场景为什么用内存池
网络数据包缓冲区包大小固定，高频分配/释放，O(1) 确定性时间
传感器数据缓存每次读到的数据大小固定，且可能来自中断（需 OS_NO_WAIT）
通信协议控制块每个连接一个固定大小的控制块，频繁创建/销毁
任务栈/信号量等内核对象数量固定、大小固定，避免堆碎片

选型边界表（内存池 vs 堆）：

判断条件选内存池选堆
块大小固定？是否（大小不定）
分配时间要求确定？是否（可能耗时）
能忍受内存浪费？可（按块大小向上取整）否（按需分配）
中断中分配？可（OS_NO_WAIT）不可
需要等待空闲块？可（超时/永久等待）不可

选型关键注意点：

  • 内存池内部碎片：若请求 40 字节、块是 64 字节，浪费 24 字节。块越小越省。
  • 内存池只能分配固定大小，大小必须提前规划好（OS_MEMPOOL_SIZE 算好）。
  • 中断中只能 OS_NO_WAIT，不能阻塞等待空闲块。

二、配置

#define OS_USING_MEM_POOL            /* 必须：启用内存池 */
#define OS_USING_MEMPOOL_CHECK_TAG   /* 可选：启用溢出检测 */

三、Shell 命令

show_mempool                        # 显示所有内存池信息
show_mempool <mempool_address>      # 显示指定内存池信息

输出示例：

MemPool      TotalCount FreeCount  PerSize    Block Task
----------   ---------- ---------- ---------- ----------
SENSOR_POOL  20         18         128        0
PKT_POOL     100        95         256        5: task1

四、内部实现要点

4.1 核心数据结构与宏

os_mempool_t 控制块完整源码（kernel/source/os_prototypes.h，与项目逐字一致）：

来源：kernel/source/os_prototypes.h

字段含义：

字段含义
start_addr内存池数据区起始地址（对齐后）
free_list空闲块单向链表头（指向第一个空闲块）
size内存池总大小（字节）
blk_size单个块完整大小（含头部，不是用户可用大小）
blk_total_num块总数量（size / blk_size）
blk_free_num当前空闲块数量
task_list_head阻塞等待该内存池的任务链表
resource_node全局资源链表节点
object_alloc_type对象分配类型（静态/动态）
object_inited是否已初始化
name[]内存池名称

MEMPOOL 相关宏完整源码（kernel/source/os_mem_pool.c，与项目逐字一致）：

来源：kernel/source/os_mem_pool.c

关键宏含义：

宏含义
MEMPOOL_TAG_SIZE块头部大小（开启检测=4，否则=0）
MEMPOOL_PTR_WITHOUT_TAG(mem)数据指针 → 跳过头部，返回用户指针
MEMPOOL_PTR_WITH_TAG(mem)用户指针 → 回退头部，得到块头
MEMPOOL_GET_ALIGN_BLK_SIZE(blk_size)块大小 + 头部后向上对齐到 OS_ALIGN_SIZE
struct mempool_check_tag溢出检测标记（31 位魔数 + 1 位已用标记）

溢出检测标签详解（合并自内存块章节）：

  • magic_number（31 位）：魔数 0x504F4F4C（ASCII "POOL"），识别"这是内存池的块头"。
  • used_flag（1 位）：已用标记 OS_TRUE(1)。

检测原理：

  • 写标签（分配时）：MEMPOOL_SET_BLK_TAG(mem) 写入 magic_number = 0x504F4F4C、used_flag = OS_TRUE。
  • 验标签（释放时）：MEMPOOL_BLK_TAG_OK(mem) 校验 magic_number == 0x504F4F4C 且 used_flag == OS_TRUE。
  • 检测失败：OS_ASSERT(MEMPOOL_BLK_TAG_OK(mem)) 触发断言崩溃，定位"谁越界写坏了块头"。

if-else 条件走向总结（释放时的标签校验）：

os_mempool_free(id, mem) 的标签校验
  │
  ├─ mem = MEMPOOL_PTR_WITH_TAG(mem)  /* 回退到块头 */
  │
  └─ if (MEMPOOL_BLK_TAG_OK(mem))？  /* 魔数+已用标记是否完好？ */
      ├─ 是（标签完好）→ 继续释放流程
      └─ 否（被越界写坏）→ OS_ASSERT 断言崩溃

数值演算（块地址 0x1040，启用检测）：

项计算结果
块头0x1040（struct mempool_check_tag）4 字节
分配写标签magic_number=0x504F4F4C，used_flag=1块头 OK
返回用户指针0x1040 + 40x1044
用户越界前写把 0x504F4F4C 覆盖为 0x12345678标签损坏
释放验标签MEMPOOL_BLK_TAG_OK(0x1040)magic_number 不匹配 → 断言

4.2 内存对齐与块大小计算

内存对齐完整源码（os_mempool_init 片段，kernel/source/os_mem_pool.c）：

来源：kernel/source/os_mem_pool.c

    start_addr = (void *)OS_ALIGN_UP((os_ubase_t)start, OS_ALIGN_SIZE);
    size       = OS_ALIGN_DOWN((os_ubase_t)start + size - (os_ubase_t)start_addr, OS_ALIGN_SIZE);
    blk_size   = MEMPOOL_GET_ALIGN_BLK_SIZE(blk_size);
  • start_addr = 起始地址向上对齐到 OS_ALIGN_SIZE。
  • size = 向下对齐（去掉起始对齐的偏移）。
  • blk_size = 用户块大小 + 头部（若启用检测）后向上对齐。

数值演算（start = 0x1008、size = 0x520（1312）、blk_size = 64，OS_ALIGN_SIZE = 8）：

项计算结果
start_addrOS_ALIGN_UP(0x1008, 8)0x1008（已对齐）
sizeOS_ALIGN_DOWN(0x1008 + 0x520 - 0x1008, 8)0x520（1312）
无检测 blk_sizeOS_ALIGN_UP(64, 8)64
有检测 blk_sizeOS_ALIGN_UP(64 + 4, 8) = OS_ALIGN_UP(68, 8)72
无检测块数1312 / 6420 块
有检测块数1312 / 7218 块

注意：启用溢出检测后，每个块额外占 4 字节头部，同样大小的内存池可容纳的块数减少（20 → 18）。

4.3 空闲链表

所有空闲块通过单向链表连接，链表节点 blk_head 直接复用空闲块自身的开头字节（不额外分配节点）。完整源码（kernel/source/os_mem_pool.c，与项目逐字一致）：

来源：kernel/source/os_mem_pool.c

struct blk_head
{
    struct blk_head *next;
};
  • 分配：从链表头部取一个块，free_list = free_list->next（跳过头节点）。
  • 释放：将块插入链表头部，block->next = free_list; free_list = block。
  • 关键：blk_head 复用空闲块数据区开头的几个字节存 next 指针。只有空闲块才需要存 next，被分配的块（数据在用户手中）无需该指针，因此"链表节点"不额外占用内存。

为什么 blk_head 复用块数据区开头、不额外占内存？

核心疑问：内存池把内存分成 N 个固定大小块，没有单独的"链表节点存储区"。空闲链表怎么串联这些块？——直接借用每个空闲块自己的数据区开头几个字节存 next。

  • 空闲块：躺在链表里、当前没有用户数据，开头几个字节是闲置的，正好用来存 next 指针。
  • 被分配的块：已给用户、全是用户数据，没有多余空间（也不需要）存 next。

因为"空闲（存指针）"和"被分配（存数据）"在时间上互斥，所以复用安全、零开销。

举例（start_addr = 0x1000、blk_size = 64，4 个块）：

初始化时，所有块空闲，串成链表：

每个空闲块开头 4/8 字节存下一个空闲块的地址，其余空间（如 64 - 4 = 60 字节）当前空闲未用。

分配块 0 后，整块 64 字节全给用户，next 指针"消失"（空间归用户数据）：

0x1000 ──► ┌──────────────────────────────┐
块0(已分配) │  用户数据（整块 64 字节）       │  ← 开头 next 的空间也归用户
           └──────────────────────────────┘
0x1040 ──► ┌──────────────┬──────────────┐
块1(空闲)   │  next=0x1080 │              │  ← 仍是空闲块，开头存 next
           └──────────────┴──────────────┘
free_list 现在指向块1（0x1040）

为什么这样设计：若为每块单独分配一个 blk_head 节点，会额外浪费内存（每块多一个指针）。复用空闲块自身空间，链表节点"寄生"在空闲块里，零额外开销。

与 BUDDY 的对比：BUDDY 每个块有固定独立的块头（buddy_block），始终占 8 字节；内存池则无固定块头，块头（next）只在空闲时借用数据区。所以内存池分配返回的指针就是块起始地址（不跳过头部），而 BUDDY 返回的是跳过块头的数据指针。

块的实际布局（合并自内存块章节）：

  • 启用检测：块 = 4 字节标签（mempool_check_tag）+ 用户数据区，总大小 OS_ALIGN_UP(blk_size + TAG_SIZE, ALIGN)。
  • 未启用：块 = 纯用户数据区，总大小 OS_ALIGN_UP(blk_size, ALIGN)。

4.4 初始化流程

os_mempool_init 完整源码（kernel/source/os_mem_pool.c，与项目逐字一致）：

来源：kernel/source/os_mem_pool.c

分步详解：

第一步：参数校验（无条件执行）

    OS_ASSERT(OS_FALSE == os_is_irq_active());
    OS_ASSERT(mempool_cb);
    OS_ASSERT(start);
    OS_ASSERT(size >= OS_ALIGN_SIZE);
    OS_ASSERT(blk_size > 0);
  • 校验：不能在中断中调用、控制块/起始地址非空、堆大小 ≥ 对齐大小、块大小 > 0。

第二步：对齐与块大小换算（无条件执行）

    start_addr = (void *)OS_ALIGN_UP((os_ubase_t)start, OS_ALIGN_SIZE);
    size       = OS_ALIGN_DOWN((os_ubase_t)start + size - (os_ubase_t)start_addr, OS_ALIGN_SIZE);
    blk_size   = MEMPOOL_GET_ALIGN_BLK_SIZE(blk_size);

见 4.2 的数值演算。

第三步：判断能否容纳至少一个块（条件：0 != (size / blk_size)）

  • 条件成立（能装下至少 1 个块）：
    • 先加入全局资源链表（_k_mempool_add_resourcelist），若该内存池已存在则返回 OS_INVAL（重复创建）。
    • 子分支：加入成功 → 调用 _k_mempool_init 真正初始化（见 4.8 辅助函数）。
    • 子分支：加入失败（已存在）→ mempool = OS_NULL。
  • 条件不成立（装不下任何块）→ mempool = OS_NULL。

if-else 条件走向总结（树状图）：

数值演算（延续 4.2：size=1312、blk_size=64、无检测）：

项计算结果
size / blk_size1312 / 6420 ≠ 0 → 条件成立
加入资源链表内存池不在全局列表成功
_k_mempool_init初始化控制块blk_total_num = 20

4.5 分配流程

os_mempool_alloc 完整源码（kernel/source/os_mem_pool.c，与项目逐字一致）：

来源：kernel/source/os_mem_pool.c

分步详解：

第一步：进入临界区（无条件执行）

    mem = OS_NULL;
    ret = OS_SUCCESS;

    OS_KERNEL_ENTER();   /* 或 SMP 下 os_spin_lock_irq */

初始化 mem = OS_NULL、ret = OS_SUCCESS，进入临界区（关闭调度或加自旋锁），保证分配操作互斥。

第二步：循环等待空闲块（条件：free_list == OS_NULL）

  • 条件 free_list == OS_NULL（无空闲块）：进入循环。
    • 子分支 timeout == OS_NO_WAIT：不等待，ret = OS_NOMEM，break 跳出。
    • 子分支有超时/永久等待：记录 tick_before，调用 k_block_task 阻塞当前任务。若阻塞失败返回，ret = OS_FAILURE 直接返回。唤醒后更新剩余 timeout。
  • 条件 free_list != OS_NULL（有空闲块）：跳过循环，直接取块。

第三步：取块并返回（条件：ret == OS_SUCCESS）

  • 条件 ret == OS_SUCCESS（有块可取）：
    • mem = free_list 取链表头；free_list 跳到下一块；blk_free_num--。
    • 启用检测时：给块头打魔数标记 MEMPOOL_SET_BLK_TAG，mem = MEMPOOL_PTR_WITHOUT_TAG(mem) 跳过头部返回用户指针。
  • 条件 ret != OS_SUCCESS：mem 保持 OS_NULL。
  • 离开临界区，返回 mem。

if-else 条件走向总结（树状图）：

数值演算（free_list 链：块0→块1→块2→NULL，blk_free_num = 3）：

项计算结果
分配前free_list = 块0，blk_free_num = 3—
取块mem = 块0；free_list = 块1块 0 出链
blk_free_num--3 - 12
无检测返回mem = 块0（用户直接用）块 0 数据指针
有检测返回mem = 块0 + 4（跳过头部）用户指针

4.6 释放流程

os_mempool_free 完整源码（kernel/source/os_mem_pool.c，与项目逐字一致）：

来源：kernel/source/os_mem_pool.c

分步详解：

第一步：参数与地址校验（无条件执行）

    OS_ASSERT(mem);
    OS_ASSERT((mem >= mempool->start_addr) && ((char *)mem < ((char *)mempool->start_addr + mempool->size)));
#ifdef OS_USING_MEMPOOL_CHECK_TAG
    mem = MEMPOOL_PTR_WITH_TAG(mem);
    OS_ASSERT(MEMPOOL_BLK_TAG_OK(mem));
#endif
    OS_ASSERT((((os_size_t)((char *)mem - (char *)mempool->start_addr) % mempool->blk_size) == 0));
  • 校验 mem 非空、且在内存池范围内。
  • 启用检测时：mem 回退头部 MEMPOOL_PTR_WITH_TAG，校验块头魔数是否有效（防止释放非本池/非法指针）。
  • 校验 mem 相对 start_addr 的偏移是 blk_size 的整数倍（确保是合法的块边界）。

第二步：释放块回链表（无条件执行）

    ((struct blk_head *)mem)->next = mempool->free_list;
    mempool->free_list             = mem;
    mempool->blk_free_num++;
  • 把 mem 块头 next 指向当前链表头，free_list = mem，块插入链表头部；blk_free_num++。

第三步：唤醒等待任务（条件：有任务在等待）

    if (!os_list_empty(&mempool->task_list_head))
    {
        task       = os_list_first_entry(&mempool->task_list_head, os_task_t, task_node);
        need_sched = k_unblock_task(task);
    }
    else
    {
        need_sched = OS_FALSE;
    }
  • 条件成立（有任务阻塞等待）：唤醒链表头的第一个等待任务（k_unblock_task）。
  • 条件不成立（无等待任务）：need_sched = OS_FALSE，无需调度。

if-else 条件走向总结（树状图）：

数值演算（分配例子的延续：释放块 0，blk_free_num 从 2 变回 3）：

项计算结果
释放前free_list = 块1，blk_free_num = 2—
头插块0->next = 块1；free_list = 块0块 0 回到链表头
blk_free_num++2 + 13
唤醒若有任务等待唤醒一个分配任务

4.7 获取信息

os_mempool_info 完整源码（kernel/source/os_mem_pool.c，与项目逐字一致）：

来源：kernel/source/os_mem_pool.c

分步详解：

  • 校验 mempool/info 有效。
  • 进入临界区，读取三个字段：
    • info->blk_size = mempool->blk_size - MEMPOOL_TAG_SIZE：用户可用大小 = 完整块大小 - 头部（对应 3.2 os_mpinfo_t 的 blk_size 语义）。
    • info->blk_total_num = 块总数。
    • info->blk_free_num = 空闲块数。
  • 离开临界区。

数值演算（blk_size = 72（有检测）、blk_total_num = 18、blk_free_num = 10）：

字段计算结果
info->blk_size72 - 468（用户可用）
info->blk_total_num1818
info->blk_free_num1010

4.8 辅助函数 _k_mempool_init / _k_mempool_init_free_list

初始化主流程调用了两个辅助函数，这里单独成节详解。

_k_mempool_init 完整源码（kernel/source/os_mem_pool.c，与项目逐字一致）：

来源：kernel/source/os_mem_pool.c

分步详解：

  • 复制名称（if (name != NULL) → 拷贝，否则置空）。
  • 设置 start_addr、size、blk_size；blk_total_num = size / blk_size；blk_free_num = blk_total_num（初始全空闲）。
  • _k_mempool_init_free_list(mempool)：串联所有空闲块成单向链表（见下）。
  • 初始化任务阻塞链表 task_list_head、SMP 自旋锁、标记 object_inited。

_k_mempool_init_free_list 完整源码（kernel/source/os_mem_pool.c，与项目逐字一致）：

来源：kernel/source/os_mem_pool.c

分步详解：

  • free_list = start_addr：链表头指向第一个块。
  • for 循环：从第一个块开始，每块的 next 指向 下一块（偏移 blk_size），遍历 blk_total_num - 1 次，把 blk_total_num 个块全部串联。
  • 最后一个块的 next = OS_NULL（链表结尾）。

数值演算（start_addr = 0x1000、blk_size = 64、blk_total_num = 4）：

块 0: 0x1000  ──►  块 1: 0x1040  ──►  块 2: 0x1080  ──►  块 3: 0x10C0  ──► NULL
      free_list 头指向块 0，每块 next = 前一块地址 + 64

4.9 任务阻塞与唤醒

当无空闲块时，分配任务会通过 k_block_task 阻塞在内存池的 task_list_head 上（见 4.5 第二步）。当有块被释放时，os_mempool_free 会通过 k_unblock_task 唤醒链表头的一个等待任务（见 4.6 第三步）。

关键点：

  • 阻塞：k_block_task(&lock, irq_save, &task_list_head, timeout, OS_TRUE) 把当前任务挂到 task_list_head，同时释放临界区（lock），让其他任务能操作内存池。
  • 唤醒：释放块后，从 task_list_head 取出第一个任务 k_unblock_task 唤醒。被唤醒的任务回到 os_mempool_alloc 的 while 循环，重新判断 free_list 是否非空。
  • 超时：若等待超时（k_block_task 返回非成功），分配返回 OS_NULL。

📝 本节小结

核心要点回顾

  • 内存池：预先分配一块内存，划分为固定大小的块，分配/释放时间为 O(1)、无外部碎片。
  • 适用场景：高频固定大小对象分配（网络包、传感器缓存、通信控制块等），且需要确定性分配时间。
  • 核心数据结构：os_mempool_t（控制块）+ blk_head 单向空闲链表（复用块数据区开头）。
  • 初始化（4.4）：对齐地址/大小 → _k_mempool_init_free_list 把所有空闲块串成链表。
  • 分配（4.5）：无空闲块时按 timeout 阻塞等待或返回 OS_NULL；有块则取链表头。
  • 释放（4.6）：块插回链表头，blk_free_num++，唤醒一个等待任务。
  • 溢出检测：OS_USING_MEMPOOL_CHECK_TAG 在块头加 4 字节魔数标记，越界写入会被检测。

关键易错点速查表

易错点说明对应章节
块大小固定只能分配固定大小，不能像堆那样按需伸缩1.1
内部碎片请求 40 字节、块 64 字节会浪费 24 字节1.3
中断中分配只能 OS_NO_WAIT，不能阻塞3.5
溢出检测影响块数开启后每块多占 4 字节头部，同大小池块数减少4.2
释放非法指针mem 必须来自同一内存池，否则断言崩溃4.6
重复释放已释放块再释放 → 魔数/状态校验失败4.6
blk_size 语义os_mempool_t.blk_size 是含头部，os_mpinfo_t.blk_size 是用户可用4.7
永久等待风险OS_WAIT_FOREVER 若无块释放会一直阻塞3.5

下一步

继续学习 4.4.5 内存追踪，了解如何追踪内存分配/释放来定位内存泄漏与使用异常。内存块的块布局、溢出检测标签、地址验证等细节已并入本章（4.3 块布局、4.1 溢出检测）。

OneOS-Lite 文档 | 学习阁
Copyright © 2026 学习阁