Linux内核，slub分配流程

server/2025/2/25 2:02:55/

在这里插入图片描述

我们根据上面的流程图，依次看下slub是如何分配的
首先从kmem_cache_cpu中分配，如果没有则从kmem_cache_cpu的partial链表分配，如果还没有则从kmem_cache_node中分配，如果kmem_cache_node中也没有，则需要向伙伴系统申请内存。
第一步先看看kmem_cache_cpu是如何实现

/** When changing the layout, make sure freelist and tid are still compatible* with this_cpu_cmpxchg_double() alignment requirements.*/
struct kmem_cache_cpu {union {struct {void **freelist;  /* Pointer to next available object */unsigned long tid; /* Globally unique transaction id */};freelist_aba_t freelist_tid; /* 将 freelist 和 tid 封装为原子操作单元 */};struct slab *slab;        /* 当前用于分配对象的Slab页 */
#ifdef CONFIG_SLUB_CPU_PARTIALstruct slab *partial;     /* 部分分配的冻结Slab链表（仅启用CPU Partial时存在） */
#endiflocal_lock_t lock;        /* 保护上述字段的本地CPU锁 */
#ifdef CONFIG_SLUB_STATSunsigned stat[NR_SLUB_STAT_ITEMS]; /* Slab分配统计信息 */
#endif
};

接下来，我们可以详细拆解一下这段代码：
联合体（Union）中的 freelist 和 tid

