第 7 章 进程调度器
《深入理解 Linux 进程与内存》第七章,书页 196–245,PDF 第 224–273 页。原书第七章
公平调度和负载均衡以书中的 Linux 5.4 为例,唤醒选核以 Linux 6.2 为例。Linux 从 6.6 开始向 EEVDF 过渡,查较新内核时,公平类挑选任务的细节要按对应版本阅读。Linux 内核文档:CFS · Linux 内核文档:EEVDF
1. 先看懂一次调度 · 2. 调度演变 · 3. 队列与 CFS · 4. 选核与入队 · 5. 重调度与切换 · 6. 切换开销 · 7. 调度命令 · 8. 动手实验 · 9. 本章总结 · 10. 原书索引
3.2 nice · 3.4 红黑树 · 4.2 wake_affine · 5.1 调度节拍 · 5.4 负载均衡 · 5.5 ksoftirqd · 9.4 在线与离线任务混部
1. 先看懂一次调度
打开浏览器时,后台下载、界面绘制和其他程序都可能同时想用 CPU。操作系统能单独安排执行的是线程。一个进程可以有多个线程,共享该进程的地址空间,各自有执行到哪一步的记录。下文用「任务」指 Linux 能独立调度的执行单位。一个逻辑 CPU 是内核看到的一个执行位置,同一时刻执行一个任务。开启 SMT 时,一个物理核心可能提供多个逻辑 CPU,它们共享部分硬件资源。
- 运行中:A 正在 CPU 0 上做计算。
- 就绪:C 已经有工作可做,正在等 CPU。每个逻辑 CPU 都有自己的运行队列,保存它的可运行任务和调度状态。
- 阻塞:B 在等网络数据。数据到达前,即使有空闲 CPU,B 也无法继续。系统调用里等待输入输出(I/O)就是常见的阻塞原因。
图 7.32,235 页。沿着「运行 → 阻塞 → 就绪 → 运行」看一次等待数据和恢复执行的过程。
现在数据到了。内核唤醒 B,让它从阻塞变成可运行,然后给它选一个 CPU。如果 B 也进了 CPU 0 的队列,内核可能请求抢占,也就是让仍然能运行的 A 暂时停下。真正选中 B 时,内核保存 A 的状态、恢复 B 的状态,B 从等待网络数据的地方继续执行。保存和恢复状态的过程叫上下文切换。A 仍可运行,可以等待下一次被选中。
B 等网络数据 → 数据到达,B 可运行 → 选择 CPU 并入队
→ 到了可以重新选任务的时机 → 若选中 B,保存 A 的状态并恢复 B
后面会反复遇到两个问题。选核决定 B 进哪个 CPU 的队列。选任务决定这个 CPU 下一步运行谁。
2. 调度器的演变
如果一个长计算先到、一个按键处理任务后到,先来先服务会让按键一直等。给任务分时间片,即本轮允许连续运行的一段 CPU 时间,就能让长任务跑一会儿先让出 CPU。短作业优先可以减少短任务的等待,但要先估算任务会运行多久。优先级和轮转回答的是「谁先拿到 CPU,拿到后多久让出」。下面的 n 指候选任务数,O(1) 表示这个选取步骤的开销基本不随 n 增大。
| Linux 调度器 | 怎样选任务 | 改进与局限 |
|---|---|---|
| Linux 2.4 的 O(n) | 扫描共享运行队列,比较任务的调度得分。 | 可运行任务越多,扫描越久。多个 CPU 还要竞争同一把队列锁。 |
| Linux 2.5 开发期的 O(1) | 每 CPU 维护独立队列。位图找到最高优先级的非空链表,再取队首。 | 选任务的开销不随任务数增长,但普通任务仍可能等很长一轮。 |
| Linux 2.6.23 引入的 CFS | 普通任务按 vruntime 排序,较小的实体优先成为候选。 | 按权重分配 CPU 时间,运行份额随同队列的竞争者变化。 |
O(n) 每次选任务都要遍历候选者。多个逻辑 CPU 操作同一个队列时,还得争用保护队列的锁,也就是一次只准一个 CPU 修改共享状态的机制。O(1) 让每个 CPU 各自排队,再用位图快速查出哪条高优先级队列有任务。位图可以想成一排开关,每一位记录该优先级有没有任务。O(1) 调度器设计文档
沿图中的普通任务路径看,active 保存本轮还能跑的任务,expired 保存用完时间片、要等下一轮的任务。active 空了就交换两组队列。书中 Linux 2.5.68 的时间片示例约为 10–200 ms。假设前面有 10 个任务各跑完 10 ms,这一轮仍要约 100 ms 才能走完。CFS 改为随竞争者和权重计算运行份额,用累计的虚拟运行时间作为主要排序依据。
图 7.12,202 页。任务用完时间片后从 active 转入 expired。
3. 运行队列与选任务的规则
3.1 每个逻辑 CPU 有一个 rq
struct rq 保存一个逻辑 CPU 的调度状态。rq->curr 指向当前正在运行的任务,cfs_rq 保存公平调度相关状态,rt_rq 保存实时调度相关状态。CPU 0 改动自己的队列时,CPU 1 通常可以同时改动它自己的队列。书中双路服务器共有 16 个物理核,每核提供两个逻辑 CPU,所以内核为它建立 32 个 rq。
图 7.17,207 页。每个逻辑 CPU 对应一个 struct rq。
调度策略规定任务按什么规则运行。内核把使用同一套操作的策略归入一个调度类。任务的 sched_class 指向这套操作,调度器通过它知道应调用哪个入队、出队和选任务函数。同一个 CPU 上,符合运行条件的实时任务优先于普通公平类任务。这里的「实时」指 SCHED_FIFO、SCHED_RR 这一类策略,普通任务内部的权重另有一套规则。
| 策略 | 在本类中怎样运行 |
|---|---|
SCHED_FIFO | 实时优先级高的任务先运行。同级按队列顺序执行,当前任务可以继续运行,直到阻塞、让出 CPU 或被更高优先级任务抢占。 |
SCHED_RR | 同样按实时优先级选任务,同级任务用完时间片后回到该优先级队尾。 |
SCHED_OTHER | 普通任务使用公平调度类,书中的 CFS 根据权重分配 CPU 时间。 |
实时队列通过位图找到最高优先级的非空链表。图 7.19 的 0–99 是内核数组下标,靠前的下标优先。chrt 使用的用户态实时优先级范围是 1–99,数值越大越优先。
图 7.19,208 页。实时队列 rt_rq 按优先级组织任务链表。
3.2 nice 值怎样改变 CPU 份额
CFS 是 Completely Fair Scheduler,即完全公平调度器。假设两条普通线程都在不停地计算,并且只能用同一个 CPU。两条线程权重相同时,长期看各分到约一半的 CPU 时间。若希望其中一条多分一些,就可以通过 nice 值改变它的权重。普通任务的 nice 范围是 -20 到 19,常用基准是 0。数值越大,任务越愿意把 CPU 时间让给其他任务。只有一个普通任务可运行时,它可以继续使用空余的 CPU 时间,即使 nice 很大。
Linux 先把 nice 映射成内部静态优先级,再查 sched_prio_to_weight。下面两行是 Linux 5.4 权重表的原文。每一行有五个权重,第一行对应 nice -5 到 -1,第二行对应 0 到 4。Linux 5.4 权重表
/* -5 */ 3121, 2501, 1991, 1586, 1277,
/* 0 */ 1024, 820, 655, 526, 423,
让 A 的 nice 为 0(权重 1024),让 C 的 nice 为 -5(权重 3121)。如果 A、C 在同一个 CPU、同一个公平队列里持续竞争,A 的理想份额约为 1024 ÷ (1024 + 3121) = 24.7%,C 约为 75.3%。这两个数是长期分配比例。此刻谁先运行,还要看队列里的运行记账和是否有抢占机会。若 A 和 C 在两个各自空闲的 CPU 上,两者都可能跑满自己的 CPU。
实验一用同权重、同核不同权重、分开两核三组对照,把「权重」和「有没有竞争」各自的作用测出来。
3.3 vruntime 是怎样记账的
普通任务先后进入队列,调度器怎样判断谁已经用够了?CFS 为每个调度实体维护 vruntime,即虚拟运行时间。实际花掉的 CPU 时间先按权重折算,再记到这笔账里。update_curr 先计算当前实体自上次记账以来跑了多久,随后用 calc_delta_fair 计算增量。Linux 5.4 的 calc_delta_fair · Linux 5.4 的 update_curr
本次实际运行增量 = 当前记账时刻 − exec_start
vruntime 增量 ≈ 本次实际运行增量 × nice 0 的基准权重 / 任务权重
curr->vruntime += calc_delta_fair(delta_exec, curr);
A 和 C 各跑 3 ms,A 的 vruntime 约增加 3 ms,C 约增加 0.98 ms。如果二者起点相同,C 此时的账更小,可以多拿到一些实际 CPU 时间,才追上 A 的账。这个例子解释了为什么 C 权重更大,也解释了为什么直接比较两者已经运行的实际时间会丢掉 nice 带来的差别。
3.4 CFS 为什么用红黑树
假设有三个等待运行的实体,vruntime 分别为 4、7、9。调度器想先看 4。此时一个 vruntime 为 6 的任务醒来,要把它放到 4 和 7 之间。拿走 4 之后,新的最小值是 6。实际运行中,唤醒、阻塞和迁移都会反复改变这组候选,所以队列既要快取最小值,也要快插入和删除任意一个已知节点。
| 数据结构 | 找最小值 | 插入与删除的代价 |
|---|---|---|
| 无序链表 | 扫描全部 n 个实体。 | 已知节点时可以快速插入和摘除。 |
| 有序链表 | 直接取表头。 | 插入要沿链表找位置,最坏看完 n 个实体。 |
| 缓存最左节点的红黑树 | 直接读取已缓存的最左节点。 | 插入和删除已知节点最坏为 O(log n),实体越多,增长越慢。 |
红黑树是一种能限制高度的二叉搜索树。搜索时,较小的键往左找,较大的键往右找。插入和删除后,树通过调整节点颜色和局部旋转,把树的高度限制在 O(log n),避免连续插入升序数据时一路长成链。CFS 把实体里的 run_node 直接挂在这棵树上,rb_root_cached 还额外记住最左节点,因此取候选时连从根一路向左的步骤也省了。Linux 5.4 红黑树文档 · Linux 5.4 的 __enqueue_entity
下面两行取自 __enqueue_entity。进入这两行时,前面的循环已经按 vruntime 找到了空位置 link。rb_link_node 先把实体挂到那里,rb_insert_color_cached 再恢复红黑树约束,并按 leftmost 维护最左节点缓存。
rb_link_node(&se->run_node, parent, link);
rb_insert_color_cached(&se->run_node,
&cfs_rq->tasks_timeline, leftmost);
sched_entity 就是树里参与比较的调度实体,可以代表一个线程,启用组调度时也可以代表一组任务。当前正在运行的实体由 cfs_rq->curr 单独记录,它的 vruntime 会随执行增加。图里的最左节点是等待运行的主要候选,实际选任务还会考虑当前实体等条件。Linux 5.4 的 pick_next_entity
图 7.20,210 页。从 rq 找到 cfs_rq,再沿 tasks_timeline 看右侧的树。图里画的是树的骨架,Linux 5.4 源码用 rb_root_cached 一并保存最左节点。
| 读源码时会碰到的字段 | 用途 |
|---|---|
load.weight | 计算 CPU 时间份额和 vruntime 增量。 |
exec_start、sum_exec_runtime | 记录最近一次记账的起点和累计实际运行时间。 |
vruntime、run_node | 保存虚拟运行时间及其对应的红黑树节点。 |
cfs_rq->min_vruntime | 队列单调推进的虚拟时间基准,供新任务放置和跨队列换算使用。 |
4. 任务怎样进入运行队列
等待 I/O 的 B 会退出可运行状态。数据到达后,B 重新具备运行条件,可以加入某个 CPU 的队列。新创建的任务也要经历选核和入队,区别在于它的调度状态刚刚初始化。原书 7.3 节,211–221 页
4.1 先选 CPU,再入队
假设机器有 4 个逻辑 CPU,而 B 的CPU 亲和性掩码只允许它使用 CPU 0 和 1。选核时就只能在这两个编号里找。亲和性可以用 taskset 查看。确定候选范围后,select_task_rq 把具体选择交给任务所属的调度类,公平类使用 select_task_rq_fair。新建任务与被唤醒的任务会带不同的标志进入这个函数。Linux 6.2 的 select_task_rq_fair
| 入口 | 入队前的处理 |
|---|---|
| 新任务 | copy_process 调用 sched_fork 初始化调度状态。随后 wake_up_new_task 选核、设置 CPU 归属,再在目标 rq 的锁保护下激活任务。 |
| 唤醒任务 | try_to_wake_up 检查任务状态。对于需要重新入队的任务,选核并在需要时更新归属,再经 ttwu_queue 等路径激活。 |
普通任务最终经 enqueue_task_fair 进入公平队列。
activate_task → enqueue_task → enqueue_task_fair
→ enqueue_entity → __enqueue_entity
图 7.23,218 页。从左到右追踪一次入队。先选 CPU,再找到它的公平队列。图中箭头只举了一个插入位置,实际位置按 vruntime 比较得出。
4.2 wake_affine 怎样给刚醒来的任务选核
CPU 缓存保存近期用过的指令和数据。B 刚在 CPU 0 上运行过,回到 CPU 0 有机会用到原来留在缓存里的数据,这叫缓存局部性。假设 CPU 1 上的线程 D 写完数据并唤醒 B,B 也可能在 CPU 1 上接着处理 D 刚生产的数据。可如果 CPU 1 仍有很多任务,B 过去就得排队。唤醒选核要兼顾缓存复用和排队时间。
在 Linux 6.2 的公平类唤醒路径里,满足条件时会调用 wake_affine。它先比较 执行唤醒的 CPU(this_cpu)和 B 上次所在的 CPU(prev_cpu)。例如唤醒者所在 CPU 必须在 B 的允许掩码内,并且两个 CPU 要落在一个支持 SD_WAKE_AFFINE 的调度域里。调度域可以先理解为内核按硬件拓扑划出的一组 CPU,后面做负载均衡也会用到它。Linux 6.2 的 select_task_rq_fair
wake_affine_idle先看即时空闲情况。例如两个 CPU 共享缓存且都空闲时,保留prev_cpu。若只有唤醒方 CPU 空闲且共享缓存,可以用唤醒方 CPU。同步唤醒标志WF_SYNC还提示唤醒者可能很快让出 CPU,代码会结合它的运行队列检查。- 如果空闲条件没有给出结论,并且启用了相应特性,
wake_affine_weight会估算两个 CPU 的有效负载,并考虑它们的计算能力。两种判断都没有选出新位置时,函数返回prev_cpu。 - 这个结果是候选 CPU。唤醒快路径后面还会用
select_idle_sibling检查附近可用的空闲 CPU,实际入队的位置仍有可能改变。Linux 6.2 的wake_affine
下面是 wake_affine_idle 中处理「唤醒方 CPU 空闲且共享缓存」的原文。?: 是 C 的条件表达式,冒号前是条件成立时的返回值,冒号后是另一种结果。Linux 6.2 的 wake_affine_idle
if (available_idle_cpu(this_cpu) && cpus_share_cache(this_cpu, prev_cpu))
return available_idle_cpu(prev_cpu) ? prev_cpu : this_cpu;
taskset 设置的是 B 能去哪里,wake_affine 帮内核在允许范围内挑候选位置。若 B 只允许在 CPU 0 运行,即使 CPU 1 唤醒它,B 也得回 CPU 0。
4.3 入队时放到什么位置
min_vruntime 是公平队列不断向前推进的虚拟时间基准。假设 CPU 0 的队列已经推进到虚拟时间 100 ms。如果每个新建线程都以 0 ms 直接入树,老线程要等它追上这 100 ms,才能再和它公平竞争。Linux 5.4 的 place_entity 因此以队列基准为起点,新任务还可能加上一个初始虚拟份额。
B 阻塞时没有获得 CPU 时间,原来的账可能是 60 ms。若唤醒时队列基准已到 100 ms,并且按当时配置可以落后 12 ms,入队时会把 B 的账抬到至少 88 ms。这样给刚醒来的任务留一点响应优势,也限制了长时间睡眠积累的优势。数字只用来说明 max(旧值, 基准 − 允许落后量) 怎样取值。Linux 5.4 的 place_entity
5. 什么时候重调度,怎样切换任务
5.1 调度节拍是什么
假设 A 在用户态运行一个死循环,一直计算,也一直没有发起系统调用。内核仍然需要知道 A 已经跑了多久。启用周期节拍时,定时器到点会发出中断,CPU 暂停执行 A 的指令,转去执行内核的中断处理代码。这个时间事件给了调度器一次检查的机会,这就是调度节拍。在周期模式下,CONFIG_HZ=1000 表示标称间隔约 1 ms。配置了 NO_HZ 的系统可在 CPU 空闲等条件下停掉周期节拍。Linux 5.4 的计时入口 · Linux 5.4 的 NO_HZ 文档
scheduler_tick() 找到当前 CPU 的 rq 和正在运行的 curr。下面三行取自 Linux 5.4。第一行更新队列时钟,第二行调用当前任务所属调度类的节拍函数,第三行更新系统负载统计。公平类的回调 task_tick_fair 会走到 entity_tick,更新当前调度实体的执行时间,在有其他实体竞争时检查是否该重调度。没有换任务的需要时,中断处理完成后 A 可以继续执行。Linux 5.4 的 scheduler_tick · Linux 5.4 的 entity_tick
update_rq_clock(rq);
curr->sched_class->task_tick(rq, curr, 0);
calc_global_load_tick(rq);
换任务还有两个常见入口。A 在系统调用中等待磁盘时,可以主动进入 schedule(),让另一个就绪任务先跑。B 被唤醒时,唤醒路径也可以立刻检查它是否值得抢占,无须等下一次节拍。普通公平类的唤醒抢占会比较当前实体与新唤醒实体的虚拟运行时间差,还会考虑唤醒粒度,免得两者只差一点就频繁切换。Linux 5.4 的 check_preempt_wakeup
grep '^CONFIG_HZ=' "/boot/config-$(uname -r)"
这条命令查的是正在运行的内核的编译配置。部分发行版或容器没有这个文件。
5.2 CFS 怎样判断当前任务跑得够不够久
经典 CFS 先估算让一组可运行任务各跑一次需要的时间,这个估算窗口叫调度周期。再按队列中各实体的权重,把这段时间分给它们。书中示例的 sched_latency 为 24 ms,sched_min_granularity 为 3 ms。若只有 2 个等权重任务,理想份额约为每个 12 ms。若有 10 个等权重任务,按 24 ms 硬分会只剩 2.4 ms 一次,切换也会变密。因此超过实体数量阈值后,周期估算拉长到 10 × 3 ms = 30 ms,每个任务的理想份额约为 3 ms。Linux 5.4 的 __sched_period 和 sched_slice
可运行实体较少时:period ≈ sched_latency
超过阈值时: period ≈ nr_running × sched_min_granularity
单层公平队列中: ideal_runtime ≈ period × 本实体权重 / 队列总权重
节拍和调度周期是两件事。以 1 ms 的节拍和 12 ms 的理想份额为例,每隔约 1 ms 可以检查一次。A 到第 3 ms 时可能继续跑,超过 12 ms 后的检查则可能要求重新选任务。中途若 B 醒来、A 阻塞或队列变长,结果也会变。
Linux 5.4 的 check_preempt_tick 可以按下面的伪代码读。sched_min_granularity 是第二项检查的门槛,第一项可能更早触发。实际运行时长还受唤醒抢占等路径影响。Linux 5.4 的 check_preempt_tick
本轮已运行时间 = 累计实际运行时间 − 上次被选中时的累计值
如果 本轮已运行时间 > 理想份额:请求重调度,结束本次检查
如果 本轮已运行时间 < 最小调度粒度:结束本次检查
如果 当前实体的 vruntime − 最左候选的 vruntime > 理想份额:请求重调度
5.3 从重调度请求到上下文切换
resched_curr 可以给当前任务设置 TIF_NEED_RESCHED,意思是「到安全的时机重新选一次任务」。例如 A 被时钟中断打断,处理完中断、准备回用户态时,内核可以检查这个标记。__schedule 才会调用 pick_next_task,从当前 CPU 的队列选任务。公平类通常从红黑树最左侧找候选,再结合当前实体等规则。如果选中的仍是 A,就接着执行 A。Linux 5.4 的 resched_curr · Linux 5.4 的 __schedule
图 7.29,233 页。公平调度类从当前 CPU 的红黑树找最左候选。
如果选中 B,context_switch 会把执行状态从 A 交给 B。寄存器保存正在计算的值和执行位置,内核栈保存各线程进入内核后尚未完成的调用状态。switch_to 切换这些与执行相关的状态。若 A、B 使用不同的用户地址空间,还要让 CPU 用 B 的地址映射来访问内存,相关路径是 switch_mm_irqs_off。同一进程的线程通常共享地址空间,但各自的执行状态仍要切换。A 如果还可运行,就继续等待下一次调度。Linux 5.4 的 context_switch
5.4 为什么还需要负载均衡
假设 A 正在 CPU 0 上计算,B 和 C 也在 CPU 0 的队列里等,CPU 1 此时空闲。B、C 本来都允许使用 CPU 1,可是 CPU 1 的调度器只从自己的队列选任务。即使 CPU 0 把时间分得很公平,CPU 1 还是没有工作,B 和 C 仍在排队。负载均衡解决的是 CPU 之间分工不均的问题。例如把 C 从 CPU 0 移到 CPU 1,A 与 C 就能并行执行,B 也少等一项工作。
内核通常会选择有余力的 CPU 去找较忙的队列,拉取符合条件的任务。参与比较的不只是队列里有几个任务,还包括任务负载、CPU 容量、当前忙闲状态。迁移会有成本。C 原本使用的数据可能留在 CPU 0 所在核心的缓存里,换地方后可能要重新取数据。迁移跨越不同的 NUMA 节点(各自有本地内存的处理器组)时,C 的数据还可能留在原来的节点,需要跨节点访问。Linux 5.4 的 load_balance
图 7.25 给了三种距离。CPU 0 和 4 属于同一个物理核。0 和 1 分属不同的核,但共享末级缓存。0 和 2 跨 NUMA 节点。这样的拓扑为均衡时先看哪里、再往哪里找提供了依据,具体的 CPU 编号随机器变化。
图 7.25,227 页。同核、跨核和跨 NUMA 节点的迁移代价不同。
内核用 sched_domain 表示一层拓扑范围,例如同一个末级缓存覆盖的 CPU。每个域用 sched_group 表示比较时的一组 CPU,例如先比较两个组谁更忙,再到忙的组里找源队列。周期检查会按各域自己的间隔进行,沿较近的域向外尝试。调度节拍是周期均衡的入口之一,CPU 准备进入空闲时也有尝试拉取任务的路径。Linux 5.4 调度域文档 · Linux 5.4 的 rebalance_domains
图 7.27,230 页。负载均衡可以逐步扩大检查范围。
load_balance 找到较忙的调度组和源队列后,detach_tasks 从源队列摘下可迁移的任务,attach_tasks 再把它们加到目标队列。can_migrate_task 要检查目标 CPU 是否在任务的允许列表内,也会考虑任务正在运行或缓存仍可能很热等情况。若 C 只允许使用 CPU 0,普通均衡就不能把它移到 CPU 1。Linux 5.4 的 can_migrate_task
图 7.28,231 页。把可迁移任务从较忙的队列移到有余力的队列。
5.5 什么是软中断,ksoftirqd 又是什么
硬件中断让 CPU 先停一下手头的指令,去处理来自定时器或设备的事件。中断处理程序通常先做需要立刻完成的部分,其余工作可以用软中断延后处理。软中断由内核标记为待处理,等合适时机再调用对应处理函数。例如网卡收到数据后,部分收包工作可以交给 NET_RX_SOFTIRQ,调度器的周期负载均衡则用 SCHED_SOFTIRQ。Linux 5.4 的软中断类型 · Linux 5.4 的 irq_exit
以调度节拍为例,scheduler_tick 处理完本 CPU 的记账和检查后,会调用 trigger_load_balance。到达下次均衡检查时间才标记 SCHED_SOFTIRQ。下面两行是 Linux 5.4 原文。jiffies 是内核计时所用的计数,next_balance 是该队列下次检查的时间。真正找源队列、比较负载、尝试迁移的入口是 run_rebalance_domains,它是注册给这个软中断的处理函数。Linux 5.4 的 trigger_load_balance · Linux 5.4 的 run_rebalance_domains
if (time_after_eq(jiffies, rq->next_balance))
raise_softirq(SCHED_SOFTIRQ);
如果当前 CPU 即将退出硬件中断,内核可以顺手处理这批软中断。若还有积压,继续处理会拖太久,或者调度器已经要求让出 CPU,内核可以唤醒 ksoftirqd/N 来接手。ksoftirqd/N 是逻辑 CPU N 的软中断内核线程,比如 ksoftirqd/0 处理 CPU 0 上待办的软中断。它会像其他线程一样等待调度,运行后再检查本 CPU 的待处理项。同一个 SCHED_SOFTIRQ 处理函数可以在中断退出路径被调用,也可以由 ksoftirqd/N 执行。这个内核线程还处理网络等其他类型的软中断。Linux 5.4 的软中断处理与积压唤醒 · Linux 5.4 的 run_ksoftirqd
下面三行取自 run_ksoftirqd 确认有待处理工作后的分支。__do_softirq() 处理本 CPU 挂起的软中断。处理后重新开放本地硬件中断,cond_resched() 给当前内核线程一个在需要时让出 CPU 的机会。
__do_softirq();
local_irq_enable();
cond_resched();
可以把这条路径连起来看。先由节拍发起,再由软中断处理函数执行。在普通周期均衡路径上,处理函数会进入 rebalance_domains。如果它找到可迁移任务,才会改变 CPU 之间的队列分布。
定时器到点 → scheduler_tick → 到期时挂起 SCHED_SOFTIRQ
→ 退出中断时处理,或交给 ksoftirqd/N
→ run_rebalance_domains → 检查调度域,需要时迁移任务
在 top 中看到 ksoftirqd/0 占用 CPU,说明 CPU 0 有软中断处理工作。可以在 Linux 上间隔一段时间运行两次下面的命令,比较 CPU0 列里的 NET_RX 和 SCHED 增量。计数包含该 CPU 不同执行路径处理的软中断,表示处理次数,无法直接推算 ksoftirqd 在某一类软中断上用了多久。
grep -E 'CPU0|NET_RX:|SCHED:' /proc/softirqs
6. 切换开销怎么测
切换的直接开销包括调度、保存和恢复执行状态,以及需要时切换地址空间。B 开始运行后,还可能发现 CPU 缓存里主要是 A 的数据。B 要等自己的数据重新被读进来,这是间接开销。TLB 是 CPU 用来加速从虚拟地址找到物理地址的缓存,切换之后也可能少一些可复用的条目。两个线程共享地址空间,可以省去一部分工作,但缓存命中情况还取决于各自访问的数据及所在 CPU。
原书用两个任务传递令牌测切换开销。A 写入一条管道后等待回信,B 读到令牌再向另一条管道回信,每一轮包含 A 到 B、B 回 A 两次交接。另做一次基线测量,再用总时间差除以交接次数。表里的工作集是测试中任务反复访问的数据范围,范围越大,切换后需要重新读入缓存的数据可能越多。
| 原书实验 | 测量方法 | 书中结果 |
|---|---|---|
| 两个进程传递令牌 | 两条管道往返 10,000 轮,每轮按两次切换估算。 | 约 3.4 µs/次 |
lmbench 进程切换 | 对比 2、8、16 个进程和不同工作集大小。 | 约 2.70–5.48 µs/次 |
| 线程间传递令牌 | 20 个线程用管道传递信号,扣除单独测得的传递开销。 | 约 3.86 µs/次,书中记为约 3.8 µs |
两进程实验用 (842852 − 774767) ÷ (10000 × 2) 算出约 3.4 µs。这个估算包含管道系统调用、阻塞和唤醒。对比进程与线程时,还要对齐工作集、亲和性和测量方法,三组数值对应的是各自的实验条件。
实验二保留书中的两条管道和 10,000 轮往返,加上一组同进程管道对照,分别记录父进程自愿和非自愿切换的次数。
7. 用命令查看调度状态
下面的命令在 Linux 终端运行。PID 是进程编号,TID 是线程编号。多线程进程里,各线程可以有各自的调度设置,查看时可用 ps -L 展开。将 $pid 替换为要查看的进程编号,或先运行下面的 sleep 120 & 和 pid=$!。$! 是 shell 记录的最近一个后台任务的 PID。
| 想确认什么 | 命令 | 看什么 |
|---|---|---|
| 任务属于哪种调度策略 | chrt -p "$pid" | SCHED_OTHER、SCHED_FIFO、SCHED_RR 等策略及实时优先级。 |
| 普通任务竞争时的相对权重 | ps -p "$pid" -o pid,ni,comm | NI 是 nice 值。书中的 NICE_TO_PRIO 将其换成内部静态优先级,再查 sched_prio_to_weight。 |
| 任务允许在哪些 CPU 上运行 | taskset -pc "$pid" | 允许的逻辑 CPU 列表。 |
| 每个线程最近在哪个 CPU 上运行 | ps -L -p "$pid" -o tid,psr,cls,ni,rtprio,comm | PSR 是最近执行的 CPU,CLS、NI、RTPRIO 对应调度类、nice 和实时优先级。 |
下面用自己启动的 sleep 任务演示。chrt --max 可以查询各策略的优先级范围,修改为实时策略需要相应权限。util-linux 的 chrt 手册
sleep 120 &
pid=$!
chrt -p "$pid"
chrt --max
sudo chrt -r -p 10 "$pid" # 设置 SCHED_RR,实时优先级为 10
chrt -p "$pid"
sudo chrt -o -p 0 "$pid" # 恢复 SCHED_OTHER
nice 用于启动任务时调整 nice,renice 用于已有任务。普通任务的 nice 范围是 -20 到 19。在同一公平队列中,nice 越低,持续竞争时分到的 CPU 份额通常越大。util-linux 的 renice 手册
nice -n 5 sleep 10 # 在当前 nice 基础上增加 5 后启动任务
renice 5 -p "$pid" # 把已有任务的 nice 设为 5
ps -p "$pid" -o pid,ni,comm
这里用 sleep 是为了留下一个方便查询的任务。它大部分时间在等定时器,NI 列可以验证设置,而 CPU 使用比例要用同一个 CPU 上持续计算的任务比较。
taskset 通过 sched_getaffinity 和 sched_setaffinity 查询及设置任务允许使用的 CPU。下面的 1 是逻辑 CPU 编号,应从查询到的允许列表中选取。多线程进程可加 -a 查看或设置所有已有线程。util-linux 的 taskset 手册
taskset -pc "$pid" # 查询允许的 CPU 列表
taskset -pc 1 "$pid" # 限制到逻辑 CPU 1
taskset -p "$pid" # 十六进制掩码中,CPU 1 对应 0x2
taskset -apc "$pid" # 查看所有线程的亲和性
8. 动手实验
以下实测在 Windows 上的 QEMU 虚拟机完成。来宾是 Alpine Linux,内核 6.1.128-0-virt(x86-64),有 2 个逻辑 CPU,taskset 来自 util-linux 2.38.1。实验二用 Zig 0.14.1 的 C 编译器以 -O2 构建。读者可以在自己的 Linux 机器上用普通用户权限复现。
8.1 测量 nice 和 CPU 亲和性的影响
让 A 和 B 都执行同一个空循环,始终有活可做。先让它们挤在同一个逻辑 CPU 上,比较两者 nice 相同与 B 的 nice 增加 5 的结果。再给 B 换一个空闲的逻辑 CPU,保留 nice 的差异。这样可以看出 CPU 份额变化出现在什么条件下。
在 Linux 使用 sh、taskset、nice 和 awk。先运行 grep '^Cpus_allowed_list:' /proc/self/status 查看允许的 CPU 编号。把下方保存为 nice-lab.sh,运行 sh nice-lab.sh 0 1,将 0 1 换成两个允许使用的编号。只有一个可用 CPU 时,只传一个编号,前两组仍可运行。脚本每组采样 4 秒,退出时结束两个后台任务。
#!/bin/sh
set -eu
cpu_a=${1:-0}
cpu_b=${2:-}
work='while :; do :; done'
cpu_ticks() {
# 去掉 PID 和括号中的进程名,再读取 utime 与 stime。
awk '{ sub(/^.*) /, ""); print $12 + $13 }' "/proc/$1/stat"
}
run_pair() (
label=$1
target_b=$2
nice_delta=$3
taskset -c "$cpu_a" sh -c "$work" &
a=$!
taskset -c "$target_b" nice -n "$nice_delta" sh -c "$work" &
b=$!
trap 'kill "$a" "$b" 2>/dev/null || :; wait "$a" "$b" 2>/dev/null || :' 0
trap 'exit 130' INT
trap 'exit 143' TERM
sleep 1
a_before=$(cpu_ticks "$a")
b_before=$(cpu_ticks "$b")
sleep 4
a_after=$(cpu_ticks "$a")
b_after=$(cpu_ticks "$b")
da=$((a_after - a_before))
db=$((b_after - b_before))
awk -v label="$label" -v a="$da" -v b="$db" 'BEGIN {
if (a + b == 0) exit 1
printf "%s: A=%d B=%d A_share=%.1f%%\n", label, a, b, 100 * a / (a + b)
}'
)
run_pair same_cpu_same_nice "$cpu_a" 0
run_pair same_cpu_B_plus5 "$cpu_a" 5
if [ -n "$cpu_b" ] && [ "$cpu_b" != "$cpu_a" ]; then
run_pair separate_cpus_B_plus5 "$cpu_b" 5
fi
/proc/<PID>/stat 原始第 14、15 列分别记录任务在用户态、内核态消耗的 CPU 时间。相减得到采样窗口内的增量。A_share 是 A 在这两个任务累计 CPU 时间中占的比例。这里计量 CPU 时间的单位可由 getconf CLK_TCK 查询,与内核的调度节拍频率 CONFIG_HZ 是两个概念。Linux 内核文档:/proc · Linux 5.4 的 nice 权重表
预期是第一组接近五五分。A 从 nice 0 开始时,在同一个公平队列中竞争的第二组,A 的理想比例约为 1024 ÷ (1024 + 335) ≈ 75.35%。分开两个空闲 CPU 后,两者各自能持续计算,比例应重新接近五五分,同时 A + B 的总量会增加。
实测结果
| 对照组 | A 的 CPU 时间计数 | B 的 CPU 时间计数 | A 在两者中的份额 |
|---|---|---|---|
| 同核,nice 相同 | 202 | 200 | 50.2% |
| 同核,B 的 nice 增加 5 | 304 | 99 | 75.4% |
| 分开两核,B 的 nice 仍增加 5 | 411 | 410 | 50.1% |
第二组中,A 的份额接近按权重算出的 75.35%。第一组和第三组的百分比都接近 50%,但两者的 CPU 时间总计分别是 402 和 821 个计数单位。第一组是两人分用一个 CPU,第三组是两人分别使用一个 CPU。若只有份额百分比而没看总量,就容易错过这两种情况的差别。
8.2 复现原书的管道往返
管道可以在进程之间传递字节。读端在没有数据时可以阻塞,等写端写入才被唤醒。沿用原书的两条管道,把一个字节从父进程传给子进程,再传回来。一轮会发生两次交接。先加一组对照,让同一个进程做两次写和两次读,保留四次管道调用,但不等待另一个进程。原书配套实验源码 chapter-07/test-01/main.c
下面是教学改写,使用普通调度策略和单调时钟。保存为 pipe-switch.c,在 Linux 上执行 cc -O2 -Wall -Wextra pipe-switch.c -o pipe-switch,再执行 taskset -c 0 ./pipe-switch。将 0 换为允许使用的 CPU 编号。父子进程继承相同的亲和性掩码,必须轮流使用这个 CPU。测试结束后可删除 pipe-switch 可执行文件。
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <sys/resource.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
enum { ROUNDS = 10000 };
static void require(int ok, const char *message)
{
if (!ok) {
fprintf(stderr, "%s\n", message);
exit(EXIT_FAILURE);
}
}
static double now_us(void)
{
struct timespec t;
require(clock_gettime(CLOCK_MONOTONIC, &t) == 0, "clock_gettime failed");
return t.tv_sec * 1e6 + t.tv_nsec / 1e3;
}
static void send_byte(int fd)
{
require(write(fd, "x", 1) == 1, "pipe write failed");
}
static void receive_byte(int fd)
{
char byte;
require(read(fd, &byte, 1) == 1, "pipe read failed");
}
int main(void)
{
int to_child[2], to_parent[2], status;
struct rusage before, after;
require(pipe(to_child) == 0 && pipe(to_parent) == 0, "pipe failed");
double start = now_us();
for (int i = 0; i < ROUNDS; i++) {
send_byte(to_child[1]);
receive_byte(to_child[0]);
send_byte(to_parent[1]);
receive_byte(to_parent[0]);
}
double baseline = now_us() - start;
pid_t child = fork();
require(child >= 0, "fork failed");
if (child == 0) {
close(to_child[1]);
close(to_parent[0]);
for (int i = 0; i < ROUNDS; i++) {
receive_byte(to_child[0]);
send_byte(to_parent[1]);
}
_exit(EXIT_SUCCESS);
}
close(to_child[0]);
close(to_parent[1]);
require(getrusage(RUSAGE_SELF, &before) == 0, "getrusage failed");
start = now_us();
for (int i = 0; i < ROUNDS; i++) {
send_byte(to_child[1]);
receive_byte(to_parent[0]);
}
double elapsed = now_us() - start;
require(getrusage(RUSAGE_SELF, &after) == 0, "getrusage failed");
require(waitpid(child, &status, 0) == child && WIFEXITED(status) &&
WEXITSTATUS(status) == 0, "child failed");
printf("rounds=%d baseline_us=%.0f pingpong_us=%.0f\n", ROUNDS, baseline, elapsed);
printf("parent_voluntary=%ld parent_involuntary=%ld estimated_us_per_handoff=%.2f\n",
after.ru_nvcsw - before.ru_nvcsw, after.ru_nivcsw - before.ru_nivcsw,
(elapsed - baseline) / (2 * ROUNDS));
return 0;
}
parent_voluntary 记录父进程主动交出 CPU 的次数,例如 read() 等不到回复而阻塞。parent_involuntary 记录父进程仍能运行时被换出的次数,例如唤醒子进程后触发了抢占。预期父进程每轮要给子进程一次运行机会,因此两项相加应接近 10,000。(pingpong_us − baseline_us) ÷ 20000 则估算每次交接的增量耗时,包含阻塞、唤醒和排队等路径。Linux 手册 getrusage(2)
实测结果
| 试次 | 同进程基线(µs) | 父子往返(µs) | 父进程自愿切换 | 父进程非自愿切换 | 每次交接估算(µs) |
|---|---|---|---|---|---|
| 1 | 61,181 | 588,906 | 6,378 | 3,624 | 26.39 |
| 2 | 59,904 | 581,174 | 7,206 | 2,796 | 26.06 |
| 3 | 60,178 | 563,050 | 5,707 | 4,296 | 25.14 |
第一轮两类计数加起来是 10,002,符合父进程每轮通常要让子进程运行一次的预期。只数自愿切换会漏掉 3,624 次。一个可能的过程是父进程写完、唤醒子进程后就被抢占,重新运行时回信已在管道里,read() 可以直接返回。这里只记录了累计次数,定位某一轮在哪一步被抢占需要逐次调度跟踪。
三次估算的中位数是 26.06 µs,反映的是这台虚拟机里两进程用管道交接的开销。原书约 3.4 µs 的结果对应书中的测量环境。QEMU 的指令模拟、内核配置和测量方式都会影响绝对数值。
9. 本章总结(原书 7.7 节)
以下为原书第 7.7 节,书页 242–245,PDF 第 270–273 页。工程细节可结合文末的源码对照阅读。原书 7.7 节
9.1 调度器回顾
本章从以下几方面展开对调度器的介绍。
1. 调度器的发展简史
Linux 的调度器发展大致经历了 O(n) 调度器、O(1) 调度器和完全公平调度器几个过程。在 O(n) 调度器中,整个系统只有一个任务队列,锁竞争严重。在 O(1) 调度器中,为每个逻辑核都设置了一个任务队列,解决了锁竞争的问题。每个进程的时间片是按优先级来提前算出来的,优先级越高,运行时间越长。这会导致在任务比较多的时候,调度延迟非常不可控。
完全公平调度器 CFS 通过引入 vruntime、nice 等概念对原来的优先级和时间片都进行了重构。先根据当前系统的情况动态地计算调度周期。然后根据调度周期和每个进程的 vruntime 来动态地计算是否该调度下一个进程了。整体上维护的是运行时间的相对公平。
2. 调度器是如何定义的,运行队列到底长什么样子?
在本书使用的 5.4 版本内核中,Linux 调度器会为每一个核都准备一个运行队列,struct rq。在每个运行队列中,分为实时进程和普通进程两种。
实时进程的任务相比普通进程有绝对高的优先权。实时进程在实现上是通过多优先级任务队列的方式实现的。优先级分别为 0~99。每个优先级都有一个用链表实现的队列。优先级高的会抢占优先级低的任务的 CPU。同优先级内部通过时间片轮转或者先来先服务的算法来调度。
在普通进程中不再使用链表,而是使用了一棵以 vruntime 大小为 key 的红黑树。调度器在选择下一个进程的时候,直接从红黑树最左侧的节点选择即可,因为它是整个用户进程任务队列中 vruntime 最小的任务,也是对 CPU 需求最迫切的任务。红黑树中的每个节点都是一个调度实体,这个调度实体一般来说就是一个进程,但也有可能是一个进程组。
3. 新进程和老进程是如何确定自己该加入哪个运行队列的?
系统中往往会存在很多个核,每个核都有一个任务队列,所以进程在刚创建的时候和被唤醒的时候需要确定加入哪个运行队列。在选择上,会尽量优先选择要唤醒的进程上一次使用的 CPU 逻辑核,或者要唤醒它的进程所在的核(当前逻辑核)。因为这两个核上的缓存大概率还是热的,进程调度上来会运行得比较快。然后考虑共享缓存且 idle 的 CPU,最后考虑负载最小的核。
在综合考虑缓存友好性及空闲状况后,选择一个 CPU 运行队列,并将新进程添加到该队列的红黑树中。
4. 调度器是何时触发选择下一个待运行进程的?
调度器主要在两个时机触发真正的任务调度:一是调度节拍,二是其他任务主动放弃 CPU 的时候。其中调度节拍是调度器中非常重要的执行入口。在每个核上都会定时触发调度节拍的执行。在这里会计算当前核上所有任务的 vruntime,并判断是否需要切到下一个任务上来运行。
然后还会触发负载均衡,判断其他核是否过于繁忙。如果是的话,就主动迁移一些任务到当前核上来执行。
理解了以上四个问题,我们就对 Linux 的调度器有了更深入的理解和认识了。下面再来看开篇提到的几个实践中息息相关的问题。
9.2 实践问答
1. 进程不主动释放 CPU 的话,每次调度最少能运行多久?
先要明白的是,过于频繁的进程上下文切换对系统的性能是非常有害的。这就好比你每一分钟都切换大脑去处理一个其他问题,你的工作效率根本就提不起来。在人的工作方面,有个高效的方法叫番茄工作法,目的是保证你在一段时间内,比如 25 分钟左右,只专心地处理一项工作。下一项工作在下一个番茄钟到来时再处理。
进程调度也是如此。在完全公平调度器中,出于减少频繁切换进程所带来的成本的考虑,一个进程一旦被分配到 CPU 就会持续运行相对较长的一段时间,避免频繁的进程上下文切换导致的性能损耗。这段时间的最小值由 sched_min_granularity_ns 这个内核参数来控制,单位是 ns(纳秒)。例如下面这个配置的最短运行时间是 10 ms。
# sysctl -a | grep min_granularity
kernel.sched_min_granularity_ns = 10000000
当然,如果进程因为等待网络、磁盘等资源时主动放弃 CPU 那是另一码事。
2. 现在的进程调度还是按时间片来执行的吗?
过去开发人员经常喜欢说进程运行了多长的时间片,但现在的完全公平调度器中早已不再按时间片调度进程了。每次调度节拍是根据当前在运行的任务的 vruntime 和任务队列中最小的 vruntime 相比较,判断是否有必要把下一个进程切换上来的。
3. 进程的 nice 值的含义是什么?
很多人都喜欢把 nice 值说成是优先级,我认为这是不恰当的。对实时进程来说优先级在 1~99 之间。但对于使用 SCHED_OTHER 策略的普通用户进程来讲,优先级全部是 0。
# chrt --max
SCHED_OTHER min/max priority : 0/0
SCHED_FIFO min/max priority : 1/99
SCHED_RR min/max priority : 1/99
优先级讲究的是抢占。优先级高的拥有绝对的调度优先权。但普通进程的 nice 值的含义其实是一个 CPU 分配上的权重。对于 nice 值低(会抢占更多 CPU 资源)的进程,内核并不一定绝对优先调度它,而仅保证它在整个运行的过程中获得的 CPU 比例会多一些。反之,如果 nice 值高(会让着其他进程),内核给它分配的 CPU 比例就会低一些。但如果 nice 值高的进程等待的时间过长,仍然可能会被优先调度。总之,nice 值代表的是一个权重比例,而不是优先级。
4. 在用户进程中,高优先级是否能抢占低优先级的 CPU?
在实时任务,如 migration 内核线程中,是按优先级调度的。优先级强调的是抢占,高优先级比低优先级有优先获得 CPU 的权利。
但是对于用户进程来讲,一般都采用完全公平调度器进行 CPU 资源的分配。在这种调度器中,nice 其实是一个权重的概念,而不太像传统的优先级。优先级强调的是抢占,高优先级比低优先级有优先获得 CPU 的权利。而用户进程中的 nice 值强调的是获取 CPU 运行时间的权重比例。在完全公平调度器中,真正决定是否能抢占的只有 vruntime,而不是 nice 值的高低。只不过 nice 值越低的进程,其 vruntime 下降得越快,触发抢占的可能性越高。
5. 业界流行的在离线混部有没有副作用?
现在业界为了更充分地将 CPU 利用率拉起来,降低成本,会在在线业务的机器上部署离线计算任务。但是这里有一个被很多人忽视的细节,那就是在离线混部会破坏内核的 wake_affine 机制。内核调度时为了性能考虑,会倾向于让 CPU 在之前自己跑过的核上运行,这样 CPU 的缓存还有不少能用的。但是在离线混部会让 wake_affine 机制成功的概率大大降低。进程在不同的核上运行的概率增加,Cache 中的数据都是“凉的”,穿透到内存的访问次数增加,进程的运行性能就会下降很多。
6. 为什么进程会在 CPU 各个核之间飘来飘去?
既然系统中存在多个任务队列,那就有可能会出现有的任务队列特别忙,有的任务队列特别闲,所以完全公平调度器还有一个负载均衡模块,在调度节拍触发的时候会主动去其他队列上看看能不能帮忙。这个机制有可能会将其他核的任务队列中的进程拉取到自己核上执行。因为负载均衡机制的存在,所以进程可能会在各个核之间飘来飘去,而不是固定使用某一个核。
7. taskset 命令是如何让一个进程钉在某个核上的?
我去理发店理发的时候,不管有多少理发师,我只会选择最熟悉的那位。在进程调度中也是这样的,如果你不想让负载均衡模块把你的进程拉到别的核上运行,可以使用 taskset 命令来设置进程的 CPU 亲和性。在设置完后,负载均衡模块会判断它,会尊重你的亲和性设置。这样你的进程就可以只在你希望的核上运行了。
最后我想说的是,Linux 在调度器上固然已经做了很多事情,它关注的重点就是咱们前面说过的某个 CPU 核要运行哪个进程及运行多长时间。
但对于我们开发者来说,我们也许更应该关注的是进程调度到哪个 CPU 核上运行。因为对核的亲和性做得好,会对应用程序的性能有较大帮助。因此在完全公平调度器基础上合理地使用 taskset,或者 cgroup 下的 cpuset 等,让进程按照我们预期的核来调度,也许是我们更应该关注的事情。
9.3 源码对照
- 上文的 0~99 对应实时队列的内部索引范围。
chrt查到的 1~99 是用户可以为SCHED_FIFO和SCHED_RR设置的实时优先级范围。见 3. 运行队列与选任务的规则。 - 节拍路径更新的是当前运行的调度实体,随后才检查抢占条件。
sched_min_granularity_ns约束其中一次检查,10 ms 是书中机器的配置示例。见 5. 什么时候重调度,怎样切换任务。 - 上文写作
vruntime“下降得越快”。同样运行一段时间,nice越低,权重越大,vruntime的增量越小。见 3. 运行队列与选任务的规则。 - 混部会改变
wake_affine所观察到的空闲和负载条件,影响唤醒选核。是否发生更多迁移、是否影响延迟,要看业务负载、亲和性和硬件拓扑。见 4.2wake_affine怎样给刚醒来的任务选核。
9.4 在线与离线任务混部
在线任务要尽快答复用户请求,离线任务可以在后台慢慢完成。混部就是让这两类任务共用机器,用离线计算填上在线业务的低谷。假设 A 是离线计算任务,B 是处理在线请求的线程。B 醒来后如果留在繁忙的 CPU 上,可能要多等一会儿。若换到其他 CPU,之前使用的数据可能需要重新载入缓存。整台机器的 CPU 利用率因此可能上升,同时一部分请求的响应时间也可能变长。
排查时,可以先核对任务的调度策略、nice 和亲和性,再查看在线线程最近执行的 CPU。在相同负载下比较亲和性调整前后的延迟和 CPU 利用率。缩小亲和性范围可以减少部分迁移,也可能让更多线程挤在少数 CPU 上。
10. 原书索引
| 内容 | 书页 | 插图本地副本 |
|---|---|---|
| 任务从阻塞到就绪的状态变化 | 235 | 图 7.32 |
| 7.1 调度器演变 | 197–205 | 图 7.12 |
| 7.2 每 CPU 队列、实时调度与 CFS | 205–211 | 图 7.17、图 7.19、图 7.20 |
| 7.3 新任务与唤醒任务入队 | 211–221 | 图 7.23 |
| 7.4 调度节拍、均衡与切换 | 221–234 | 图 7.25、图 7.27、图 7.28、图 7.29 |
| 7.5 切换开销实测 | 234–238 | — |
| 7.6 调度命令 | 238–242 | — |
| 7.7 本章总结 | 242–245 | — |