union {struct {void **freelist;      // 指向当前Slab中下一个可用对象的指针unsigned long tid;    // 全局唯一的事务ID（Transaction ID）};freelist_aba_t freelist_tid; // 将两者封装为一个原子操作单元
};

目的：

无锁快速路径：在SLUB分配器中，对象的分配和释放通常通过无锁操作（如this_cpu_cmpxchg_double()）实现，以规避传统锁的性能开销。

ABA问题防御：tid（事务ID）用于防止ABA问题。每次修改freelist时，tid会递增，确保即使freelist的值在并发操作中“看似未变”（如A→B→A），其tid也已变化，使得原子操作能检测到状态不一致。

联合体的作用：

freelist_tid（类型通常为u64或类似）将freelist和tid在内存中紧密打包，确保它们占据连续且对齐的内存空间，满足双字原子操作（如cmpxchg_double）的硬件对齐要求。

例如，在64位系统中，freelist（8字节）和tid（8字节）组合为一个16字节的单元，对齐到16字节边界，从而允许通过单条指令原子地比较和交换这两个字段。## 对齐要求：

this_cpu_cmpxchg_double()需要操作的两个字段必须满足：
a. 在内存中连续。
b. 对齐到双字（例如，16字节对齐）。
联合体强制freelist和tid共享同一内存区域，确保它们的布局符合上述条件。

slab指针

struct slab *slab; // 当前活跃的Slab页，用于快速分配对象

作用：指向当前CPU正在使用的Slab页，其中包含可分配的对象。
性能优化：通过本地化访问减少NUMA或缓存一致性开销。

partial 指针（条件编译）

#ifdef CONFIG_SLUB_CPU_PARTIAL
struct slab *partial; // 部分空闲的冻结Slab链表
#endif

功能：

当启用CONFIG_SLUB_CPU_PARTIAL时，每个CPU会缓存部分空闲的Slab（称为“冻结”状态），避免频繁向全局链表归还/申请Slab。
在内存压力或特定条件下（如flush_slab），这些Partial Slab会被转移到全局链表（NUMA节点的partial链表）。

local_lock_t lock

local_lock_t lock; // 本地CPU锁，保护kmem_cache_cpu结构中的字段

作用：

在慢速路径（如Slab切换、统计更新）中，防止同一CPU上的不同上下文（如进程与中断）竞争访问kmem_cache_cpu结构。
注意：快速路径（无锁分配/释放）不依赖此锁，仅在慢速路径中使用。

stat 统计数组（条件编译）

#ifdef CONFIG_SLUB_STATS
unsigned stat[NR_SLUB_STAT_ITEMS]; // 统计计数器（如分配次数、缓存命中率等）
#endif

功能：在内核启用CONFIG_SLUB_STATS时，记录Slab分配器的运行时性能指标，用于调优和监控。

现在我们来看看kmem_cache_cpu在慢速分配时候是如何工作（___slab_alloc）

/** Slow path. The lockless freelist is empty or we need to perform* debugging duties.** Processing is still very fast if new objects have been freed to the* regular freelist. In that case we simply take over the regular freelist* as the lockless freelist and zap the regular freelist.** If that is not working then we fall back to the partial lists. We take the* first element of the freelist as the object to allocate now and move the* rest of the freelist to the lockless freelist.** And if we were unable to get a new slab from the partial slab lists then* we need to allocate a new slab. This is the slowest path since it involves* a call to the page allocator and the setup of a new slab.** Version of __slab_alloc to use when we know that preemption is* already disabled (which is the case for bulk allocation).*/
static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,unsigned long addr, struct kmem_cache_cpu *c, unsigned int orig_size)
{void *freelist;struct slab *slab;unsigned long flags;struct partial_context pc;stat(s, ALLOC_SLOWPATH);reread_slab:slab = READ_ONCE(c->slab);if (!slab) {/** if the node is not online or has no normal memory, just* ignore the node constraint*/if (unlikely(node != NUMA_NO_NODE &&!node_isset(node, slab_nodes)))node = NUMA_NO_NODE;goto new_slab;}
redo:if (unlikely(!node_match(slab, node))) {/** same as above but node_match() being false already* implies node != NUMA_NO_NODE*/if (!node_isset(node, slab_nodes)) {node = NUMA_NO_NODE;} else {stat(s, ALLOC_NODE_MISMATCH);goto deactivate_slab;}}/** By rights, we should be searching for a slab page that was* PFMEMALLOC but right now, we are losing the pfmemalloc* information when the page leaves the per-cpu allocator*/if (unlikely(!pfmemalloc_match(slab, gfpflags)))goto deactivate_slab;/* must check again c->slab in case we got preempted and it changed */local_lock_irqsave(&s->cpu_slab->lock, flags);if (unlikely(slab != c->slab)) {local_unlock_irqrestore(&s->cpu_slab->lock, flags);goto reread_slab;}freelist = c->freelist;if (freelist)goto load_freelist;freelist = get_freelist(s, slab);if (!freelist) {c->slab = NULL;c->tid = next_tid(c->tid);local_unlock_irqrestore(&s->cpu_slab->lock, flags);stat(s, DEACTIVATE_BYPASS);goto new_slab;}stat(s, ALLOC_REFILL);load_freelist:lockdep_assert_held(this_cpu_ptr(&s->cpu_slab->lock));/** freelist is pointing to the list of objects to be used.* slab is pointing to the slab from which the objects are obtained.* That slab must be frozen for per cpu allocations to work.*/VM_BUG_ON(!c->slab->frozen);c->freelist = get_freepointer(s, freelist);c->tid = next_tid(c->tid);local_unlock_irqrestore(&s->cpu_slab->lock, flags);return freelist;deactivate_slab:local_lock_irqsave(&s->cpu_slab->lock, flags);if (slab != c->slab) {local_unlock_irqrestore(&s->cpu_slab->lock, flags);goto reread_slab;}freelist = c->freelist;c->slab = NULL;c->freelist = NULL;c->tid = next_tid(c->tid);local_unlock_irqrestore(&s->cpu_slab->lock, flags);deactivate_slab(s, slab, freelist);new_slab:if (slub_percpu_partial(c)) {local_lock_irqsave(&s->cpu_slab->lock, flags);if (unlikely(c->slab)) {local_unlock_irqrestore(&s->cpu_slab->lock, flags);goto reread_slab;}if (unlikely(!slub_percpu_partial(c))) {local_unlock_irqrestore(&s->cpu_slab->lock, flags);/* we were preempted and partial list got empty */goto new_objects;}slab = c->slab = slub_percpu_partial(c);slub_set_percpu_partial(c, slab);local_unlock_irqrestore(&s->cpu_slab->lock, flags);stat(s, CPU_PARTIAL_ALLOC);goto redo;}new_objects:pc.flags = gfpflags;pc.slab = &slab;pc.orig_size = orig_size;freelist = get_partial(s, node, &pc);if (freelist)goto check_new_slab;slub_put_cpu_ptr(s->cpu_slab);slab = new_slab(s, gfpflags, node);c = slub_get_cpu_ptr(s->cpu_slab);if (unlikely(!slab)) {slab_out_of_memory(s, gfpflags, node);return NULL;}stat(s, ALLOC_SLAB);if (kmem_cache_debug(s)) {freelist = alloc_single_from_new_slab(s, slab, orig_size);if (unlikely(!freelist))goto new_objects;if (s->flags & SLAB_STORE_USER)set_track(s, freelist, TRACK_ALLOC, addr);return freelist;}/** No other reference to the slab yet so we can* muck around with it freely without cmpxchg*/freelist = slab->freelist;slab->freelist = NULL;slab->inuse = slab->objects;slab->frozen = 1;inc_slabs_node(s, slab_nid(slab), slab->objects);check_new_slab:if (kmem_cache_debug(s)) {/** For debug caches here we had to go through* alloc_single_from_partial() so just store the tracking info* and return the object*/if (s->flags & SLAB_STORE_USER)set_track(s, freelist, TRACK_ALLOC, addr);return freelist;}if (unlikely(!pfmemalloc_match(slab, gfpflags))) {/** For !pfmemalloc_match() case we don't load freelist so that* we don't make further mismatched allocations easier.*/deactivate_slab(s, slab, get_freepointer(s, freelist));return freelist;}retry_load_slab:local_lock_irqsave(&s->cpu_slab->lock, flags);if (unlikely(c->slab)) {void *flush_freelist = c->freelist;struct slab *flush_slab = c->slab;c->slab = NULL;c->freelist = NULL;c->tid = next_tid(c->tid);local_unlock_irqrestore(&s->cpu_slab->lock, flags);deactivate_slab(s, flush_slab, flush_freelist);stat(s, CPUSLAB_FLUSH);goto retry_load_slab;}c->slab = slab;goto load_freelist;
}

`___slab_alloc 是 SLUB 分配器的慢速路径函数，当快速路径（无锁分配）失败时，负责处理复杂场景

___slab_alloc 是 Linux 内核 SLUB 分配器中处理慢速路径的核心函数，主要用于以下场景和逻辑：

核心作用

  1. 处理快速路径失败
    当 CPU 本地缓存（kmem_cache_cpu->freelist）无可用对象时，通过慢速路径获取新对象。
  2. NUMA 优化
    确保内存分配符合请求的 NUMA 节点，减少跨节点访问延迟。
  3. 调试与隔离
    支持调试功能（如内存跟踪、毒化）和隔离 PFMEMALLOC 内存（用于内存回收的专用页）。
  4. 并发同步
    通过锁和事务 ID（tid）确保多核环境下的数据一致性，避免 ABA 问题。

核心逻辑流程

  1. 初始化检查

    • 读取当前 CPU 的活跃 Slab（c->slab），若为空则跳转至新 Slab 分配（new_slab）。
    • 检查 NUMA 节点是否有效，若无效则忽略节点约束。

  2. NUMA 与 PFMEMALLOC 匹配

    • 若 Slab 的 NUMA 节点与请求不匹配，停用当前 Slab（deactivate_slab）。
    • 检查 Slab 的 PFMEMALLOC 标志是否与分配标志（gfpflags）匹配，不匹配则停用。

  3. 加锁与状态重验

    • 获取本地锁（local_lock_irqsave），防止同一 CPU 上的进程与中断竞争。
    • 二次验证 Slab 是否被其他上下文修改，若已修改则重新读取（reread_slab）。

  4. 获取空闲链表（Freelist）

    • 若本地 freelist 存在可用对象，直接分配。
    • 若本地 freelist 为空，尝试从 Slab 页获取新 freelist（get_freelist）。
    • 若获取失败，标记 Slab 失效（c->slab = NULL），触发新 Slab 分配。

  5. 分配新对象

    • 从 CPU 的 Partial 链表获取：若启用 CONFIG_SLUB_CPU_PARTIAL，优先重用部分空闲 Slab。
    • 从节点的 Partial 链表获取：通过 get_partial 批量获取部分空闲对象。
    • 分配全新 Slab：调用伙伴系统（new_slab）分配新页，初始化并冻结 Slab。

  6. 更新状态

    • 递增事务 ID（c->tid），确保后续快速路径能检测到状态变化。
    • 若启用调试，记录内存分配跟踪信息（set_track）。

  7. 异常处理

    • 若内存不足（slab_out_of_memory），触发 OOM 处理。
    • 若并发冲突（如锁内发现 Slab 被修改），回滚并重试。

关键设计

  1. 锁与无锁混合

    • 快速路径无锁：通过原子操作（this_cpu_cmpxchg_double）实现高效分配。
    • 慢速路径加锁：使用本地锁保护 kmem_cache_cpu 结构，避免并发修改。

  2. 事务 ID（tid）防 ABA

    • 每次修改 freelist 后递增 tid，确保并发操作能检测到状态变化。

  3. Partial 链表优化

    • 缓存部分空闲 Slab，减少全局锁争用和内存碎片化。

  4. NUMA 感知

    • 优先从请求的 NUMA 节点分配，降低跨节点访问开销。

性能影响

  • 快速恢复：通过重用 Partial 链表，减少全新 Slab 分配频率。
  • 最小化锁范围：仅对关键操作加锁，缩短锁持有时间。
  • 统计与调试：通过 stat() 记录性能事件，支持调优和问题排查。

总结

___slab_alloc 是 SLUB 分配器在复杂场景下（如本地缓存耗尽、NUMA 约束、调试需求）实现内存分配的核心逻辑。其通过精细的状态管理、锁优化和资源重用，平衡了性能与可靠性，确保多核系统中内存分配的高效性和正确性。

（参考链接：https://zhuanlan.zhihu.com/p/382056680#/）


http://www.ppmy.cn/server/170451.html

相关文章

【电路笔记】-简单的LED闪烁器

【电路笔记】-简单的LED闪烁器

简单的LED闪烁器 文章目录 简单的LED闪烁器1、概述2、简单的LED闪烁器3、纹波计数器输出4、纹波计数器晶体管驱动器5、总结一个简单的 LED 闪光灯电路，使用纹波计数器顺序点亮 LED 或灯。 1、概述 电子学生或爱好者总是喜欢为他们的家庭或学校制作各种电路，尤其是那些闪烁一…
阅读更多...
问题：Flask应用中的用户会话(Session)管理失效

问题：Flask应用中的用户会话(Session)管理失效

我来分享一个常见的PythonWeb开发问题： 问题：Flask应用中的用户会话(Session)管理失效 这是一个在Flask开发中经常遇到的问题。当用户登录后，有时会话会意外失效，导致用户需要重复登录。 解决方案： 1. 首先&#x…
阅读更多...
PyTorch 深度学习框架中 torch.cuda.empty_cache() 的妙用与注意事项

PyTorch 深度学习框架中 torch.cuda.empty_cache() 的妙用与注意事项

🍉 CSDN 叶庭云：https://yetingyun.blog.csdn.net/ 在使用 PyTorch 进行深度学习模型训练与调优过程中，torch.cuda.empty_cache() 方法作为一种高效工具被广泛采用；但其正确应用要求充分理解该方法的功能及最佳实践。下文将对该方…
阅读更多...
机器视觉视觉halcon3d中位姿的定义

机器视觉视觉halcon3d中位姿的定义

在Halcon中，3D位姿（pose）用于描述物体在三维空间中的位置和方向。其定义结合了平移（translation）和旋转（rotation）参数，具体如下： 位姿的组成 Halcon的3D位姿通常由 6个参数 表示，形式为：[Tx, Ty, Tz, Rx, Ry, Rz] 平移分量：Tx, Ty, Tz 表示物体在X、Y、Z轴上的平移…
阅读更多...
rkipc main.c 中 rk_param_init函数分析

rkipc main.c 中 rk_param_init函数分析

rk_param_init函数 这个函数是用来读取配置文件进行参数配置 这个函数在 luckfox-pico/project/app/rk_smart_door/smart_door/common/uvc/param/param.c 中 这个函数在main函数中被调用 //通过-c 配置文件路径 把配置文件传进来 case c:rkipc_ini_path_ optarg;//调用&am…
阅读更多...
Qt的QToolButton的使用

Qt的QToolButton的使用

在C中使用QToolButton的详细步骤如下&#xff1a; 1. 包含头文件 #include <QToolButton> #include <QAction> #include <QMenu>2. 创建QToolButton实例 QToolButton *toolButton new QToolButton(parentWidget); // parentWidget为父部件指针3. 基础属性…
阅读更多...
STM32——HAL库开发笔记21（定时器2—输出比较）（参考来源：b站铁头山羊）

STM32——HAL库开发笔记21（定时器2—输出比较）（参考来源：b站铁头山羊）

本文主要讲述输出比较及PWM信号相关知识。 一、概念 所谓输出比较&#xff0c;就是通过单片机的定时器向外输出精确定时的方波信号。 1.1 PWM信号 PWM信号即脉冲宽度调制信号。PWM信号的占空比 &#xff08;高电压 所占周期 / 整个周期&#xff09; * 100% 。所以PWM信号…
阅读更多...
uni-app 系统学习，从入门到实战（一）—— 从零开始搭建第一个跨平台应用

uni-app 系统学习，从入门到实战（一）—— 从零开始搭建第一个跨平台应用

全篇大概 1500 字&#xff0c;建议阅读时间 5min 简介 UniApp 是一个基于 Vue.js 的跨平台开发框架&#xff0c;开发者可以通过编写一套代码&#xff0c;同时发布到 iOS、Android、H5、微信小程序、支付宝小程序、百度小程序等多个平台。本文将带你从零开始&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023