diff --git a/study/kernel/00-DESCRIPTION/SCHEDULER.md b/study/kernel/00-DESCRIPTION/SCHEDULER.md
index 4cb60db..634af58 100644
--- a/study/kernel/00-DESCRIPTION/SCHEDULER.md
+++ b/study/kernel/00-DESCRIPTION/SCHEDULER.md
@@ -10,8 +10,8 @@
-------
-**概述: **Linux 是一个遵循 POSIX 标准的类 Unix 操作系统(然而它并不是 Unix 系统[1](#refer-anchor-1)), POSIX 1003.1b 定义了调度相关的一个功能集合和 API 接口[2](#refer-anchor-2). 调度器的任务是分配 CPU 运算资源, 并以协调效率和公平为目的. **效率**可从两方面考虑: 1) 吞吐量(throughput) 2)延时(latency). 不做精确定义, 这两个有相互矛盾的衡量标准主要体现为两大类进程: 一是 CPU 密集型, 少量 IO 操作, 少量或无与用户交互操作的任务(强调吞吐量, 对延时不敏感, 如高性能计算任务 HPC), 另一则是 IO 密集型, 大量与用户交互操作的任务(强调低延时, 对吞吐量无要求, 如桌面程序). **公平**在于有区分度的公平, 多媒体任务和数值计算任务对延时和限定性的完成时间的敏感度显然是不同的.
-为此, POSIX 规定了操作系统必须实现以下**调度策略(scheduling policies),** 以针对上述任务进行区分调度:
+** 概述: **Linux 是一个遵循 POSIX 标准的类 Unix 操作系统 (然而它并不是 Unix 系统[1](#refer-anchor-1)), POSIX 1003.1b 定义了调度相关的一个功能集合和 API 接口[2](#refer-anchor-2). 调度器的任务是分配 CPU 运算资源, 并以协调效率和公平为目的. ** 效率 ** 可从两方面考虑: 1) 吞吐量(throughput) 2) 延时(latency). 不做精确定义, 这两个有相互矛盾的衡量标准主要体现为两大类进程: 一是 CPU 密集型, 少量 IO 操作, 少量或无与用户交互操作的任务(强调吞吐量, 对延时不敏感, 如高性能计算任务 HPC), 另一则是 IO 密集型, 大量与用户交互操作的任务(强调低延时, 对吞吐量无要求, 如桌面程序). ** 公平 ** 在于有区分度的公平, 多媒体任务和数值计算任务对延时和限定性的完成时间的敏感度显然是不同的.
+为此, POSIX 规定了操作系统必须实现以下 ** 调度策略(scheduling policies),** 以针对上述任务进行区分调度:
**- SCHED\_FIFO**
@@ -28,18 +28,18 @@
此调度策略包含除上述实时进程之外的其他进程, 亦称普通进程. 采用分时策略, 根据动态优
-先级(可用 **nice()** API设置), 分配 CPU 运算资源. **注意: 这类进程比上述两类实时进程优先级低, 换言之, 在有实时进程存在时, 实时进程优先调度**.
+先级(可用 **nice()** API 设置), 分配 CPU 运算资源. ** 注意: 这类进程比上述两类实时进程优先级低, 换言之, 在有实时进程存在时, 实时进程优先调度 **.
Linux 除了实现上述策略, 还额外支持以下策略:
-- **SCHED\_IDLE** 优先级最低, **在系统空闲时才跑这类进程**(如利用闲散计算机资源跑地外文明搜索, 蛋白质结构分析等任务, 是此调度策略的适用者)
+- **SCHED\_IDLE** 优先级最低, ** 在系统空闲时才跑这类进程 **(如利用闲散计算机资源跑地外文明搜索, 蛋白质结构分析等任务, 是此调度策略的适用者)
- **SCHED\_BATCH** 是 SCHED\_OTHER 策略的分化, 与 SCHED\_OTHER 策略一样, 但针对吞吐量优化
- **SCHED\_DEADLINE** 是新支持的实时进程调度策略, 针对突发型计算, 且对延迟和完成时间高度敏感的任务适用.
-除了完成以上基本任务外, Linux 调度器还应提供高性能保障, 对吞吐量和延时的均衡要有好的优化; 要提供高可扩展性(scalability)保障, 保障上千节点的性能稳定; 对于广泛作为服务器领域操作系统来说, 它还提供丰富的组策略调度和节能调度的支持.
+除了完成以上基本任务外, Linux 调度器还应提供高性能保障, 对吞吐量和延时的均衡要有好的优化; 要提供高可扩展性 (scalability) 保障, 保障上千节点的性能稳定; 对于广泛作为服务器领域操作系统来说, 它还提供丰富的组策略调度和节能调度的支持.
## 0.2 主线内存管理分支合并窗口
@@ -53,15 +53,15 @@ Mainline Merge Window
```cpp
-git log --oneline v5.15...v5.16 | grep -E "Merge tag | Linux " | grep -E "sched| Linux "
+git log --oneline v5.15...v5.16 | grep -E "Merge tag | Linux" | grep -E "sched| Linux"
```
| 版本 | 发布时间 | 合并链接 |
|:---:|:-------:|:-------:|
-| 5.13 | 2021/06/28 | [Merge tag 'sched-core-2021-04-28', 5.13-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=16b3d0cf5bad844daaf436ad2e9061de0fe36e5c)
[Merge tag 'sched-urgent-2021-05-09', 5.13-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9819f682e48c6a7055c5d7a6746411dd3969b0e5)
[Merge tag 'sched-urgent-2021-05-15', 5.13-rc2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c12a29ed9094b4b9cde8965c12850460b9a79d7c)
[Merge tag 'sched-urgent-2021-06-12', 5.13-rc6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=99f925947ab0fd5c17b74460d8b32f1aa1c86e3a)
[Merge tag 'sched_urgent_for_v5.13_rc6', 5.13-rc7, 2021/06/20](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cba5e97280f53ec7feb656fcdf0ec00a5c6dd539)
[Merge tag 'sched-urgent-2021-06-24', 5.13](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=666751701b6e4b6b6ebc82186434806fa8a09cf3)
|
-| 5.14 | 2021/08/29 | [Merge tag 'sched-core-2021-06-28', 5.14-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=54a728dc5e4feb0a9278ad62b19f34ad21ed0ee4)
[Merge tag 'sched-urgent-2021-06-30', 5.14-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a6eaf3850cb171c328a8b0db6d3c79286a1eba9d)
[Merge tag 'sched-urgent-2021-07-11', 5.14-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=877029d9216dcc842f50d37571f318cd17a30a2d)
[Merge tag 'sched-urgent-2021-08-08', 5.14-rc5](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=713f0f37e8128e8a0190a98f5a4be71fb32a671a)
[Merge tag 'sched_urgent_for_v5.14', 5.14](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=537b57bd5a202af145c266d4773971c2c9f90cd9) |
-| 5.15 | 2021/11/1 | NA | [Merge tag 'sched-core-2021-08-30'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5d3c0db4598c5de511824649df2aa976259cf10a)
[Merge remote-tracking branch 'tip/sched/arm64'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=65266a7c6abf)
[Merge tag 'sched_urgent_for_v5.15_rc1'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=56c244382fdb)
[Merge tag 'sched_urgent_for_v5.15_rc4'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=777feabaea77)
[Merge tag 'sched_urgent_for_v5.15_rc7'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6c62666d8879)
-| 5.16 | 2022/01/09 | [Merge tag 'sched-core-2021-11-01', 5.16-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9a7e0a90a454a7826ecbca055a6ec9271b70c686)
[Merge tag 'sched_urgent_for_v5.16_rc1', 5.16-rc3](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fc661f2dcb7e)
[Merge tag 'sched-urgent-2021-11-28', 5.16-rc3](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=97891bbf38f7)
[Merge tag 'sched_urgent_for_v5.16_rc4', 5.16-rc4](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1d213767dc6f)
[Merge tag 'sched-urgent-2021-12-12', 5.16-rc5](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=773602256a2ca73455b0baeae5737c4a9ed6ef49) |
+| 5.13 | 2021/06/28 | [Merge tag'sched-core-2021-04-28', 5.13-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=16b3d0cf5bad844daaf436ad2e9061de0fe36e5c)
[Merge tag'sched-urgent-2021-05-09', 5.13-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9819f682e48c6a7055c5d7a6746411dd3969b0e5)
[Merge tag'sched-urgent-2021-05-15', 5.13-rc2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c12a29ed9094b4b9cde8965c12850460b9a79d7c)
[Merge tag'sched-urgent-2021-06-12', 5.13-rc6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=99f925947ab0fd5c17b74460d8b32f1aa1c86e3a)
[Merge tag'sched_urgent_for_v5.13_rc6', 5.13-rc7, 2021/06/20](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cba5e97280f53ec7feb656fcdf0ec00a5c6dd539)
[Merge tag'sched-urgent-2021-06-24', 5.13](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=666751701b6e4b6b6ebc82186434806fa8a09cf3)
|
+| 5.14 | 2021/08/29 | [Merge tag'sched-core-2021-06-28', 5.14-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=54a728dc5e4feb0a9278ad62b19f34ad21ed0ee4)
[Merge tag'sched-urgent-2021-06-30', 5.14-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a6eaf3850cb171c328a8b0db6d3c79286a1eba9d)
[Merge tag'sched-urgent-2021-07-11', 5.14-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=877029d9216dcc842f50d37571f318cd17a30a2d)
[Merge tag'sched-urgent-2021-08-08', 5.14-rc5](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=713f0f37e8128e8a0190a98f5a4be71fb32a671a)
[Merge tag'sched_urgent_for_v5.14', 5.14](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=537b57bd5a202af145c266d4773971c2c9f90cd9) |
+| 5.15 | 2021/11/1 | NA | [Merge tag'sched-core-2021-08-30'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5d3c0db4598c5de511824649df2aa976259cf10a)
[Merge remote-tracking branch'tip/sched/arm64'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=65266a7c6abf)
[Merge tag'sched_urgent_for_v5.15_rc1'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=56c244382fdb)
[Merge tag'sched_urgent_for_v5.15_rc4'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=777feabaea77)
[Merge tag'sched_urgent_for_v5.15_rc7'](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6c62666d8879)
+| 5.16 | 2022/01/09 | [Merge tag'sched-core-2021-11-01', 5.16-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9a7e0a90a454a7826ecbca055a6ec9271b70c686)
[Merge tag'sched_urgent_for_v5.16_rc1', 5.16-rc3](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fc661f2dcb7e)
[Merge tag'sched-urgent-2021-11-28', 5.16-rc3](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=97891bbf38f7)
[Merge tag'sched_urgent_for_v5.16_rc4', 5.16-rc4](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1d213767dc6f)
[Merge tag'sched-urgent-2021-12-12', 5.16-rc5](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=773602256a2ca73455b0baeae5737c4a9ed6ef49) |
| 5.17 | 2022/03/20 | [sched_core_for_v5.17_rc1, 5.17-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6ae71436cda7)
[sched_urgent_for_v5.17_rc2, 5.17-rc2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=10c64a0f2806)
[sched_urgent_for_v5.17_rc2_p2, 5.17-rc2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=24f4db1f3a27)
[sched_urgent_for_v5.17_rc4, 5.17-rc4](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6f3573672324)
[sched_urgent_for_v5.17_rc5, 5.17-rc5](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0b0894ff78cc) |
| 5.18 | NA | [sched-core-2022-03-22, 5.18-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3fe2f7446f1e029b220f7f650df6d138f91651f2), [scheduler updates for v5.18](https://lore.kernel.org/lkml/YjhZUezhnamHAl0H@gmail.com) |
@@ -139,10 +139,10 @@ Scheduler Microconference Accepted into Linux Plumbers Conference
# 1 进程调度类
-------
-## 1.1 普通进程调度器(SCHED\_NORMAL)之纠极进化史
+## 1.1 普通进程调度器 (SCHED\_NORMAL) 之纠极进化史
-------
-Linux 一开始, 普通进程和实时进程都是基于优先级的一个调度器, 实时进程支持 100 个优先级, 普通进程是优先级小于实时进程的一个静态优先级, 所有普通进程创建时都是默认此优先级, 但可通过 **nice()** 接口调整动态优先级(共40个). 实时进程的调度器比较简单, 而普通进程的调度器, 则历经变迁[5](#refer-anchor-5):
+Linux 一开始, 普通进程和实时进程都是基于优先级的一个调度器, 实时进程支持 100 个优先级, 普通进程是优先级小于实时进程的一个静态优先级, 所有普通进程创建时都是默认此优先级, 但可通过 **nice()** 接口调整动态优先级(共 40 个). 实时进程的调度器比较简单, 而普通进程的调度器, 则历经变迁[5](#refer-anchor-5):
在 CFS 算法引入之前, Linux 使用过几种不同的调度算法, 一开始的调度器是复杂度为 O(n) 的始调度算法 (实际上每次会遍历所有任务, 所以复杂度为 O(n)), 这个算法的缺点是当内核中有很多任务时, 调度器本身就会耗费不少时间, 所以, 从 linux 2.5 开始引入赫赫有名的 O(1) 调度器, 然而, linux 是集全球很多程序员的聪明才智而发展起来的超级内核, 没有最好, 只有更好, 在 O(1) 调度器风光了没几天就又被另一个更优秀的调度器取代了, 它就是 CFS 调度器 Completely Fair Scheduler. 这个也是在 2.6 内核中引入的, 具体为 2.6.23, 即从此版本开始, 内核使用 CFS 作为它的默认调度器, O (1) 调度器被抛弃了.
@@ -158,9 +158,9 @@ O(n) 调度理解起来简单:
### 1.1.1 O(1) 调度器
-------
-2.6 时代开始支持(2002年引入).
+2.6 时代开始支持(2002 年引入).
-顾名思义, 此调度器为O(1)时间复杂度. 该调度器修正之前的O(n) 时间复杂度调度器, 以解决扩展性问题. 为每一个动态优先级维护队列, 从而能在常数时间内选举下一个进程来执行.
+顾名思义, 此调度器为 O(1)时间复杂度. 该调度器修正之前的 O(n) 时间复杂度调度器, 以解决扩展性问题. 为每一个动态优先级维护队列, 从而能在常数时间内选举下一个进程来执行.
其基本思想是根据进程的优先级进行调度. 进程有两个优先级, 一个是静态优先级, 一个是动态优先级. 静态优先级是用来计算进程运行的时间片长度的, 动态优先级是在调度器进行调度时用到的, 调度器每次都选取动态优先级最高的进程运行. 由于其数据结构设计上采用了一个优先级数组, 这样在选择最优进程时时间复杂度为 O(1), 所以被称为 O(1) 调度.
@@ -180,7 +180,7 @@ O(n) 调度理解起来简单:
O(1) 调度器存在一个比较严重的问题: 复杂的交互进程识别启发式算法 - 为了识别交互性的和批处理型的两大类进程, 该启发式算法融入了睡眠时间作为考量的标准, 但对于一些特殊的情况, 经常判断不准, 而且是改完一种情况又发现一种情况.
-Con Kolivas (八卦: 这家伙白天是个麻醉医生)为解决这个问题提出 **RSDL(The Rotating Staircase Deadline Scheduler)** 算法. 该算法的亮点是对公平概念的重新思考: **交互式(A)**和**批量式(B)**进程应该是被完全公平对待的, 对于两个动态优先级完全一样的 A, B 进程, **它们应该被同等地对待, 至于它们是交互式与否(交互式的应该被更快调度), 应该从他们对分配给他们的时间片的使用自然地表现出来, 而不是应该由调度器自作高明地根据他们的睡眠时间去猜测**. 这个算法的核心是**Rotating Staircase**, 是一种衰减式的优先级调整, 不同进程的时间片使用方式不同, 会让它们以不同的速率衰减(在优先级队列数组中一级一级下降, 这是下楼梯这名字的由来), 从而自然地区分开来进程是交互式的(间歇性的少量使用时间片)和批量式的(密集的使用时间片). 具体算法细节可看这篇文章: [The Rotating Staircase Deadline Scheduler [LWN.net]](https://link.zhihu.com/?target=https%3A//lwn.net/Articles/224865/)
+Con Kolivas (八卦: 这家伙白天是个麻醉医生)为解决这个问题提出 **RSDL(The Rotating Staircase Deadline Scheduler)** 算法. 该算法的亮点是对公平概念的重新思考: ** 交互式 (A)** 和 ** 批量式(B)** 进程应该是被完全公平对待的, 对于两个动态优先级完全一样的 A, B 进程, ** 它们应该被同等地对待, 至于它们是交互式与否(交互式的应该被更快调度), 应该从他们对分配给他们的时间片的使用自然地表现出来, 而不是应该由调度器自作高明地根据他们的睡眠时间去猜测 **. 这个算法的核心是 **Rotating Staircase**, 是一种衰减式的优先级调整, 不同进程的时间片使用方式不同, 会让它们以不同的速率衰减(在优先级队列数组中一级一级下降, 这是下楼梯这名字的由来), 从而自然地区分开来进程是交互式的(间歇性的少量使用时间片) 和批量式的(密集的使用时间片). 具体算法细节可看这篇文章: [The Rotating Staircase Deadline Scheduler [LWN.net]](https://link.zhihu.com/?target=https%3A//lwn.net/Articles/224865/)
[RSDL cpu scheduler v0.33](https://lore.kernel.org/lkml/200703232005.05839.kernel@kolivas.org)
@@ -193,14 +193,14 @@ Con Kolivas (八卦: 这家伙白天是个麻醉医生)为解决这个问题提
### 1.1.3 完全公平的调度器(CFS)
-------
-**2.6.23(2007年10月发布)**
+**2.6.23(2007 年 10 月发布)**
-Con Kolivas 的完全公平的想法启发了原 O(1) 调度器作者 Ingo Molnar, 他重新实现了一个新的调度器, 叫 CFS(Completely Fair Scheduler). 它从 RSDL/SD 中吸取了完全公平的思想, 不再跟踪进程的睡眠时间, 也不再企图区分交互式进程. 它将所有的进程都统一对待, 这就是公平的含义. CFS的算法和实现都相当简单, 众多的测试表明其性能也非常优越.
+Con Kolivas 的完全公平的想法启发了原 O(1) 调度器作者 Ingo Molnar, 他重新实现了一个新的调度器, 叫 CFS(Completely Fair Scheduler). 它从 RSDL/SD 中吸取了完全公平的思想, 不再跟踪进程的睡眠时间, 也不再企图区分交互式进程. 它将所有的进程都统一对待, 这就是公平的含义. CFS 的算法和实现都相当简单, 众多的测试表明其性能也非常优越.
-> 新的 CFS 调度器的核心同样是**完全公平性**, 即平等地看待所有普通进程, 让它们自身行为彼此区分开来, 从而指导调度器进行下一个执行进程的选举.
+> 新的 CFS 调度器的核心同样是 ** 完全公平性 **, 即平等地看待所有普通进程, 让它们自身行为彼此区分开来, 从而指导调度器进行下一个执行进程的选举.
-不管是 O(n) 还是 O(1) 调度算法, 其基本思路都是通过一系列运行指标确定进程的优先级, 然后根据进程的优先级确定调度哪个进程, 而 CFS 则转换了一种思路, 它不计算优先级, 而是通过计算进程消耗的 CPU 时间(标准化以后的虚拟 CPU 时间)来确定谁来调度. 从而到达所谓的公平性.
+不管是 O(n) 还是 O(1) 调度算法, 其基本思路都是通过一系列运行指标确定进程的优先级, 然后根据进程的优先级确定调度哪个进程, 而 CFS 则转换了一种思路, 它不计算优先级, 而是通过计算进程消耗的 CPU 时间 (标准化以后的虚拟 CPU 时间) 来确定谁来调度. 从而到达所谓的公平性.
| 公平性 | 描述 |
| 绝对公平性 | CFS 定义了一种新的模型, 其基本思路很简单, 他把 CPU 当做一种资源, 并记录下每一个进程对该资源使用的情况, 在调度时, 调度器总是选择消耗资源最少的进程来运行. 这就是所谓的 "完全公平". 但这种绝对的公平有时也是一种不公平, 因为有些进程的工作比其他进程更重要, 我们希望能按照权重来分配 CPU 资源. |
@@ -211,9 +211,9 @@ Con Kolivas 的完全公平的想法启发了原 O(1) 调度器作者 Ingo Molna
至于这种算法如何区分交互式进程和批量式进程, 很简单. 交互式的进程大部分时间在睡眠, 因此它的实际运行时间很小, 而理想运行时间是随着时间的前进而增加的, 所以这两个时间的差值会变大. 与之相反, 批量式进程大部分时间在运行, 它的实际运行时间和理想运行时间的差距就较小. 因此, 这两种进程被区分开来.
-CFS的算法和实现都相当简单, 众多的测试表明其性能也非常优越. 并得到更多的开发者支持, 所以它最终替代了 RSDL 在 2.6.23 进入内核, 一直使用到现在.
+CFS 的算法和实现都相当简单, 众多的测试表明其性能也非常优越. 并得到更多的开发者支持, 所以它最终替代了 RSDL 在 2.6.23 进入内核, 一直使用到现在.
-[Linux的公平调度(CFS)原理 - kummer话你知](https://www.jianshu.com/p/673c9e4817a8)
+[Linux 的公平调度(CFS)原理 - kummer 话你知](https://www.jianshu.com/p/673c9e4817a8)
[CFS scheduler, -v16](https://lore.kernel.org/lkml/20070608195840.GA14928@elte.hu)
@@ -237,18 +237,18 @@ CFS的算法和实现都相当简单, 众多的测试表明其性能也非常优
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
-| 2007/08/09 | Ingo Molnar | [sched: make the multiplication table more accurate](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=254753dc321ea2b753ca9bc58ac329557a20efac) | 对 prio_to_weight 和 prio_to_wmult 做一定的调整. | v1 ☐ | [ 2020/12/17 v1](https://lore.kernel.org/patchwork/cover/1396878) |
+| 2007/08/09 | Ingo Molnar | [sched: make the multiplication table more accurate](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=254753dc321ea2b753ca9bc58ac329557a20efac) | 对 prio_to_weight 和 prio_to_wmult 做一定的调整. | v1 ☐ | [2020/12/17 v1](https://lore.kernel.org/patchwork/cover/1396878) |
### 1.1.4 CK 的 BFS 和 MuQSS
-------
-可以八卦的是, Con Kolivas (因此)离开了社区, 不过他本人否认是因为此事而心生龃龉. 后来, 2009 年, 他对越来越庞杂的 CFS 不满意, 认为 CFS 过分注重对大规模机器, 而大部分人都是使用少 CPU 的小机器, 因此于 2009年8月31日发布了 BFS 调度器(Brain Fuck Scheduler)[48](#refer-anchor-48).
+可以八卦的是, Con Kolivas (因此)离开了社区, 不过他本人否认是因为此事而心生龃龉. 后来, 2009 年, 他对越来越庞杂的 CFS 不满意, 认为 CFS 过分注重对大规模机器, 而大部分人都是使用少 CPU 的小机器, 因此于 2009 年 8 月 31 日发布了 BFS 调度器(Brain Fuck Scheduler)[48](#refer-anchor-48).
-BFS调度器的原理十分简单, 是为桌面交互式应用专门设计, 使得用户的桌面环境更为流畅, 早期使用CFS编译内核时, 音讯视讯同时出现会出现严重的停顿(delay), 而使用 BFS 则没有这些问题. 【注意】
+BFS 调度器的原理十分简单, 是为桌面交互式应用专门设计, 使得用户的桌面环境更为流畅, 早期使用 CFS 编译内核时, 音讯视讯同时出现会出现严重的停顿(delay), 而使用 BFS 则没有这些问题. 【注意】
-BFS 的原理是将所有行程被安排到103组伫列(queue)之中. BFS本身是O(n)调度器, 但大部份的时间比目前Linux上拥有O(log n)效能的主流调度器CFS还优异. [2]Con Kolivas 并没有打算将BFS应用在 mainline Linux[3]. 他再度以 -ck 的补丁来维护这套原始码.
+BFS 的原理是将所有行程被安排到 103 组伫列 (queue) 之中. BFS 本身是 O(n)调度器, 但大部份的时间比目前 Linux 上拥有 O(log n)效能的主流调度器 CFS 还优异. [2]Con Kolivas 并没有打算将 BFS 应用在 mainline Linux[3]. 他再度以 -ck 的补丁来维护这套原始码.
Android 曾经在试验性的分支, 使用 BFS 作为其操作系统排程器. 但是经过测试发现对使用者并没有明显的改进, 因此并未合入之后发表的正式版本. 初次之外当时很多人和厂商都做过 BFS 和 CFS 的对比测试.
@@ -261,7 +261,7 @@ Android 曾经在试验性的分支, 使用 BFS 作为其操作系统排程器.
[bfs-faq](http://ck.kolivas.org/patches/bfs/bfs-faq.txt)
https://lkml.org/lkml/2007/8/30/307
-https://www.wikiwand.com/zh-hans/腦殘排程器
+https://www.wikiwand.com/zh-hans / 腦殘排程器
BFS 的最后版本是 2016 年 12 月发布的 v0.512, 基于 v4.8 内核.
@@ -272,24 +272,24 @@ BFS 的最后版本是 2016 年 12 月发布的 v0.512, 基于 v4.8 内核.
### 1.1.5 不那么重要的进程 SCHED\_IDLE
-------
-**2.6.23(2007年10月发布)**
+**2.6.23(2007 年 10 月发布)**
-~~此调度策略和 CFS 调度器在同一版本引入. 系统在空闲时, 每个 CPU 都有一个 idle 线程在跑, 它什么也不做, 就是把 CPU 放入硬件睡眠状态以节能(需要特定CPU的driver支持), 并等待新的任务到来, 以把 CPU 从睡眠状态中唤醒. 如果你有任务想在 CPU 完全 idle 时才执行, 就可以用 **sched\_setscheduler()** API 设置此策略.~~
+~~ 此调度策略和 CFS 调度器在同一版本引入. 系统在空闲时, 每个 CPU 都有一个 idle 线程在跑, 它什么也不做, 就是把 CPU 放入硬件睡眠状态以节能(需要特定 CPU 的 driver 支持), 并等待新的任务到来, 以把 CPU 从睡眠状态中唤醒. 如果你有任务想在 CPU 完全 idle 时才执行, 就可以用 **sched\_setscheduler()** API 设置此策略.~~
注意上面的描述是有问题的, SCHED_IDLE 和 idle 进程是完全不同的东西
-SCHED_IDLE 跟 SCHED_BATCH 一样, 是 CFS 中的一个策略, SCHED\_IDLE 的进程也是 CFS 调度类的一员, CFS内部的家务事, 意味着 SCHED\_IDLE 进程也是需要按照权重来分配CPU时间的, 只是权重很低而已, 权重默认被[设置为 WEIGHT_IDLEPRIO(3), 参见 [cce7ade80369 sched: SCHED_IDLE weight change](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cce7ade803699463ecc62a065ca522004f7ccb3d).
+SCHED_IDLE 跟 SCHED_BATCH 一样, 是 CFS 中的一个策略, SCHED\_IDLE 的进程也是 CFS 调度类的一员, CFS 内部的家务事, 意味着 SCHED\_IDLE 进程也是需要按照权重来分配 CPU 时间的, 只是权重很低而已, 权重默认被[设置为 WEIGHT_IDLEPRIO(3), 参见 [cce7ade80369 sched: SCHED_IDLE weight change](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cce7ade803699463ecc62a065ca522004f7ccb3d).
另一方面, SCHED_IDLE 是用户赋予的, 的确可以用 **sched\_setscheduler()** API 设置此策略
使用了 SCHED_IDLE 策略, 这意味着这些进程是不重要的, 但是 CFS 又号称完全公平, 这体现在哪些方面呢?
-- 首先设置了 SCHED_IDLE 策略的进程优先级(nice值)都很低, 这将影响到进程的时间片和负载信息
-- SCHED_IDLE 调度策略只在进行抢占处理的时候有一些特殊处理, 比如 check_preempt_curr() 中, 这里当前正在运行的如果是 SCHED_IDLE task 的话, 会马上被新唤醒的 SCHED_NORMAL task抢占, 即 SCHED_NORMAL 的进程可以抢占 SCHED_IDLE 的进程.
+- 首先设置了 SCHED_IDLE 策略的进程优先级 (nice 值) 都很低, 这将影响到进程的时间片和负载信息
+- SCHED_IDLE 调度策略只在进行抢占处理的时候有一些特殊处理, 比如 check_preempt_curr() 中, 这里当前正在运行的如果是 SCHED_IDLE task 的话, 会马上被新唤醒的 SCHED_NORMAL task 抢占, 即 SCHED_NORMAL 的进程可以抢占 SCHED_IDLE 的进程.
-因此 Linux 社区里面并没有多少人会使用 SCHED_IDLE 调度策略, 因此自从Linux 2.6.23 引入之后, 就没人对它进行改进.
+因此 Linux 社区里面并没有多少人会使用 SCHED_IDLE 调度策略, 因此自从 Linux 2.6.23 引入之后, 就没人对它进行改进.
#### 1.1.5.1 引入 SCHED_IDLE
-------
@@ -308,13 +308,13 @@ SCHED_IDLE 跟 SCHED_BATCH 一样, 是 CFS 中的一个策略, SCHED\_IDLE 的
那么这就有一个矛盾的地方了, 那就是在选核的时候, 如果当前 CPU 上正运行 SCHED_IDLE 的进程. 那么选择这样的 CPU 更合适, 还是继续往下寻找 idle 的 CPU 更合适?
-* 当前的策略是倾向于是唤醒完全 idle 的 CPU, 而保持 SCHED_IDLE 进程继续占有原来的CPU. 这显然与 SCHED_NORMAL 可以抢占 SCHED_IDLE 的初衷相违背. 这样的好处是系统会更加均衡一些, 但是另外一方面唤醒 idle 的 CPU 是有一定延迟的, 在当前的 CPU 上这样的操作往往可能耗时若干 ms 的时间, 远远比一次抢占的时间要长.
+* 当前的策略是倾向于是唤醒完全 idle 的 CPU, 而保持 SCHED_IDLE 进程继续占有原来的 CPU. 这显然与 SCHED_NORMAL 可以抢占 SCHED_IDLE 的初衷相违背. 这样的好处是系统会更加均衡一些, 但是另外一方面唤醒 idle 的 CPU 是有一定延迟的, 在当前的 CPU 上这样的操作往往可能耗时若干 ms 的时间, 远远比一次抢占的时间要长.
* 另外一种策略就是抢占 SCHED_IDLE 进程, 这样可以保持完全 idle 的 CPU 继续 idle, 降低功耗;
第二种策略虽然从负载均衡看来, 系统貌似不那么均衡了, 但是看起来有诸多的好处. 于是一组特性 [sched/fair: Fallback to sched-idle CPU in absence of idle CPUs](https://lwn.net/Articles/805317), [patchwork](https://lore.kernel.org/patchwork/cover/1094197), [lkml-2019-06-26](https://lkml.org/lkml/2019/6/26/16) 被提出, 并于 5.4-rc1 合入主线.
-后续对此补丁还有一些细微的优化,比如 [sched/fair: Make sched-idle cpu selection consistent throughout 1143783 diffmboxseries](https://lore.kernel.org/patchwork/patch/1143783), 优化了选核的逻辑, 之前的逻辑中认为, 如果 find_idlest_group_cpu/sched_idle_core 中如果查找不到 avaliable_idle_cpu(处于 IDLE 状态的 CPU), 才寻找 sched_idle_cpu(运行 SCHED_IDLE 的 CPU), 即优先 IDLE, 其次 SCHED_IDLE. 而 select_idle_sibling 中则认为 avaliable_idle_cpu 和 sched_idle_cpu 都是可以接受的, 找到了任何一个满足要求的则返回. 可以看到不同的选核流程下, 对 avaliable_idle_cpu 和 sched_idle_cpu 的接受程度不同. 但是这其实本身就是一个没有对错的问题, 其实我们选核的时候, 不一定 IDLE 一定是最优的, 如果直接选一个 sched_idle_cpu 的 CPU 有时候是优于 avaliable_idle_cpu 的, 因为这些核是不需要(发 IPI)唤醒的. 因此这个补丁就将选核流程上做了归一, 所有的选核流程都将 avaliable_idle_cpu 和 sched_idle_cpu 同等对待, 只要找到了一个 avaliable_idle_cpu 或者 sched_idle_cpu 都是可以接受的, 没必要在 avaliable_idle_cpu 找不到的时候才去选则 sched_idle_cpu
+后续对此补丁还有一些细微的优化, 比如 [sched/fair: Make sched-idle cpu selection consistent throughout 1143783 diffmboxseries](https://lore.kernel.org/patchwork/patch/1143783), 优化了选核的逻辑, 之前的逻辑中认为, 如果 find_idlest_group_cpu/sched_idle_core 中如果查找不到 avaliable_idle_cpu(处于 IDLE 状态的 CPU), 才寻找 sched_idle_cpu(运行 SCHED_IDLE 的 CPU), 即优先 IDLE, 其次 SCHED_IDLE. 而 select_idle_sibling 中则认为 avaliable_idle_cpu 和 sched_idle_cpu 都是可以接受的, 找到了任何一个满足要求的则返回. 可以看到不同的选核流程下, 对 avaliable_idle_cpu 和 sched_idle_cpu 的接受程度不同. 但是这其实本身就是一个没有对错的问题, 其实我们选核的时候, 不一定 IDLE 一定是最优的, 如果直接选一个 sched_idle_cpu 的 CPU 有时候是优于 avaliable_idle_cpu 的, 因为这些核是不需要 (发 IPI) 唤醒的. 因此这个补丁就将选核流程上做了归一, 所有的选核流程都将 avaliable_idle_cpu 和 sched_idle_cpu 同等对待, 只要找到了一个 avaliable_idle_cpu 或者 sched_idle_cpu 都是可以接受的, 没必要在 avaliable_idle_cpu 找不到的时候才去选则 sched_idle_cpu
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:-----------:|:---:|
@@ -328,8 +328,8 @@ SCHED_IDLE 跟 SCHED_BATCH 一样, 是 CFS 中的一个策略, SCHED\_IDLE 的
|:----:|:----:|:---:|:---:|:-----------:|:---:|
| 2019/12/24 | Viresh Kumar | [sched/fair: Load balance aggressively for SCHED_IDLE CPUs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=323af6deaf70f204880caf94678350802682e0dc) | LOAD_BALANCE 感知 SCHED_IDLE 优化, SCHED_IDLE 的 CPU 虽然运行着进程但是在调度器看来其实也是空闲的, 应该积极地进行负载均衡 | v1 ☑✓ 5.6-rc1 | [LORE](https://lore.kernel.org/all/885b1be9af68d124f44a863f54e337f8eb6c4917.1577090998.git.viresh.kumar@linaro.org)
*-*-*-*-*-*-*-*
[LKML](https://lkml.org/lkml/2020/1/8/112) |
| 2021/02/22 | NA | [sched: pull tasks when CPU is about to run SCHED_IDLE tasks](https://lore.kernel.org/patchwork/patch/1382990) | 在 CPU 从 SCHED_NORMAL 进程切换到 SCHED_IDLE 任务之前, 尝试通过 load_balance 从其他核上 PULL SCHED_NORMAL 进程过来执行. | v2 | [2020/12/27 v1](https://lore.kernel.org/patchwork/patch/1356241), [2021/02/22 v2](https://lore.kernel.org/patchwork/patch/1143783) |
-| 2022/02/17 | Abel Wu | [introduce sched-idle balancing](https://lore.kernel.org/all/20220217154403.6497-1-wuyun.abel@bytedance.com) | 当前负载平衡主要基于 cpu capacity 和 task util, 这在整体吞吐量的 POV 中是有意义的. 虽然如果存在 sched 闲置或闲置 RQ, 则可以通过减少过载 CFS RQ 的数量来完成一些改进. 当 CFS RQ 上有多个可伸缩的非闲置任务时(因为 schedidle CPU 被视为闲置 CPU), CFS RQ 被认为是过载的. 空闲任务计入 rq->cfs.idle_h_nr_running.
过载的 CFS RQ 可能会导致两种任务类型的性能问题:
1. 对于诸如 SCHED_NORMAL 之类的延迟关键任务, RQ 中的等待时间将增加并导致更高的 PCT99 延迟, 并且如果存在 SCHED_DILE, 批处理任务 SCHED_BATCH 可能无法充分利用 CPU 容量, 因此吞吐量较差.
所以简而言之, sched-idle balancing 的目标是让非闲置任务充分利用 CPU 资源.
为此, 我们主要做两件事:
1. 为 sched-idle 的 CPU 拉取 non-idle 的任务来运行, 或者将 overload CPU 上的任务拉取到 idle 的 CPU 上.
2. 防止在 RQ 中 PULL 出最后一个非闲置任务. 此外 overloaded CPUs 的掩码会周期性更新, 空闲路径在 LLC 域上. 这个 cpumask 还将在 SIS 中用作过滤器, 改善空闲的 CPU 搜索. | v1 ☐☑✓ | [LORE v1,0/5](https://lore.kernel.org/all/20220217154403.6497-1-wuyun.abel@bytedance.com)
*-*-*-*-*-*-*-*
[LORE v2,0/2](https://lore.kernel.org/lkml/20220409135104.3733193-1-wuyun.abel@bytedance.com) |
-| 2022/08/09 | zhangsong | [sched/fair: Introduce priority load balance for CFS]](https://lore.kernel.org/all/20220809132945.3710583-1-zhangsong34@huawei.com) | 对于 NORMAL 和 IDLE 任务的共存, 当 CFS 触发负载均衡时, 将 NORMAL(Latency Sensitive) 任务从繁忙的 src CPU 迁移到 dst CPU, 最后迁移 IDLE 任务是合理的. 这对于减少 SCHED_IDLE 任务的干扰非常重要.
但是当前的 cfs_tasks 链表同时包含了 NORMAL 任务和 SCHED_IDLE 等任务, 且没有按照优先级进行排序, 因此无法保证能及时从 busiest 的等待队列中拉出一定数量的正常任务而不是空闲任务
因此需要将 cfs_tasks 分成两个不同的列表, 并确保非空闲列表中的任务能够首先迁移. 该补丁引入 cfs_idle_tasks 链表维护 SCHED_IDLE 的任务, 原来的 cfs_tasks 只维护 SCHED_NORMAL 的任务. 负载均衡时优先迁移 SCHED_NORMAL 的任务.
测试发现: 少量的 NORMAL 任务与大量的 IDLE 任务搭配, 通过该补丁, NORMAL 任务延迟较当前降低约 5~10%. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20220809132945.3710583-1-zhangsong34@huawei.com)
*-*-*-*-*-*-*-*
[LORE v2](https://lore.kernel.org/lkml/20220810015636.3865248-1-zhangsong34@huawei.com)
*-*-*-*-*-*-*-*
[LORE v3](https://lore.kernel.org/lkml/20220810092546.3901325-1-zhangsong34@huawei.com))
*-*-*-*-*-*-*-*
[LORE v4](https://lore.kernel.org/all/20221102035301.512892-1-zhangsong34@huawei.com) |
+| 2022/02/17 | Abel Wu | [introduce sched-idle balancing](https://lore.kernel.org/all/20220217154403.6497-1-wuyun.abel@bytedance.com) | 当前负载平衡主要基于 cpu capacity 和 task util, 这在整体吞吐量的 POV 中是有意义的. 虽然如果存在 sched 闲置或闲置 RQ, 则可以通过减少过载 CFS RQ 的数量来完成一些改进. 当 CFS RQ 上有多个可伸缩的非闲置任务时(因为 schedidle CPU 被视为闲置 CPU), CFS RQ 被认为是过载的. 空闲任务计入 rq->cfs.idle_h_nr_running.
过载的 CFS RQ 可能会导致两种任务类型的性能问题:
1. 对于诸如 SCHED_NORMAL 之类的延迟关键任务, RQ 中的等待时间将增加并导致更高的 PCT99 延迟, 并且如果存在 SCHED_DILE, 批处理任务 SCHED_BATCH 可能无法充分利用 CPU 容量, 因此吞吐量较差.
所以简而言之, sched-idle balancing 的目标是让非闲置任务充分利用 CPU 资源.
为此, 我们主要做两件事:
1. 为 sched-idle 的 CPU 拉取 non-idle 的任务来运行, 或者将 overload CPU 上的任务拉取到 idle 的 CPU 上.
2. 防止在 RQ 中 PULL 出最后一个非闲置任务. 此外 overloaded CPUs 的掩码会周期性更新, 空闲路径在 LLC 域上. 这个 cpumask 还将在 SIS 中用作过滤器, 改善空闲的 CPU 搜索. | v1 ☐☑✓ | [LORE v1,0/5](https://lore.kernel.org/all/20220217154403.6497-1-wuyun.abel@bytedance.com)
*-*-*-*-*-*-*-*
[LORE v2,0/2](https://lore.kernel.org/lkml/20220409135104.3733193-1-wuyun.abel@bytedance.com) |
+| 2022/08/09 | zhangsong | [sched/fair: Introduce priority load balance for CFS]](https://lore.kernel.org/all/20220809132945.3710583-1-zhangsong34@huawei.com) | 对于 NORMAL 和 IDLE 任务的共存, 当 CFS 触发负载均衡时, 将 NORMAL(Latency Sensitive) 任务从繁忙的 src CPU 迁移到 dst CPU, 最后迁移 IDLE 任务是合理的. 这对于减少 SCHED_IDLE 任务的干扰非常重要.
但是当前的 cfs_tasks 链表同时包含了 NORMAL 任务和 SCHED_IDLE 等任务, 且没有按照优先级进行排序, 因此无法保证能及时从 busiest 的等待队列中拉出一定数量的正常任务而不是空闲任务
因此需要将 cfs_tasks 分成两个不同的列表, 并确保非空闲列表中的任务能够首先迁移. 该补丁引入 cfs_idle_tasks 链表维护 SCHED_IDLE 的任务, 原来的 cfs_tasks 只维护 SCHED_NORMAL 的任务. 负载均衡时优先迁移 SCHED_NORMAL 的任务.
测试发现: 少量的 NORMAL 任务与大量的 IDLE 任务搭配, 通过该补丁, NORMAL 任务延迟较当前降低约 5~10%. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20220809132945.3710583-1-zhangsong34@huawei.com)
*-*-*-*-*-*-*-*
[LORE v2](https://lore.kernel.org/lkml/20220810015636.3865248-1-zhangsong34@huawei.com)
*-*-*-*-*-*-*-*
[LORE v3](https://lore.kernel.org/lkml/20220810092546.3901325-1-zhangsong34@huawei.com))
*-*-*-*-*-*-*-*
[LORE v4](https://lore.kernel.org/all/20221102035301.512892-1-zhangsong34@huawei.com) |
| 2022/08/25 | Vincent Guittot | [sched/fair: fixes in presence of lot of sched_idle tasks](https://lore.kernel.org/all/20220825122726.20819-1-vincent.guittot@linaro.org) | TODO | v1 ☐☑✓ | [LORE v1,0/4](https://lore.kernel.org/all/20220825122726.20819-1-vincent.guittot@linaro.org) |
| 2022/10/03 | Vincent Guittot | [sched/fair: limit sched slice duration](https://lore.kernel.org/all/20221003122111.611-1-vincent.guittot@linaro.org) | TODO | v3 ☐☑✓ | [LORE](https://lore.kernel.org/all/20221003122111.611-1-vincent.guittot@linaro.org) |
@@ -339,7 +339,7 @@ SCHED_IDLE 跟 SCHED_BATCH 一样, 是 CFS 中的一个策略, SCHED\_IDLE 的
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:-----------:|:---:|
-| 2021/08/20 | Josh Don |[cgroup SCHED_IDLE support/SCHED_IDLE extensions](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=304000390f88d049c85e9a0958ac5567f38816ee) | 1. cgroup [组支持 SCHED_IDLE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=304000390f88)
2. RQ 上维护了 [idle_nr_running](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a480addecc0d) 的跟踪.
3. 引入 [`sysctl_sched_idle_min_granularity`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=51ce83ed523b), 当 SCHED_IDLE 任务与正常任务竞争时适用, 表示 SCHED_IDLE 任务的最小抢占粒度. 这样在与普通实体竞争时, 通过对 SCHED_IDLE 的调度实体使用较小的、无伸缩性的最小抢占粒度(由 sched_slice 计算). 可以减少普通调度实体切回来的延迟, 但代价是增加了SCHED_IDLE实体的上下文切换频率. 有效地减少了普通调度实体在与 SCHED_IDLE 调度实体竞争时的轮询延迟.
4. 在 place_entity() 中对于 `SCHED_IDLE` 实体唤醒时得到的补偿减少到 `sysctl_sched_min_granularity`. 因此, 唤醒的 SCHED_IDLE 实体将花费更长的时间来抢占正常实体. 此更改的好处是, 降低了新唤醒的 `SCHED_IDLE` 实体在阻塞之前抢占短期运行的普通调度实体的可能性. | v3 ☑ [5.15-rc1](https://kernelnewbies.org/LinuxChanges#Linux_5.15.cgroup_support_for_SCHED_IDLE) | [2021/06/08 v1](https://lore.kernel.org/lkml/20210608231132.32012-1-joshdon@google.com)
*-*-*-*-*-*-*-*
[2021/7/29 LKML v2 0/2](https://lkml.org/lkml/2021/7/29/1201)
*-*-*-*-*-*-*-*
[2021/08/20 LORE v3,0/4](https://lore.kernel.org/all/20210820010403.946838-1-joshdon@google.com)
*-*-*-*-*-*-*-*
[关键 commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=304000390f88d049c85e9a0958ac5567f38816ee) |
+| 2021/08/20 | Josh Don |[cgroup SCHED_IDLE support/SCHED_IDLE extensions](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=304000390f88d049c85e9a0958ac5567f38816ee) | 1. cgroup [组支持 SCHED_IDLE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=304000390f88)
2. RQ 上维护了 [idle_nr_running](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a480addecc0d) 的跟踪.
3. 引入 [`sysctl_sched_idle_min_granularity`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=51ce83ed523b), 当 SCHED_IDLE 任务与正常任务竞争时适用, 表示 SCHED_IDLE 任务的最小抢占粒度. 这样在与普通实体竞争时, 通过对 SCHED_IDLE 的调度实体使用较小的、无伸缩性的最小抢占粒度(由 sched_slice 计算). 可以减少普通调度实体切回来的延迟, 但代价是增加了 SCHED_IDLE 实体的上下文切换频率. 有效地减少了普通调度实体在与 SCHED_IDLE 调度实体竞争时的轮询延迟.
4. 在 place_entity() 中对于 `SCHED_IDLE` 实体唤醒时得到的补偿减少到 `sysctl_sched_min_granularity`. 因此, 唤醒的 SCHED_IDLE 实体将花费更长的时间来抢占正常实体. 此更改的好处是, 降低了新唤醒的 `SCHED_IDLE` 实体在阻塞之前抢占短期运行的普通调度实体的可能性. | v3 ☑ [5.15-rc1](https://kernelnewbies.org/LinuxChanges#Linux_5.15.cgroup_support_for_SCHED_IDLE) | [2021/06/08 v1](https://lore.kernel.org/lkml/20210608231132.32012-1-joshdon@google.com)
*-*-*-*-*-*-*-*
[2021/7/29 LKML v2 0/2](https://lkml.org/lkml/2021/7/29/1201)
*-*-*-*-*-*-*-*
[2021/08/20 LORE v3,0/4](https://lore.kernel.org/all/20210820010403.946838-1-joshdon@google.com)
*-*-*-*-*-*-*-*
[关键 commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=304000390f88d049c85e9a0958ac5567f38816ee) |
| 2022/10/27 | Chuyi Zhou | [sched/fair: favor non-idle group in tick preemption](https://lore.kernel.org/all/20221027081630.34081-1-zhouchuyi@bytedance.com) | [commit 304000390f88 ("sched: Cgroup SCHED_IDLE support")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=304000390f88d049c85e9a0958ac5567f38816ee) 在支持了 group 级别的 SCHED_IDLE 时, 在 check_preempt_wakeup() 路径下, 实现了 SCHED_IDLE 的感知, 总是[倾向于抢占空闲的 group sched_entity 而不是非空闲 group sched_entity 组](https://elixir.bootlin.com/linux/v5.15/source/kernel/sched/fair.c#L7125), 反之不允许抢占. 但是 check_preempt_tick() 中却没有感知 SCHED_IDLE, 类似地非空闲的 sched_entity 相对于空闲 sched_entity 应该更具有竞争优势. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20221027081630.34081-1-zhouchuyi@bytedance.com) |
@@ -347,7 +347,7 @@ SCHED_IDLE 跟 SCHED_BATCH 一样, 是 CFS 中的一个策略, SCHED\_IDLE 的
### 1.1.6 吭哧吭哧跑计算 SCHED\_BATCH
-------
-**2.6.16(2006年3月发布)**
+**2.6.16(2006 年 3 月发布)**
概述中讲到 SCHED\_BATCH 并非 POSIX 标准要求的调度策略, 而是 Linux 自己额外支持的.
@@ -358,9 +358,9 @@ SCHED_IDLE 跟 SCHED_BATCH 一样, 是 CFS 中的一个策略, SCHED\_IDLE 的
-从 Linux 2.6.16 开始, SCHED\_BATCH 可以用于静态优先级为 0 的线程. 该策略类似 SCHED_NORMAL, 并根据动态优先级(nice值)进行调度. 区别是使用该策略时, 调度器会假设线程是 CPU 密集型的, 因此, 该调度器会根据线程的唤醒行为施加调度惩罚, 因此这种调度策略比较不受欢迎.
+从 Linux 2.6.16 开始, SCHED\_BATCH 可以用于静态优先级为 0 的线程. 该策略类似 SCHED_NORMAL, 并根据动态优先级 (nice 值) 进行调度. 区别是使用该策略时, 调度器会假设线程是 CPU 密集型的, 因此, 该调度器会根据线程的唤醒行为施加调度惩罚, 因此这种调度策略比较不受欢迎.
-该策略比较适用于非交互且不期望降低 nice 值的负载, 以及需要不因为交互而(在负载之间)造成额外抢占的调度策略的负载
+该策略比较适用于非交互且不期望降低 nice 值的负载, 以及需要不因为交互而 (在负载之间) 造成额外抢占的调度策略的负载
[batch/idle priority scheduling, SCHED_BATCH](https://lwn.net/Articles/3866)
@@ -371,7 +371,7 @@ SCHED_IDLE 跟 SCHED_BATCH 一样, 是 CFS 中的一个策略, SCHED\_IDLE 的
| 2007/12/04 | Ingo Molnar | [8ca0e14ffb12 sched: disable sleeper_fairness on SCHED_BATCH](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8ca0e14ffb12) | NA | v1 ☑ 2.6.24-rc1 | [PATCH HISTORY](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8ca0e14ffb12) |
| 2007/12/04 | Ingo Molnar | [91c234b4e341 sched: do not wakeup-preempt with SCHED_BATCH tasks](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=91c234b4e341) | 不要用 SCHED\_BATCH 任务唤醒时抢占其他进程, 它们的抢占由 tick 驱动. | v1 ☑ 2.6.24-rc5 | [PATCH HISTORY](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=91c234b4e341) |
| 2007/12/04 | Ingo Molnar | [db292ca302e8 sched: default to more agressive yield for SCHED_BATCH tasks](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=db292ca302e8) | 对 SCHED\_BATCH 调优的任务执行更积极的 yield. | v1 ☑ 2.6.24-rc5 | [PATCH HISTORY](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=db292ca302e8) |
-| 2007/12/18 | Ingo Molnar | [6cbf1c126cf6 sched: do not hurt SCHED_BATCH on wakeup](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6cbf1c126cf6) | Yanmin Zhang的测量表明, 如果 SCHED\_BATCH 任务运行与 SCHED\_OTHER 任务相同的 place_entity() 逻辑, 则它们将受益. 因此统一该领域的行为. SCHED\_BATCH 进程唤醒时 vruntime 也将进行补偿. | v1 ☑ 2.6.24-rc6 | [PATCH HISTORY](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6cbf1c126cf6) |
+| 2007/12/18 | Ingo Molnar | [6cbf1c126cf6 sched: do not hurt SCHED_BATCH on wakeup](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6cbf1c126cf6) | Yanmin Zhang 的测量表明, 如果 SCHED\_BATCH 任务运行与 SCHED\_OTHER 任务相同的 place_entity() 逻辑, 则它们将受益. 因此统一该领域的行为. SCHED\_BATCH 进程唤醒时 vruntime 也将进行补偿. | v1 ☑ 2.6.24-rc6 | [PATCH HISTORY](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6cbf1c126cf6) |
| 2011/02/22 | Darren Hart | [a2f5c9ab79f7 sched: Allow SCHED_BATCH to preempt SCHED_IDLE tasks](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a2f5c9ab79f7) | 非交互式任务 SCHED\_BATCH 仍然比 SCHED_BATCH 的任务重要, 因此应该优先于 SCHED\_IDLE 的任务唤醒和运行. | v1 ☑ 2.6.39-rc1 | [PATCH HISTORY](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a2f5c9ab79f7) |
| 2022/03/11 | Chen Ying | [sched/fair: prioritize normal task over sched_idle task with vruntime offset](https://lore.kernel.org/all/f87a8c0d-527d-a9bc-9653-ff955e0e95b4@bytedance.com) | 对 SCHED_IDLE 类型的进程, 将其 vruntime 添加一个 sched_idle_vruntime_offset 的增量, 从而保证 SCHED_IDLE 进程的 sched_entity 在 CFS 红黑树中总是在非 SCHED_IDLE sched_entity 的右侧. 这可以允许选择非 SCHED_IDLE 任务, 并在空闲任务之前运行. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/f87a8c0d-527d-a9bc-9653-ff955e0e95b4@bytedance.com) |
@@ -385,24 +385,24 @@ RT 有两种调度策略, SCHED_FIFO 先到先服务 和 SCHED_RR 时间片轮
系统中的实时进程将比 CFS 优先得到调度, 实时进程根据实时优先级决定调度权值
-RR进程和FIFO进程都采用实时优先级做为调度的权值标准, RR是FIFO的一个延伸. FIFO时, 如果两个进程的优先级一样, 则这两个优先级一样的进程具体执行哪一个是由其在队列中的位置决定的, 这样导致一些不公正性(优先级是一样的, 为什么要让你一直运行?),如果将两个优先级一样的任务的调度策略都设为RR,则保证了这两个任务可以循环执行, 保证了公平.
+RR 进程和 FIFO 进程都采用实时优先级做为调度的权值标准, RR 是 FIFO 的一个延伸. FIFO 时, 如果两个进程的优先级一样, 则这两个优先级一样的进程具体执行哪一个是由其在队列中的位置决定的, 这样导致一些不公正性(优先级是一样的, 为什么要让你一直运行?), 如果将两个优先级一样的任务的调度策略都设为 RR, 则保证了这两个任务可以循环执行, 保证了公平.
-SHCED_RR和SCHED_FIFO的不同:
+SHCED_RR 和 SCHED_FIFO 的不同:
-1. 当采用SHCED_RR策略的进程的时间片用完, 系统将重新分配时间片, 并置于就绪队列尾. 放在队列尾保证了所有具有相同优先级的RR任务的调度公平.
+1. 当采用 SHCED_RR 策略的进程的时间片用完, 系统将重新分配时间片, 并置于就绪队列尾. 放在队列尾保证了所有具有相同优先级的 RR 任务的调度公平.
-2. SCHED_FIFO一旦占用cpu则一直运行. 一直运行直到有更高优先级任务到达或自己放弃.
+2. SCHED_FIFO 一旦占用 cpu 则一直运行. 一直运行直到有更高优先级任务到达或自己放弃.
-3. 如果有相同优先级的实时进程(根据优先级计算的调度权值是一样的)已经准备好, FIFO时必须等待该进程主动放弃后才可以运行这个优先级相同的任务. 而RR可以让每个任务都执行一段时间.
+3. 如果有相同优先级的实时进程 (根据优先级计算的调度权值是一样的) 已经准备好, FIFO 时必须等待该进程主动放弃后才可以运行这个优先级相同的任务. 而 RR 可以让每个任务都执行一段时间.
相同点:
-1. RR和FIFO都只用于实时任务.
+1. RR 和 FIFO 都只用于实时任务.
-2. 创建时优先级大于0(1-99).
+2. 创建时优先级大于 0(1-99).
3. 按照可抢占优先级调度算法进行.
@@ -414,15 +414,15 @@ SHCED_RR和SCHED_FIFO的不同:
用户总是期望 RT 来完成一些非常紧急, 尽管 linux 不是一个严格意义上的实时内核, 但是也要保证 RT 的实时性, 但是总有一些场景会打破这种限制. 一个进程组中的 RT 任务或者不同用户的 RT 任务, 在一个环境下运行. 如果某些 RT 进程负载非常大, 经常在一段时间内把整个 CPU 占满了, 还有一些 RT 进程往往只是偶尔在非常紧急的时候出来运行.
由于 RT_BANDWIDTH 机制的存在, 当一个 CPU 上的 RT 配额被某个 RT 进程吃掉的时候, 如果这时候也放弃其他的 CPU 是非常不公平, 不实时的. 假如车载事实场景上, 发现系统故障了, 要紧急刹车, 这个处理任务是个 RT 进程, 当他被唤醒了, 但是却发现没有配额无法运行. 那岂不是要出大问题的. 因此内核提供了 RT_RUNTIME_SHARE 特性. 如果当前 RT 队列的运行时间超过了最大运行时间, 则可以从其他 cpu 上借用时间. 只要整个系统中其他 CPU 上有 RT 的配额, 那这个 CPU 上 RT 进程就可以继续运行. 从而可以尽可能的保证 RT 的实时性要求.
-RT_RUNTIME_SHARE 这个机制本身是为了解决不同 CPU 上, 以及不同分组的 RT 进程繁忙程度不同, 从而一些运行时间不长的进程因为其他繁忙的 RT 进程占用 CPU 导致被限流的不公平性/不实时的问题. 但是却导致了上述提到的 RT_BANDWIDTH 失效. 因此当 RT 可以源源不断的从其他 CPU 上窃取时间, 将会造成本核上 CFS 进程无法得到调度而出现饿死.
+RT_RUNTIME_SHARE 这个机制本身是为了解决不同 CPU 上, 以及不同分组的 RT 进程繁忙程度不同, 从而一些运行时间不长的进程因为其他繁忙的 RT 进程占用 CPU 导致被限流的不公平性 / 不实时的问题. 但是却导致了上述提到的 RT_BANDWIDTH 失效. 因此当 RT 可以源源不断的从其他 CPU 上窃取时间, 将会造成本核上 CFS 进程无法得到调度而出现饿死.
内核社区对此特性多有异议, 但是却一直没有什么完美的解决方案, 之前提出的一些方案也都没有被接受:
[sched/rt: RT_RUNTIME_GREED sched feature](https://lore.kernel.org/patchwork/patch/732374) 实现了一套有环保意识的解决方案, 当发现当前 RT 可以窃取时间, 但是有其他 CFS 进程已经在等待的时候, 那么他将主动放弃窃取的机会, 让位给 CFS 进程运行.
[sched/rt: disable RT_RUNTIME_SHARE by default and document it](https://lore.kernel.org/patchwork/cover/735472) 既然解决方案不被认可, 那就接受他. 但是默认把他禁用, 同时在注释中强烈的标注这个问题, 来表达自己迫切不想再出问题的愿望.
-> 通过设置/proc/sys/kernel/sched_rt_runtime_us 和/proc/sys/kernel/sched_rt_period_us配合实现; sched_rt_period_us默认值是1s(1000000us), sched_rt_runtime_us默认是0.95s(950000us); 通过此项配置的RT进程利用率, 是针对整个CPU的, 对于多核处理器, 每个CPU仍然可以跑到100%, 那么怎么让每cpu的利用率都是95%呢?可以设置
-> echo NO_RT_RUNTIME_SHARE > /sys/kernel/debug/sched_features; 这样每个核不去借用别的cpu时间, 可以达到95%的限制
+> 通过设置 / proc/sys/kernel/sched_rt_runtime_us 和 / proc/sys/kernel/sched_rt_period_us 配合实现; sched_rt_period_us 默认值是 1s(1000000us), sched_rt_runtime_us 默认是 0.95s(950000us); 通过此项配置的 RT 进程利用率, 是针对整个 CPU 的, 对于多核处理器, 每个 CPU 仍然可以跑到 100%, 那么怎么让每 cpu 的利用率都是 95% 呢?可以设置
+> echo NO_RT_RUNTIME_SHARE > /sys/kernel/debug/sched_features; 这样每个核不去借用别的 cpu 时间, 可以达到 95% 的限制
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
@@ -436,7 +436,7 @@ RT_RUNTIME_SHARE 这个机制本身是为了解决不同 CPU 上, 以及不同
## 1.3 十万火急, 限期完成 SCHED\_DEADLINE
-------
-**3.14(2014年3月发布)**
+**3.14(2014 年 3 月发布)**
此策略支持的是一种实时任务. 对于某些实时任务, 具有阵发性(sporadic), 它们阵发性地醒来执行任务, 且任务有 deadline 要求, 因此要保证在 deadline 时间到来前完成. 为了完成此目标, 采用该 SCHED\_DEADLINE 的任务是系统中最高优先级的, 它们醒来时可以抢占任何进程.
@@ -466,7 +466,7 @@ RT_RUNTIME_SHARE 这个机制本身是为了解决不同 CPU 上, 以及不同
此外还有 [xanmod](https://github.com/xanmod/linux) 补丁集.
-同样 [linux-tkg](https://github.com/Frogging-Family/linux-tkg) 是一个高度可定制的内核构建系统, 提供一系列补丁和调整, 旨在提高桌面和游戏性能. 它由Etienne Juvigny维护. 在其他补丁中, 它提供了各种CPU调度程序: CFS, Project C PDS, Project C BMQ, MuQSS 和 CacULE.
+同样 [linux-tkg](https://github.com/Frogging-Family/linux-tkg) 是一个高度可定制的内核构建系统, 提供一系列补丁和调整, 旨在提高桌面和游戏性能. 它由 Etienne Juvigny 维护. 在其他补丁中, 它提供了各种 CPU 调度程序: CFS, Project C PDS, Project C BMQ, MuQSS 和 CacULE.
参考 [ARCHLINUX Kernel WIKI](https://wiki.archlinux.org/title/kernel).
@@ -500,7 +500,7 @@ linux 调度器定义了多个调度类, 不同调度类的调度优先级不同
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
-| 2019/12/19 | Kirill Tkhai | [sched: Micro optimization in pick_next_task() and in check_preempt_curr()](https://lore.kernel.org/patchwork/cover/1170294) | 在二进制中通过 xxx_sched_class 地址顺序标记调度类的优先级, 从而可以通过直接比较两个 xxx_sched_class 地址的方式, 优化调度器中两个热点函数 pick_next_task()和check_preempt_curr(). | v2 ☐ |[PatchWork RFC](https://lore.kernel.org/patchwork/cover/1170249)
*-*-*-*-*-*-*-*
[PatchWork v2](https://lore.kernel.org/patchwork/cover/1170294) |
+| 2019/12/19 | Kirill Tkhai | [sched: Micro optimization in pick_next_task() and in check_preempt_curr()](https://lore.kernel.org/patchwork/cover/1170294) | 在二进制中通过 xxx_sched_class 地址顺序标记调度类的优先级, 从而可以通过直接比较两个 xxx_sched_class 地址的方式, 优化调度器中两个热点函数 pick_next_task()和 check_preempt_curr(). | v2 ☐ |[PatchWork RFC](https://lore.kernel.org/patchwork/cover/1170249)
*-*-*-*-*-*-*-*
[PatchWork v2](https://lore.kernel.org/patchwork/cover/1170294) |
| 2019/12/19 | Steven Rostedt | [sched: Optimizations to sched_class processing](https://lore.kernel.org/patchwork/cover/1170901) | 对上面补丁的进一步优化, 对齐数据结构保证 cache 对齐, 通过链接脚本保证数据的排布顺序. | RFC ☑ 5.9-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/1170901) |
这组补丁在 5.9-rc1 时合入主线, 至此, 我们可以[直接在调度器中通过比较地址高低, 直接判断两个调度类的优先级](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=aa93cd53bc1b91b5f99c7b55e3dcc1ac98e99558). 当然这组补丁还有个附带的好处, 就是 `kernel/sched/core.o` 的二进制体积更小了.
@@ -525,11 +525,11 @@ linux 调度器定义了多个调度类, 不同调度类的调度优先级不同
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
| 2010/6/8 | Michael Neuling | [sched: asymmetrical packing for POWER7 SMT4](https://lkml.org/lkml/2010/6/8/6) | POWER7 是 SMT4, 并且支持动态 SMT 模式切换, 为内核调度器带来了挑战.
1. 首先是[对 CPU power 和 capacity 的处理](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9d5efe05eb0c904545a28b19c18b949f23334de0), 如果简单的认为每个 CPU power 为 total/4, 则值很小, 极容易被调度器认为 CPU capacity 为 0, 无法再容纳新的进程, 从而导致进程在核间来回跳跃.
2. POWER7 硬件动态 SMT 模式切换, 但是只有当更高编号的 CPU thread 处于空闲状态时, 它才能转移到 lower SMT 模式(比如从 SMT4 切换到 SMT2/SMT1). 在 lower SMT 模式下, 进程的性能会更好, 因为它们共享的核心资源更少. 为了解决 SMT4 上线程性能下降的问题, 倾向于将进程打包运行在编号小的 CPU 上. 通过 check_asym_packing() 来检查是否需要主动进行打包. 并增加了 [SD_ASYM_PACKING](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=532cb4c401e225b084c14d6bd6a2f8ee561de2f1) 标志, 从而可以以在任何调度域级别启用该特性. 当前[只在 SMT 域级别开启](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=76cbd8a8f8b0dddbff89a6708bd5bd13c0d21a00). | v1 ☑ 2.6.36-rc1 | [PatchWork 0/3](https://patchwork.ozlabs.org/project/linuxppc-dev/patch/20100608045702.2936CCC897@localhost.localdomain), [LORE 0/3](https://lore.kernel.org/lkml/1275973022.91203.586435002889.qpush@pale) |
-| 2016/11/11 | Tim Chen | [Support Intel Turbo Boost Max Technology 3.0](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=17669006adf64d35a74cb21e3c8dfb6fb8be689f) | 支持 [Intel Turbo Boost Max Technology 3.0 (ITMT)](http://www.intel.com/content/www/us/en/architecture-and-technology/turbo-boost/turbo-boost-max-technology.html) 技术, 通过 ITMT 技术硬件可以将 package 中的某些 CPU 提升到更高的 Turbo 频率, 调度器通过对非对称打包(ASYM_PACKING)功能进行扩展, 将关键任务等移动到 Turbo 的 CPU, 从而提升性能. | v8 ☑ 4.10-rc1 | [PatchWork v8,0/8](https://lore.kernel.org/all/cover.1479844244.git.tim.c.chen@linux.intel.com) |
+| 2016/11/11 | Tim Chen | [Support Intel Turbo Boost Max Technology 3.0](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=17669006adf64d35a74cb21e3c8dfb6fb8be689f) | 支持 [Intel Turbo Boost Max Technology 3.0 (ITMT)](http://www.intel.com/content/www/us/en/architecture-and-technology/turbo-boost/turbo-boost-max-technology.html) 技术, 通过 ITMT 技术硬件可以将 package 中的某些 CPU 提升到更高的 Turbo 频率, 调度器通过对非对称打包 (ASYM_PACKING) 功能进行扩展, 将关键任务等移动到 Turbo 的 CPU, 从而提升性能. | v8 ☑ 4.10-rc1 | [PatchWork v8,0/8](https://lore.kernel.org/all/cover.1479844244.git.tim.c.chen@linux.intel.com) |
| 2016/04/06 | Srikar Dronamraju | [sched/fair: Fix asym packing to select correct cpu](https://lore.kernel.org/all/1459948660-16073-1-git-send-email-srikar@linux.vnet.ibm.com) | NA | v2 ☑ 4.7-rc1 | [PatchWork v2](https://lore.kernel.org/all/1459948660-16073-1-git-send-email-srikar@linux.vnet.ibm.com) |
| 2016/12/29 | Peter Oskolkov | [sched/x86: Change CONFIG_SCHED_ITMT to CONFIG_SCHED_MC_PRIO](https://lore.kernel.org/all/2b2ee29d93e3f162922d72d0165a1405864fbb23.1480444902.git.tim.c.chen@linux.intel.com) | 将 ITMT 的 CONFIG_SCHED_ITMT 更新为 CONFIG_SCHED_MC_PRIO, 这使得该配置在将来可以扩展到希望在调度器中类似地建立 CPU 核心优先级支持的其他体系结构. | v1 ☑ 4.10-rc1 | [PatchWork](https://lore.kernel.org/all/2b2ee29d93e3f162922d72d0165a1405864fbb23.1480444902.git.tim.c.chen@linux.intel.com) |
| 2019/1/17 | Vincent Guittot | [sched/fair: some fixes for asym_packing](https://lkml.org/lkml/2019/1/17/658) | NA | v2 ☑ 5.1-rc1 | [LKML v3,0/3](https://lkml.org/lkml/2018/12/20/616), [PatchWork v3,0/3](https://lore.kernel.org/all/1545292547-18770-1-git-send-email-vincent.guittot@linaro.org)
*-*-*-*-*-*-*-*
[LKML v4,0/3](https://lkml.org/lkml/2019/1/17/658) |
-| 2021/09/10 | Ricardo Neri | [sched/fair: Fix load balancing of SMT siblings with ASYM_PACKING](https://lore.kernel.org/patchwork/cover/1428441) | 在使用非对称封装(ASM_PACKING)时, 可能存在具有三个优先级的 CPU 拓扑, 其中只有物理核心的子集支持 SMT. 这种架构下 ASM_PACKING 和 SMT 以及 load_balance 都存在冲突.
这种拓扑的一个实例是 Intel Alder Lake. 在 Alder Lake 上, 应该通过首先选择 Core(酷睿) cpu, 然后选择 Atoms, 最后再选择 Core 的 SMT 兄弟 cpu 来分散工作. 然而, 当前负载均衡器的行为与使用 ASYM_PACKING 时描述的不一致. 负载平衡器将选择高优先级的 CPU (Intel Core) 而不是中优先级的 CPU (Intel Atom), 然后将负载溢出到低优先级的 SMT 同级 CPU. 这使得中等优先级的 Atoms cpu 空闲, 而低优先级的 cpu sibling 繁忙.
1. 首先改善了 SMT 中 sibling cpu 优先级的计算方式, 它将比单个 core 优先级更低.
2. 当决定目标 CPU 是否可以从最繁忙的 CPU 提取任务时, 还检查执行负载平衡的 CPU 和最繁忙的候选组的 SMT 同级 CPU 的空闲状态. | v5 ☑ 5.16-rc1 | [PatchWork v1](https://lore.kernel.org/patchwork/cover/1408312)
*-*-*-*-*-*-*-*
[PatchWork v2](https://lore.kernel.org/patchwork/cover/1413015)
*-*-*-*-*-*-*-*
[PatchWork v3 0/6](https://lore.kernel.org/patchwork/cover/1428441)
*-*-*-*-*-*-*-*
[PatchWork v4,0/6](https://lore.kernel.org/patchwork/cover/1474500)
*-*-*-*-*-*-*-*
[LKML v5,0/6](https://lkml.org/lkml/2021/9/10/913), [LORE v5,0/6](https://lore.kernel.org/all/20210911011819.12184-1-ricardo.neri-calderon@linux.intel.com) |
+| 2021/09/10 | Ricardo Neri | [sched/fair: Fix load balancing of SMT siblings with ASYM_PACKING](https://lore.kernel.org/patchwork/cover/1428441) | 在使用非对称封装 (ASM_PACKING) 时, 可能存在具有三个优先级的 CPU 拓扑, 其中只有物理核心的子集支持 SMT. 这种架构下 ASM_PACKING 和 SMT 以及 load_balance 都存在冲突.
这种拓扑的一个实例是 Intel Alder Lake. 在 Alder Lake 上, 应该通过首先选择 Core(酷睿) cpu, 然后选择 Atoms, 最后再选择 Core 的 SMT 兄弟 cpu 来分散工作. 然而, 当前负载均衡器的行为与使用 ASYM_PACKING 时描述的不一致. 负载平衡器将选择高优先级的 CPU (Intel Core) 而不是中优先级的 CPU (Intel Atom), 然后将负载溢出到低优先级的 SMT 同级 CPU. 这使得中等优先级的 Atoms cpu 空闲, 而低优先级的 cpu sibling 繁忙.
1. 首先改善了 SMT 中 sibling cpu 优先级的计算方式, 它将比单个 core 优先级更低.
2. 当决定目标 CPU 是否可以从最繁忙的 CPU 提取任务时, 还检查执行负载平衡的 CPU 和最繁忙的候选组的 SMT 同级 CPU 的空闲状态. | v5 ☑ 5.16-rc1 | [PatchWork v1](https://lore.kernel.org/patchwork/cover/1408312)
*-*-*-*-*-*-*-*
[PatchWork v2](https://lore.kernel.org/patchwork/cover/1413015)
*-*-*-*-*-*-*-*
[PatchWork v3 0/6](https://lore.kernel.org/patchwork/cover/1428441)
*-*-*-*-*-*-*-*
[PatchWork v4,0/6](https://lore.kernel.org/patchwork/cover/1474500)
*-*-*-*-*-*-*-*
[LKML v5,0/6](https://lkml.org/lkml/2021/9/10/913), [LORE v5,0/6](https://lore.kernel.org/all/20210911011819.12184-1-ricardo.neri-calderon@linux.intel.com) |
### 1.5.4 SMT
@@ -549,18 +549,18 @@ linux 调度器定义了多个调度类, 不同调度类的调度优先级不同
core_scheduling 与 coscheduling
-* core_scheduling 是近几年(笔者当前时间 2021 年 1 月)争议颇大的一个功能.
+* core_scheduling 是近几年 (笔者当前时间 2021 年 1 月) 争议颇大的一个功能.
-随着 Intel CPU 漏洞的公布, 内核也开始关注之前硬件的一些设计所带来性能提升的同时, 引入的一些安全问题. SMT 超线程技术(simultaneous multi-threading, 或者"hyperthreading", 超线程), 通过将一个物理 core 虚拟成2个或者多个 CPU thread(PE), 从而充分使用 CPU 的流水线技术, 为了提升性能, CPU 上进程运行时的数据不可避免会被加载到 cache 中, 由于这些 cpu thread 物理上是一个 core, 因此不能排除某些不怀好意的用户或者进程可以通过窥测的方式, 窥测同一个 core 上其他进程的隐私数据, 虽然这较难实施, 但是目前是不可屏蔽的. 这被称为 侧信道攻击.
+随着 Intel CPU 漏洞的公布, 内核也开始关注之前硬件的一些设计所带来性能提升的同时, 引入的一些安全问题. SMT 超线程技术(simultaneous multi-threading, 或者"hyperthreading", 超线程), 通过将一个物理 core 虚拟成 2 个或者多个 CPU thread(PE), 从而充分使用 CPU 的流水线技术, 为了提升性能, CPU 上进程运行时的数据不可避免会被加载到 cache 中, 由于这些 cpu thread 物理上是一个 core, 因此不能排除某些不怀好意的用户或者进程可以通过窥测的方式, 窥测同一个 core 上其他进程的隐私数据, 虽然这较难实施, 但是目前是不可屏蔽的. 这被称为 侧信道攻击.
-> 一个SMT 核包含两个或者更多的CPU(有时候也被称为"hardware threads")都共享很多底层硬件. 这里共享的包括一部分cache, 这样导致SMT可能会受基于cache进行的side-channel攻击.
+> 一个 SMT 核包含两个或者更多的 CPU(有时候也被称为"hardware threads")都共享很多底层硬件. 这里共享的包括一部分 cache, 这样导致 SMT 可能会受基于 cache 进行的 side-channel 攻击.
-Core scheduling 最开始的讨论来自 Julien Desfossez 和 Vineeth Remanan Pillai. 主要目的是为了让 SMT能更加安全, 不受 speculative-execution 类型的攻击. 它的主要思路是通过一些手段(当前实现是 cgoup cpu subsystem)标记一组进程之间的相互信任的, 这组进程通常是一个单独的用户, 或者一组单独的进程, 假设他们至少彼此任务自己不是不怀好意的, 或者即使是不怀好意的, 也是用户有意为之, 影响也只是自己. 那么 core scheduling 将只允许两个相互之间信任的进程运行在一个 SMT 的两个 thread 上. 不信任的线程, 将不能在一个 core 上协同运行.
+Core scheduling 最开始的讨论来自 Julien Desfossez 和 Vineeth Remanan Pillai. 主要目的是为了让 SMT 能更加安全, 不受 speculative-execution 类型的攻击. 它的主要思路是通过一些手段 (当前实现是 cgoup cpu subsystem) 标记一组进程之间的相互信任的, 这组进程通常是一个单独的用户, 或者一组单独的进程, 假设他们至少彼此任务自己不是不怀好意的, 或者即使是不怀好意的, 也是用户有意为之, 影响也只是自己. 那么 core scheduling 将只允许两个相互之间信任的进程运行在一个 SMT 的两个 thread 上. 不信任的线程, 将不能在一个 core 上协同运行.
Core scheduling 势必带来一些性能的下降, 但是理论上性能比开了 SMT 要差一些, 但是至少会比关掉 SMT 要好一些. 但是实施起来你会发现这只是大家一厢情愿了. 不同组之间相互是独占 CPU core 的, 那么不同组之间频繁争抢 CPU 资源和频繁开销所引入的影响, 在不同场景会被无限制放大. 而且不同组之间并没有优先级的概念, 因此混布场景性能下降最明显.
-> 对于担心这类攻击的服务器来说, 最好现在就把SMT关掉, 当然这会让一些workload(负载)的性能有不少下降.
-> 在 2019 Linux Plumbers Conference 会议上至少有三个议题都提到了它. 其中主要的收获, 可能就是在最早的“防止side-channel attack”的目标之外, 又找到了其他一些应用场景.
+> 对于担心这类攻击的服务器来说, 最好现在就把 SMT 关掉, 当然这会让一些 workload(负载)的性能有不少下降.
+> 在 2019 Linux Plumbers Conference 会议上至少有三个议题都提到了它. 其中主要的收获, 可能就是在最早的 “防止 side-channel attack” 的目标之外, 又找到了其他一些应用场景.
* coscheduling 近年来已经很少能看到调度里面 60 个补丁的大特性了
@@ -577,14 +577,14 @@ coscheduling 协同调度是为了解决云服务场景, 为不同用户提供
| 2021/03/25 | Joel Fernandes 等 | [Core scheduling remaining patches rebase](https://lore.kernel.org/patchwork/cover/1369931) | Core scheduling v9 的大部分补丁都已经在 TIP 分支了, 部分未合入补丁的重构与适配. | v10 ☐ | [2021/01/23 LORE v10,0/5](https://lore.kernel.org/lkml/20210123011704.1901835-1-joel@joelfernandes.org)
*-*-*-*-*-*-*-*
[2021/03/24 LORE v10 resend,0/8](https://lore.kernel.org/lkml/20210324214020.34142-1-joel@joelfernandes.org) |
| 2021/04/01 | Peter Zijlstra | [sched: Core scheduling interfaces](https://lore.kernel.org/lkml/20210401131012.395311786@infradead.org/) | Peter 将 TIP 分支 core scheduling 进行了重构. 重新设计了 Core scheduling 的接口. | v11 ☐ |[2021/04/01 v11,0/9](https://lore.kernel.org/lkml/20210401131012.395311786@infradead.org) |
| 2021/04/22 | Peter Zijlstra | [sched: Core Scheduling](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9f26990074931bbf797373e53104216059b300b1) | Peter 重构后完整的 Core scheduling. | v12 ☑ 5.14-rc1 |[2021/04/22 LORE v12,00/19](https://lore.kernel.org/lkml/20210422120459.447350175@infradead.org) |
-| 2021/10/18 | Josh Don | [sched/core: forced idle accounting](https://lkml.org/lkml/2021/10/7/1187) | 增加了 "强制空闲" 时间的统计. 当 SMT 某个 CPU pick 了一个任务, 但是 sibling CPU 上找不到与其相互信任(cookie 相同)的任务时, sibling CPU 将不得不进入 force idle 状态, 即使有其他进程(互不信任的)在 RQ 中等待.
强制空闲时间是衡量启用 core scheduling 的一种指标. 可以估计强制闲置而导致的 CPU 容量损失. | v10 ☑ 5.14-rc1 | [2021/10/08 LKML v1](https://lkml.org/lkml/2021/10/7/1187)
*-*-*-*-*-*-*-*
[2021/10/18 LKML v2](https://lkml.org/lkml/2021/10/18/1529) |
+| 2021/10/18 | Josh Don | [sched/core: forced idle accounting](https://lkml.org/lkml/2021/10/7/1187) | 增加了 "强制空闲" 时间的统计. 当 SMT 某个 CPU pick 了一个任务, 但是 sibling CPU 上找不到与其相互信任 (cookie 相同) 的任务时, sibling CPU 将不得不进入 force idle 状态, 即使有其他进程 (互不信任的) 在 RQ 中等待.
强制空闲时间是衡量启用 core scheduling 的一种指标. 可以估计强制闲置而导致的 CPU 容量损失. | v10 ☑ 5.14-rc1 | [2021/10/08 LKML v1](https://lkml.org/lkml/2021/10/7/1187)
*-*-*-*-*-*-*-*
[2021/10/18 LKML v2](https://lkml.org/lkml/2021/10/18/1529) |
| 2021/11/23 | Christian Brauner | [core scheduling: add PR_SCHED_CORE_SHARE](https://lkml.org/lkml/2021/11/23/474) | NA | v10 ☑ 5.14-rc1 | [2021/10/08 LKML v1](https://lkml.org/lkml/2021/11/23/474) |
| 2021/12/16 | Joel Fernandes | [High latency with core scheduling](https://lore.kernel.org/all/Ybvcu5RIwV+Vko09@google.com) | Ybvcu5RIwV+Vko09@google.com | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/Ybvcu5RIwV+Vko09@google.com) |
| 2022/06/28 | Cruz Zhao | [sched/core: Optimize load balance of core scheduling](https://lore.kernel.org/all/1656403045-100840-1-git-send-email-CruzZhao@linux.alibaba.com) | 相同 cookie 的任务被认为是相互信任的, 可以在 SMT 上的两个兄弟 CPU 上运行, 它们可以在选择下一个任务时配对, 并且可以避免强制闲置. 为了实现这个目标, 必须统计运行队列中有多少带有此 cookie 的任务. 当进行此统计时, 作者也发现一个错误, 当我们更新一个未写入 cookie 的任务的 cookie 时, 任务不会进入 core 的 rbtree, 所以作者同时也修复了这个错误. | v1 ☐☑✓ | [LORE v1,0/3](https://lore.kernel.org/all/1656403045-100840-1-git-send-email-CruzZhao@linux.alibaba.com) |
| 2022/09/29 | Cruz Zhao | [sched/core: Optimize the process of picking the max prio task for the core](https://lore.kernel.org/all/1664435913-57227-1-git-send-email-CruzZhao@linux.alibaba.com) | TODO | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/1664435913-57227-1-git-send-email-CruzZhao@linux.alibaba.com)
*-*-*-*-*-*-*-*
[LORE](https://lore.kernel.org/all/1664767168-30029-1-git-send-email-CruzZhao@linux.alibaba.com) |
-#### 1.5.4.3 SMT 驱离(SMT expeller)技术
+#### 1.5.4.3 SMT 驱离 (SMT expeller) 技术
-------
| 资料 | 描述 |
@@ -632,10 +632,10 @@ b37e67a6c648 ck: sched: introduce per-cgroup identity
### 2.1.1 CFS 组调度
-------
-**2.6.24(2008年1月发布)**
+**2.6.24(2008 年1月发布)**
-2.6.23 引入的 CFS 调度器对所有进程完全公平对待. 但这有个问题, 设想当前机器有2个用户, 有一个用户跑着 9个进程, 还都是 CPU 密集型进程; 另一个用户只跑着一个 X 进程, 这是交互性进程. 从 CFS 的角度看, 它将平等对待这 10 个进程, 结果导致的是跑 X 进程的用户受到不公平对待, 他只能得到约 10% 的 CPU 时间, 让他的体验相当差.
+2.6.23 引入的 CFS 调度器对所有进程完全公平对待. 但这有个问题, 设想当前机器有2个用户, 有一个用户跑着 9 个进程, 还都是 CPU 密集型进程; 另一个用户只跑着一个 X 进程, 这是交互性进程. 从 CFS 的角度看, 它将平等对待这 10 个进程, 结果导致的是跑 X 进程的用户受到不公平对待, 他只能得到约 10% 的 CPU 时间, 让他的体验相当差.
基于此, [组调度](https://lwn.net/Articles/240474)的概念被引入. CFS 处理的不再是一个进程的概念, 而是调度实体(sched entity), 一个调度实体可以只包含一个进程, 也可以包含多个进程. 因此, 上述例子的困境可以这么解决: 分别为每个用户建立一个组, 组里放该用户所有进程, 从而保证用户间的公平性.
@@ -645,7 +645,7 @@ b37e67a6c648 ck: sched: introduce per-cgroup identity
| 2007/06/23 | Ingo Molnar | [Add group awareness to CFS - v2](https://lwn.net/Articles/239619) | 实现 CFS 组调度. | v2 ☑ 2.6.23 | [LWN](https://lwn.net/Articles/239619) |
-该功能是基于控制组(control group, cgroup)的概念, 需要内核开启 CGROUP 的支持才可使用.
+该功能是基于控制组 (control group, cgroup) 的概念, 需要内核开启 CGROUP 的支持才可使用.
### 2.1.2 autogroup
@@ -653,11 +653,11 @@ b37e67a6c648 ck: sched: introduce per-cgroup identity
CFS 用户反复在社区抱怨并行 kbuild 对桌面交互性有负面影响
-完全公平的调度程序背后的核心思想是它的完全公平性: 如果有N个进程争夺CPU, 每个进程具有相等的优先级, 那么每个进程将获得可用CPU时间的 1/N. 此策略取代了 O(1) 调度程序中发现的相当复杂的"交互性"启发式方法; 在大多数情况下, 它可以产生更好的桌面响应. 但是, 这种方法在某些地方会失败. 如果用户使用 make -j10 运行十个编译器实例以及一个视频播放应用程序, 则每个进程将获得"公平"的 9% 的 CPU. 这 9% 可能不足以提供用户所希望的视频体验. 因此, 许多用户对"公平"的看法不同也就不足为奇了. 如果编译工作作为一个整体得到50%, 而视频应用程序得到另一半, 那不是很好吗?
+完全公平的调度程序背后的核心思想是它的完全公平性: 如果有 N 个进程争夺 CPU, 每个进程具有相等的优先级, 那么每个进程将获得可用 CPU 时间的 1/N. 此策略取代了 O(1) 调度程序中发现的相当复杂的 "交互性" 启发式方法; 在大多数情况下, 它可以产生更好的桌面响应. 但是, 这种方法在某些地方会失败. 如果用户使用 make -j10 运行十个编译器实例以及一个视频播放应用程序, 则每个进程将获得 "公平" 的 9% 的 CPU. 这 9% 可能不足以提供用户所希望的视频体验. 因此, 许多用户对 "公平" 的看法不同也就不足为奇了. 如果编译工作作为一个整体得到 50%, 而视频应用程序得到另一半, 那不是很好吗?
借助组调度可能很好的解决问题, 这正是 Mike Galbraith 的 每 TTY 任务分组特性 [sched: automated per session task groups](https://lore.kernel.org/all/1290281700.28711.9.camel@maggy.simson.net) 想要完成的, 参见 [TTY-based group scheduling](https://lwn.net/Articles/415740). 其基本思想是, 会自动创建一个附加到系统中的每个 TTY 的任务组. 所有具有给定 TTY 作为其控制终端的进程都将放置在适当的分组中; 然后, 组调度代码可以在由其控制终端确定的进程组之间共享时间. 编译作业通常通过在终端仿真器窗口中键入 make 来启动. 该作业将具有与视频播放器不同的控制 TTY, 后者可能根本没有控制终端. 因此, 最终结果是, 每个 TTY 分组自动将终端中运行的任务与通过窗口系统运行的任务分开.
-但是社区不少人对此特性持反对态度, 一些开发者认为这种做法明明不需要内核补丁, 只需要[用户态配置](https://lore.kernel.org/all/20101116181603.GC19327@tango.0pointer.de)就可以达到同样地效果. 通过与 systemd 结合自动为登录的用户配置会话 session, 就可以解决问题. 另外一些开发者则对基于 TTY 的分组方式不太满意, 认为基于会话(session)的方式可能更合适一些. 参见 [Group scheduling and alternatives](https://lwn.net/Articles/418884).
+但是社区不少人对此特性持反对态度, 一些开发者认为这种做法明明不需要内核补丁, 只需要 [用户态配置](https://lore.kernel.org/all/20101116181603.GC19327@tango.0pointer.de) 就可以达到同样地效果. 通过与 systemd 结合自动为登录的用户配置会话 session, 就可以解决问题. 另外一些开发者则对基于 TTY 的分组方式不太满意, 认为基于会话 (session) 的方式可能更合适一些. 参见 [Group scheduling and alternatives](https://lwn.net/Articles/418884).
最终基于 session 的自动创建任务组方案 autogroup(CONFIG_SCHED_AUTOGROUP) 于 v2.6.38 合入主线, 并得到 Linus 的好评.
@@ -680,17 +680,17 @@ CFS 用户反复在社区抱怨并行 kbuild 对桌面交互性有负面影响
| 2010/01/05 | Paul Turner | [CFS Hard limits - v5](https://lwn.net/Articles/368685) | 实现 CFS 组调度. | v5 ☐ | [LWN v5,0/8](https://lwn.net/Articles/368685) |
| 2011/02/15 | Paul Turner | [CFS Bandwidth Control: Introduction](https://lwn.net/Articles/428175) | 实现 CFS Bandwidth. | v7.2 ☑ 2.6.23 | [LWN](https://lore.kernel.org/all/20110721164325.231521704@google.com) |
| 2022/05/18 | Fam Zheng | [sched: Enable root level cgroup bandwidth control](https://lore.kernel.org/all/20220518100841.1497391-1-fam.zheng@bytedance.com) | TODO | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20220518100841.1497391-1-fam.zheng@bytedance.com) |
-| 2022/10/19 | Chuyi Zhou | [sched/fair: Add min_ratio for cfs bandwidth_control](https://lore.kernel.org/all/20221019031551.24312-1-zhouchuyi@bytedance.com) | 如果用户设置的配额/周期比过小, 在当前的cfs带宽控制机制下, 长时间持锁可能会导致任务被节流, 导致整个[系统卡住](https://lore.kernel.org/lkml/5987be34-b527-4ff5-a17d-5f6f0dc94d6d@huawei.com). 为了防止上述情况的发生, 本补丁在 `procfs` 中增加了 `sysctl_sched_cfs_bandwidth_min_ratio`, 它表示用户可以设置的配额/周期的最小百分比. 默认值为0, 用户可以设置配额和周期而不触发此约束. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20221019031551.24312-1-zhouchuyi@bytedance.com) |
+| 2022/10/19 | Chuyi Zhou | [sched/fair: Add min_ratio for cfs bandwidth_control](https://lore.kernel.org/all/20221019031551.24312-1-zhouchuyi@bytedance.com) | 如果用户设置的配额 / 周期比过小, 在当前的 cfs 带宽控制机制下, 长时间持锁可能会导致任务被节流, 导致整个[系统卡住](https://lore.kernel.org/lkml/5987be34-b527-4ff5-a17d-5f6f0dc94d6d@huawei.com). 为了防止上述情况的发生, 本补丁在 `procfs` 中增加了 `sysctl_sched_cfs_bandwidth_min_ratio`, 它表示用户可以设置的配额 / 周期的最小百分比. 默认值为 0, 用户可以设置配额和周期而不触发此约束. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20221019031551.24312-1-zhouchuyi@bytedance.com) |
| 2022/10/17 | Josh Don | [sched: async unthrottling for cfs bandwidth](https://lore.kernel.org/all/20221017234750.454419-1-joshdon@google.com) | CFS 带宽目前分配新的运行时, 并在 hrtimer 回调中取消 cfs_rq 的内联. 运行时分发是一个每个 CPU 的操作, 而取消节流是一个每个 cgroup 的操作, 因为需要 tg 遍历. 在拥有大量 CPU 和大型 cgroup 层次结构的机器上, CPU *cgroups 的工作可能在单个 hrtimer 回调中无法完成: 由于 IRQ 被禁用, 很容易发生 hard lockup. 具体来说, 我们发现在 256 个 CPU、O(1000) 个 cCGROUP 在层次结构中被限制以及高内存带宽使用的配置中存在可伸缩性问题. 要解决这个问题, 我们可以通过 CSD 异步取消 cfs_rq 的节流. 每个 CPU 负责自己进行节流, 从而在整个系统中更公平地划分总体工作, 并避免 hard lockup. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20221017234750.454419-1-joshdon@google.com)
*-*-*-*-*-*-*-*
[LORE v2](https://lore.kernel.org/all/20221026224449.214839-1-joshdon@google.com) |
这个 bandwidth controller 提供了两个参数来管理针对各个 cgroup 的限制.
| 参数 | 描述 |
|:---:|:----:|
-| cpu.cfs_quota_us | 是这个 cgroup 在每个统计周期(accounting period)内可用的 CPU 时间(以微秒为单位). |
+| cpu.cfs_quota_us | 是这个 cgroup 在每个统计周期 (accounting period) 内可用的 CPU 时间(以微秒为单位). |
| cpu.cfs_period_us | 是统计周期的长度, 也是以微秒为单位 |
-因此, 假如我们将 cpu.cfs_quota_us 设置为 50000, cpu.cfs_period_us 设置为 100000, 将使该组在每 100ms 周期内消耗 50ms 的 CPU 时间. 将这些值减半(将 cpu.cfs_quota_us 设置为 25000, cpu.cfs_period_us 设置为 50000)的话, 就是每 50ms 消耗 25ms 的 CPU 时间. 在这两种情况下, 这个 cgroup 就被授权可以占用一个 CPU 的 50% 资源, 但在后一种设置下, 可供使用的 CPU 时间会来得更频繁, 更小块.
+因此, 假如我们将 cpu.cfs_quota_us 设置为 50000, cpu.cfs_period_us 设置为 100000, 将使该组在每 100ms 周期内消耗 50ms 的 CPU 时间. 将这些值减半 (将 cpu.cfs_quota_us 设置为 25000, cpu.cfs_period_us 设置为 50000) 的话, 就是每 50ms 消耗 25ms 的 CPU 时间. 在这两种情况下, 这个 cgroup 就被授权可以占用一个 CPU 的 50% 资源, 但在后一种设置下, 可供使用的 CPU 时间会来得更频繁, 更小块.
这两种情况的区别很重要. 想象一下, 某个 cgroup 中只有一个进程, 需要运行 30ms. 在第一种情况下, 30ms 小于被授予的 50ms 时长, 所以进程能够完成任务, 不会被限制. 在第二种情况下, 进程在运行 25ms 后将被停止执行, 不得不等待下一个 50ms 周期再继续运行来完成工作. 如果 workload 对延迟敏感的话, 就需要仔细考虑 bandwidth controller 参数的设置.
@@ -701,7 +701,7 @@ CFS 用户反复在社区抱怨并行 kbuild 对桌面交互性有负面影响
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:---:|:----:|:---:|:----:|:---------:|:----:|
-| 2019/09/06 | Rik van Riel | [sched,fair: flatten CPU controller runqueues](https://lore.kernel.org/lkml/20190906191237.27006-1-riel@surriel.com/) | 当前 CPU cgroup 的实现使用了分层的运行队列, 当一个任务被唤醒时, 它会被放到它所在组的运行队列中, 这个组也会被放到它上面的组的运行队列中, 以此类推.对于每秒进行大量唤醒的工作负载, 这将增加相当大的开销, 特别是在默认的 systemd 层次结构为 2 或 3 级的情况下. 这个补丁系列试图通过将所有任务放在相同层次的运行队列上, 并根据组的优先级来调整任务优先级, 从而减少这种开销. 组的优先级是周期性计算的.
后续版本还计划完成 CONFIG_CFS_BANDWIDTH 的重构:
1. 当一个 cgroup 被 throttle 时, 将该 cgroup 及其子组标记为 throttle.
2. 当 pick_next_entity 发现一个任务在一个 throttched cgroup 上, 将它隐藏在 cgroup 运行队列(它不再用于可运行的任务). 保持 vruntime 不变, 并调整运行队列的 vruntime 为最左边的任务的 vruntime.
3. 当一个 cgroup 被 unthrottle, 并且上面有任务时, 把它放在一个 vruntime 排序的堆上, 与主运行队列分开.
4. 让 pick_next_task_fair 在每次调用时从堆中抓取一个任务, 并且该堆的最小 vruntime 低于 CPU 的 cfs_rq 的 vruntime (或者 CPU 没有其他可运行的任务).
5. 将选中的任务放置在 CPU 的 cfs_rq 上, 将其 vruntime 与 GENTLE_FAIR_SLEEPERS 逻辑重新规范化. 这应该有助于将已经可运行的任务与最近未被限制的组交织在一起, 并防止严重的群体问题.
6. 如果组在所有的任务都有机会运行之前再次被节流, 那么 vruntime 排序将确保被节流的 cgroup 中的所有任务都有机会运行一段 | v9 ☑ 4.6-rc1 | [LKML v8,0/5](https://lore.kernel.org/all/1455871601-27484-1-git-send-email-wagi@monom.org) |
+| 2019/09/06 | Rik van Riel | [sched,fair: flatten CPU controller runqueues](https://lore.kernel.org/lkml/20190906191237.27006-1-riel@surriel.com/) | 当前 CPU cgroup 的实现使用了分层的运行队列, 当一个任务被唤醒时, 它会被放到它所在组的运行队列中, 这个组也会被放到它上面的组的运行队列中, 以此类推. 对于每秒进行大量唤醒的工作负载, 这将增加相当大的开销, 特别是在默认的 systemd 层次结构为 2 或 3 级的情况下. 这个补丁系列试图通过将所有任务放在相同层次的运行队列上, 并根据组的优先级来调整任务优先级, 从而减少这种开销. 组的优先级是周期性计算的.
后续版本还计划完成 CONFIG_CFS_BANDWIDTH 的重构:
1. 当一个 cgroup 被 throttle 时, 将该 cgroup 及其子组标记为 throttle.
2. 当 pick_next_entity 发现一个任务在一个 throttched cgroup 上, 将它隐藏在 cgroup 运行队列(它不再用于可运行的任务). 保持 vruntime 不变, 并调整运行队列的 vruntime 为最左边的任务的 vruntime.
3. 当一个 cgroup 被 unthrottle, 并且上面有任务时, 把它放在一个 vruntime 排序的堆上, 与主运行队列分开.
4. 让 pick_next_task_fair 在每次调用时从堆中抓取一个任务, 并且该堆的最小 vruntime 低于 CPU 的 cfs_rq 的 vruntime (或者 CPU 没有其他可运行的任务).
5. 将选中的任务放置在 CPU 的 cfs_rq 上, 将其 vruntime 与 GENTLE_FAIR_SLEEPERS 逻辑重新规范化. 这应该有助于将已经可运行的任务与最近未被限制的组交织在一起, 并防止严重的群体问题.
6. 如果组在所有的任务都有机会运行之前再次被节流, 那么 vruntime 排序将确保被节流的 cgroup 中的所有任务都有机会运行一段 | v9 ☑ 4.6-rc1 | [LKML v8,0/5](https://lore.kernel.org/all/1455871601-27484-1-git-send-email-wagi@monom.org) |
* bursty 应对进程的突发负载
@@ -717,11 +717,11 @@ CFS 用户反复在社区抱怨并行 kbuild 对桌面交互性有负面影响
2. 另一种选择就是同时增加配额和周期, 但如果进程最终还是要等到下一个周期才能完成工作的话, 那也会导致延迟增加.
-社区提出的一组 patch 旨在让它更好地适用于突发的(bursty)、对延迟敏感(latency-sensitive)的 workload.
+社区提出的一组 patch 旨在让它更好地适用于突发的 (bursty)、对延迟敏感(latency-sensitive) 的 workload.
Chang 的 patch set 采用了与之前不同的方法: 允许 cgroup 将一些未使用的配额从一个周期转到下一个周期. 引入的新参数 cpu.cfs_burst_us 就设置了这种方式可以累积的时长上限. 举个例子, 继续讨论配额为 25ms, 周期为 50ms 的 cgroup 配置. 如果将 cpu.cfs_burst_us 设置为 40000(40ms), 那么这个 cgroup 中的进程在某个周期内最多可以运行 40ms, 但前提是它已经在之前的周期中省下了这次额外所需的 15ms. 这样一来, 这个 cgroup 就可以既满足它的突发性工作需求, 又能够在长时间的统计中保证它的 CPU 耗时仍然不超过配额上限.
-可以用另一种方式来解释这个做法, 当使用了 cpu.cfs_burst_us 的时候, 配额(quota)的定义就跟从前不一样了. 配额不再是绝对的数值上限, 而是在每个周期内向此 CPU 时间账户内存入的时长, cfs_burst_us 值就是这个账户的封顶值. 需要预先为突发事件做准备的 cgroup 就可以在该账户中来储蓄一些(有限的) CPU 时间, 在需要时使用.
+可以用另一种方式来解释这个做法, 当使用了 cpu.cfs_burst_us 的时候, 配额 (quota) 的定义就跟从前不一样了. 配额不再是绝对的数值上限, 而是在每个周期内向此 CPU 时间账户内存入的时长, cfs_burst_us 值就是这个账户的封顶值. 需要预先为突发事件做准备的 cgroup 就可以在该账户中来储蓄一些(有限的) CPU 时间, 在需要时使用.
默认情况下, cpu.cfs_burst_us 为 0, 这就禁用了 burst 机制, 而遵照传统行为执行. 系统中有一个 sysctl 开关可以用来在整个系统中禁止使用 burst 方式. 还有另一个开关 (sysctl_sched_cfs_bw_burst_onset_percent), 用来每个周期开始时给每个组一个规定百分比的突发配额(burst quota), 不管以前的周期中是否积累出了这些时间.
@@ -736,7 +736,7 @@ Chang 的 patch set 采用了与之前不同的方法: 允许 cgroup 将一些
|:----:|:----:|:---:|:----:|:---------:|:----:|
| 2018/05/21 | Cong Wang | [sched/fair: improve CFS throttle](https://lore.kernel.org/all/20180522062017.5193-1-xiyou.wangcong@gmail.com) | TODO | v1 ☐☑✓ | [LORE v1,0/3](https://lore.kernel.org/all/20180522062017.5193-1-xiyou.wangcong@gmail.com) |
| 2019/11/26 | Konstantin Khlebnikov | [sched/fair: add burst to cgroup cpu bandwidth controller](https://lore.kernel.org/all/157476581065.5793.4518979877345136813.stgit@buzz) | TODO | v2 ☐☑✓ | [LORE](https://lore.kernel.org/all/157476581065.5793.4518979877345136813.stgit@buzz) |
-| 2021/06/21 | JHuaixin Chang | [sched/fair: Burstable CFS bandwidth controller](https://lore.kernel.org/patchwork/cover/1396878) | 突发任务的带宽控制优化, 通过临时之前剩余累计的配额, 使得突发进程在当前周期的配额突然用尽之后, 还可以临时使用之前累计的配额使用, 从而降低突发任务的时延. | v6 ☑ 5.14-rc1 | [ 2020/12/17 v1](https://lore.kernel.org/patchwork/cover/1354613)
*-*-*-*-*-*-*-*
[2021/01/20 v2](https://lore.kernel.org/patchwork/cover/1368037)
*-*-*-*-*-*-*-*
[2021/01/21 v3](https://lore.kernel.org/patchwork/cover/1368746)
*-*-*-*-*-*-*-*
[2021-02-02 v4](https://lore.kernel.org/patchwork/cover/1396878)
*-*-*-*-*-*-*-*
[2021/05/20 v5](https://lore.kernel.org/patchwork/cover/1433660)
*-*-*-*-*-*-*-*
[2021/06/21 v6](https://lore.kernel.org/patchwork/cover/1449268)
*-*-*-*-*-*-*-*
[commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f4183717b370ad28dd0c0d74760142b20e6e7931) |
+| 2021/06/21 | JHuaixin Chang | [sched/fair: Burstable CFS bandwidth controller](https://lore.kernel.org/patchwork/cover/1396878) | 突发任务的带宽控制优化, 通过临时之前剩余累计的配额, 使得突发进程在当前周期的配额突然用尽之后, 还可以临时使用之前累计的配额使用, 从而降低突发任务的时延. | v6 ☑ 5.14-rc1 | [2020/12/17 v1](https://lore.kernel.org/patchwork/cover/1354613)
*-*-*-*-*-*-*-*
[2021/01/20 v2](https://lore.kernel.org/patchwork/cover/1368037)
*-*-*-*-*-*-*-*
[2021/01/21 v3](https://lore.kernel.org/patchwork/cover/1368746)
*-*-*-*-*-*-*-*
[2021-02-02 v4](https://lore.kernel.org/patchwork/cover/1396878)
*-*-*-*-*-*-*-*
[2021/05/20 v5](https://lore.kernel.org/patchwork/cover/1433660)
*-*-*-*-*-*-*-*
[2021/06/21 v6](https://lore.kernel.org/patchwork/cover/1449268)
*-*-*-*-*-*-*-*
[commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f4183717b370ad28dd0c0d74760142b20e6e7931) |
| 2021/08/30 | Huaixin Chang | [Add statistics and ducument for cfs bandwidth burst](https://lore.kernel.org/patchwork/cover/1396878) | 为 Burstable CFS bandwidth 添加统计信息和文档. | v1 ☑ 5.16-rc1 | [2020/12/17 v1](https://lore.kernel.org/patchwork/cover/1396878)
*-*-*-*-*-*-*-*
[2021/08/30 LORE v2 0/2](https://lore.kernel.org/all/20210830032215.16302-1-changhuaixin@linux.alibaba.com) |
| 2021/11/29 | Honglei Wang | [sched/fair: prevent cpu burst too many periods](https://lore.kernel.org/patchwork/cover/1396878) | commit f4183717b370 ("sched/fair: Introduce the burstable CFS controller") 引入了一个问题, 任务在持久性期间可能获得比配额更多的 cpu. 例如, 一个任务组的配额为每周期 100ms, 可以获得 100ms 突发, 其平均利用率约为每周期 105ms. 一旦这个组获得了一个空闲时间段, 它就有机会在公共带宽配置中获得超过其配额的 10 个或更多时间段的计算能力(例如, 100 毫秒作为时间段). 这意味着任务获得了可以 "偷走" 完成日常工作的能力, 因为所有任务都可以安排出去或睡觉, 以帮助团队获得空闲时间. cpu burst 的本来目的是帮助处理突发性工作负载. 但是, 如果一个任务组在没有突发性工作负载的情况下, 能够在持续时间内获得超过其配额的计算能力, 那么它违背了初衷. 此修补程序将突发限制为一个时段, 以便在很长时间内不会突破配额限制. 有了这个, 我们可以给任务组更多的 cpu 突发能力来处理真正的突发性工作负载, 而不必担心被恶意 "窃取". | v1 ☑ 5.16-rc1 | [LKML](https://lkml.org/lkml/2021/11/29/663) |
| 2022/05/18 | Fam Zheng | [sched: Enable root level cgroup bandwidth control](https://lore.kernel.org/all/20220518100841.1497391-1-fam.zheng@bytedance.com) | TODO | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20220518100841.1497391-1-fam.zheng@bytedance.com) |
@@ -755,7 +755,7 @@ Chang 的 patch set 采用了与之前不同的方法: 允许 cgroup 将一些
-------
-**2.6.25(2008年4月发布)**
+**2.6.25(2008 年 4 月发布)**
该功能同普通进程的组调度功能一样, 只不过是针对实时进程的.
@@ -763,26 +763,26 @@ Chang 的 patch set 采用了与之前不同的方法: 允许 cgroup 将一些
## 2.3 组调度带宽控制(CFS bandwidth control)
-------
-**3.2(2012年1月发布)**
+**3.2(2012 年 1 月发布)**
-组调度的支持, 对实现多租户系统的管理是十分方便的, 在一台机器上, 可以方便对多用户进行 CPU 均分.然后, 这还不足够, 组调度只能保证用户间的公平, 但若管理员想控制一个用户使用的最大 CPU 资源, 则需要带宽控制.3.2 针对 CFS组调度, 引入了此功能[8](#refer-anchor-8), 该功能可以让管理员控制在一段时间内一个组可以使用 CPU 的最长时间.
+组调度的支持, 对实现多租户系统的管理是十分方便的, 在一台机器上, 可以方便对多用户进行 CPU 均分.然后, 这还不足够, 组调度只能保证用户间的公平, 但若管理员想控制一个用户使用的最大 CPU 资源, 则需要带宽控制.3.2 针对 CFS 组调度, 引入了此功能[8](#refer-anchor-8), 该功能可以让管理员控制在一段时间内一个组可以使用 CPU 的最长时间.
## 2.4 极大提高体验的自动组调度(Auto Group Scheduling)
-------
-**2.6.38(2011年3月发布)**
+**2.6.38(2011 年 3 月发布)**
-试想, 你在终端里熟练地敲击命令, 编译一个大型项目的代码, 如 Linux内核, 然后在编译的同时悠闲地看着电影等待, 结果电脑却非常卡, 体验一定很不爽.
+试想, 你在终端里熟练地敲击命令, 编译一个大型项目的代码, 如 Linux 内核, 然后在编译的同时悠闲地看着电影等待, 结果电脑却非常卡, 体验一定很不爽.
-2.6.38 引入了一个针对桌面用户体验的改进, 叫做自动组调度.短短400多行代码[9](#refer-anchor-9), 就很大地提高了上述情形中桌面使用者体验, 引起不小轰动.
+2.6.38 引入了一个针对桌面用户体验的改进, 叫做自动组调度.短短 400 多行代码[9](#refer-anchor-9), 就很大地提高了上述情形中桌面使用者体验, 引起不小轰动.
-其实原理不复杂, 它是基于之前支持的组调度的一个延伸.Unix 世界里, 有一个**会话(session)** 的概念, 即跟某一项任务相关的所有进程, 可以放在一个会话里, 统一管理.比如你登录一个系统, 在终端里敲入用户名, 密码, 然后执行各种操作, 这所有进程, 就被规划在一个会话里.
+其实原理不复杂, 它是基于之前支持的组调度的一个延伸.Unix 世界里, 有一个 ** 会话(session)** 的概念, 即跟某一项任务相关的所有进程, 可以放在一个会话里, 统一管理.比如你登录一个系统, 在终端里敲入用户名, 密码, 然后执行各种操作, 这所有进程, 就被规划在一个会话里.
因此, 在上述例子里, 编译代码和终端进程在一个会话里, 你的浏览器则在另一个会话里.自动组调度的工作就是, 把这些不同会话自动分成不同的调度组, 从而利用组调度的优势, 使浏览器会话不会过多地受到终端会话的影响, 从而提高体验.
@@ -798,7 +798,7 @@ Chang 的 patch set 采用了与之前不同的方法: 允许 cgroup 将一些
[PELT vs Window tracking and EAS on SMP multi-cluster](https://static.linaro.org/connect/bkk16/Presentations/Tuesday/BKK16-208.pdf)
-[CPU负载均衡之 loadavg、pelt、walt 涉及到结构体记录](https://blog.csdn.net/xiaoqiaoq0/article/details/107499007)
+[CPU 负载均衡之 loadavg、pelt、walt 涉及到结构体记录](https://blog.csdn.net/xiaoqiaoq0/article/details/107499007)
## 3.1 WALT
-------
@@ -807,7 +807,7 @@ Chang 的 patch set 采用了与之前不同的方法: 允许 cgroup 将一些
[improving exynos 9810 galaxy s9](https://www.anandtech.com/show/12620/improving-the-exynos-9810-galaxy-s9-part-2)
-[悟空明镜-CSDN 博客--[scheduler for WALT] task 运行时间, util 和 frequency 三者之前的关系](https://blog.csdn.net/wukongmingjing/article/details/100164365)
+[悟空明镜 - CSDN 博客 --[scheduler for WALT] task 运行时间, util 和 frequency 三者之前的关系](https://blog.csdn.net/wukongmingjing/article/details/100164365)
[CPU 负载均衡之 WALT 学习](https://blog.csdn.net/xiaoqiaoq0/article/details/107135747)
@@ -837,7 +837,7 @@ $walt\_util=\frac{\sum_{1}^{n}scale\_exec\_time}{walt\_ravg\_window} \times 1024
$walt\_util=\frac{\sum_{1}^{n}delta}{walt\_ravg\_window} \times capacity\_curr\_of$
-ARM big.LITTLE 上, 一个进程以大核最高频(capacity = 1024)跑满一个窗口, 其 util 即为 1024.
+ARM big.LITTLE 上, 一个进程以大核最高频 (capacity = 1024) 跑满一个窗口, 其 util 即为 1024.
### 3.1.2 WALT @ QCOM-4.14
@@ -859,9 +859,7 @@ $cc.time = wallclock - p->ravg.mark\_start$
```cpp
update_task_rq_cpu_cycles(struct task_struct *p, struct rq *rq, int event, u64 wallclock, u64 irqtime)
-{
- if (!use_cycle_counter) {
- rq->cc.cycles = cpu_cur_freq(cpu);
+{if (!use_cycle_counter) {rq->cc.cycles = cpu_cur_freq(cpu);
rq->cc.time = 1;
return;
}
@@ -890,26 +888,26 @@ $scale\_exec\_time=\frac{delta\_time \times task\_exec\_scale_{rq}}{1024}$
v3.8 合入了 [LWN-2013/01/29, Per-entity load tracking](https://lwn.net/Articles/531853).
-从Arm的资源来看, 这很像该公司意识到性能问题, 并正在积极尝试改善 PELT 的行为以使其更接近 WALT.
+从 Arm 的资源来看, 这很像该公司意识到性能问题, 并正在积极尝试改善 PELT 的行为以使其更接近 WALT.
1. 一个重要的变化是称为 [util_est 利用率估计的特性](http://retis.santannapisa.it/~luca/ospm-summit/2017/Downloads/OSPM_PELT_DecayClampingVsUtilEst.pdf), [Utilization estimation (util_est) for FAIR tasks](https://lore.kernel.org/patchwork/cover/932237)
-2. 改善PELT的另一种简单方法是[减少斜坡/衰减时间](https://lore.kernel.org/lkml/20180409165134.707-1-patrick.bellasi@arm.com/#r), 主线默认的 PELT 衰减周期为 32MS, 该补丁提供了 8MS/16MS/32MS 的可选择衰减周期. 通常的测试结果会认为 8ms 的半衰期是一种偏性能的选择, 默认的 32ms 设置, 无法满足终端场景突发的负载变化, 因此往往 16ms 的折中方案能提供最佳性能和电池折衷.
+2. 改善 PELT 的另一种简单方法是[减少斜坡 / 衰减时间](https://lore.kernel.org/lkml/20180409165134.707-1-patrick.bellasi@arm.com/#r), 主线默认的 PELT 衰减周期为 32MS, 该补丁提供了 8MS/16MS/32MS 的可选择衰减周期. 通常的测试结果会认为 8ms 的半衰期是一种偏性能的选择, 默认的 32ms 设置, 无法满足终端场景突发的负载变化, 因此往往 16ms 的折中方案能提供最佳性能和电池折衷.
| 日期 | LWN | 翻译 |
|:---:|:----:|:---:|
-| 2013/01/29 | [Per-entity load tracking](https://lwn.net/Articles/531853) | [郭健-蜗窝科技--PELT](http://www.wowotech.net/process_management/PELT.html), [郭健-蜗窝科技--PELT tag](http://www.wowotech.net/tag/pelt) |
+| 2013/01/29 | [Per-entity load tracking](https://lwn.net/Articles/531853) | [郭健 - 蜗窝科技 --PELT](http://www.wowotech.net/process_management/PELT.html), [郭健 - 蜗窝科技 --PELT tag](http://www.wowotech.net/tag/pelt) |
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
| 2012/08/23 | pjt@google.com | [sched: per-entity load-tracking](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e9c84cb8d5f1b1ea6fcbe6190d51dc84b6975938) | PELT | v1 ☐☑✓ | [LORE v1,0/16](https://lore.kernel.org/all/20120823141422.444396696@google.com) |
| 2018/04/09 | Patrick Bellasi | [sched/fair: add support to tune PELT ramp/decay timings](https://lore.kernel.org/all/20180409165134.707-1-patrick.bellasi@arm.com) | 内核支持不同的 PELT 半衰期设置, 通过 CONFIG_PELT_HALFLIFE_32/CONFIG_PELT_HALFLIFE_16/CONFIG_PELT_HALFLIFE_8 选择. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20180409165134.707-1-patrick.bellasi@arm.com) |
-| 2022/08/29 | Dietmar Eggemann | [sched/pelt: Change PELT halflife at runtime](https://lore.kernel.org/all/20220829055450.1703092-1-dietmar.eggemann@arm.com) | 允许系统运行时设置 PELT 的半衰期. 新的 sysctl sched_pelt_multiplier 允许用户将时钟乘数设置为 x1, x2 或 x4. 该时钟倍增器(clock multiplier artificially)加速 PELT 斜坡上升/下降, 它将影响 PELT 的半衰期(x1 对应 32ms, x2 对应 16ms, x3 对应 8ms). | v1 ☐☑✓ | [LORE v1,1/1](https://lore.kernel.org/all/20220829055450.1703092-2-dietmar.eggemann@arm.com) |
+| 2022/08/29 | Dietmar Eggemann | [sched/pelt: Change PELT halflife at runtime](https://lore.kernel.org/all/20220829055450.1703092-1-dietmar.eggemann@arm.com) | 允许系统运行时设置 PELT 的半衰期. 新的 sysctl sched_pelt_multiplier 允许用户将时钟乘数设置为 x1, x2 或 x4. 该时钟倍增器 (clock multiplier artificially) 加速 PELT 斜坡上升 / 下降, 它将影响 PELT 的半衰期(x1 对应 32ms, x2 对应 16ms, x3 对应 8ms). | v1 ☐☑✓ | [LORE v1,1/1](https://lore.kernel.org/all/20220829055450.1703092-2-dietmar.eggemann@arm.com) |
| 扩展资料 | 描述 |
|:-------:|:---:|
-| [linux 中的 pelt](https://blog.hidva.com/2022/01/13/pelt) | 关于 PELT 的一些总结和思考
1. 介绍了 util 与 load 以及 capacity 的差异.
2. 总结了 cfs_rq, group se pelt 的计算. |
+| [linux 中的 pelt](https://blog.hidva.com/2022/01/13/pelt) | 关于 PELT 的一些总结和思考
1. 介绍了 util 与 load 以及 capacity 的差异.
2. 总结了 cfs_rq, group se pelt 的计算. |
| [Evolution of load tracking mechanism in scheduler](https://static.linaro.org/connect/yvr18/presentations/yvr18-205.pdf) | 介绍了 linux PELT 算法和实现的演进 |
| [Improve utilization and load tracking in the scheduler](https://blog.linuxplumbersconf.org/2016/ocw/proposals/3603.html) | LPC-2016 的议题, 介绍了 PELT 的一些优化. |
@@ -921,19 +919,19 @@ v3.8 合入了 [LWN-2013/01/29, Per-entity load tracking](https://lwn.net/Articl
* 一个进程即便当前没有在 CPU 上运行, 该进程仅仅是挂入 runqueue 等待执行, 它也能够对 CPU 负载作出贡献. "负载" 是一个瞬时量, 表示当前时间点的进程对系统产生的 "压力" 是怎样的? 显然 runqueue 中有 10 个等待运行的进程对系统造成的 "压力" 要大于一个 runqueue 中只有 1 个等待进程的场景.
-* 与之相对的 "CPU 使用率(usage)不一样, 它不是瞬时量, 而是一个累积量. 有一个长时间运行的进程, 它可能上周占用大量的处理器时间, 但是现在可能占用很少的 CPU 时间, 尽管它过去曾经 "辉煌" 过(占用大量 CPU 时间), 但这对现在的系统负荷贡献很小.
+* 与之相对的 "CPU 使用率 (usage) 不一样, 它不是瞬时量, 而是一个累积量. 有一个长时间运行的进程, 它可能上周占用大量的处理器时间, 但是现在可能占用很少的 CPU 时间, 尽管它过去曾经 "辉煌" 过(占用大量 CPU 时间), 但这对现在的系统负荷贡献很小.
-PELT 很好地解决了这些问题, 这是通过把负载跟踪从 per rq 推进到 per-entity 的层次. 所谓调度实体(scheduling entity)其实就是一个进程或者 control group 中的一组进程. 为了做到 Per-entity 的负载跟踪:
+PELT 很好地解决了这些问题, 这是通过把负载跟踪从 per rq 推进到 per-entity 的层次. 所谓调度实体 (scheduling entity) 其实就是一个进程或者 control group 中的一组进程. 为了做到 Per-entity 的负载跟踪:
* 将时间切分为以 1ms 为单位的 period, 为了便于计算, 将 1ms 设置为 1024us.
* 在一个单位 period 中, 一个 scheduling entity 对系统的负载贡献, 可以根据该 entity 处于 runnable 状态的时间进行计算. 如果在该 period 中, runnable 的时间为 delta, 那么对系统负载的贡献 $L = \frac{delta}{1024}$.
-* 离当前越近的历史负载对当前负载的贡献越高, 越早之前的历史负载对当前负载的贡献越小. 因此对于过去的负载, 要乘上一个衰减因子(decay factor)进行负载衰减.
+* 离当前越近的历史负载对当前负载的贡献越高, 越早之前的历史负载对当前负载的贡献越小. 因此对于过去的负载, 要乘上一个衰减因子 (decay factor) 进行负载衰减.
* 以上这个系统负载值也可能会超过 1024us, 这是因为我们会累积过去 period 中的负载.
-如果我们用 $L_i$ 表示在周期 $P_i$ 中该 scheduling entity 对系统负载的贡献, 然后用 y 表示衰减因子, 那么 i 个周期之间该 entity 的负载 $L_i$ 对当前周期的负载贡献(需要衰减 i 次)就是 $L_iy^i$, 那么该 entity 对系统负载的总贡献(累积负载)就是自 entity 最早开始运行开始到现在为止所有周期 $P_i$ 的历史负载贡献 $L_iy^i$ 之和表示为:
+如果我们用 $L_i$ 表示在周期 $P_i$ 中该 scheduling entity 对系统负载的贡献, 然后用 y 表示衰减因子, 那么 i 个周期之间该 entity 的负载 $L_i$ 对当前周期的负载贡献 (需要衰减 i 次) 就是 $L_iy^i$, 那么该 entity 对系统负载的总贡献 (累积负载) 就是自 entity 最早开始运行开始到现在为止所有周期 $P_i$ 的历史负载贡献 $L_iy^i$ 之和表示为:
$load = \displaystyle \sum^{n}_{i = 0}{{L_i}{y^i}} = L_0+L_1y+L_2y^2+L_3y^3......+L_ny^n$
@@ -964,7 +962,7 @@ $Sum_{\infty} = L_i{\frac{1}{1-q}}$
$load_{\infty} = {1024} \times {L_i{\frac{1}{1-q}}} = {\frac{1024}{1-0.97857206}} \approx 47788.07482193801$
-但是计算机计算误差的存在, PELT 算法所能达到的 LOAD_AVG_MAX 的值计算结果为 47742. 而我们知道, 无穷级数最终会越来越趋近于最大值, 但是永远达不到. 而这个误差值 47742 是可以达到的, 达到 LOAD_AVG_MAX 理论上需要经过的周期 LOAD_AVG_MAX_N 大约(同样存在误差)为 345. 而半衰期就用 LOAD_AVG_PERIOD(32 个周期) 表示.
+但是计算机计算误差的存在, PELT 算法所能达到的 LOAD_AVG_MAX 的值计算结果为 47742. 而我们知道, 无穷级数最终会越来越趋近于最大值, 但是永远达不到. 而这个误差值 47742 是可以达到的, 达到 LOAD_AVG_MAX 理论上需要经过的周期 LOAD_AVG_MAX_N 大约 (同样存在误差) 为 345. 而半衰期就用 LOAD_AVG_PERIOD(32 个周期) 表示.
> 此无穷级数还有一个很关键的信息是:
>
@@ -1009,7 +1007,7 @@ $y^n = (runnable\_avg\_yN\_inv_{n\%32}) >> (\frac{n}{32})$
[PELT(Per-Entity Load Tracking)](https://blog.csdn.net/weixin_30911451/article/details/102086050)
-[内核工匠--PELT 算法浅析](https://blog.csdn.net/feelabclihu/article/details/108414156)
+[内核工匠 --PELT 算法浅析](https://blog.csdn.net/feelabclihu/article/details/108414156)
但是我们 PELT 在计算负载时不能使用这种无穷级数或者等比数列求和极简的公式去计算, 我们只能从当前的输入出来来计算 entity 的负载.
@@ -1035,15 +1033,15 @@ sa->last_update_time 记录上一次更新计算的时间, 灰色部分为上次
整个 PELT 累计负载的计算, 就是不断地追踪三个时间段 (d1/d2/d3), 对其 load 分别做衰减, 从而来计算 now 时刻的 load, 周而复始, 生生不息.
-记三个时间区段分比为 d1, d2, d3, 上次 d1 段之前(上次更新累计负载贡献的时刻)到 now 时刻总计经历了 p 个周期, 上次计算出的累计负载贡献为 u, 当前时刻 now 的累计负载贡献为 u', 则:
+记三个时间区段分比为 d1, d2, d3, 上次 d1 段之前 (上次更新累计负载贡献的时刻) 到 now 时刻总计经历了 p 个周期, 上次计算出的累计负载贡献为 u, 当前时刻 now 的累计负载贡献为 u', 则:
-$$u' = (u + d_1) \times {y^p}+ 1024 \times \displaystyle \sum^{p-1}_{n = 0}{y^n} + {d_3} \times {y^0}$$
+$$u'= (u + d_1) \times {y^p}+ 1024 \times \displaystyle \sum^{p-1}_{n = 0}{y^n} + {d_3} \times {y^0}$$
#### 3.2.3.1 runnable_avg_yN_sum[] 与 `__compute_runnable_contrib()`
-------
-v4.12 之前, 内核采用了与 decay_load() 类似的查表法来计算 entity 的累计负载贡献值. 参见 [悟空明镜-CSDN 博客--[scheduler] 八. CFS 调度算法怎么计算进程 (PELT 算法)/cpu/ 系统 利用率的](https://blog.csdn.net/wukongmingjing/article/details/82531950)
+v4.12 之前, 内核采用了与 decay_load() 类似的查表法来计算 entity 的累计负载贡献值. 参见 [悟空明镜 - CSDN 博客 --[scheduler] 八. CFS 调度算法怎么计算进程 (PELT 算法)/cpu/ 系统 利用率的](https://blog.csdn.net/wukongmingjing/article/details/82531950)
runnable_avg_yN_sum[] 数组缓存了用于查表的 32 以内等比队列的和, 即:
@@ -1052,7 +1050,7 @@ $runnable\_avg\_yN\_sum_n= \displaystyle \sum^{n}_{i = 0}{{L_i}{y^i}} = L_0+L_1y
首先是
-1. 首先是历史累计负载贡献[补齐了 1024us 的窗口](https://elixir.bootlin.com/linux/v3.8/source/kernel/sched/fair.c#L1272)后, 直接使用[同步 decay_load() 衰减 p 个周期](https://elixir.bootlin.com/linux/v3.8/source/kernel/sched/fair.c#L1282)即可.
+1. 首先是历史累计负载贡献 [补齐了 1024us 的窗口](https://elixir.bootlin.com/linux/v3.8/source/kernel/sched/fair.c#L1272) 后, 直接使用 [同步 decay_load() 衰减 p 个周期](https://elixir.bootlin.com/linux/v3.8/source/kernel/sched/fair.c#L1282) 即可.
2. 对中间 d2 窗口内的, 每个 1024us 的周期由近及远依次衰减 p-1 ~ 1 个周期. 使用 [`__compute_runnable_contrib()`](https://elixir.bootlin.com/linux/v3.8/source/kernel/sched/fair.c#L1286) 借助 runnable_avg_yN_sum[] 来完成.
@@ -1082,8 +1080,7 @@ $$
假设在 d2 阶段之前, 当前 entity 的累计负载贡献为 u, 则每执行 32 个周期, 其负载累计贡献都为:
$$
-u'
-= \frac{u + 1024 \times \displaystyle \sum^{32}_{i = 0}{y^i}}{2}
+u'= \frac{u + 1024 \times \displaystyle \sum^{32}_{i = 0}{y^i}}{2}
= \frac{u + runnable\_avg\_yN\_sum_{31}}{2}
$$
@@ -1114,8 +1111,7 @@ $$
因为整个周期 delta = (d1 + d2 + d3), 计算累计负载的公式可以继续展开, 如下所示:
$$
-u'
-\\ = (u + d_1) \times {y^p}+ 1024 \times \displaystyle \sum^{p-1}_{n = 0}{y^n} + {d_3} \times {y^0}
+u'\\ = (u + d_1) \times {y^p}+ 1024 \times \displaystyle \sum^{p-1}_{n = 0}{y^n} + {d_3} \times {y^0}
\\ = u \times {y^p} + d_1 \times {y^p} + 1024 \times \displaystyle \sum^{p-1}_{n = 0}{y^n} + {d_3}
\\ = u \times {y^p} + d_1 \times {y^p} + 1024 \times ({\displaystyle \sum^{\infty}_{n = 0}{y^n}} - {\displaystyle \sum^{\infty}_{n = p}{y^n}} - {y^0}) + {d_3}
\\ = u \times {y^p} + d_1 \times {y^p} + 1024 \times ({\displaystyle \sum^{\infty}_{n = 0}{y^n}} - {\displaystyle \sum^{\infty}_{n = 0}{y^{n+p}}} - {y^0}) + {d_3}
@@ -1127,13 +1123,13 @@ $$
&space;\times&space;{y^p}+&space;&space;1024&space;\times&space;\displaystyle&space;\sum^{p-1}_{n&space;=&space;0}{y^n}&space;+&space;{d_3}&space;\times&space;{y^0}\\&space;=&space;u&space;\times&space;{y^p}&space;+&space;d_1&space;\times&space;{y^p}&space;+&space;1024&space;\times&space;\displaystyle&space;\sum^{p-1}_{n&space;=&space;0}{y^n}&space;+&space;{d_3}\\&space;=&space;u&space;\times&space;{y^p}&space;+&space;d_1&space;\times&space;{y^p}&space;+&space;1024&space;\times&space;({\displaystyle&space;\sum^{\infty}_{n&space;=&space;0}{y^n}}&space;-&space;{\displaystyle&space;\sum^{\infty}_{n&space;=&space;p}{y^n}}&space;-&space;{y^0})&space;+&space;{d_3}\\&space;=&space;u&space;\times&space;{y^p}&space;+&space;d_1&space;\times&space;{y^p}&space;+&space;1024&space;\times&space;({\displaystyle&space;\sum^{\infty}_{n&space;=&space;0}{y^n}}&space;-&space;{\displaystyle&space;\sum^{\infty}_{n&space;=&space;0}{y^{n+p}}}&space;-&space;{y^0})&space;+&space;{d_3}\\&space;=&space;u&space;\times&space;{y^p}&space;+&space;d_1&space;\times&space;{y^p}&space;+&space;1024&space;\times&space;({Sum_{\infty}}&space;-&space;{Sum_{\infty}}&space;\times&space;{y^p}&space;-&space;1)&space;+&space;{d_3}\\&space;=&space;u&space;\times&space;{y^p}&space;+&space;d_1&space;\times&space;{y^p}&space;+&space;(LOAD\_AVG\_MAX&space;-&space;LOAD\_AVG\_MAX&space;\times&space;{y^p}&space;-&space;1024)&space;+&space;{d_3}\\&space;=&space;u&space;\times&space;{y^p}&space;\qquad&space;\qquad&space;\qquad\qquad&space;\qquad&space;\qquad&space;\qquad&space;\qquad(Step&space;1)\\&space;+&space;d_1&space;\times&space;{y^p}&space;+&space;(LOAD\_AVG\_MAX&space;-&space;LOAD\_AVG\_MAX&space;\times&space;{y^p}&space;-&space;1024)&space;+&space;{d_3}\qquad&space;\qquad&space;(Step&space;2))
-PELT 计算过程中, 将计算 u' 拆分成 2 个 step 来计算, 参见 [accumulate_sum, v4.12](https://elixir.bootlin.com/linux/v4.12/source/kernel/sched/fair.c#L2786).
+PELT 计算过程中, 将计算 u'拆分成 2 个 step 来计算, 参见 [accumulate_sum, v4.12](https://elixir.bootlin.com/linux/v4.12/source/kernel/sched/fair.c#L2786).
| step 1 | step 2 |
|:------:|:------:|
| $u \times {y^p}$ | $d_1 \times {y^p} + 1024 \times (LOAD\_AVG\_MAX - LOAD\_AVG\_MAX \times {y^p} - 1) + {d_3}$ |
-step 2 的计算再被拆分成 3 个小段(segments)来完成, 参见 [`__accumulate_pelt_segments()`, v4.12](https://elixir.bootlin.com/linux/v4.12/source/kernel/sched/fair.c#L2760).
+step 2 的计算再被拆分成 3 个小段 (segments) 来完成, 参见 [`__accumulate_pelt_segments()`, v4.12](https://elixir.bootlin.com/linux/v4.12/source/kernel/sched/fair.c#L2760).
| c1 | c2 | c3 |
|:--:|:--:|:--:|
@@ -1171,7 +1167,7 @@ Per Entity Load Tracking(PELT) 算法本身是高效. 然而, 它不能完全通
2. 其次, 如果 PELT 衰减的存在(且衰减永远不会被限制), 因此通常一个历史上高负载的任务, 在长时间的阻塞后醒来, 可能会使其负载衰减到一定阈值以下甚至完全衰减.
-为了应对 PELT 的上述问题, 在 [2016 年的 LPC 会议](http://wiki.linuxplumbersconf.org/2016:power_management_and_energy-awareness)上, Paul Turner 建议实施 Decay Clamping 机制. 它的基本思想是, 一旦任务睡眠, 任务的负载只会在一定的时间(可动态配置)内衰减, 因此实际上在唤醒时保留我们在上次运行期间负载的一部分. Morten 已经实现了这种方法, 并将原型实现用于测试和评估. 总体结论是这种方法无法胜任这项工作
+为了应对 PELT 的上述问题, 在 [2016 年的 LPC 会议](http://wiki.linuxplumbersconf.org/2016:power_management_and_energy-awareness)上, Paul Turner 建议实施 Decay Clamping 机制. 它的基本思想是, 一旦任务睡眠, 任务的负载只会在一定的时间 (可动态配置) 内衰减, 因此实际上在唤醒时保留我们在上次运行期间负载的一部分. Morten 已经实现了这种方法, 并将原型实现用于测试和评估. 总体结论是这种方法无法胜任这项工作
随后 Morten Rasmussen, Patrick Bellasi 提出了一种新的思路 Utilization Estimation, 并在 [2017 年的 LPC](https://blog.linuxplumbersconf.org/2017/ocw/proposals/4771.html) 上进行了演示, 通过与 Decay Clamping 机制对比, 可预见性地证实 Utilization Estimation 机制更合理一些. 参见 [Slides--Improving PELT--Decay Clamping vs Utilization Estimation](http://retis.sssup.it/luca/ospm-summit/2017/Downloads/OSPM_PELT_DecayClampingVsUtilEst.pdf).
@@ -1184,7 +1180,7 @@ Per Entity Load Tracking(PELT) 算法本身是高效. 然而, 它不能完全通
#### 3.2.5.1 util_est on top of PELT
-------
-cfs_rq->avg.util_est.enqueued 记录了所有 enqueue 到 rq 上的任务(包括 runnable + runing)的 util_est 之和. 参见 [commit 7f65ea42eb00 ("sched/fair: Add util_est on top of PELT")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7f65ea42eb00bc902f1c37a71e984e4f4064cfa9).
+cfs_rq->avg.util_est.enqueued 记录了所有 enqueue 到 rq 上的任务 (包括 runnable + runing) 的 util_est 之和. 参见 [commit 7f65ea42eb00 ("sched/fair: Add util_est on top of PELT")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7f65ea42eb00bc902f1c37a71e984e4f4064cfa9).
1. 进程发生阻塞, 当任务 p 出队 dequeue 时:
@@ -1231,7 +1227,7 @@ enqueue_task()
为了方便演示 Utilization Estimation(UTIL_EST) 的作者 Patrick Bellasi(derkling) 制作了几个 PELT 的示例 DEMO, 参见 [Analysis of PELT behaviours and DecayClamping effects](https://gist.github.com/derkling/6d1d3a3164b0291ef64fa409f61a81cb) 和 [pelt/PELT_Analysis.ipynb](https://gist.github.com/derkling/a0c6e03310a03e9721edbf453e131d25).
-[博客园--调度器3—PELT算法下util_avg的增速和减速](https://www.cnblogs.com/hellokitty2/p/15361706.html) 则使用示例程序演示了不同半衰期下 util_avg 的增长和衰减.
+[博客园 -- 调度器 3—PELT 算法下 util_avg 的增速和减速](https://www.cnblogs.com/hellokitty2/p/15361706.html) 则使用示例程序演示了不同半衰期下 util_avg 的增长和衰减.
### 3.2.7 PELT Optimization
@@ -1274,7 +1270,7 @@ enqueue_task()
最早的时候是 Valentin Schneider 在 HUAWEI KunPeng 920 上发现了一个问题, 构建调度域的过程中在部分 CPU 构建时 报了 `ERROR: groups don't span domain->span`. 参见 [sched/topology: Fix overlapping sched_group build](https://lore.kernel.org/lkml/20200324125533.17447-1-valentin.schneider@arm.com). 这台机器由 2 socket(每个 scoker 由 2 个 DIE 组成, 每个 DIE 包含 24 个 CPU).
-社区经过讨论发现, 这是由于内核当前调度域构建的方式存在诸多限制, 对超过 2 个 NUMA 层级的系统支持不完善. 因此我们称这个问题为 3 跳问题(3 htops)暂时没有想到好的解决方法. 因此 Valentin Schneider 决定先通过 WARN_ON 警告此问题 [sched/topology: Warn when NUMA diameter > 2](https://lore.kernel.org/lkml/20201110184300.15673-1-valentin.schneider@arm.com).
+社区经过讨论发现, 这是由于内核当前调度域构建的方式存在诸多限制, 对超过 2 个 NUMA 层级的系统支持不完善. 因此我们称这个问题为 3 跳问题 (3 htops) 暂时没有想到好的解决方法. 因此 Valentin Schneider 决定先通过 WARN_ON 警告此问题 [sched/topology: Warn when NUMA diameter> 2](https://lore.kernel.org/lkml/20201110184300.15673-1-valentin.schneider@arm.com).
@@ -1282,7 +1278,7 @@ enqueue_task()
|:----:|:----:|:----:|:---:|:----------:|:---:|
| 2020/3/24 | Valentin Schneider | [sched/topology: Fix overlapping sched_group build](https://lore.kernel.org/lkml/20200324125533.17447-1-valentin.schneider@arm.com) | NA | v1 ☐ | [LKML](https://lkml.org/lkml/2020/3/24/615) |
| 2020/8/14 | Valentin Schneider | [sched/topology: NUMA topology limitations](https://lkml.org/lkml/2020/8/14/214) | 修复 | v1 ☐ | [LKML](https://lkml.org/lkml/2020/8/14/214) |
-| 2020/11/10 | Valentin Schneider | [sched/topology: Warn when NUMA diameter > 2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b5b217346de85ed1b03fdecd5c5076b34fbb2f0b) | WARN | v1 ☑ 5.11-rc1 | [PatchWork](https://lore.kernel.org/lkml/20201110184300.15673-1-valentin.schneider@arm.com), [LKML](https://lkml.org/lkml/2020/11/10/925), [commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b5b217346de85ed1b03fdecd5c5076b34fbb2f0b) |
+| 2020/11/10 | Valentin Schneider | [sched/topology: Warn when NUMA diameter> 2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b5b217346de85ed1b03fdecd5c5076b34fbb2f0b) | WARN | v1 ☑ 5.11-rc1 | [PatchWork](https://lore.kernel.org/lkml/20201110184300.15673-1-valentin.schneider@arm.com), [LKML](https://lkml.org/lkml/2020/11/10/925), [commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b5b217346de85ed1b03fdecd5c5076b34fbb2f0b) |
随后告警的合入, 越来越多的人发现了这个问题, 并进行了讨论 [5.11-rc4+git: Shortest NUMA path spans too many nodes](https://lkml.org/lkml/2021/1/21/726).
@@ -1314,7 +1310,7 @@ enqueue_task()
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:--:|:----:|:---------:|:----:|
-| 2021/01/15 | Song Bao Hua (Barry Song) | [sched/fair: first try to fix the scheduling impact of NUMA diameter > 2](https://lore.kernel.org/lkml/20210115203632.34396-1-song.bao.hua@hisilicon.com/) | 修复问题 2 | RFC ☐ | [LORE](https://lore.kernel.org/lkml/20210115203632.34396-1-song.bao.hua@hisilicon.com) |
+| 2021/01/15 | Song Bao Hua (Barry Song) | [sched/fair: first try to fix the scheduling impact of NUMA diameter> 2](https://lore.kernel.org/lkml/20210115203632.34396-1-song.bao.hua@hisilicon.com/) | 修复问题 2 | RFC ☐ | [LORE](https://lore.kernel.org/lkml/20210115203632.34396-1-song.bao.hua@hisilicon.com) |
| 2021/2/23 | Song Bao Hua (Barry Song) | [sched/topology: fix the issue groups don't span domain->span for NUMA diameter > 2](https://lore.kernel.org/patchwork/patch/1371875) | 修复问题 2
build_overlap_sched_groups() 中构建调度域的时候如果将某个 (child) sched_domain 作为 sched_group 加进 (parent) sched_domain 的时候, 如果发现其 sched_group_span 不是 parent sched_domain_span 子集的情况, 则通过 find_descended_sibling() 查找该 (child) sched_doman 的 child, 将符合要求的 child 作为 sched_group 加进来. | v4 ☑ 5.13-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/1371875), [LKML](https://lkml.org/lkml/2021/2/23/1010), [commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=585b6d2723dc927ebc4ad884c4e879e4da8bc21f) |
@@ -1327,7 +1323,7 @@ X86 下提供了一种 Fake Numa 的方式来模拟 NUMA 配置.
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2004/08/30 | Andi Kleen | [x86_64: emulate NUMA on non-NUMA hardware](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=60b292cab32ba482d8119906fbd4f73c7117c70b) | 实现 numa_emulation() 功能. | v1 ☑✓ 2.6.9-rc2 | [LORE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=60b292cab32ba482d8119906fbd4f73c7117c70b) |
| 2004/08/30 | Andi Kleen | [x86_64 Kconfig: Split CONFIG_NUMA_EMU and CONFIG_K8_NUMA](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c47f0fce497e6f86e02ff448812b542c6732ea2c) | 为 numa_emulation() 通过宏 CONFIG_NUMA_EMU 隔离. | v1 ☑✓ 2.6.10-rc1 | [LORE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c47f0fce497e6f86e02ff448812b542c6732ea2c) |
-| 2011/01/19 | Jan Beulich | [x86: Unify "numa=" command line option handling](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9032160275ba) | 使用 `numa=` 内核启动参数统一管理 NUMA 配置. | v1 ☐☑✓ | [LORE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9032160275ba) |
+| 2011/01/19 | Jan Beulich | [x86: Unify"numa="command line option handling](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9032160275ba) | 使用 `numa=` 内核启动参数统一管理 NUMA 配置. | v1 ☐☑✓ | [LORE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9032160275ba) |
| 2011/02/14 | Tejun Heo | [x86-64, NUMA: bring sanity to NUMA emulation](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e23bba604433a202cd301a976454a90ea6b783ef) | TODO | v1 ☑✓ 2.6.39-rc1 | [LORE](https://lore.kernel.org/all/1297711715-3086-1-git-send-email-tj@kernel.org) |
| 2012/05/01 | Peter Zijlstra | [x86/numa: Allow specifying node_distance() for numa=fake](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=ad7687dde8780a0d618a3e3b5a62bb383696fc22) | TODO | v1 ☑✓ 3.5-rc1 | [LORE v1,0/5](https://lore.kernel.org/all/20120501181430.007891123@chello.nl) |
@@ -1340,7 +1336,7 @@ X86 下提供了一种 Fake Numa 的方式来模拟 NUMA 配置.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:---:|:----:|:---:|:----:|:---------:|:----:|
-| 2022/07/19 | Tariq Toukan | [Introduce and use NUMA distance metrics](https://lore.kernel.org/all/20220719162339.23865-1-tariqt@nvidia.com) | NVIDIA 工程师一直在 Linux 内核中研究 NUMA 距离指标, 以取代某些驱动程序目前用于 NUMA 感知内存分配的简单本地/远程 NUMA 首选项接口. 在他们的测试中, 这种改进的 NUMA 距离处理对吞吐量和 CPU 利用率产生了"显著的性能影响". 根据调度程序的 sched_numa_find_closest() 实现并公开 CPU spread API sched_cpus_set_spread(). 在给定 NUMA 节点的情况下, 基于距离设置 CPU 分布替代基于 cpumask_local_spread() 的传统逻辑. 在 mlx5 和 enic 设备驱动程序中使用它. 这将使得 NUMA 首选项(本地/远程)替换为考虑实际距离的改进首选项, 因此短距离的远程 NUMA 优先于较远的 NUMA. | v3 ☐☑✓ | [LORE v3,0/3](https://lore.kernel.org/all/20220719162339.23865-1-tariqt@nvidia.com)
*-*-*-*-*-*-*-*
[2022/07/28 LORE v4,0/3](20220728191203.4055-1-tariqt@nvidia.com) |
+| 2022/07/19 | Tariq Toukan | [Introduce and use NUMA distance metrics](https://lore.kernel.org/all/20220719162339.23865-1-tariqt@nvidia.com) | NVIDIA 工程师一直在 Linux 内核中研究 NUMA 距离指标, 以取代某些驱动程序目前用于 NUMA 感知内存分配的简单本地 / 远程 NUMA 首选项接口. 在他们的测试中, 这种改进的 NUMA 距离处理对吞吐量和 CPU 利用率产生了 "显著的性能影响". 根据调度程序的 sched_numa_find_closest() 实现并公开 CPU spread API sched_cpus_set_spread(). 在给定 NUMA 节点的情况下, 基于距离设置 CPU 分布替代基于 cpumask_local_spread() 的传统逻辑. 在 mlx5 和 enic 设备驱动程序中使用它. 这将使得 NUMA 首选项 (本地 / 远程) 替换为考虑实际距离的改进首选项, 因此短距离的远程 NUMA 优先于较远的 NUMA. | v3 ☐☑✓ | [LORE v3,0/3](https://lore.kernel.org/all/20220719162339.23865-1-tariqt@nvidia.com)
*-*-*-*-*-*-*-*
[2022/07/28 LORE v4,0/3](20220728191203.4055-1-tariqt@nvidia.com) |
| 2022/08/17 | Valentin Schneider | [cpumask, sched/topology: NUMA-aware CPU spreading interface](https://lore.kernel.org/all/20220816180727.387807-1-vschneid@redhat.com) | TODO | v1 ☐☑✓ | [2022/08/16 LORE v1,0/5](https://lore.kernel.org/all/20220816180727.387807-1-vschneid@redhat.com)
*-*-*-*-*-*-*-*
[2022/08/17 LORE v2,0/5](https://lore.kernel.org/lkml/20220817175812.671843-1-vschneid@redhat.com)
*-*-*-*-*-*-*-*
[LORE v5,0/3](https://lore.kernel.org/all/20221021121927.2893692-1-vschneid@redhat.com) |
@@ -1348,9 +1344,9 @@ X86 下提供了一种 Fake Numa 的方式来模拟 NUMA 配置.
-------
-**2.6.7(2004年6月发布)**
+**2.6.7(2004 年 6 月发布)**
-计算机依靠并行度来突破性能瓶颈, CPU个数也是与日俱增. 最早的是 SMP(对称多处理), 所以 CPU共享内存, 并访问速度一致. 随着 CPU 个数的增加, 这种做法不适应了, 因为 CPU 个数的增多, 增加了总线访问冲突, 这样 CPU 增加的并行度被访问内存总线的瓶颈给抵消了, 于是引入了 NUMA(非一致性内存访问)的概念. 机器分为若干个node, 每个node(其实一般就是一个 socket)有本地可访问的内存, 也可以通过 interconnect 中介机构访问别的 node 的内存, 但是访问速度降低了, 所以叫非一致性内存访问. Linux 2.5版本时就开始了对 NUMA 的支持[7](#refer-anchor-7).
+计算机依靠并行度来突破性能瓶颈, CPU 个数也是与日俱增. 最早的是 SMP(对称多处理), 所以 CPU 共享内存, 并访问速度一致. 随着 CPU 个数的增加, 这种做法不适应了, 因为 CPU 个数的增多, 增加了总线访问冲突, 这样 CPU 增加的并行度被访问内存总线的瓶颈给抵消了, 于是引入了 NUMA(非一致性内存访问)的概念. 机器分为若干个 node, 每个 node(其实一般就是一个 socket)有本地可访问的内存, 也可以通过 interconnect 中介机构访问别的 node 的内存, 但是访问速度降低了, 所以叫非一致性内存访问. Linux 2.5 版本时就开始了对 NUMA 的支持[7](#refer-anchor-7).
而在调度器领域, 调度器有一个重要任务就是做负载均衡. 当某个 CPU 出现空闲, 就要从别的 CPU 上调整任务过来执行; 当创建新进程时, 调度器也会根据当前负载状况分配一个最适合的 CPU 来执行. 然后, 这些概念是大大简化了实际情形.
@@ -1358,18 +1354,18 @@ X86 下提供了一种 Fake Numa 的方式来模拟 NUMA 配置.
在一个 NUMA 机器上, 存在下列层级:
-> 1. 每一个 NUMA node 是一个 CPU socket(你看主板上CPU位置上那一块东西就是一个 socket).
-> 2. 每一个socket上, 可能存在两个核, 甚至四个核.
+> 1. 每一个 NUMA node 是一个 CPU socket(你看主板上 CPU 位置上那一块东西就是一个 socket).
+> 2. 每一个 socket 上, 可能存在两个核, 甚至四个核.
> 3. 每一个核上, 可以打开硬件多纯程(HyperThread).
-如果一个机器上同时存在这三人层级, 则对调度器来说, 它所见的一个逻辑 CPU其实是一人 HyperThread.处理同一个core 中的CPU , 可以共享L1, 乃至 L2 缓存, 不同的 core 间, 可以共享 L3 缓存(如果存在的话).
+如果一个机器上同时存在这三人层级, 则对调度器来说, 它所见的一个逻辑 CPU 其实是一人 HyperThread.处理同一个 core 中的 CPU , 可以共享 L1, 乃至 L2 缓存, 不同的 core 间, 可以共享 L3 缓存(如果存在的话).
-基于此, 负载均衡不能简单看不同 CPU 上的任务个数, 还要考虑缓存, 内存访问速度.所以, 2.6.7 引入了**调度域(sched domain)** 的概念, 把 CPU 按上述层级划分为不同的层级, 构建成一棵树, 叶子节点是每个逻辑 CPU, 往上一层, 是属于 core 这个域, 再往上是属于 socket 这个域, 再往上是 NUMA 这个域, 包含所有 CPU.
+基于此, 负载均衡不能简单看不同 CPU 上的任务个数, 还要考虑缓存, 内存访问速度.所以, 2.6.7 引入了 ** 调度域(sched domain)** 的概念, 把 CPU 按上述层级划分为不同的层级, 构建成一棵树, 叶子节点是每个逻辑 CPU, 往上一层, 是属于 core 这个域, 再往上是属于 socket 这个域, 再往上是 NUMA 这个域, 包含所有 CPU.
-当进行负载均衡时, 将从最低一级域往上看, 如果能在 core 这个层级进行均衡, 那最好; 否则往上一级, 能在socket 一级进行均衡也还凑合; 最后是在 NUMA node 之间进行均衡, 这是代价非常大的, 因为跨 node 的内存访问速度会降低, 也许会得不偿失, 很少在这一层进行均衡.
+当进行负载均衡时, 将从最低一级域往上看, 如果能在 core 这个层级进行均衡, 那最好; 否则往上一级, 能在 socket 一级进行均衡也还凑合; 最后是在 NUMA node 之间进行均衡, 这是代价非常大的, 因为跨 node 的内存访问速度会降低, 也许会得不偿失, 很少在这一层进行均衡.
@@ -1383,7 +1379,7 @@ X86 下提供了一种 Fake Numa 的方式来模拟 NUMA 配置.
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2009/09/01 | Peter Zijlstra | [load-balancing and cpu_power -v2](https://lore.kernel.org/patchwork/patch/169381) | load balance 感知 CPU PWOER, 对于 RT 任务, 引入了 sched_time_avg 来平均一段时间内实时任务的 CPU 消耗. 用得到的平均值来调整非实时任务的 CPU 功率, 以确保实时任务不必争抢 CPU. | v4 ☑ |[PatchWork](https://lore.kernel.org/patchwork/patch/169381) |
-[内核工匠-负载均衡情景分析](https://blog.csdn.net/feelabclihu/article/details/112057633)
+[内核工匠 - 负载均衡情景分析](https://blog.csdn.net/feelabclihu/article/details/112057633)
[干货|CPU 可运行进程队列的负载均衡](https://zhuanlan.zhihu.com/p/489829757)
@@ -1393,7 +1389,7 @@ X86 下提供了一种 Fake Numa 的方式来模拟 NUMA 配置.
2. 是为 idle CPU 们准备的空闲调度器 idle balancer, 用于把繁忙 CPU 上的任务均衡到 idle CPU 上来. idle balancer 有两种, 一种是 nohz idle balancer, 另外一种是 new idle balancer.
-周期性负载均衡(periodic load balance 或者 tick load balance)是指在 tick 中, 周期性的检测系统的负载均衡状况, 找到系统中负载最重的 sched_domain、 sched_group 和 CPU, 将其上的 runnable 任务拉到本 CPU 以便让系统的负载处于均衡的状态.
+周期性负载均衡 (periodic load balance 或者 tick load balance) 是指在 tick 中, 周期性的检测系统的负载均衡状况, 找到系统中负载最重的 sched_domain、 sched_group 和 CPU, 将其上的 runnable 任务拉到本 CPU 以便让系统的负载处于均衡的状态.
周期性负载均衡只能在 busy CPU 之间均衡, 要想让系统中的 idle CPU "燥起来" 就需要借助 idle load balance.
@@ -1489,7 +1485,7 @@ rebalance_domains()
v2.6.26 引入了单 RQ 组调度 [Single RQ group scheduling](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=486fdae21458bd9f4e125099bb3c38a4064e450e).
-1. 引入了[基于 cfs_rq 维护的](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4a55bd5e97b1775913f88f11108a4f144f590e89)进程链表 cfs_rq->tasks, 在进行 Group Load Balancing 的过程中 `__load_balance_iterator()` 基于[此链表进行遍历](https://elixir.bootlin.com/linux/v2.6.26/source/kernel/sched_fair.c#L1285), 替代了直接[使用 rbtree 进行遍历](https://elixir.bootlin.com/linux/v2.6.25/source/kernel/sched_fair.c#L1207)的方式. 参见 [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4a55bd5e97b1775913f88f11108a4f144f590e89).
+1. 引入了 [基于 cfs_rq 维护的](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4a55bd5e97b1775913f88f11108a4f144f590e89) 进程链表 cfs_rq->tasks, 在进行 Group Load Balancing 的过程中 `__load_balance_iterator()` 基于 [此链表进行遍历](https://elixir.bootlin.com/linux/v2.6.26/source/kernel/sched_fair.c#L1285), 替代了直接[使用 rbtree 进行遍历](https://elixir.bootlin.com/linux/v2.6.25/source/kernel/sched_fair.c#L1207) 的方式. 参见 [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4a55bd5e97b1775913f88f11108a4f144f590e89).
2. 引入了 `__load_balance_fair()` 辅助 load_balance_fair 完成 Load Balancing 工作.
@@ -1500,7 +1496,7 @@ v3.4 [commit c308b56b5398 ("sched: Ditch per cgroup task lists for load-balancin
1. PER-cgroup Load Balancing 有许多问题, 其中最主要的问题是没有真正合理的顺序. 因此把所有的任务从 PER-cgroup PER-CPU 的 cfs_rq->tasks 链表转换到一个 [PER CPU 的 rq->cfs_tasks 链表](https://elixir.bootlin.com/linux/v3.4/source/kernel/sched/fair.c#L787)上. 这样 cfs_tasks 链表就维护运行队列上的全部 CFS 任务, 在迁移失败时[旋转该列表](https://elixir.bootlin.com/linux/v3.4/source/kernel/sched/fair.c#L3289), 通过 list_move_tail() 将 task 移动到末尾.
-2. 这也允许我们更容易地修复因为过度持锁(时间太久)而导致的 fwd 进程问题, 当 dest rq 上的任务数比较多的时候, 并且需要迁移大量的任务才能完成均衡时, 可能造成 Load Balancing 迁移过程中长时间关中断持锁. 为了减少关中断的区间. ① 首先 lb_env 引入了限制循环次数的控制变量, 将[总迭代次数 env.loop 限制 env.loop_max 在 nr_running 以内](https://elixir.bootlin.com/linux/v3.4/source/kernel/sched/fair.c#L4453), 这有效地限制了关中断的时间. ② , 迁移需要分段进行([每 sched_nr_migrate_break 暂停一下 LBF_NEED_BREAK](https://elixir.bootlin.com/linux/v3.4/source/kernel/sched/fair.c#L3246)), 从而把大的临界区分成几个小的临界区, 确保系统的延迟性能.
+2. 这也允许我们更容易地修复因为过度持锁 (时间太久) 而导致的 fwd 进程问题, 当 dest rq 上的任务数比较多的时候, 并且需要迁移大量的任务才能完成均衡时, 可能造成 Load Balancing 迁移过程中长时间关中断持锁. 为了减少关中断的区间. ① 首先 lb_env 引入了限制循环次数的控制变量, 将[总迭代次数 env.loop 限制 env.loop_max 在 nr_running 以内](https://elixir.bootlin.com/linux/v3.4/source/kernel/sched/fair.c#L4453), 这有效地限制了关中断的时间. ② , 迁移需要分段进行([每 sched_nr_migrate_break 暂停一下 LBF_NEED_BREAK](https://elixir.bootlin.com/linux/v3.4/source/kernel/sched/fair.c#L3246)), 从而把大的临界区分成几个小的临界区, 确保系统的延迟性能.
3. 还添加了一个过滤器(可以[用 sched-feature LB_MIN 来控制](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=eb95308ee2a69403909e111837b9068c64cfc349)), 在第一次尝试列表时[跳过非常轻的任务](https://elixir.bootlin.com/linux/v3.4/source/kernel/sched/fair.c#L3257), 这试图避免在不影响过度平衡的情况下遍历整个 cgroup.
@@ -1532,15 +1528,15 @@ v3.13 [Various load-balance cleanups/optimizations -v2](https://git.kernel.org/p
1. 首先是对 [struct sd_lb_stat](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L5202) 结构做了精简, 在 sd_lb_stat 中为 this_group 和 busiest_group 重复维护 truct sg_lb_stats 中已有的统计信息是没有意义的. 由于这个结构总是在堆栈中分配, peterz 认为这有效地减少堆栈占用, 可读性也增加足够多. [sched: Clean-up struct sd_lb_stat](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=56cf515b4b1567c4e8fa9926175b40c66b9ec472).
-2. 最重要的是 [commit 6263322c5e8f ("sched/fair: Rewrite group_imb trigger")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6263322c5e8ffdaf5eaaa29e9d02d84a786aa970) 将 group_imb 检测从旧的 "load-spike" 检测更改为实际的失衡检测. 当它无法在任务亲和性存在的情况(LBF_SOME_PINNED)下完成负载平衡时, 允许在[较低的域平衡通道](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L6266)设置它. 这样做的好处是, 它将不再产生假阳性的 group_imb 条件, group_imb 条件是由正常的平衡/批量唤醒等行为产生的瞬态负载峰值产生的.
+2. 最重要的是 [commit 6263322c5e8f ("sched/fair: Rewrite group_imb trigger")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6263322c5e8ffdaf5eaaa29e9d02d84a786aa970) 将 group_imb 检测从旧的 "load-spike" 检测更改为实际的失衡检测. 当它无法在任务亲和性存在的情况 (LBF_SOME_PINNED) 下完成负载平衡时, 允许在 [较低的域平衡通道](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L6266) 设置它. 这样做的好处是, 它将不再产生假阳性的 group_imb 条件, group_imb 条件是由正常的平衡 / 批量唤醒等行为产生的瞬态负载峰值产生的.
-v3.18 使用了 enum group_type 替代原来 group_imb 的表达方式. update_sd_pick_busiest() 用于检查当前探测的 sched_group 是不是比之前找到的 busier_group 更 BUSY, 如果是的, 就会返回 true, 但是当前只能标识[过载](https://elixir.bootlin.com/linux/v3.17/source/kernel/sched/fair.c#L5974)或[组失衡](https://elixir.bootlin.com/linux/v3.17/source/kernel/sched/fair.c#L5977)的最繁忙的 sd. 当没有 sd 不均衡或负载过重时, 负载均衡器无法找到最繁忙的域 busiest_group. 特别是 !SD_ASYM_PACKING 情况下, 直接打破了未过载域之间的负载平衡.
+v3.18 使用了 enum group_type 替代原来 group_imb 的表达方式. update_sd_pick_busiest() 用于检查当前探测的 sched_group 是不是比之前找到的 busier_group 更 BUSY, 如果是的, 就会返回 true, 但是当前只能标识 [过载](https://elixir.bootlin.com/linux/v3.17/source/kernel/sched/fair.c#L5974) 或[组失衡](https://elixir.bootlin.com/linux/v3.17/source/kernel/sched/fair.c#L5977)的最繁忙的 sd. 当没有 sd 不均衡或负载过重时, 负载均衡器无法找到最繁忙的域 busiest_group. 特别是 !SD_ASYM_PACKING 情况下, 直接打破了未过载域之间的负载平衡.
-于是 [commit caeb178c60f4 ("sched/fair: Make update_sd_pick_busiest() return 'true' on a busier sd")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=caeb178c60f4f93f1b45c0bc056b5cf6d217b67f) 优化了当前 sched_group 和已经查找到的 busiest 的比较逻辑, 使得 update_sd_pick_busiest() 在遇到更繁忙的 sd 时总能正确返回 true. 在 Peter Zijlstra 的建议下, 使用 enum group_type 标记和分类 sched_group 的当前不均衡状态, 当前的排列顺序是超载 group_overloaded > 不平衡 group_imbalanced > 其他 group_other, 即使负载较低, 级别较高的组也获得优先级, 这通过直接[比较两个 sched_group 的 group_type 来确定](https://elixir.bootlin.com/linux/v3.18/source/kernel/sched/fair.c#L6067). 并且直接[考虑了 SD_ASYM_PACKING 的情况](https://elixir.bootlin.com/linux/v3.18/source/kernel/sched/fair.c#L6085), 组内的域之间可能存在不平等的容量和 cpumask.
+于是 [commit caeb178c60f4 ("sched/fair: Make update_sd_pick_busiest() return'true'on a busier sd")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=caeb178c60f4f93f1b45c0bc056b5cf6d217b67f) 优化了当前 sched_group 和已经查找到的 busiest 的比较逻辑, 使得 update_sd_pick_busiest() 在遇到更繁忙的 sd 时总能正确返回 true. 在 Peter Zijlstra 的建议下, 使用 enum group_type 标记和分类 sched_group 的当前不均衡状态, 当前的排列顺序是超载 group_overloaded> 不平衡 group_imbalanced > 其他 group_other, 即使负载较低, 级别较高的组也获得优先级, 这通过直接[比较两个 sched_group 的 group_type 来确定](https://elixir.bootlin.com/linux/v3.18/source/kernel/sched/fair.c#L6067). 并且直接[考虑了 SD_ASYM_PACKING 的情况](https://elixir.bootlin.com/linux/v3.18/source/kernel/sched/fair.c#L6085), 组内的域之间可能存在不平等的容量和 cpumask.
-这样是为了确保系统中的负载平衡不会过载, 但是他也有副作用. 这样修改后, update_sd_pick_busiest() 总是返回一个最繁忙的 sched_group, 但是这个 sched_group 可能是一个既不平衡也不超载的组, 它只是比其他 sched_group 负载更大,这就造成它可能在 sched_group 之间生成无用的主动迁移(active load_balance()).
+这样是为了确保系统中的负载平衡不会过载, 但是他也有副作用. 这样修改后, update_sd_pick_busiest() 总是返回一个最繁忙的 sched_group, 但是这个 sched_group 可能是一个既不平衡也不超载的组, 它只是比其他 sched_group 负载更大, 这就造成它可能在 sched_group 之间生成无用的主动迁移(active load_balance()).
-让我们以四核系统上的 3 个任务为例. 我们总是有一个空闲的 CPU, 所以每当 ILB 被触发时, 负载均衡就会找到一个最繁忙的 CPU, 它会强制一个主动迁移(一旦超过 nr_balance_failed 阈值), 这样空闲的 CPU 会变得繁忙, 而另一个 CPU会变得空闲. 在下一个 ILB 中, 新空闲的 CPU 将尝试拉出一个繁忙的 CPU 的任务. 这造成了任务频繁地颠簸. 在四核系统中, 由于 ILB 的触发较少, 假主动迁移的数量并不大. 但是, 如果您有多个 sched_domain 级别, 比如在四核的双集群中, 当有一个以上的 busy_cpu 时, 每隔一次就会触发 ILB, 那么这个问题就变得更加严重. 因此我们需要确保迁移生成一个真正的 improveùent, 而不仅仅是移动另一个 CPU 上的 avg_load 不平衡. 在 v3.18 之前, 这是通过在 FBG(find_busiest_group()) 中进行以下测试来确保该用例的过滤:
+让我们以四核系统上的 3 个任务为例. 我们总是有一个空闲的 CPU, 所以每当 ILB 被触发时, 负载均衡就会找到一个最繁忙的 CPU, 它会强制一个主动迁移(一旦超过 nr_balance_failed 阈值), 这样空闲的 CPU 会变得繁忙, 而另一个 CPU 会变得空闲. 在下一个 ILB 中, 新空闲的 CPU 将尝试拉出一个繁忙的 CPU 的任务. 这造成了任务频繁地颠簸. 在四核系统中, 由于 ILB 的触发较少, 假主动迁移的数量并不大. 但是, 如果您有多个 sched_domain 级别, 比如在四核的双集群中, 当有一个以上的 busy_cpu 时, 每隔一次就会触发 ILB, 那么这个问题就变得更加严重. 因此我们需要确保迁移生成一个真正的 improveùent, 而不仅仅是移动另一个 CPU 上的 avg_load 不平衡. 在 v3.18 之前, 这是通过在 FBG(find_busiest_group()) 中进行以下测试来确保该用例的过滤:
```cpp
@@ -1555,12 +1551,10 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
* there is no imbalance between this and busiest group
* wrt to idle cpu's, it is balanced.
*/
- if ((local->idle_cpus < busiest->idle_cpus) &&
+ if ((local->idle_cpus idle_cpus) &&
busiest->sum_nr_running <= busiest->group_weight)
goto out_balanced;
- } else {
- // ......
- }
+ } else {// ......}
```
[commit 43f4d66637bc ("sched: Improve sysbench performance by fixing spurious active migration")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=43f4d66637bc752e93a77ff2536474a5a3888442) 修改了此判断条件, 以考虑最忙组未过载的情况: 如果两个组中空闲 CPU 的数量之差小于或等于 1, 并且最忙的 sched_group 未过载, 则迁移任务不会改善负载平衡.
@@ -1585,7 +1579,7 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
| 2014/07/28 | riel@redhat.com | [load balancing fixes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9a5d9ba6a3631d55c358fe1bdbaa162a97471a05) | TODO | v1 ☑✓ 3.18-rc1 | [LORE v1,0/2](https://lore.kernel.org/all/1406571388-3227-1-git-send-email-riel@redhat.com) |
| 2014/10/01 | Vincent Guittot | [sched: Improve sysbench performance by fixing spurious active migration](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=43f4d66637bc752e93a77ff2536474a5a3888442) | TODO | v2 ☑✓ 3.18-rc1 | [LORE](https://lore.kernel.org/all/1412170735-5356-1-git-send-email-vincent.guittot@linaro.org) |
| 2014/11/05 | Wanpeng Li | [sched/fair: fix use stale overloaded status to find busiest group](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=c51b8ab5ad972df26fd9c0ffad34870e98273c4c) | TODO | v2 ☑✓ 3.19-rc1 | [LORE](https://lore.kernel.org/all/1415144690-25196-1-git-send-email-wanpeng.li@linux.intel.com) |
-| 2017/12/18 | Vincent Guittot | [sched/fair: Improve fairness between cfs tasks](https://lore.kernel.org/patchwork/cover/1308748) | 当系统没有足够的周期用于所有任务时, 调度器必须确保在CFS任务之间公平地分配这些cpu周期. 某些用例的公平性不能通过在系统上静态分配任务来解决, 需要对系统进行周期性的再平衡但是, 这种动态行为并不总是最优的, 也不总是能够确保CPU绑定的公平分配.
这组补丁通过减少选择可迁移任务的限制来提高公平性. 这个更改可以降低不平衡阈值, 因为 1st LB将尝试迁移完全匹配不平衡的任务. | v1 ☑ [5.10-rc1](https://kernelnewbies.org/Linux_5.10#Memory_management) | [PatchWork](https://lore.kernel.org/patchwork/cover/1308748) |
+| 2017/12/18 | Vincent Guittot | [sched/fair: Improve fairness between cfs tasks](https://lore.kernel.org/patchwork/cover/1308748) | 当系统没有足够的周期用于所有任务时, 调度器必须确保在 CFS 任务之间公平地分配这些 cpu 周期. 某些用例的公平性不能通过在系统上静态分配任务来解决, 需要对系统进行周期性的再平衡但是, 这种动态行为并不总是最优的, 也不总是能够确保 CPU 绑定的公平分配.
这组补丁通过减少选择可迁移任务的限制来提高公平性. 这个更改可以降低不平衡阈值, 因为 1st LB 将尝试迁移完全匹配不平衡的任务. | v1 ☑ [5.10-rc1](https://kernelnewbies.org/Linux_5.10#Memory_management) | [PatchWork](https://lore.kernel.org/patchwork/cover/1308748) |
| 2021/01/06 | Vincent Guittot | [Reduce number of active LB](https://lore.kernel.org/patchwork/cover/1361676) | 减少 ACTIVE LOAD_BALANCE 的次数 | v2 ☑ 5.12-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/1361676) |
| 2020/01/14 | Mel Gorman | [sched, fair: Allow a small load imbalance between low utilisation SD_NUMA domains v4](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b396f52326de20ec974471b7b19168867b365cbf) | TODO | v4 ☑✓ 5.6-rc2 | [LORE v4](https://lore.kernel.org/all/20200114101319.GO3466@techsingularity.net) |
@@ -1603,9 +1597,9 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
1. 遍历所有 CPU, 查找到负载最高的 CPU 及其 Load max_load. 那么 imbalance = max_load - nr_running;
-2. 保持[至少 25% 以上的不均衡差异](https://elixir.bootlin.com/linux/v2.6.0/source/kernel/sched.c#L1109)才触发负载均衡, 否则就认为不均衡的程度很细微, 没必要触发负载均衡.
+2. 保持 [至少 25% 以上的不均衡差异](https://elixir.bootlin.com/linux/v2.6.0/source/kernel/sched.c#L1109) 才触发负载均衡, 否则就认为不均衡的程度很细微, 没必要触发负载均衡.
-3. 尝试从 busiest_rq 上[迁移 imbalance/2 的负载量](https://elixir.bootlin.com/linux/v2.6.0/source/kernel/sched.c#L1193)过来. 由于 load 近似用 nr_running 表示的, 则自然就是通过 pull_task() [迁移 imbalance/2 个进程](https://elixir.bootlin.com/linux/v2.6.0/source/kernel/sched.c#L1243)过来.
+3. 尝试从 busiest_rq 上 [迁移 imbalance/2 的负载量](https://elixir.bootlin.com/linux/v2.6.0/source/kernel/sched.c#L1193) 过来. 由于 load 近似用 nr_running 表示的, 则自然就是通过 pull_task() [迁移 imbalance/2 个进程](https://elixir.bootlin.com/linux/v2.6.0/source/kernel/sched.c#L1243)过来.
随后 v2.6.7 引入了 sched_domain 的支持, 也对 CPU Capacity/Power 做了最基础的感知, 此时 load 不是直接用 nr_running 表示, 而是用 nr_running * SCHED_LOAD_SCALE 类似的形式表达, 参见 [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8c136f71934b05aebb7ffb9631415b74f0906bad), [COMMIT2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3dfa303d9839496fc21d3ac47d10ff017dbb1c3a), [COMMIT3](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=482b99334b6998fbd3f2b048f90c56de33dd667b).
@@ -1652,8 +1646,7 @@ v2.6.12 通过 [sched: find_busiest_group fixlets](https://git.kernel.org/pub/s
static struct sched_group *
find_busiest_group(struct sched_domain *sd, int this_cpu,
unsigned long *imbalance, enum idle_type idle)
-{
- *imbalance = min((max_load - avg_load) * busiest->cpu_power,
+{*imbalance = min((max_load - avg_load) * busiest->cpu_power,
(avg_load - this_load) * this->cpu_power)
/ SCHED_LOAD_SCALE;
// ......
@@ -1678,8 +1671,7 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
static struct sched_group *
find_busiest_group(struct sched_domain *sd, int this_cpu,
unsigned long *imbalance, enum idle_type idle, int *sd_idle)
-{
- /* Don't want to pull so many tasks that a group would go idle */
+{/* Don't want to pull so many tasks that a group would go idle */
max_pull = min(max_load - avg_load, max_load - SCHED_LOAD_SCALE);
/* How much load to actually move to equalise the imbalance */
@@ -1728,8 +1720,7 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
*/
if (busiest->group_type != group_misfit_task &&
(busiest->avg_load <= sds->avg_load ||
- local->avg_load >= sds->avg_load)) {
- env->imbalance = 0;
+ local->avg_load >= sds->avg_load)) {env->imbalance = 0;
return fix_small_imbalance(env, sds);
}
@@ -1745,14 +1736,12 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
max_pull = min(busiest->avg_load - sds->avg_load, load_above_capacity);
/* How much load to actually move to equalise the imbalance */
- env->imbalance = min(
- max_pull * busiest->group_capacity,
+ env->imbalance = min(max_pull * busiest->group_capacity,
(sds->avg_load - local->avg_load) * local->group_capacity
) / SCHED_CAPACITY_SCALE;
/* Boost imbalance to allow misfit task to be balanced. */
- if (busiest->group_type == group_misfit_task) {
- env->imbalance = max_t(long, env->imbalance,
+ if (busiest->group_type == group_misfit_task) {env->imbalance = max_t(long, env->imbalance,
busiest->group_misfit_task_load);
}
@@ -1762,7 +1751,7 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
* a think about bumping its value to force at least one task to be
* moved
*/
- if (env->imbalance < busiest->load_per_task)
+ if (env->imbalance load_per_task)
return fix_small_imbalance(env, sds);
}
```
@@ -1785,7 +1774,7 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
2019 年的 [Vincent Guittot](https://www.youtube.com/watch?v=cfv63BMnIug) 的 [LWN: Reworking CFS load balancing](https://lwn.net/Articles/793427) 是近几年特别有亮点的补丁.
-博主个人一直是计算机先驱"高德纳"教授"文学化编程"思想的坚定追随者, 小米创始人雷军雷布斯先生也说"写代码要有写诗一样的感觉". 这种代码才真的让人眼前一亮, 如沐春风. 这个就是我看到 [rework_load_balance 这组补丁](https://lore.kernel.org/patchwork/cover/1141687) 的感觉. 这组补丁通过重构 (CFS) load_balance 的逻辑, 将原来逻辑混乱的 load_balance 变成了内核中一抹亮丽的风景, 不光使得整个 load_balance 的框架更清晰, 可读性更好. 更带来了性能的提升.
+博主个人一直是计算机先驱 "高德纳" 教授 "文学化编程" 思想的坚定追随者, 小米创始人雷军雷布斯先生也说 "写代码要有写诗一样的感觉". 这种代码才真的让人眼前一亮, 如沐春风. 这个就是我看到 [rework_load_balance 这组补丁](https://lore.kernel.org/patchwork/cover/1141687) 的感觉. 这组补丁通过重构 (CFS) load_balance 的逻辑, 将原来逻辑混乱的 load_balance 变成了内核中一抹亮丽的风景, 不光使得整个 load_balance 的框架更清晰, 可读性更好. 更带来了性能的提升.
* 它将系统中调度组的状态[归结于几种类型](https://lore.kernel.org/lkml/1571405198-27570-5-git-send-email-vincent.guittot@linaro.org), 对于其中的负载不均衡状态分别采用不同的处理方式.
@@ -1840,7 +1829,7 @@ load_balance()
| 2019/10/18 | Vincent Guittot | [sched/fair: rework the CFS load balance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=57abff067a084889b6e06137e61a3dc3458acd56) | 重构 load balance, 参见 [LPC](https://linuxplumbersconf.org/event/4/contributions/480)) | v4 ☑ 5.5-rc1 | [LWN](https://lwn.net/Articles/793427), [PatchWork](https://lore.kernel.org/all/1571405198-27570-1-git-send-email-vincent.guittot@linaro.org), [lkml](https://lkml.org/lkml/2019/10/18/676), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0b0695f2b34a4afa3f6e9aa1ff0e5336d8dad912) |
| 2019/10/22 | | [sched/fair: fix rework of find_idlest_group()](https://lore.kernel.org/patchwork/patch/1143049) | fix 补丁 | | |
| 2019/11/29 | | [sched/cfs: fix spurious active migration](https://lore.kernel.org/patchwork/patch/1160934) | fix 补丁 | | |
-| 2020/11/02 | Vincent Guittot | [sched/fair: ensure tasks spreading in LLC during LB](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=16b0a7a1a0af9db6e008fecd195fe4d6cb366d83) | 之前的重构导致 schbench 延迟增加95%以上, 因此将 load_balance 的行为与唤醒路径保持一致, 尝试为任务选择一个同属于LLC 的空闲 CPU. 从而在空闲 CPU 上更好地分散任务. | v1 ☑✓ 5.10-rc4 | [LORE](https://lore.kernel.org/all/20201102102457.28808-1-vincent.guittot@linaro.org) |
+| 2020/11/02 | Vincent Guittot | [sched/fair: ensure tasks spreading in LLC during LB](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=16b0a7a1a0af9db6e008fecd195fe4d6cb366d83) | 之前的重构导致 schbench 延迟增加 95% 以上, 因此将 load_balance 的行为与唤醒路径保持一致, 尝试为任务选择一个同属于 LLC 的空闲 CPU. 从而在空闲 CPU 上更好地分散任务. | v1 ☑✓ 5.10-rc4 | [LORE](https://lore.kernel.org/all/20201102102457.28808-1-vincent.guittot@linaro.org) |
CPU 负载均衡器在不同的域之间进行平衡, 以分散负载, 并努力在所有域之间保持平衡. 同时期望相互之间有通信的任务可以迁移到接近的拓扑上, 以便于通信的时延最小. 但是这些决策是独立的. 因此在负载较轻的 NUMA 机器上, 两个在唤醒时本来应该拉在一起的通信任务可以被负载平衡器推开.
@@ -1857,9 +1846,9 @@ CPU 负载均衡器在不同的域之间进行平衡, 以分散负载, 并努力
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2020/01/14 | Kefeng Wang | [sched/fair: Allow a small load imbalance between low utilisation SD_NUMA domains](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b396f52326de20ec974471b7b19168867b365cbf) | 此补丁允许 NUMA 域之间存在固定程度的两个任务不平衡, 而不管利用率如何. 在许多情况下, 这可以防止通信任务被分离. 一般来说, 补丁只是仅当目标节点几乎完全空闲时才允许出现不平衡, 倾向于在不平衡很小的基本情况下, 寻求避免不必要的跨节点迁移. 对于低利用率的通信工作负载, 这个补丁通常表现得更好, 更少的 NUMA 平衡活动. 对于高使用率而言, 行为没有变化. 评估了不平衡是否应按域大小进行缩放. | v4 ☑ 5.6-rc2 | [LORE v2](https://lore.kernel.org/lkml/20191220084252.GL3178@techsingularity.net)
*-*-*-*-*-*-*-*
[PatchWork v4](https://lore.kernel.org/all/20200114101319.GO3466@techsingularity.net), [LKML](https://lkml.org/lkml/2020/1/14/376), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b396f52326de20ec974471b7b19168867b365cbf) |
| 2020/02/24 | Mel Gorman | [Reconcile NUMA balancing decisions with the load balancer](https://linuxplumbersconf.org/event/4/contributions/480) | NUMA Balancing 和 Load Blance 经常会做出一些相互冲突的决策(任务放置和页面迁移), 导致不必要的迁移, 这组补丁减少了冲突. 其中 [sched/numa: Use similar logic to the load balancer for moving between domains with spare capacity](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fb86f5b2119245afd339280099b4e9417cc0b03a) 引入了 adjust_numa_imbalance() 单独处理和计算 NUMA 层次的不均衡. | v6 ☑ 5.7-rc1 | [LWN](https://lwn.net/Articles/793427), [PatchWork](https://lore.kernel.org/patchwork/cover/1199507) |
-| 2020/2/21 | Vincent Guittot | [remove runnable_load_avg and improve group_classify](https://lore.kernel.org/patchwork/cover/1198654) | 重构组调度的 PELT 跟踪, 在每次更新平均负载的时候, 更新整个 CFS_RQ 的平均负载| V10 ☑ 5.7 | [PatchWork](https://lore.kernel.org/patchwork/cover/1198654), [lkml](https://lkml.org/lkml/2020/2/21/1386) |
+| 2020/2/21 | Vincent Guittot | [remove runnable_load_avg and improve group_classify](https://lore.kernel.org/patchwork/cover/1198654) | 重构组调度的 PELT 跟踪, 在每次更新平均负载的时候, 更新整个 CFS_RQ 的平均负载 | V10 ☑ 5.7 | [PatchWork](https://lore.kernel.org/patchwork/cover/1198654), [lkml](https://lkml.org/lkml/2020/2/21/1386) |
| 2020/02/03 | Mel Gorman | [Accumulated fixes for Load/NUMA Balancing reconcilation series](https://lore.kernel.org/patchwork/cover/1203922) | 解决一个负载平衡问题 | | [PatchWork](https://lore.kernel.org/patchwork/cover/1203922) |
-| 2020/02/03 | Mel Gorman | [Revisit NUMA imbalance tolerance and fork balancing](https://lore.kernel.org/patchwork/patch/1340184) | 解决一个负载平衡问题
之前解决 NUMA Balancing 和 Load Balancing 被调和时, 尝试允许在一定程度的不平衡, 但是也引入了诸多问题. 因此当时限制不平衡只允许在几乎空闲的 NUMA 域. 现在大多数问题都已经解决掉了, 现在[允许不平衡扩大一定的范围](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc48095651f1b85f751eef610b3e034). 同时该补丁还解决了 fork 时候 balance 的问题. 性能测试发现, 这个补丁可以提升约 1.5% unixbench 的跑分, 参见 [e7f28850ea: unixbench.score 1.5% improvement](https://lore.kernel.org/lkml/20201122150415.GJ2390@xsang-OptiPlex-9020) | RFC ☑ 5.11-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/1340184) |
+| 2020/02/03 | Mel Gorman | [Revisit NUMA imbalance tolerance and fork balancing](https://lore.kernel.org/patchwork/patch/1340184) | 解决一个负载平衡问题
之前解决 NUMA Balancing 和 Load Balancing 被调和时, 尝试允许在一定程度的不平衡, 但是也引入了诸多问题. 因此当时限制不平衡只允许在几乎空闲的 NUMA 域. 现在大多数问题都已经解决掉了, 现在[允许不平衡扩大一定的范围](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc48095651f1b85f751eef610b3e034). 同时该补丁还解决了 fork 时候 balance 的问题. 性能测试发现, 这个补丁可以提升约 1.5% unixbench 的跑分, 参见 [e7f28850ea: unixbench.score 1.5% improvement](https://lore.kernel.org/lkml/20201122150415.GJ2390@xsang-OptiPlex-9020) | RFC ☑ 5.11-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/1340184) |
此外 load_balance 上还有一些接口层次的变化.
@@ -1900,7 +1889,7 @@ Mel Gorman 深耕与解决 load_balance 以及 wake_affine 流程中一些不合
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2022/05/05 | Peter Zijlstra | [sched: simplify the group load balancer](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=55e12e5e7b1d7e7c05a4be10cb5fd092c039aa78) | 引入 update_shares() 更新 sched_domain 下所有 task_group 之间的相对负载. 这是一项非常耗时的操作, 通过 walk_tg_tree() 遍历所有的 task_group, 然后[使用 `tg_shares_up() -=> __update_group_shares_cpu()`](https://elixir.bootlin.com/linux/v2.6.27/source/kernel/sched.c#L1490) 更新其[各个 sched_domain 层级之间](https://elixir.bootlin.com/linux/v2.6.27/source/kernel/sched.c#L1510)的相对负载. 这需要以自下而上的方式进行, 因为父 task_group 的 rq 权重 rq_weight 取决于其子组的份额 tg->shares. | v1 ☑✓ 2.6.27-rc1 | [LORE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=55e12e5e7b1d7e7c05a4be10cb5fd092c039aa78) |
+| 2022/05/05 | Peter Zijlstra | [sched: simplify the group load balancer](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=55e12e5e7b1d7e7c05a4be10cb5fd092c039aa78) | 引入 update_shares() 更新 sched_domain 下所有 task_group 之间的相对负载. 这是一项非常耗时的操作, 通过 walk_tg_tree() 遍历所有的 task_group, 然后 [使用 `tg_shares_up() -=> __update_group_shares_cpu()`](https://elixir.bootlin.com/linux/v2.6.27/source/kernel/sched.c#L1490) 更新其[各个 sched_domain 层级之间](https://elixir.bootlin.com/linux/v2.6.27/source/kernel/sched.c#L1510) 的相对负载. 这需要以自下而上的方式进行, 因为父 task_group 的 rq 权重 rq_weight 取决于其子组的份额 tg->shares. | v1 ☑✓ 2.6.27-rc1 | [LORE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=55e12e5e7b1d7e7c05a4be10cb5fd092c039aa78) |
| 2010/11/15 | Paul Turner | [reduce overhead for tg->shares distribution](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9437178f623a19af5951808d880a8599f66ac150) | 重构了整个 update_shares() -=> update_shares_cpu() 的逻辑, 优化了其整体开销. update_shares_cpu() 的工作被拆分成了两个主要流程, 各层级 task_group [相对权重的更新](https://elixir.bootlin.com/linux/v2.6.38/source/kernel/sched_fair.c#L2126)被 update_cfs_shares() 接管, 而 update_cfs_load() 则完成了[相对负载的更新](https://elixir.bootlin.com/linux/v2.6.38/source/kernel/sched_fair.c#L2120). | v4 ☑✓ 2.6.38-rc1 | [LORE v4,0/11](https://lore.kernel.org/all/20101115234659.610333554@google.com) |
| 2012/8/23 | Paul Turner | [sched: Refactor update_shares_cpu() -> update_blocked_averages()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=48a1675323fa1b7844e479ad2a4469f4558c0f79) | [per-entity load-tracking](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e9c84cb8d5f1b1ea6fcbe6190d51dc84b6975938) 的其中 2 个补丁. [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=82958366cfea1a50e7e90907b2d55ae29ed69974) 将 update_cfs_shares() 从 update_shares_cpu() 中移除, 自此 update_shares() -=> update_shares_cpu() 中要完成的工作已经脱离了之前的语义, 其最主要的工作已经被局限于被阻塞调度实体负载的周期性衰减, 即 Blocked Load 的更新. 因此 [COMMIT2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=48a1675323fa1b7844e479ad2a4469f4558c0f79) 将函数重命名为 `update_blocked_averages() -=> __update_blocked_averages_cpu()`, 并放大了 rq-lock 的持有范围. | v1 ☑✓ 3.8 | [LWN](https://lwn.net/Articles/531853), [LORE v1,00/16](https://lore.kernel.org/lkml/20120823141422.444396696@google.com) |
| 2012/8/23 | Yuyang Du | [Rewrite runnable load and utilization average tracking](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=7ea241afbf4924c58d41078599f7a32ba49fb985) | 重构组调度的 PELT 跟踪, 在每次更新平均负载的时候, 更新整个 CFS_RQ 的平均负载 | v10 ☑ 4.3-rc1 | [LWN](https://lwn.net/Articles/579066), [LORE v10,0/7](https://lore.kernel.org/all/1436918682-4971-1-git-send-email-yuyang.du@intel.com/), [lkml](https://lkml.org/lkml/2015/7/15/159) |
@@ -1911,7 +1900,7 @@ Mel Gorman 深耕与解决 load_balance 以及 wake_affine 流程中一些不合
-------
-update_blocked_averages() 在多个场景都被发现成为非常严重的性能瓶颈, [OOM and High CPU utilization in update_blocked_averages because of too many cfs_rqs in rq->leaf_cfs_rq_list](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1747896). 原因在于 rq->leaf_cfs_rq_list 是当前 CPU 上所有处于活动状态的 cfs_rq 的有序队列, update_blocked_averages 大多数 cgroup 中启用 CPU 控制器的系统中的负载均衡路径中, CPU消耗较少, 调度延迟增加. 特别是在临时创建了多个 cgroup 分组(称为 cgroup 泄漏) 的特殊情况下, 这会导致内核在运行 update_blocked_average() 耗时过程, 每次运行都要花费数毫秒. perf top 查看, update_blocked_averages 函数的热点占比甚至达到 30% 左右.
+update_blocked_averages() 在多个场景都被发现成为非常严重的性能瓶颈, [OOM and High CPU utilization in update_blocked_averages because of too many cfs_rqs in rq->leaf_cfs_rq_list](https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1747896). 原因在于 rq->leaf_cfs_rq_list 是当前 CPU 上所有处于活动状态的 cfs_rq 的有序队列, update_blocked_averages 大多数 cgroup 中启用 CPU 控制器的系统中的负载均衡路径中, CPU 消耗较少, 调度延迟增加. 特别是在临时创建了多个 cgroup 分组(称为 cgroup 泄漏) 的特殊情况下, 这会导致内核在运行 update_blocked_average() 耗时过程, 每次运行都要花费数毫秒. perf top 查看, update_blocked_averages 函数的热点占比甚至达到 30% 左右.
为此主线体现了解决思路, 通过删除空的和完全衰减的 cfs_rq 来减低遍历的层次和开销.
@@ -1983,10 +1972,10 @@ idle balance 中执行 update_blocked_average 是很费时费力的, 可以做
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2021/02/05 | Vincent Guittot | [move update blocked load outside newidle_balance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=39b6a429c30482c349f1bb3746470fe473cbdb0f) | Joel报告了 newidle_balance 中的抢占和irq关闭序列很长, 因为大量的 CPU cgroup 正在使用, 并且需要更新. 这个补丁集优化 NEWLY_IDLE CPU 的 Blocked Load 更新. | v1 ☑✓ 5.13-rc1 | [LORE v1,0/6](https://lore.kernel.org/all/20210205114830.781-1-vincent.guittot@linaro.org)
*-*-*-*-*-*-*-*
[LORE v4,0/7](https://lore.kernel.org/all/20210224133007.28644-1-vincent.guittot@linaro.org) |
+| 2021/02/05 | Vincent Guittot | [move update blocked load outside newidle_balance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=39b6a429c30482c349f1bb3746470fe473cbdb0f) | Joel 报告了 newidle_balance 中的抢占和 irq 关闭序列很长, 因为大量的 CPU cgroup 正在使用, 并且需要更新. 这个补丁集优化 NEWLY_IDLE CPU 的 Blocked Load 更新. | v1 ☑✓ 5.13-rc1 | [LORE v1,0/6](https://lore.kernel.org/all/20210205114830.781-1-vincent.guittot@linaro.org)
*-*-*-*-*-*-*-*
[LORE v4,0/7](https://lore.kernel.org/all/20210224133007.28644-1-vincent.guittot@linaro.org) |
| 2021/02/24 | Aubrey Li | [sched/fair: reduce long-tail newly idle balance cost](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=acb4decc1e900468d51b33c5f1ee445278e716a7) | TODO | v2 ☑✓ 5.13-rc1 | [LORE](https://lore.kernel.org/all/1614154549-116078-1-git-send-email-aubrey.li@intel.com) |
-| 2021/10/19 | Vincent Guittot | [Improve newidle lb cost tracking and early abort](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=8ea9183db4ad8afbcb7089a77c23eaf965b0cacd) | 通过考虑更新阻塞负载 update_blocked_averages() 所花费的时间, 在没有机会运行至少一个负载平衡循环的情况下完全跳过负载平衡循环. 因此在 newidle_balance()中, 当 this_rq 的第一个 sd 满足 `this_rq->avg_idle < sd->max_newidle_lb_cost` 时, 认为执行 update_blocked_averages() 是非常昂贵且没有收益的, 只会增加开销. 因此在 newidle_balance() 中尽早检查条件, 尽可能跳过 update_blocked_averages() 的执行. | v3 ☑ [5.16-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9a7e0a90a454) | [2021/10/4 LKML v1](https://lkml.org/lkml/2021/10/4/1188)
*-*-*-*-*-*-*-*
[2021/10/04 PatchWork](https://lore.kernel.org/lkml/20211004171451.24090-1-vincent.guittot@linaro.org), [LKML](https://lkml.org/lkml/2021/10/4/1188)
*-*-*-*-*-*-*-*
[LKML v3,0/5](https://lkml.org/lkml/2021/10/19/590), [LORE v3,0/5](https://lore.kernel.org/all/20211019123537.17146-1-vincent.guittot@linaro.org), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9d783c8dd112) |
-| 2022/06/08 | Josh Don | [sched: allow newidle balancing to bail out of load_balance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=792b9f65a568f48c50b3175536db9cde5a1edcc0) | 在执行 newidle 负载平衡时, 可能会有新任务到达, 也可能有挂起的唤醒. 如果检测到这些情况, newidle_balance() 已经通过退出 sched_domain load_balance() 解决了这个问题. 这对于最小化唤醒延迟非常重要.
然而, 如果我们已经在 load_balance() 中, 在返回到 newidle_balance() 之前, 我们可能会在那里停留一段时间. 如果我们在 LBF_ALL_PINNED 情况下输入 "goto redo" 循环, 情况会更加恶化. 一个非常直接的解决方法是调整 should_we_balance(), 以便在执行 CPU_NEWLY_IDLE Balance 且检测到新任务时释放. 测试发现, 两个轮流休眠和相互唤醒的线程绑定到两个核上, 其他大量利用率为 100% 的线程被绑定到所有其他核上, 如果没有这个补丁, 这对线程的唤醒延迟约为 120us, 几乎全部花费在 load_balance() 中. 合入这个补丁后, 唤醒延迟降低到 6us. | v1 ☑✓ 6.0-rc1 | [LORE](https://lore.kernel.org/all/20220609025515.2086253-1-joshdon@google.com) |
+| 2021/10/19 | Vincent Guittot | [Improve newidle lb cost tracking and early abort](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=8ea9183db4ad8afbcb7089a77c23eaf965b0cacd) | 通过考虑更新阻塞负载 update_blocked_averages() 所花费的时间, 在没有机会运行至少一个负载平衡循环的情况下完全跳过负载平衡循环. 因此在 newidle_balance()中, 当 this_rq 的第一个 sd 满足 `this_rq->avg_idle max_newidle_lb_cost` 时, 认为执行 update_blocked_averages() 是非常昂贵且没有收益的, 只会增加开销. 因此在 newidle_balance() 中尽早检查条件, 尽可能跳过 update_blocked_averages() 的执行. | v3 ☑ [5.16-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9a7e0a90a454) | [2021/10/4 LKML v1](https://lkml.org/lkml/2021/10/4/1188)
*-*-*-*-*-*-*-*
[2021/10/04 PatchWork](https://lore.kernel.org/lkml/20211004171451.24090-1-vincent.guittot@linaro.org), [LKML](https://lkml.org/lkml/2021/10/4/1188)
*-*-*-*-*-*-*-*
[LKML v3,0/5](https://lkml.org/lkml/2021/10/19/590), [LORE v3,0/5](https://lore.kernel.org/all/20211019123537.17146-1-vincent.guittot@linaro.org), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9d783c8dd112) |
+| 2022/06/08 | Josh Don | [sched: allow newidle balancing to bail out of load_balance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=792b9f65a568f48c50b3175536db9cde5a1edcc0) | 在执行 newidle 负载平衡时, 可能会有新任务到达, 也可能有挂起的唤醒. 如果检测到这些情况, newidle_balance() 已经通过退出 sched_domain load_balance() 解决了这个问题. 这对于最小化唤醒延迟非常重要.
然而, 如果我们已经在 load_balance() 中, 在返回到 newidle_balance() 之前, 我们可能会在那里停留一段时间. 如果我们在 LBF_ALL_PINNED 情况下输入 "goto redo" 循环, 情况会更加恶化. 一个非常直接的解决方法是调整 should_we_balance(), 以便在执行 CPU_NEWLY_IDLE Balance 且检测到新任务时释放. 测试发现, 两个轮流休眠和相互唤醒的线程绑定到两个核上, 其他大量利用率为 100% 的线程被绑定到所有其他核上, 如果没有这个补丁, 这对线程的唤醒延迟约为 120us, 几乎全部花费在 load_balance() 中. 合入这个补丁后, 唤醒延迟降低到 6us. | v1 ☑✓ 6.0-rc1 | [LORE](https://lore.kernel.org/all/20220609025515.2086253-1-joshdon@google.com) |
### 4.4.3 Task Stealing
@@ -2032,7 +2021,7 @@ dynticks 刚引入内核的时候, 空闲负载平衡并不能很好的工作.
1. 对于第一种机制, 时间间隔的设定会很棘手, 如果间隔太大, 那么响应延迟也会很高, 我们将无法对负载的突然变化做出响应. 如果它很小, 那么 dynticks 就没有什么意义了, 并不能有效地节省功耗.
-2. 第二种机制将进一步加重繁忙 CPU 上的负载, 它将执行更多的负载平衡工作, 而该 CPU 上的其他任务正在急切地等待 CPU 周期. 况且负载平衡( busy load balancing)的时间间隔与空闲负载平衡的时间间隔也有很大的不同. 与第一种机制类似, 我们依旧无法对负载变化做出快速反应. 此外, 要弄清楚 CPU 负载过重以及需要将额外负载转移到哪里, 本身是一件非常困难的工作.
+2. 第二种机制将进一步加重繁忙 CPU 上的负载, 它将执行更多的负载平衡工作, 而该 CPU 上的其他任务正在急切地等待 CPU 周期. 况且负载平衡 (busy load balancing) 的时间间隔与空闲负载平衡的时间间隔也有很大的不同. 与第一种机制类似, 我们依旧无法对负载变化做出快速反应. 此外, 要弄清楚 CPU 负载过重以及需要将额外负载转移到哪里, 本身是一件非常困难的工作.
### 4.5.1 dynticks: idle load balancing @2.6.22
@@ -2065,7 +2054,7 @@ dynticks 刚引入内核的时候, 空闲负载平衡并不能很好的工作.
### 4.5.2 Nominate a power-efficient ILB @2.6.31
-------
-trigger_load_balance() 执行空闲负载均衡时, 如果没有设置 ILB owner, 那么将直接使用 first_cpu(nohz.CPU_mask) 来执行空闲负载均衡, 这个策略非常简单. 因为如果不考虑功耗, 那么从所有的 IDLE CPU 中随便选择一个(比如 first_cpu(nohz.CPU_mask))就 OK 了, 然而, 在异构系统中(例如手机环境), 我们要考虑更多. 例如: 如果大核 CPU 和小核 CPU 都处于 IDLE 状态, 那么选择唤醒大核 CPU 还是小核 CPU? 大核 CPU 虽然算力强, 但是功耗高. 如果选择小核, 虽然能省功耗, 但是提供的算力是否足够. 此外, 发起 idle balance 请求的 CPU 在那个 cluster? 是否首选同一个 cluster 的 cpu 来执行 nohz idle balance? 还有 cpu IDLE 的深度如何?
+trigger_load_balance() 执行空闲负载均衡时, 如果没有设置 ILB owner, 那么将直接使用 first_cpu(nohz.CPU_mask) 来执行空闲负载均衡, 这个策略非常简单. 因为如果不考虑功耗, 那么从所有的 IDLE CPU 中随便选择一个 (比如 first_cpu(nohz.CPU_mask)) 就 OK 了, 然而, 在异构系统中(例如手机环境), 我们要考虑更多. 例如: 如果大核 CPU 和小核 CPU 都处于 IDLE 状态, 那么选择唤醒大核 CPU 还是小核 CPU? 大核 CPU 虽然算力强, 但是功耗高. 如果选择小核, 虽然能省功耗, 但是提供的算力是否足够. 此外, 发起 idle balance 请求的 CPU 在那个 cluster? 是否首选同一个 cluster 的 cpu 来执行 nohz idle balance? 还有 cpu IDLE 的深度如何?
而 v2.6 的时代, 其他节能设置, 如 sched_mc_power_savings/sched_smt_power_savings 和感知功耗的 IRQ 负载均衡, 都尝试通过考虑系统拓扑来使系统的任务和 IRQ 更加均衡, 其目的是让尽可能多的 "电源域" 处于低功耗状态. 例如, 我们可以让任务和中断大部分在第一个 socket 上运行, 目的是让第二个 socket 保持空闲, 从而节省更多的功耗.
@@ -2102,7 +2091,7 @@ ILB owner(nohz.load_balancer) 的更新, 还是由 select_nohz_load_balancer(tic
nohz_kick_needed() 实现了一个启发式的空闲负载均衡触发算法, 通过 first_pick_cpu 和 second_pick_cpu 记录了系统中两个比较繁忙的 CPU, trigger_load_balance() -=> nohz_kick_needed() 中只要检查发现这些繁忙 CPU 任务比较繁重, 或者有多于 1 个的繁忙 CPU, 那么 NO_HZ Idle Balancing 都会被触发.
-1. 如果 [first_pick_cpu 一个是繁忙](https://elixir.bootlin.com/linux/v2.6.36/source/kernel/sched_fair.c#L3644)的 CPU, 当它上面有[多个进程处于活动状态(即 rq->nr_running > 1)](https://elixir.bootlin.com/linux/v2.6.36/source/kernel/sched_fair.c#L3646)时, 它将启动空闲的负载均衡器. 因为当系统中只有一个正在运行的进程时, 是没有必要使用空闲负载平衡的.
+1. 如果 [first_pick_cpu 一个是繁忙](https://elixir.bootlin.com/linux/v2.6.36/source/kernel/sched_fair.c#L3644)的 CPU, 当它上面有 [多个进程处于活动状态(即 rq->nr_running > 1)](https://elixir.bootlin.com/linux/v2.6.36/source/kernel/sched_fair.c#L3646) 时, 它将启动空闲的负载均衡器. 因为当系统中只有一个正在运行的进程时, 是没有必要使用空闲负载平衡的.
2. 而如果有多个繁忙的 CPU, 空闲的负载均衡器可能需要运行 active_load_balance 才能运行 (即, 两个繁忙的 CPU 是 SMT 或核心兄弟, 如果它们迁移到不同的物理 CPU 上, 可以运行得更好). 因此, second_pick_cpu 是第二个繁忙的 cpu, [一旦有负载(即 rq->nr_running != 0](https://elixir.bootlin.com/linux/v2.6.36/source/kernel/sched_fair.c#L3651), 它就会启动空闲的负载均衡器.
@@ -2157,12 +2146,12 @@ v3.3 [commit 0b005cf54eac ("sched, nohz: Implement sched group, domain aware noh
2. rq->nohz_flags 替代了 rq->nohz_balance_kick 的形式, 支持更多的状态, NOHZ_TICK_STOPPED, NOHZ_TICK_STOPPED (参见 [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1c792db7f7957e2e34b9a164f08200e36a25dfd0)) 和 NOHZ_IDLE(参见 [COMMIT2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=69e1e811dcc436a6b129dbef273ad9ec22d095ce)).
-3. 通过使用调度域拓扑和结构 [sched_group_power 中的 "nr_busy_cpu"](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=786d6dc7aeb2bfbfe417507b7beb83919f319db3), 使 NO_HZ Idle Balancing 更具可伸缩性.
+3. 通过使用调度域拓扑和结构 [sched_group_power 中的"nr_busy_cpu"](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=786d6dc7aeb2bfbfe417507b7beb83919f319db3), 使 NO_HZ Idle Balancing 更具可伸缩性.
| rq->nohz_flags | 描述 |
|:--------------:|:---:|
-| NOHZ_TICK_STOPPED | 跟踪 CPU 的 TICK 停止状态, 重点用于更新空闲负载平衡器的全局 struct nohz 数据结构, 每次 CPU 进入和推出 NO_HZ 时, 更新 struct nohz 全局数据结构时进行置位和清除. 辅助维护的 nohz.nr_cpus 和 nohz.idle_cpus_mask 分别记录了处理 NO_HZ 状态的 CPU 数目和 CPUMASK.
1. SET: 在 CPU 的 TICK 被停掉后更新 struct nohz 时, select_nohz_load_balancer() 中将该 CPU [对应的 NOHZ_TICK_STOPPED 被设置](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L4930).
2. CLEAR: 在 CPU 从 NO_HZ 退出(TICK 被重启)后, 第一次 TICK 到来时, nohz_kick_needed() 中 [NOHZ_TICK_STOPPED 标志将被重置](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L5102).
这将最小化当前每一次无 TICK 退出时发生的 NO_HZ 空闲负载均衡器状态更新, 使其在有许多逻辑 CPU 频繁进入和退出 NO_HZ 时, 对全局 struct nohz 数据结构的冲突和争用最小, 提高可伸缩性. |
-| NOHZ_BALANCE_KICK | 将跟踪此 rq 上对 nohz 空闲负载平衡的需求. 替代 rq->nohz_balance_kick 的形式, 后者不是以原子方式更新的. 每次 ILB owner 被 kicked 时置位, 完成 ILB 后清除.
1. SET: 每次 busy CPU KICK idle CPU 时, [nohz_balancer_kick() 中](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L4859) 将 ILB owner 的 NOHZ_BALANCE_KICK 置位
2. CLEAR: nohz_idle_balance() 中完成 NO_HZ Idle Balancing 后, 再将[该位清除](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L5077). |
+| NOHZ_TICK_STOPPED | 跟踪 CPU 的 TICK 停止状态, 重点用于更新空闲负载平衡器的全局 struct nohz 数据结构, 每次 CPU 进入和推出 NO_HZ 时, 更新 struct nohz 全局数据结构时进行置位和清除. 辅助维护的 nohz.nr_cpus 和 nohz.idle_cpus_mask 分别记录了处理 NO_HZ 状态的 CPU 数目和 CPUMASK.
1. SET: 在 CPU 的 TICK 被停掉后更新 struct nohz 时, select_nohz_load_balancer() 中将该 CPU [对应的 NOHZ_TICK_STOPPED 被设置](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L4930).
2. CLEAR: 在 CPU 从 NO_HZ 退出 (TICK 被重启) 后, 第一次 TICK 到来时, nohz_kick_needed() 中 [NOHZ_TICK_STOPPED 标志将被重置](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L5102).
这将最小化当前每一次无 TICK 退出时发生的 NO_HZ 空闲负载均衡器状态更新, 使其在有许多逻辑 CPU 频繁进入和退出 NO_HZ 时, 对全局 struct nohz 数据结构的冲突和争用最小, 提高可伸缩性. |
+| NOHZ_BALANCE_KICK | 将跟踪此 rq 上对 nohz 空闲负载平衡的需求. 替代 rq->nohz_balance_kick 的形式, 后者不是以原子方式更新的. 每次 ILB owner 被 kicked 时置位, 完成 ILB 后清除.
1. SET: 每次 busy CPU KICK idle CPU 时, [nohz_balancer_kick() 中](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L4859) 将 ILB owner 的 NOHZ_BALANCE_KICK 置位
2. CLEAR: nohz_idle_balance() 中完成 NO_HZ Idle Balancing 后, 再将[该位清除](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L5077). |
| NOHZ_IDLE | 跟踪 CPU 的繁忙状态, CPU 开始进入 NO_HZ 时置位, 退出 NO_HZ 第一次 TICK 到来时清除. 辅助维护的 `sd->groups->sgp->nr_busy_cpus` 跟踪了调度域上 busy CPUs 的数量.
1. SET: 每次 CPU 进入 NO_HZ 状态时, tick_nohz_idle_enter() -=> set_cpu_sd_state_idle() 中会设置 NOHZ_IDLE 位.
2. CLEAR: 每次 CPU 退出 NO_HZ 状态第一次 TICK 到来时, nohz_kick_needed() -=> set_cpu_sd_state_busy() 中[清除 NOHZ_IDLE 标记](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L5101). |
至此已经没有 load_balancer selector 了, 所有的 ILB owner 的设置, 都被 find_new_il() 接管, 因此 select_nohz_load_balancer() 和 clear_nohz_tick_stopped() 函数名字已经非常不合适, 对它们重命名. select_nohz_load_balancer() -=> nohz_balance_enter_idle(), clear_nohz_tick_stopped() -=> nohz_balance_exit_idle(). 随后 v4.17 彻底[移除了 NOHZ_TICK_STOPPED 标记](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=00357f5ec5d67a52a175da6f29f85c2c19d59bc8), 退回到用 rq->nohz_tick_stopped 来标记的实现.
@@ -2170,7 +2159,7 @@ v3.3 [commit 0b005cf54eac ("sched, nohz: Implement sched group, domain aware noh
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2011/11/18 | Suresh Siddha | [nohz idle load balancing patches](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=786d6dc7aeb2bfbfe417507b7beb83919f319db3) | NA | v1 ☑✓ 3.3-rc1 | [LORE](https://lore.kernel.org/all/1320191558.28097.44.camel@sbsiddha-desk.sc.intel.com)
*-*-*-*-*-*-*-*
[LORE v1,0/6](https://lore.kernel.org/all/20111118230323.592022417@sbsiddha-desk.sc.intel.com)
*-*-*-*-*-*-*-*
[LORE v3,0/6](https://lore.kernel.org/all/20111202010731.344451602@sbsiddha-desk.sc.intel.com) |
-| 2012/09/10 | Alex Shi | [nohz: clean up select_nohz_load_balancer()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c1cc017c59c44d9ede7003631c43adc0cfdce2f9) | 现在已经没有 load_balancer selector. 因此重新命名函数.nohz_balance_exit_idle | v1 ☑✓ 3.7-rc1 | [LORE v1,0/2](https://lore.kernel.org/all/1347261059-24747-1-git-send-email-alex.shi@intel.com) |
+| 2012/09/10 | Alex Shi | [nohz: clean up select_nohz_load_balancer()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c1cc017c59c44d9ede7003631c43adc0cfdce2f9) | 现在已经没有 load_balancer selector. 因此重新命名函数. nohz_balance_exit_idle | v1 ☑✓ 3.7-rc1 | [LORE v1,0/2](https://lore.kernel.org/all/1347261059-24747-1-git-send-email-alex.shi@intel.com) |
此后经历了诸多 bugfix 修复.
@@ -2199,7 +2188,7 @@ v3.3 [commit 0b005cf54eac ("sched, nohz: Implement sched group, domain aware noh
将 rq->nohz_flags 从 unsigned long 的 转变成了 atomic_t, 原来 set_bit/clear_bit 的方式[变成了 atomic 操作](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a22e47a4e3f5a9e50a827c5d94705ace3b1eac0b), [引入了 NOHZ_STATS_KICK](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b7031a02ec753bf9b52a94a966b05e1abad3b7a9), [移除了 NOHZ_TICK_STOPPED](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=00357f5ec5d67a52a175da6f29f85c2c19d59bc8).
-[commit 4550487a993d ("sched/fair: Restructure nohz_balance_kick()")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4550487a993d579c7329bb5b19e516d36800c8bf) 重构了 nohz_balance_kick() 的逻辑, 移除了 nohz_kick_needed(), 将整个 nohz_kick_needed() 的逻辑内联到了 nohz_balancer_kick() 中, 并引入 [kick_ilb() 封装了其原始的 KICK 操作](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9301), 供[新的 nohz_balancer_kick() 函数](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9413)以及 [nohz_newidle_balance()](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9688) 调用. 参见 [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4550487a993d579c7329bb5b19e516d36800c8bf)
+[commit 4550487a993d ("sched/fair: Restructure nohz_balance_kick()")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4550487a993d579c7329bb5b19e516d36800c8bf) 重构了 nohz_balance_kick() 的逻辑, 移除了 nohz_kick_needed(), 将整个 nohz_kick_needed() 的逻辑内联到了 nohz_balancer_kick() 中, 并引入 [kick_ilb() 封装了其原始的 KICK 操作](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9301), 供 [新的 nohz_balancer_kick() 函数](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9413) 以及 [nohz_newidle_balance()](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9688) 调用. 参见 [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4550487a993d579c7329bb5b19e516d36800c8bf)
将 NOHZ idle balancer 拆分成两个两个单独的操作:
@@ -2215,7 +2204,7 @@ v3.3 [commit 0b005cf54eac ("sched, nohz: Implement sched group, domain aware noh
| NOHZ_TICK_STOPPED | v4.17 彻底[移除了 NOHZ_TICK_STOPPED 标记](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=00357f5ec5d67a52a175da6f29f85c2c19d59bc8), 退回到用 rq->nohz_tick_stopped 来标记的实现. NO_HZ 的进入和退出总是来自当前的 CPU, 实在没必要用原子变量来实现. |
| NOHZ_IDLE | 被移除 |
| NOHZ_STATS_KICK | 跟踪 NO_HZ Idle Balancing 过程中的 Blocked Load 更新过程. |
-| NOHZ_BALANCE_KICK | 将跟踪此 rq 上对 nohz 空闲负载平衡的需求. 替代 rq->nohz_balance_kick 的形式, 后者不是以原子方式更新的. 每次 ILB owner 被 kicked 时置位, 完成 ILB 后清除.
1. SET: 每次 busy CPU KICK IDLE CPU 时, [nohz_balancer_kick() 中](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L4859) 将 ILB owner 的 NOHZ_BALANCE_KICK 置位
2. CLEAR: nohz_idle_balance() 中完成 NO_HZ Idle Balancing 后, 再将[该位清除](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L5077). |
+| NOHZ_BALANCE_KICK | 将跟踪此 rq 上对 nohz 空闲负载平衡的需求. 替代 rq->nohz_balance_kick 的形式, 后者不是以原子方式更新的. 每次 ILB owner 被 kicked 时置位, 完成 ILB 后清除.
1. SET: 每次 busy CPU KICK IDLE CPU 时, [nohz_balancer_kick() 中](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L4859) 将 ILB owner 的 NOHZ_BALANCE_KICK 置位
2. CLEAR: nohz_idle_balance() 中完成 NO_HZ Idle Balancing 后, 再将[该位清除](https://elixir.bootlin.com/linux/v3.3/source/kernel/sched/fair.c#L5077). |
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
@@ -2243,53 +2232,44 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
if (env->idle == CPU_NEWLY_IDLE && READ_ONCE(nohz.has_blocked))
env->flags |= LBF_NOHZ_STATS;
#endif
- do {
- update_sg_lb_stats(env, sg, load_idx, local_group, sgs, &overload);
+ do {update_sg_lb_stats(env, sg, load_idx, local_group, sgs, &overload);
sg = sg->next;
} while (sg != env->sd->groups);
}
static inline void update_sg_lb_stats(struct lb_env *env, struct sched_group *group, int load_idx, int local_group, struct sg_lb_stats *sgs, bool *overload)
-{
- for_each_cpu_and(i, sched_group_span(group), env->cpus) {
- if ((env->flags & LBF_NOHZ_STATS) && update_nohz_stats(rq, false))
+{for_each_cpu_and(i, sched_group_span(group), env->cpus) {if ((env->flags & LBF_NOHZ_STATS) && update_nohz_stats(rq, false))
env->flags |= LBF_NOHZ_AGAIN;
}
}
```
-2. 但是 NEWLY_IDLE Load Balancing 并不总是会发生, 比如检测[发现 CPU 的平均休眠时间 avg_idle 远小于迁移成本](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9735), 那么这时候 idle balance 是没有意义的, 因此你还没有把进程 PULL 过来, 这个 CPU 就从 IDLE 被唤醒了, 这种情况下 [NEWLY_IDLE load balance 不会触发](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9744)的时候, 但是我们却可以更新 Blocked Load, 此时使用 `nohz_newidle_balance(this_rq) -=> _nohz_idle_balance() -=> update_nohz_stats() -=> update_blocked_averages()` 来[更新其他所有 IDLE CPUs 的 Blocked Load](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9682). 此时 NEWLY_IDLE 的 CPU 即将休眠, 没有 Blocked Load 需要被更新. 而如果 NEWLY_IDLE CPU 更新 Blocked Load 也失败了, 那我们不得不 KICK 一个 IDLE CPU 通过 [kick_ilb(NOHZ_STATS_KICK)](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9688) 来执行这项工作.
+2. 但是 NEWLY_IDLE Load Balancing 并不总是会发生, 比如检测 [发现 CPU 的平均休眠时间 avg_idle 远小于迁移成本](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9735), 那么这时候 idle balance 是没有意义的, 因此你还没有把进程 PULL 过来, 这个 CPU 就从 IDLE 被唤醒了, 这种情况下 [NEWLY_IDLE load balance 不会触发](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9744) 的时候, 但是我们却可以更新 Blocked Load, 此时使用 `nohz_newidle_balance(this_rq) -=> _nohz_idle_balance() -=> update_nohz_stats() -=> update_blocked_averages()` 来[更新其他所有 IDLE CPUs 的 Blocked Load](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9682). 此时 NEWLY_IDLE 的 CPU 即将休眠, 没有 Blocked Load 需要被更新. 而如果 NEWLY_IDLE CPU 更新 Blocked Load 也失败了, 那我们不得不 KICK 一个 IDLE CPU 通过 [kick_ilb(NOHZ_STATS_KICK)](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9688) 来执行这项工作.
```cpp
static int idle_balance(struct rq *this_rq, struct rq_flags *rf)
-{
- if (this_rq->avg_idle < sysctl_sched_migration_cost || // CPU 的平均休眠时间 avg_idle 远小于迁移成本, 不进行 NEWLY_IDLE Load Balancing
+{if (this_rq->avg_idle < sysctl_sched_migration_cost || // CPU 的平均休眠时间 avg_idle 远小于迁移成本, 不进行 NEWLY_IDLE Load Balancing
!this_rq->rd->overload) { // 这个 CPU 所在的调度域没有过载, 也没有必要做 NEWLY_IDLE Load Balancing
nohz_newidle_balance(this_rq);
goto out;
}
update_blocked_averages(this_cpu);
- for_each_domain(this_cpu, sd) {
- pulled_task = load_balance(this_cpu, this_rq, sd, CPU_NEWLY_IDLE, &continue_balancing);
+ for_each_domain(this_cpu, sd) {pulled_task = load_balance(this_cpu, this_rq, sd, CPU_NEWLY_IDLE, &continue_balancing);
}
}
static void nohz_newidle_balance(struct rq *this_rq)
-{
- if (!_nohz_idle_balance(this_rq, NOHZ_STATS_KICK, CPU_NEWLY_IDLE))
+{if (!_nohz_idle_balance(this_rq, NOHZ_STATS_KICK, CPU_NEWLY_IDLE))
kick_ilb(NOHZ_STATS_KICK);
}
static bool _nohz_idle_balance(struct rq *this_rq, unsigned int flags, enum cpu_idle_type idle)
-{
- for_each_cpu(balance_cpu, nohz.idle_cpus_mask) {
- if (balance_cpu == this_cpu || !idle_cpu(balance_cpu)) // 跳过当前 ILB owner CPU
+{for_each_cpu(balance_cpu, nohz.idle_cpus_mask) {if (balance_cpu == this_cpu || !idle_cpu(balance_cpu)) // 跳过当前 ILB owner CPU
continue;
has_blocked_load |= update_nohz_stats(rq, true); // 更新 balance_cpu 的 Blocked Load
- if (time_after_eq(jiffies, rq->next_balance)) {
- if (flags & NOHZ_BALANCE_KICK)
+ if (time_after_eq(jiffies, rq->next_balance)) {if (flags & NOHZ_BALANCE_KICK)
rebalance_domains(rq, CPU_IDLE); // 触发 Load Balancing
}
}
@@ -2318,8 +2298,7 @@ static void kick_ilb(unsigned int flags)
```cpp
static __latent_entropy void run_rebalance_domains(struct softirq_action *h)
-{
- struct rq *this_rq = this_rq();
+{struct rq *this_rq = this_rq();
enum cpu_idle_type idle = this_rq->idle_balance ? CPU_IDLE : CPU_NOT_IDLE;
/*
* If this CPU has a pending nohz_balance_kick, then do the
@@ -2359,7 +2338,7 @@ Blocked Load 的更新本身可能成为一项非常繁重的工作. 2021 年左
2. newidle_balance() 中没有触发 NEWLY_IDLE Balancing 的情况下, 参见 [commit c6f886546cb8 ("sched/fair: Trigger the update of blocked load on newly idle cpu")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c6f886546cb8a38617cdbe755fe50d3acd2463e4).
-* newidle_balance() 依旧会尝试[使用 nohz_newidle_balance(this_rq) (来通知需要)更新 Blocked Load](https://elixir.bootlin.com/linux/v5.13/source/kernel/sched/fair.c#L10730). 只是整个[过程不再持有 this_rq->lock](https://elixir.bootlin.com/linux/v5.13/source/kernel/sched/fair.c#L10667).
+* newidle_balance() 依旧会尝试 [使用 nohz_newidle_balance(this_rq) (来通知需要) 更新 Blocked Load](https://elixir.bootlin.com/linux/v5.13/source/kernel/sched/fair.c#L10730). 只是整个[过程不再持有 this_rq->lock](https://elixir.bootlin.com/linux/v5.13/source/kernel/sched/fair.c#L10667).
* nohz_newidle_balance(this_rq) 的更新的方式上也做了优化, 引入了 NOHZ_NEWILB_KICK, 在 NEWLY_IDLE CPU 即将休眠前来更新 Blocked Load. 之前通过 NEWLY_IDLE CPU 使用 `nohz_newidle_balance()` [更新其他所有 IDLE CPUs 的 Blocked Load](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9682). 首先先通过 `_nohz_idle_balance()` 尝试通过当前这个 NEWLY_IDLE 的 CPU 来直接更新 Blocked Load, 如果更新失败了, 才 KICK 一个 IDLE CPU 通过 [kick_ilb(NOHZ_STATS_KICK)](https://elixir.bootlin.com/linux/v4.17/source/kernel/sched/fair.c#L9688) 来执行这项工作. 但是优化后, nohz_newidle_balance() 只作为一个通知机制, 不再直接更新 Blocked Load, 它只是[将 NOHZ_NEWILB_KICK 标记设置到当前 NEWLY_IDLE CPU 的 this_rq->nohz_flags](https://elixir.bootlin.com/linux/v5.13/source/kernel/sched/fair.c#L10603) 中, 在[当前 NEWLY_IDLE CPU 真正将陷入 IDLE(C-State) 的时候](https://elixir.bootlin.com/linux/v5.13/source/kernel/sched/idle.c#L268), 才使用 `do_idle() -=> nohz_run_idle_balance() -=> _nohz_idle_balance()` 去更新 Blocked Load, nohz_run_idle_balance() 中会[检查设置了 NOHZ_NEWILB_KICK 标记](https://elixir.bootlin.com/linux/v5.13/source/kernel/sched/fair.c#L10575), 才会调用 `_nohz_idle_balance()` 进行 Blocked Load 的更新.
@@ -2367,8 +2346,7 @@ Blocked Load 的更新本身可能成为一项非常繁重的工作. 2021 年左
```cpp
static int newidle_balance(struct rq *this_rq, struct rq_flags *rf)
-{
- if (pulled_task)
+{if (pulled_task)
this_rq->idle_stamp = 0;
else
nohz_newidle_balance(this_rq);
@@ -2408,7 +2386,7 @@ void nohz_run_idle_balance(int cpu)
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2021/01/22 | Joel Fernandes (Google)" | [sched/fair: Rate limit calls to update_blocked_averages() for NOHZ](https://lore.kernel.org/lkml/20210122154600.1722680-1-joel@joelfernandes.org) | 在运行ChromeOS Linux kernel v5.4 的 octacore ARM64 设备上, 发现有很多对 update_blocked_averages() 的调用, 导致调度的开销增大, 造成 newilde_balance() 有时需要最多 500 微秒. 我在周期平衡器中也看到了这一点. 将 update_blocked_averages() 调用速率限制为每秒 20 次 | v1 ☐ | [PatchWork](https://lore.kernel.org/lkml/20210122154600.1722680-1-joel@joelfernandes.org) |
+| 2021/01/22 | Joel Fernandes (Google)" | [sched/fair: Rate limit calls to update_blocked_averages() for NOHZ](https://lore.kernel.org/lkml/20210122154600.1722680-1-joel@joelfernandes.org) | 在运行 ChromeOS Linux kernel v5.4 的 octacore ARM64 设备上, 发现有很多对 update_blocked_averages() 的调用, 导致调度的开销增大, 造成 newilde_balance() 有时需要最多 500 微秒. 我在周期平衡器中也看到了这一点. 将 update_blocked_averages() 调用速率限制为每秒 20 次 | v1 ☐ | [PatchWork](https://lore.kernel.org/lkml/20210122154600.1722680-1-joel@joelfernandes.org) |
| 2021/02/05 | Vincent Guittot | [move update blocked load outside newidle_balance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=39b6a429c30482c349f1bb3746470fe473cbdb0f) | 优化 NEWLY_IDLE CPU 的 Blocked Load 更新. | v1 ☑✓ 5.13-rc1 | [LORE v1,0/6](https://lore.kernel.org/all/20210205114830.781-1-vincent.guittot@linaro.org)
*-*-*-*-*-*-*-*
[LORE v4,0/7](https://lore.kernel.org/all/20210224133007.28644-1-vincent.guittot@linaro.org) |
| 2021/11/12 | Vincent Guittot | [avoid spurious blocked load update](https://lore.kernel.org/all/20211112095857.7016-1-vincent.guittot@linaro.org) | 20211112095857.7016-1-vincent.guittot@linaro.org | v1 ☐☑✓ | [LORE v1,0/2](https://lore.kernel.org/all/20211112095857.7016-1-vincent.guittot@linaro.org) |
@@ -2427,7 +2405,7 @@ void nohz_run_idle_balance(int cpu)
* 使用 rq->next_balance 作为执行 ILB 的必要条件
-之前 NO_HZ Idle Balancing 所有 空闲 CPU 都进行了负载平衡, 而不考虑负载均衡的间隔 interval, 这引入了比必要时高得多的负载平衡开销. v3.16 [commit ed61bbc69c77 ("sched/balancing: Reduce the rate of needless idle load balancing")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ed61bbc69c773465782476c7e5869fa5607fa73a) 只会[在需要进行负载平衡(即 time_after_eq(jiffies, rq->next_balance))时](https://elixir.bootlin.com/linux/v3.16/source/kernel/sched/fair.c#L7204), ILB owner 才会代表空闲 CPU 进行空闲负载平衡. 至此除了 nohz.next_balance 作为触发 KICK 和 ILB 的检查条件外, ILB owner CPU 的 rq->next_balance 也作为执行 ILB 的必要条件.
+之前 NO_HZ Idle Balancing 所有 空闲 CPU 都进行了负载平衡, 而不考虑负载均衡的间隔 interval, 这引入了比必要时高得多的负载平衡开销. v3.16 [commit ed61bbc69c77 ("sched/balancing: Reduce the rate of needless idle load balancing")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ed61bbc69c773465782476c7e5869fa5607fa73a) 只会 [在需要进行负载平衡(即 time_after_eq(jiffies, rq->next_balance)) 时](https://elixir.bootlin.com/linux/v3.16/source/kernel/sched/fair.c#L7204), ILB owner 才会代表空闲 CPU 进行空闲负载平衡. 至此除了 nohz.next_balance 作为触发 KICK 和 ILB 的检查条件外, ILB owner CPU 的 rq->next_balance 也作为执行 ILB 的必要条件.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
@@ -2482,7 +2460,7 @@ void nohz_run_idle_balance(int cpu)
### 4.6.1 PROT_NONE Fault Driven 的 Automatic NUMA balancing
-------
-**3.8(2013年2月发布)**
+**3.8(2013 年 2 月发布)**
NUMA 机器一个重要特性就是不同 node 之间的内存访问速度有差异, 访问本地 node 很快, 访问别的 node 则很慢.所以进程分配内存时, 总是优先分配所在 node 上的内存.然而, 前面说过, 调度器的负载均衡是可能把一个进程从一个 node 迁移到另一个 node 上的, 这样就造成了跨 node 的内存访问; Linux 支持 CPU 热插拔, 当一个 CPU 下线时, 它上面的进程会被迁移到别的 CPU 上, 也可能出现这种情况.
@@ -2496,7 +2474,7 @@ NUMA 机器一个重要特性就是不同 node 之间的内存访问速度有差
Peter 将 sched/numa 的整体思路上也做了不断的调整和改动, 也开始使用 [PROT_NONE fault 驱动的内存迁移策略](https://lore.kernel.org/lkml/20120731191204.540691987@chello.nl), 甚至还提出了 [Announcement: Enhanced NUMA scheduling with adaptive affinity](https://lore.kernel.org/lkml/20121112160451.189715188@chello.nl).介绍 3.8 前两套竞争方案的文章: [A potential NUMA scheduling solution](https://lwn.net/Articles/522093). 但是总体上仍然有很多未能达成一致的问题.
-在 v3.8 快要发布的时候, 意见还没有统一, 于是内存领域的知名黑客 Mel Gorman 基于此情况, 引入一个叫自动 NUMA 均衡(Automatic NUMA Balancing)的框架, 以期将现存的两套解决方案可以在此框架上进行整合; 同时, 他在此框架上实现了简单的策略: 每当发现有跨 node 访问内存的情况时, 就马上把该内存页面迁移到当前 node 上.参见 [NUMA in a hurry [LWN.net]](https://lwn.net/Articles/524977). 第一版本的 RFC 见 [Foundation for automatic NUMA balancing [LORE]](https://lore.kernel.org/lkml/1352193295-26815-1-git-send-email-mgorman@suse.de). [RFC: Unified NUMA balancing tree, v1](https://lkml.org/lkml/2012/12/2/87)
+在 v3.8 快要发布的时候, 意见还没有统一, 于是内存领域的知名黑客 Mel Gorman 基于此情况, 引入一个叫自动 NUMA 均衡 (Automatic NUMA Balancing) 的框架, 以期将现存的两套解决方案可以在此框架上进行整合; 同时, 他在此框架上实现了简单的策略: 每当发现有跨 node 访问内存的情况时, 就马上把该内存页面迁移到当前 node 上.参见 [NUMA in a hurry [LWN.net]](https://lwn.net/Articles/524977). 第一版本的 RFC 见 [Foundation for automatic NUMA balancing [LORE]](https://lore.kernel.org/lkml/1352193295-26815-1-git-send-email-mgorman@suse.de). [RFC: Unified NUMA balancing tree, v1](https://lkml.org/lkml/2012/12/2/87)
不过到 v4.2, 似乎也没发现之前的两套方案有任意一个迁移到这个框架上, 倒是, 在前述的简单策略上进行更多改进.
@@ -2527,7 +2505,7 @@ Peter 将 sched/numa 的整体思路上也做了不断的调整和改动, 也开
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2021/10/27 | Gang Li | [sched/numa: add per-process numa_balancing](https://lkml.org/lkml/2021/10/27/517) | 这个补丁在 prctl 中添加了一个新的 api PR_NUMA_BALANCING 来控制当个进程参与和禁止 numa_balancing. 在执行 numa_balancing 时, 大量的页面错误会导致性能损失. 因此, 那些关心最坏情况下性能的进程需要禁用 numa_balancing. 相反, 另一些则允许暂时的性能损失以换取更高的平均性能, 因此启用 numa 平衡对它们来说更好. 但是当前 numa balancing 只能由 `/proc/sys/kernel/numa_balancing` 全局控制. 因此这个特性希望禁用/启用每个进程的 numa_balancing. 在 mm_struct 下添加 numa_balancing. 然后在 task_tick_numa 中使用来控制. mm ->numa_balancing 仅在全局 numa_balancing 启用时有效. 当全局 numa_balancing 被禁用时, mm->numa_blancing 不会改变, 当你想要获得进程 numa_balancing 状态时, 你总是会得到 0, 并且当你使用 prctl set 它时, 内核将返回 err. | v1 ☐ | [LKML](https://lkml.org/lkml/2021/10/27/517)
*-*-*-*-*-*-*-*
[LORE v1,0/1](https://lore.kernel.org/r/20220224075227.27127-1-ligang.bdlg@bytedance.com)
*-*-*-*-*-*-*-*
[2022/09/29 LORE v4](https://lore.kernel.org/all/20220929064359.46932-1-ligang.bdlg@bytedance.com)
*-*-*-*-*-*-*-*
[2022/10/27 LORE v5,0/2](https://lore.kernel.org/all/20221027025302.45766-1-ligang.bdlg@bytedance.com) |
+| 2021/10/27 | Gang Li | [sched/numa: add per-process numa_balancing](https://lkml.org/lkml/2021/10/27/517) | 这个补丁在 prctl 中添加了一个新的 api PR_NUMA_BALANCING 来控制当个进程参与和禁止 numa_balancing. 在执行 numa_balancing 时, 大量的页面错误会导致性能损失. 因此, 那些关心最坏情况下性能的进程需要禁用 numa_balancing. 相反, 另一些则允许暂时的性能损失以换取更高的平均性能, 因此启用 numa 平衡对它们来说更好. 但是当前 numa balancing 只能由 `/proc/sys/kernel/numa_balancing` 全局控制. 因此这个特性希望禁用 / 启用每个进程的 numa_balancing. 在 mm_struct 下添加 numa_balancing. 然后在 task_tick_numa 中使用来控制. mm ->numa_balancing 仅在全局 numa_balancing 启用时有效. 当全局 numa_balancing 被禁用时, mm->numa_blancing 不会改变, 当你想要获得进程 numa_balancing 状态时, 你总是会得到 0, 并且当你使用 prctl set 它时, 内核将返回 err. | v1 ☐ | [LKML](https://lkml.org/lkml/2021/10/27/517)
*-*-*-*-*-*-*-*
[LORE v1,0/1](https://lore.kernel.org/r/20220224075227.27127-1-ligang.bdlg@bytedance.com)
*-*-*-*-*-*-*-*
[2022/09/29 LORE v4](https://lore.kernel.org/all/20220929064359.46932-1-ligang.bdlg@bytedance.com)
*-*-*-*-*-*-*-*
[2022/10/27 LORE v5,0/2](https://lore.kernel.org/all/20221027025302.45766-1-ligang.bdlg@bytedance.com) |
| 2014/05/14 | Rik van Riel | [sched/numa: Allow task switch if load imbalance improves](https://linuxplumbersconf.org/event/4/contributions/480) | 目前 NUMA 平衡代码只允许在 NUMA 节点上的负载处于平衡状态时在 NUMA 节点之间移动任务. 当负载开始不平衡时, 它就崩溃了. 因此这个补丁引入 load_too_imbalanced() 来判定, 如果不平衡较小, 或者新的不平衡小于原来的不平衡, 则允许在 NUMA 节点之间移动任务. | v1 ☑ 3.16-rc1 | [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e63da03639cc9e6e83b62e7ef8ffdbb92421416a) |
| 2018/09/21 | Srikar Dronamraju | [sched/numa: Avoid task migration for small NUMA improvement](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6fd98e775f24fd41520928d345f5db3ff52bb35d) | 如果 NUMAC 层次的任务迁移带来的改进非常小(小于 SMALLIMP), 那么应该尽量避免任务迁移. 否则可能会带来 pingpong(进程来回迁移颠簸), 甚至 cache-miss 引起的性能下降. | v1 ☑ 4.19-rc7 | [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6fd98e775f24fd41520928d345f5db3ff52bb35d) |
@@ -2539,7 +2517,7 @@ Peter 将 sched/numa 的整体思路上也做了不断的调整和改动, 也开
commit [6e5fb223e89d ("mm: sched: numa: Implement constant, per task Working Set Sampling (WSS) rate")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6e5fb223e89dbe5cb5c563f8d4a4a0a7d62455a8) 实现了一种自适应的 per task Working Set Sampling (WSS) 控制扫描的频率和范围, 从而尽可能地减少开销.
-参见 [update_task_scan_period()](https://elixir.bootlin.com/linux/v5.16/source/kernel/sched/fair.c#L2119), 它以不同的速率对工作集进行采样, 使某些任务的采样质量优于其他任务. 但是这种方式也为工作集非常大的任务带来性能问题, 具有较大地址空间但很少执行的过采样进程通过在标记扫描当前位置的地址空间中保持旋转偏移来改进该方法, 并以恒定速率(以 CPU 周期执行成比例的方式)推进它. 如果偏移量到达 mm 的最后一个映射地址, 那么它将从第一个地址重新开始.
+参见 [update_task_scan_period()](https://elixir.bootlin.com/linux/v5.16/source/kernel/sched/fair.c#L2119), 它以不同的速率对工作集进行采样, 使某些任务的采样质量优于其他任务. 但是这种方式也为工作集非常大的任务带来性能问题, 具有较大地址空间但很少执行的过采样进程通过在标记扫描当前位置的地址空间中保持旋转偏移来改进该方法, 并以恒定速率 (以 CPU 周期执行成比例的方式) 推进它. 如果偏移量到达 mm 的最后一个映射地址, 那么它将从第一个地址重新开始.
| 参数 | 描述 |
@@ -2554,9 +2532,9 @@ commit [6e5fb223e89d ("mm: sched: numa: Implement constant, per task Working Set
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2015/03/25 | Mel Gorman | [mm: numa: slow PTE scan rate if migration failures occur](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=074c238177a75f5e79af3b2cb6a84e54823ef950) | 通常情况下, 扫描速率会根据故障的位置按任务进行调整. 但是, 如果由于任何原因迁移失败, 那么如果故障仍然是远程的, PTE 扫描可能会扫描得更快. 这意味着在我们知道迁移不可能发生的时候, 系统 CPU 开销和 FAULT 的速率获会更高. 因此跟踪迁移失败的时间, 减慢 PTE 扫描的速度. | v1 ☑ 4.0-rc6 | [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=074c238177a75f5e79af3b2cb6a84e54823ef950) |
-| 2015/11/23 | Rik van Riel | [sched,numa: cap pte scanning overhead to 3% of run time](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=51170840fe91dfca10fd533b303ea39b2524782a) | task 级别基于运行时的 NUMA 扫描与 mm 级别的 NUMA 扫描之间存在根本性的不匹配. 在一个严重过载、进程非常大的系统上, 这种不匹配可能会导致系统将所有时间都花在 change_prot_numa() 上. 如果任务在 change_prot_numa() 中花费至少两个 ticks 的时间, 并且在 mm 的两个扫描间隔之间进程仅获得两个 ticks 的运行时间, 则可能会发生这种情况.
这组补丁确保任务在扫描 PTE 时的花费不会超过运行时的 3%. 它通过确保在 task_numa_work() 运行之间, 任务在其他事情上花费的时间至少是 task_numa_work() 的 32 倍.
如果在 task_numa_work() 期间发生 tick, 或者任务被重新调度, 我们会延迟 task_numa_work() 的未来运行, 直到任务在task_numa_work() 内花费的CPU时间至少是其他事情的 32 倍. | v1 ☑ 4.5-rc1 | [LORE 0/2](https://lore.kernel.org/all/1446756983-28173-1-git-send-email-riel@redhat.com) |
+| 2015/11/23 | Rik van Riel | [sched,numa: cap pte scanning overhead to 3% of run time](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=51170840fe91dfca10fd533b303ea39b2524782a) | task 级别基于运行时的 NUMA 扫描与 mm 级别的 NUMA 扫描之间存在根本性的不匹配. 在一个严重过载、进程非常大的系统上, 这种不匹配可能会导致系统将所有时间都花在 change_prot_numa() 上. 如果任务在 change_prot_numa() 中花费至少两个 ticks 的时间, 并且在 mm 的两个扫描间隔之间进程仅获得两个 ticks 的运行时间, 则可能会发生这种情况.
这组补丁确保任务在扫描 PTE 时的花费不会超过运行时的 3%. 它通过确保在 task_numa_work() 运行之间, 任务在其他事情上花费的时间至少是 task_numa_work() 的 32 倍.
如果在 task_numa_work() 期间发生 tick, 或者任务被重新调度, 我们会延迟 task_numa_work() 的未来运行, 直到任务在 task_numa_work() 内花费的 CPU 时间至少是其他事情的 32 倍. | v1 ☑ 4.5-rc1 | [LORE 0/2](https://lore.kernel.org/all/1446756983-28173-1-git-send-email-riel@redhat.com) |
| 2017/07/31 | riel@redhat.com | [numa,sched: improve performance for multi-threaded workloads](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=b5dd77c8bdada7b6262d0cba02a6ed525bf4e6e1) | NUMA Balancing 在运行多线程工作负载时花费了太多的 CPU 时间进行扫描和故障处理. 当存在大量共享故障时, 以及在处理具有大量共享故障的大型 NUMA 组时, 此补丁集会降低 NUMA PTE 扫描的速度. | v1 ☑✓ v4.14-rc1 | [LORE v1,0/2](https://lore.kernel.org/all/20170731192847.23050-1-riel@redhat.com) |
-| 2018/05/04 | Mel Gorman | [sched/numa: Stagger NUMA balancing scan periods for new threads v2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1378447598432513d94ce2c607c412dc4f260f31) | 线程共享一个地址空间, 每个线程都可以更改同一地址空间的保护以捕获 NUMA 故障. 这是多余的, 而且可能会适得其反, 因为任何执行更新的线程都已足够. 可能只需要一个线程, 但该线程可能处于空闲状态, 或者可能没有任何局部性问题, 并选择了不合适的扫描速率.
该补丁使用独立的扫描周期, 但它们是根据创建线程时地址空间用户的数量错开的. 其目的是, 线程将避免同时扫描, 并有机会在必要时调整其扫描速率. 这会减少线程生命周期早期的总扫描活动.
性能测试表明: 总体性能差异不大, 但系统 CPU 使用率和总体扫描活动都有所降低. | v2 ☑ 4.18-rc1 | [LORE v2,0/5](https://lore.kernel.org/all/20180504154109.mvrha2qo5wdl65vr@techsingularity.net) |
+| 2018/05/04 | Mel Gorman | [sched/numa: Stagger NUMA balancing scan periods for new threads v2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1378447598432513d94ce2c607c412dc4f260f31) | 线程共享一个地址空间, 每个线程都可以更改同一地址空间的保护以捕获 NUMA 故障. 这是多余的, 而且可能会适得其反, 因为任何执行更新的线程都已足够. 可能只需要一个线程, 但该线程可能处于空闲状态, 或者可能没有任何局部性问题, 并选择了不合适的扫描速率.
该补丁使用独立的扫描周期, 但它们是根据创建线程时地址空间用户的数量错开的. 其目的是, 线程将避免同时扫描, 并有机会在必要时调整其扫描速率. 这会减少线程生命周期早期的总扫描活动.
性能测试表明: 总体性能差异不大, 但系统 CPU 使用率和总体扫描活动都有所降低. | v2 ☑ 4.18-rc1 | [LORE v2,0/5](https://lore.kernel.org/all/20180504154109.mvrha2qo5wdl65vr@techsingularity.net) |
#### 4.6.3.3 Limit Scan Range
-------
@@ -2568,7 +2546,7 @@ commit [6e5fb223e89d ("mm: sched: numa: Implement constant, per task Working Set
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2015/09/11 | Rik van Riel | [sched/numa: Limit the amount of virtual memory scanned in task_numa_work()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4620f8c1fda2af4ccbd11e194e2dd785f7d7f279) | 20150911090027.4a7987bd@annuminas.surriel.com | v1 ☑✓ | [LORE](https://lore.kernel.org/all/20150911090027.4a7987bd@annuminas.surriel.com) |
-| 2022/10/21 | Hao Jia | [Optimize the process of scanning CPU for some functions](https://lore.kernel.org/all/20221021061558.34767-1-jiahao.os@bytedance.com) | 这两个补丁通过调整搜索顺序或打破循环来优化扫描 CPU 的过程.
1. 在 update_numa_stats() 中, 我们尝试在 NUMA 节点上找到一个空闲的 CPU, 最好是一个空闲的内核. 当我们找到一个闲置的核心, 我们可以停止搜索.
2. select_idle_capacity()/task_numa_assign() 等函数中扫描空闲 CPU 时,它从已经在 select_idle_sibling() 中检查过的目标 CPU 开始, 因此第一次扫描必须失败, 建议直接从下一个 CPU 开始扫描. | v1 ☐☑✓ | [LORE v1,0/2](https://lore.kernel.org/all/20221021061558.34767-1-jiahao.os@bytedance.com) |
+| 2022/10/21 | Hao Jia | [Optimize the process of scanning CPU for some functions](https://lore.kernel.org/all/20221021061558.34767-1-jiahao.os@bytedance.com) | 这两个补丁通过调整搜索顺序或打破循环来优化扫描 CPU 的过程.
1. 在 update_numa_stats() 中, 我们尝试在 NUMA 节点上找到一个空闲的 CPU, 最好是一个空闲的内核. 当我们找到一个闲置的核心, 我们可以停止搜索.
2. select_idle_capacity()/task_numa_assign() 等函数中扫描空闲 CPU 时, 它从已经在 select_idle_sibling() 中检查过的目标 CPU 开始, 因此第一次扫描必须失败, 建议直接从下一个 CPU 开始扫描. | v1 ☐☑✓ | [LORE v1,0/2](https://lore.kernel.org/all/20221021061558.34767-1-jiahao.os@bytedance.com) |
#### 4.6.3.4 Process Adaptive
@@ -2576,13 +2554,13 @@ commit [6e5fb223e89d ("mm: sched: numa: Implement constant, per task Working Set
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2022/01/28 | Bharata B Rao | [sched/numa: Process Adaptive autoNUMA](https://lore.kernel.org/lkml/20220128052851.17162-1-bharata@amd.com) | 实现了一种进程自适应 autoNUMA 算法(Process Adaptive autoNUMA, PAN), 用于计算 autoNUMA 扫描周期.
在现有的扫描周期计算机制中:1. 扫描周期是从每线程的统计数据中派生出来的.2. 静态阈值(NUMA_PERIOD_threshold)用于更改扫描速率.
这组补丁集将 NUMA fault 按照不同的维护划分, 如本地的与远程的(local vs. remote), 私有的和共享的(private vs. shared). 然后在每个进程级别收集 numa faults 统计数据, 从而更好地捕获应用程序行为. 不再使用静态阈值, 而是根据远程故障率来学习和调整扫描速率, 可以更好地响应不同的工作负载行为. 由于进程的线程已经被视为一个 numa_group, 因此我们在任务的[内存管理]中添加了一组度量标准, 以跟踪各种类型的错误并从中推导出扫描速度. 新的每进程故障统计数据只对每进程扫描周期计算有贡献, 而现有的每线程统计数据继续对 numa_group 统计数据有贡献, 后者最终确定跨节点迁移内存和线程的阈值. 参见 phoronix 的报道 [AMD Cooking Up A "PAN" Feature That Can Help Boost Linux Performance](https://www.phoronix.com/scan.php?page=news_item&px=AMD-PAN-Linux-RFC) | v0 ☐ | [LKML v0,0/5](https://lkml.org/lkml/2022/1/28/16), [LORE](https://lore.kernel.org/lkml/20220128052851.17162-1-bharata@amd.com) |
+| 2022/01/28 | Bharata B Rao | [sched/numa: Process Adaptive autoNUMA](https://lore.kernel.org/lkml/20220128052851.17162-1-bharata@amd.com) | 实现了一种进程自适应 autoNUMA 算法 (Process Adaptive autoNUMA, PAN), 用于计算 autoNUMA 扫描周期.
在现有的扫描周期计算机制中: 1. 扫描周期是从每线程的统计数据中派生出来的. 2. 静态阈值(NUMA_PERIOD_threshold) 用于更改扫描速率.
这组补丁集将 NUMA fault 按照不同的维护划分, 如本地的与远程的 (local vs. remote), 私有的和共享的(private vs. shared). 然后在每个进程级别收集 numa faults 统计数据, 从而更好地捕获应用程序行为. 不再使用静态阈值, 而是根据远程故障率来学习和调整扫描速率, 可以更好地响应不同的工作负载行为. 由于进程的线程已经被视为一个 numa_group, 因此我们在任务的[内存管理] 中添加了一组度量标准, 以跟踪各种类型的错误并从中推导出扫描速度. 新的每进程故障统计数据只对每进程扫描周期计算有贡献, 而现有的每线程统计数据继续对 numa_group 统计数据有贡献, 后者最终确定跨节点迁移内存和线程的阈值. 参见 phoronix 的报道 [AMD Cooking Up A"PAN"Feature That Can Help Boost Linux Performance](https://www.phoronix.com/scan.php?page=news_item&px=AMD-PAN-Linux-RFC) | v0 ☐ | [LKML v0,0/5](https://lkml.org/lkml/2022/1/28/16), [LORE](https://lore.kernel.org/lkml/20220128052851.17162-1-bharata@amd.com) |
### 4.6.4 NUMA Balancing Placement And Migration
-------
-Mel 在 2012 年最早的 [Automatic NUMA Balancing v10,00/49](https://lore.kernel.org/lkml/1354875832-9700-1-git-send-email-mgorman@suse.de) 方案中实现了 fault driven 的进程迁移(Task Placement)和页面迁移(Page Migration)策略的框架.
+Mel 在 2012 年最早的 [Automatic NUMA Balancing v10,00/49](https://lore.kernel.org/lkml/1354875832-9700-1-git-send-email-mgorman@suse.de) 方案中实现了 fault driven 的进程迁移 (Task Placement) 和页面迁移 (Page Migration) 策略的框架.
#### 4.6.4.1 基于 NUMA Hinting Fault 的 Page Migration 策略
-------
@@ -2595,7 +2573,7 @@ Mel 在 2012 年最早的 [Automatic NUMA Balancing v10,00/49](https://lore.kern
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2020/11/13 | Yang Shi | [skip shared exec THP for NUMA balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=d532e2e57e3c53ce74e519a07d7d2244482b7bd8) | 该补丁随后因与 THP 的兼容性问题(导致死锁)而被 [revert](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7ee820ee72388279a37077f418e32643a298243a) | v3 ☑ 5.11-rc1 | [LKML v3,0/5](https://lore.kernel.org/all/20201113205359.556831-1-shy828301@gmail.com), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c77c5cbafe549eb330e8909861a3e16cbda2c848) |
+| 2020/11/13 | Yang Shi | [skip shared exec THP for NUMA balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=d532e2e57e3c53ce74e519a07d7d2244482b7bd8) | 该补丁随后因与 THP 的兼容性问题 (导致死锁) 而被 [revert](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7ee820ee72388279a37077f418e32643a298243a) | v3 ☑ 5.11-rc1 | [LKML v3,0/5](https://lore.kernel.org/all/20201113205359.556831-1-shy828301@gmail.com), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c77c5cbafe549eb330e8909861a3e16cbda2c848) |
| 2021/01/20 | Huang Ying | [numa balancing: Migrate on fault among multiple bound nodes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=bda420b985054a3badafef23807c4b4fa38a3dff) | 即使应用程序的内存绑定到多个 NUMA 节点, 也可以使用 AutoNUMA 优化跨套接字内存访问. | v9 ☑ 5.12-rc1 | [LKML v9,0/3](https://lore.kernel.org/all/20210120061235.148637-1-ying.huang@intel.com), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=bda420b985054a3badafef23807c4b4fa38a3dff) |
| 2019/07/01 | Philip Yang | [mm/hmm: support automatic NUMA balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=789c2af88f24d1db983aae49b5c4561e6e02ff5b) | NA | v1 ☑ 5.3-rc1 | [PatchWork 04/22](https://patchwork.kernel.org/project/linux-pci/patch/20190701062020.19239-5-hch@lst.de), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=789c2af88f24d1db983aae49b5c4561e6e02ff5b) |
@@ -2664,8 +2642,8 @@ task_numa_fault()
| 原则 | 具体实现 |
|:---:|:----:|
| 对于私有内存, 使每个线程的私有内存保持在本地. | 总是倾向于在[私有的 NUMA hinting fault 上进行页面迁移](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L986). |
-| 尽量避免页面的频繁地在 NUMA 节点之间迁移. | 永远[不要将页面迁移到不在 numa_group 的活动节点中的节点](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L997)上
积极地[将页面从活动节点集之外迁移到活动节点上](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L1004). |
-| 对于共享内存, 在活动节点 active_nodes 之间分配共享内存, 以最大化工作负载可用的内存带宽此补丁系列识别工作负载在其上活动运行的 NUMA 节点, 并在这些节点之间平衡内存. | 对于 numa_group 的一组活动节点 active_nodes 之间, 仅[从 numa 页面错误较多的节点迁移到 numa 页面错误较少的节点, 留有 25% 的余量](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L1014)以避免乒乓. |
+| 尽量避免页面的频繁地在 NUMA 节点之间迁移. | 永远 [不要将页面迁移到不在 numa_group 的活动节点中的节点](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L997) 上
积极地[将页面从活动节点集之外迁移到活动节点上](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L1004). |
+| 对于共享内存, 在活动节点 active_nodes 之间分配共享内存, 以最大化工作负载可用的内存带宽此补丁系列识别工作负载在其上活动运行的 NUMA 节点, 并在这些节点之间平衡内存. | 对于 numa_group 的一组活动节点 active_nodes 之间, 仅 [从 numa 页面错误较多的节点迁移到 numa 页面错误较少的节点, 留有 25% 的余量](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L1014) 以避免乒乓. |
在某些工作负载中, 一些执行清理或者回收工作的进程将访问比执行所有活动工作的线程多几个数量级的内存, 但是他们其实负载很小, 而且并不是业务的关键进程, 在这种情况下, 简单地通过每个线程发生了 NUMA hinting fault 次数直接衡量进程的 NUMA 亲和性是不合适的, 这会导致垃圾收集器所在的节点被标记为组中唯一的活动节点. 因此如果进一步考虑组中每个任务的 CPU 使用情况就可以轻松避免这个问题. 为了实现这一点, 我们[将故障数 numa_faults_cpu 标准化为每个节点上发生的故障的加权分数](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7e2703e6099609adc93679c4d45cd6247f565971), 然后将该分数乘以自上次调用 task_numa_placement 以来任务使用的 CPU 时间分数. 这样, 活动节点掩码中的节点将是 numa 组中任务最活跃运行的节点, 并且那些无关紧要的轻载任务的影响被适当地最小化.
@@ -2682,7 +2660,7 @@ task_numa_fault()
* v4.6 渐进式 active_node 识别
-pseudo-interleaving 中 active_nodes 引入的目标是为了让共享页面在进程稳定在经常运行地(比较热)的 NUMA node 上. 通过限制共享内存页面的迁移, 防止共享内存频繁迁移出现颠簸, 或者内存 "困" 在任务几乎不运行的节点上. 但是其[设计的设置和清除 active_nodes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=20e07dea286a90f096a779706861472d296397c6) 的[硬编码的阈值 6/16 和 3/16](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L1370) 却显得笨拙. 因此为了使工作负载正确聚合, 不应在节点达到阈值时就停止内存迁移, 而应根据每个节点的内存使用量进行分配. 因此 v4.6 commit [4142c3ebb685 ("sched/numa: Spread memory according to CPU and memory use")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4142c3ebb685bb338b7d96090d8f90ff49065ff6) 从 pseudo-interleavin 的实现中删除硬阈值, 而是使用了更渐进的内存放置策略. active_nodes 不再记录活跃节点的 mask, 而是[记录活跃节点的个数](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1684). 引入了一个超限阈值 [ACTIVE_NODE_FRACTION](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1163), [超过 numa_group 的 max_faults_cpu 总数 1/ACTIVE_NODE_FRACTION](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1005) 的 NUMA node 会被认为是 active 的. [从 inactive 的节点到 active 节点的迁移](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1162), 同样参考了 ACTIVE_NODE_FRACTION 阈值. 一旦工作负载在几个活跃使用的节点上稳定下来, 我们仍然希望降低 NUMA 扫描和迁移的速度, [因此 active_node 节点之间的迁移保持 3/4 滞后](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1174). 通过这种渐进的内存放置策略, 内存迁移和任务迁移相互加强, 而不是一个对另一个施加限制. 跟踪工作负载是否在多个节点上积极运行, 以便 task_numa_migrate() 对系统进行全面扫描, 以便更好地放置任务.
+pseudo-interleaving 中 active_nodes 引入的目标是为了让共享页面在进程稳定在经常运行地 (比较热) 的 NUMA node 上. 通过限制共享内存页面的迁移, 防止共享内存频繁迁移出现颠簸, 或者内存 "困" 在任务几乎不运行的节点上. 但是其[设计的设置和清除 active_nodes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=20e07dea286a90f096a779706861472d296397c6) 的[硬编码的阈值 6/16 和 3/16](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L1370) 却显得笨拙. 因此为了使工作负载正确聚合, 不应在节点达到阈值时就停止内存迁移, 而应根据每个节点的内存使用量进行分配. 因此 v4.6 commit [4142c3ebb685 ("sched/numa: Spread memory according to CPU and memory use")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4142c3ebb685bb338b7d96090d8f90ff49065ff6) 从 pseudo-interleavin 的实现中删除硬阈值, 而是使用了更渐进的内存放置策略. active_nodes 不再记录活跃节点的 mask, 而是[记录活跃节点的个数](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1684). 引入了一个超限阈值 [ACTIVE_NODE_FRACTION](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1163), [超过 numa_group 的 max_faults_cpu 总数 1/ACTIVE_NODE_FRACTION](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1005) 的 NUMA node 会被认为是 active 的. [从 inactive 的节点到 active 节点的迁移](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1162), 同样参考了 ACTIVE_NODE_FRACTION 阈值. 一旦工作负载在几个活跃使用的节点上稳定下来, 我们仍然希望降低 NUMA 扫描和迁移的速度, [因此 active_node 节点之间的迁移保持 3/4 滞后](https://elixir.bootlin.com/linux/v4.6/source/kernel/sched/fair.c#L1174). 通过这种渐进的内存放置策略, 内存迁移和任务迁移相互加强, 而不是一个对另一个施加限制. 跟踪工作负载是否在多个节点上积极运行, 以便 task_numa_migrate() 对系统进行全面扫描, 以便更好地放置任务.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
@@ -2696,11 +2674,11 @@ pseudo-interleaving 中 active_nodes 引入的目标是为了让共享页面在
* v3.13 把 NUMA Hinting Fault 最多的结点设置为 numa_preferred_nid
-[Automatic NUMA Balancing v10,00/49](https://lore.kernel.org/lkml/1354875832-9700-1-git-send-email-mgorman@suse.de) 方案中实现的 task_numa_placement() 却只有框架, 并不包含实际的策略信息. 最终实际的进程迁移(Task Placement) 功能是在 2013 年(linux v3.13) 的时候 [Basic scheduler support for automatic NUMA balancing V9](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=2739d3eef3a93a92c366a3a0bb85a0afe09e8b8c) 中完成的. 这个前面已经提及.其中:
+[Automatic NUMA Balancing v10,00/49](https://lore.kernel.org/lkml/1354875832-9700-1-git-send-email-mgorman@suse.de) 方案中实现的 task_numa_placement() 却只有框架, 并不包含实际的策略信息. 最终实际的进程迁移(Task Placement) 功能是在 2013 年(linux v3.13) 的时候 [Basic scheduler support for automatic NUMA balancing V9](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=2739d3eef3a93a92c366a3a0bb85a0afe09e8b8c) 中完成的. 这个前面已经提及. 其中:
commit [688b7585d16a ("sched/numa: Select a preferred node with the most numa hinting faults")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=688b7585d16ab57a17aa4422a3b290b3a55fa679) 将进程 NUMA Hinting Fault 最多的那个 NUMA node 标记为 numa_preferred_nid, 然后将进程迁移过去.
-commit [0ec8aa00f2b4 ("sched/numa: Avoid migrating tasks that are placed on their preferred node")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0ec8aa00f2b4dc457836ef4e2662b02483e94fb7) 将调度域和运行队列 NUMA 位置敏感的任务数量和当前在其首选节点上运行的任务数量分类为不同 fbq_type 类型. 为了实现这一点, 这个补丁会跟踪首选节点 numa_preferred_nid 的任务数量 rq->nr_preferred_running 和关心其位置的运行任务数量 nr_numa_running. 通过分析这些信息, 只要存在更好的选择, Load Balance 就会[避免频繁或者不恰当的 NUMA 任务迁移](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L6026). 比如, 它[不会考虑在任务都被完美放置的组 all 和任务都被远程放置的组 remote 之间](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L6026)进行平衡.
+commit [0ec8aa00f2b4 ("sched/numa: Avoid migrating tasks that are placed on their preferred node")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0ec8aa00f2b4dc457836ef4e2662b02483e94fb7) 将调度域和运行队列 NUMA 位置敏感的任务数量和当前在其首选节点上运行的任务数量分类为不同 fbq_type 类型. 为了实现这一点, 这个补丁会跟踪首选节点 numa_preferred_nid 的任务数量 rq->nr_preferred_running 和关心其位置的运行任务数量 nr_numa_running. 通过分析这些信息, 只要存在更好的选择, Load Balance 就会 [避免频繁或者不恰当的 NUMA 任务迁移](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L6026). 比如, 它[不会考虑在任务都被完美放置的组 all 和任务都被远程放置的组 remote 之间](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L6026) 进行平衡.
当前分类的类型如下, 参见 [fbq_classify_group()](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L5604) 和 [fbq_classify_rq()](https://elixir.bootlin.com/linux/v3.13/source/kernel/sched/fair.c#L5613).
@@ -2730,7 +2708,7 @@ v3.19 期间 [sched,numa: weigh nearby nodes for task placement on complex NUMA
| NUMA 系统 | 描述 | 策略 | 实现 |
|:--------:|:---:|:----:|:----:|
-| NUMA_DIRECT | NA |依旧 numa_faults 最多的 NUMA NODE. | [score_nearby_nodes() 直接返回 0](https://elixir.bootlin.com/linux/v3.19/source/kernel/sched/fair.c#L949), 没有任何加权. preferred_group_nid() [直接返回 nid](https://elixir.bootlin.com/linux/v3.19/source/kernel/sched/fair.c#L1698). |
+| NUMA_DIRECT | NA | 依旧 numa_faults 最多的 NUMA NODE. | [score_nearby_nodes() 直接返回 0](https://elixir.bootlin.com/linux/v3.19/source/kernel/sched/fair.c#L949), 没有任何加权. preferred_group_nid() [直接返回 nid](https://elixir.bootlin.com/linux/v3.19/source/kernel/sched/fair.c#L1698). |
| NUMA_GLUELESS_MESH | NA | 选择 group_weight() (根据节点本身和附近节点上 NUMA hinting faults 数量对节点进行 score_nearby_nodes() 评分) 评分最高的 NUMA node. | score_nearby_nodes() 中遍历所有的 NODE, [按照 NUMA 距离做加权评分](https://elixir.bootlin.com/linux/v3.19/source/kernel/sched/fair.c#L992), 计算方式: $\displaystyle \sum^{N}_{node = 0}{faults_{node} \times \frac{sched\_max\_numa\_distance - dist_{node}}{sched\_max\_numa\_distance - LOCAL\_DISTANCE}}$, preferred_group_nid() 最终[返回评分最高的 NUMA NODE](https://elixir.bootlin.com/linux/v3.19/source/kernel/sched/fair.c#L1705). |
| NUMA_BACKPLANE | NA | 这种系统下情况稍微复杂一些, 为了查找彼此相邻的 numa_groups 中的任务, 需要向下搜索节点组的层次结构, 递归地搜索得分最高的节点组. | score_nearby_nodes() 中探索所有的 NODE 计算评分, 但是[不按照 NUMA 距离加权](https://elixir.bootlin.com/linux/v3.19/source/kernel/sched/fair.c#L997), 计算方式: $\displaystyle \sum^{N}_{node = 0}{faults_{node}}$, preferred_group_nid() 则需要[递归地向下搜索出评分最高的 NUMA 节点](https://elixir.bootlin.com/linux/v3.19/source/kernel/sched/fair.c#L1721). |
@@ -2745,7 +2723,7 @@ v3.19 期间 [sched,numa: weigh nearby nodes for task placement on complex NUMA
### 4.6.5 处理 Numa Balancing Migration vs Load Balance 的冲突
-------
-#### 4.6.5.1 最早的时代-避免 NUMA Blancing 和 Load Balance 的正面交锋 @v3.13
+#### 4.6.5.1 最早的时代 - 避免 NUMA Blancing 和 Load Balance 的正面交锋 @v3.13
-------
* NUMA Task Placement 策略(迁移与交换)
@@ -2756,7 +2734,7 @@ v3.13-rc1 实现 [Basic scheduler support for automatic NUMA balancing V9](https
* 迁移决策(正向决策 migrate_improves_locality & 反向决策 migrate_degrades_locality) @v3.13
-可以看到 NUMA Balacning Task Placement/Migration 这条路径与原生 Load Blancing 是截然不同的两条路, 因此决策上可能存在一定得冲突, Load Balancing 执行迁移决策的关键函数是 can_migration_task. 于是 NUMA Balancing 直接在 can_migration_task() 中引入了正向/反向两个决策函数 migrate_improves_locality() 和 migrate_degrades_locality().
+可以看到 NUMA Balacning Task Placement/Migration 这条路径与原生 Load Blancing 是截然不同的两条路, 因此决策上可能存在一定得冲突, Load Balancing 执行迁移决策的关键函数是 can_migration_task. 于是 NUMA Balancing 直接在 can_migration_task() 中引入了正向 / 反向两个决策函数 migrate_improves_locality() 和 migrate_degrades_locality().
| 决策 | 描述 | 实现 |
|:---:|:----:|:---:|
@@ -2797,7 +2775,7 @@ v3.16 使得 migrate_improves/degrades_locality 感知到了 pseudo-interleaving
migrate_{improves|degrades}locality 和 fbq_type 机制都是想要避免 NUMA Blancing 和 Load Balance 的正面交锋, 虽然它们在尝试解决一类问题, 但是他们相互之间却不感知.
-fbq_classify_rq() 反映了当前 CPU 上进程的 NUMA affinity 状态, RQ 上可能有一些进程期望自己被迁移/交换到首选节点上, 但是 migrate_improves/degrades_locality 并不感知这点.
+fbq_classify_rq() 反映了当前 CPU 上进程的 NUMA affinity 状态, RQ 上可能有一些进程期望自己被迁移 / 交换到首选节点上, 但是 migrate_improves/degrades_locality 并不感知这点.
因此 v4.2 [commit c1ceac6276e4 ("numa,sched: reduce conflict between fbq_classify_rq and migration")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c1ceac6276e4ee12e4129afd380db10fae0db7df) 尝试修复了这个问题. 首先优先考虑首选节点, 其次只在评估较大 NUMA 系统上的两个非首选节点之间的移动时检查故障的数量.
@@ -2843,7 +2821,7 @@ static int can_migrate_task(struct task_struct *p, struct lb_env *env)
* 考虑 score_nearby_nodes() @v4.19
-v3.19 通过临近 NUMA NODES 的评分机制实现了 NUMA 聚合功能, 从而支持各种复杂 NUMA 拓扑结构的 NUMA Task Placement, 参见 [sched,numa: weigh nearby nodes for task placement on complex NUMA topologies v2,0/6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9de05d48711cd5314920ed05f873d84eaf66ccf1). 在 NUMA_BACKPLANE 和 NUMA_GLUELESS_MESH 系统上, 总是倾向于将任务或者内存聚合到临近的一组 NUMA NODE 中. 在这种情况下, 依赖 group_fault() 度量可能并不总是有助于 NUMA 聚合. 在这种情况下, 靠近首选节点的节点可能比远离首选节点的 NUMA Faults 更少. 在这种情况下, 移动到有更多故障的节点可能会避免 NUMA consolidations. 因此使用 group_weight() 将有助于整合围绕 preferred_node 的任务/内存. 在 v4.19 [Fixes for sched/numa_balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=b6a60cf36d497e7fbde9dd5b86fabd96850249f6) 时 [commit f35678b6a170 ("sched/numa: Use group_weights to identify if migration degrades locality")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f35678b6a17063f3b0d391af5ab8f8c83cf31b0c) 开始在 migrate_degrades_locality() 中使用带 score_nearby_nodes 评分的 group_weight 而不是 group_faults() 来做决策.
+v3.19 通过临近 NUMA NODES 的评分机制实现了 NUMA 聚合功能, 从而支持各种复杂 NUMA 拓扑结构的 NUMA Task Placement, 参见 [sched,numa: weigh nearby nodes for task placement on complex NUMA topologies v2,0/6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9de05d48711cd5314920ed05f873d84eaf66ccf1). 在 NUMA_BACKPLANE 和 NUMA_GLUELESS_MESH 系统上, 总是倾向于将任务或者内存聚合到临近的一组 NUMA NODE 中. 在这种情况下, 依赖 group_fault() 度量可能并不总是有助于 NUMA 聚合. 在这种情况下, 靠近首选节点的节点可能比远离首选节点的 NUMA Faults 更少. 在这种情况下, 移动到有更多故障的节点可能会避免 NUMA consolidations. 因此使用 group_weight() 将有助于整合围绕 preferred_node 的任务 / 内存. 在 v4.19 [Fixes for sched/numa_balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=b6a60cf36d497e7fbde9dd5b86fabd96850249f6) 时 [commit f35678b6a170 ("sched/numa: Use group_weights to identify if migration degrades locality")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f35678b6a17063f3b0d391af5ab8f8c83cf31b0c) 开始在 migrate_degrades_locality() 中使用带 score_nearby_nodes 评分的 group_weight 而不是 group_faults() 来做决策.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
@@ -2870,15 +2848,15 @@ NUMA Balancing 与 Load Balancing 的主要矛盾比较麻烦, 因为两者虽
1. 首先是 task_numa_find_cpu() 的执行, 何时? 对哪个 NUMA NODE 执行 task_numa_find_cpu() 是合适的.
-这个其实主要是首选节点(numa_preferred_nid)和备选节点(其他临近结点)的倾向性问题.
+这个其实主要是首选节点 (numa_preferred_nid) 和备选节点 (其他临近结点) 的倾向性问题.
-numa_has_capacity() 检查 numa_preferred_nid 上是否有足够的 capacity 来安放当前任务, 如果 capacity 不足, 应该怎么处理, 是否依旧将 numa_preferred_nid 作为首选项. 这个早期(v3.13)的实现也比较粗糙, 如果 numa_preferred_nid 上没有剩余的 capacity 来承载当前进程, 则会遍历系统中的其他 NUMA nodes. 参照 [sched/numa: Favor placing a task on the preferred node](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2c8a50aa873a7e1d6cc0913362051ff9912dc6ca) 和 [sched/numa: Fix placement of workloads spread across multiple nodes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e1dda8a797b59d7ec4b17e393152ec3273a552d5).
+numa_has_capacity() 检查 numa_preferred_nid 上是否有足够的 capacity 来安放当前任务, 如果 capacity 不足, 应该怎么处理, 是否依旧将 numa_preferred_nid 作为首选项. 这个早期 (v3.13) 的实现也比较粗糙, 如果 numa_preferred_nid 上没有剩余的 capacity 来承载当前进程, 则会遍历系统中的其他 NUMA nodes. 参照 [sched/numa: Favor placing a task on the preferred node](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2c8a50aa873a7e1d6cc0913362051ff9912dc6ca) 和 [sched/numa: Fix placement of workloads spread across multiple nodes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e1dda8a797b59d7ec4b17e393152ec3273a552d5).
引入 pseudo-interleaving 后, 倾向于在各个 active nodes 上均匀的分配共享页面, 这时候怎么处理 numa_preferred_nid 和 active-nodes 的优先级, 通常的做法是把 active nodes 作为 numa_preferred_nid 的 FallBack 机制提供, 那么何时进行 FallBack, 怎么进行 FallBack. v3.15 实现的 pseudo-interleaving 功能引入了 active_nodes 标记了当前 numa_group 组的进程经常运行的 NUMA nodes(或者其个数), 倾向于将共享内存均匀的分布在这些 NUMA node 上.
2. 其次是 task_numa_find_cpu() 的决策, 如何决策是否将进程迁移到当前 nid, 如果决策允许迁移, 那么接下来如何搜索 best_cpu 或者 best_task.
-v3.13 实现 NUMA Balancing 执行 Task Placement 的过程中, task_numa_find_cpu() 通过 task_numa_compare() 检查如果将任务迁移到目标 dst_cpu 上, 系统的整体计算和 NUMA 访问是否会得到改善, 这时候会进一步考虑在 dst_cpu 上运行的任务 dst_rq->curr 是不是与源任务交换可能是最好的选择. 参见 [commit fb13c7ee0ed3 ("sched/numa: Use a system-wide search to find swap/migration candidates")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fb13c7ee0ed387bd6bec4b4024a4d49b1bd504f1). 但是为了防止与 NUMA Balancing 产生冲突, 目前 NUMA Balancing 仅允许[在两个 NUMA 节点上的负载平衡时](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L1202)在 NUMA 节点之间移动或者交换任务. task_numa_compare() 中一旦两个 NUMA 节点之间不均衡, 则不会通过 task_numa_assign() 更新 env->best_cpu 或 env->best_task.
+v3.13 实现 NUMA Balancing 执行 Task Placement 的过程中, task_numa_find_cpu() 通过 task_numa_compare() 检查如果将任务迁移到目标 dst_cpu 上, 系统的整体计算和 NUMA 访问是否会得到改善, 这时候会进一步考虑在 dst_cpu 上运行的任务 dst_rq->curr 是不是与源任务交换可能是最好的选择. 参见 [commit fb13c7ee0ed3 ("sched/numa: Use a system-wide search to find swap/migration candidates")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fb13c7ee0ed387bd6bec4b4024a4d49b1bd504f1). 但是为了防止与 NUMA Balancing 产生冲突, 目前 NUMA Balancing 仅允许 [在两个 NUMA 节点上的负载平衡时](https://elixir.bootlin.com/linux/v3.15/source/kernel/sched/fair.c#L1202) 在 NUMA 节点之间移动或者交换任务. task_numa_compare() 中一旦两个 NUMA 节点之间不均衡, 则不会通过 task_numa_assign() 更新 env->best_cpu 或 env->best_task.
于是 v3.16 的时候, [commit e63da03639cc ("sched/numa: Allow task switch if load imbalance improves")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e63da03639cc9e6e83b62e7ef8ffdbb92421416a) 对 task_numa_compare() 的逻辑做了一定程度的优化, 如果[不平衡较小](https://elixir.bootlin.com/linux/v3.16/source/kernel/sched/fair.c#L1110), 或者迁移后[新的不平衡小于原始不平衡](https://elixir.bootlin.com/linux/v3.16/source/kernel/sched/fair.c#L1124), 则允许在 NUMA 节点之间移动任务. 理论上讲这种情况下, 进行迁移对系统整体性能是有好处的, 至少不会造成 imbalance 的程度加剧. 引入了 [load_too_imbalanced()](https://elixir.bootlin.com/linux/v3.16/source/kernel/sched/fair.c#L1099) 来完成这项检查, 当两个 NUMA 节点之间极度不均衡的时候, 这个函数返回 true.
@@ -2904,13 +2882,13 @@ v3.13 实现 NUMA Balancing 执行 Task Placement 的过程中, task_numa_find_c
##### 4.6.5.3.2 NUMA 聚合还是不聚合? 这是个问题(numa_has_capacity() 与 load_too_imbance())
-------
-最早的时候, task_numa_migrate() 进行迁移决策的时候, 如果 numa_preferred_nid 上没有剩余 capacity, 就会跳过使用 task_numa_find_cpu() 从 numa_preferred_nid 上选择 dest_cpu/dest_task 的操作, 选择遍历系统中的其他 NUMA nodes 来查找 best_cpu(), 参照 [sched/numa: Favor placing a task on the preferred node](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2c8a50aa873a7e1d6cc0913362051ff9912dc6ca) 和 [sched/numa: Fix placement of workloads spread across multiple nodes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e1dda8a797b59d7ec4b17e393152ec3273a552d5). 这直接造成了在完全过载的系统上工作负载**无法进行 NUMA 聚合**的问题.
+最早的时候, task_numa_migrate() 进行迁移决策的时候, 如果 numa_preferred_nid 上没有剩余 capacity, 就会跳过使用 task_numa_find_cpu() 从 numa_preferred_nid 上选择 dest_cpu/dest_task 的操作, 选择遍历系统中的其他 NUMA nodes 来查找 best_cpu(), 参照 [sched/numa: Favor placing a task on the preferred node](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2c8a50aa873a7e1d6cc0913362051ff9912dc6ca) 和 [sched/numa: Fix placement of workloads spread across multiple nodes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e1dda8a797b59d7ec4b17e393152ec3273a552d5). 这直接造成了在完全过载的系统上工作负载 ** 无法进行 NUMA 聚合 ** 的问题.
-因此 v3.17 Rik van Riel 通过 [sched/numa: Ensure task_numa_migrate() checks the preferred node](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a43455a1d572daf7b730fe12eb747d1e17411365) 修复了问题. 移除了 task_numa_migrate() 中 has_free_capacity, 如果 numa_preferred_nid 上没有足够的 free_capacity, 也应该通过 task_numa_find_cpu() 选出一个 CPU 把进程迁移到 numa_preferred_nid 上. 通过即使首选节点完全繁忙时, 也依旧在其上寻找 best_cpu 来解决问题. 这种方法可以明显加快繁忙系统上任务的 NUMA 聚合. 作者测试在 4 节点系统上将 "perf bench numa mem-P4-T20-m-0-P1000" 从 15 分钟内不收敛改为在 10-20 秒内收敛. 当然可想可知, 这种策略暴力且直接, 但是又会**造成 NUMA 过度聚合的问题**, 工作负载集中在几个 NUMA 节点上, 而不是适当地分布在整个系统中, 导致系统可用内存带宽和可用 CPU 缓存减少, 从而导致可预测的性能问题.
+因此 v3.17 Rik van Riel 通过 [sched/numa: Ensure task_numa_migrate() checks the preferred node](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a43455a1d572daf7b730fe12eb747d1e17411365) 修复了问题. 移除了 task_numa_migrate() 中 has_free_capacity, 如果 numa_preferred_nid 上没有足够的 free_capacity, 也应该通过 task_numa_find_cpu() 选出一个 CPU 把进程迁移到 numa_preferred_nid 上. 通过即使首选节点完全繁忙时, 也依旧在其上寻找 best_cpu 来解决问题. 这种方法可以明显加快繁忙系统上任务的 NUMA 聚合. 作者测试在 4 节点系统上将 "perf bench numa mem-P4-T20-m-0-P1000" 从 15 分钟内不收敛改为在 10-20 秒内收敛. 当然可想可知, 这种策略暴力且直接, 但是又会 ** 造成 NUMA 过度聚合的问题 **, 工作负载集中在几个 NUMA 节点上, 而不是适当地分布在整个系统中, 导致系统可用内存带宽和可用 CPU 缓存减少, 从而导致可预测的性能问题.
接着 Rik van Riel 继续对 NUMA 聚合进行了优化, 进一步加快了其聚合速度, 参见 [sched,numa: improve NUMA convergence times](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=a22b4b012340b988dbe7a58461d6fcc582f34aa0). 在 [load_too_imbalanced()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0132c3e1777ceabc24c7d209b7cbe78c28c03c09) 中[增加了 capacity 感知](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=28a21745190a0ca613cab817bfe3dc65373158bf), 并进一步扩大了[其使用场景](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0132c3e1777ceabc24c7d209b7cbe78c28c03c09). 如果单纯迁移任务所能带来的改善 moveimp(Move Improve) 比交换带来的收益 env->best_imp 要高, 则倾向于进行迁移而不是交换, 此时会通过 [load_too_imbalanced() 决策是否允许迁移](https://elixir.bootlin.com/linux/v3.17/source/kernel/sched/fair.c#L1236), 注意此时有意设置改善的收益评分 imp 比 moveimp 略小, 即 imp = moveimp - 1, 这样 IDLE 的 CPU 仍然可以在后续的比较中胜出.
-而彼时 v3.16 刚引入 load_too_imbalance(), 这个允许在两个不均衡的 NUMA NODE 进行 NUMA Balancing Mirgarion. 在 task_numa_compare() 时只计算当前正在运行的任务, 但是如果页面被其他任务锁定, NUMA Hinting Faults 可能会导致任务阻塞. 这可能导致一个大型单一实例工作负载 (如 SPECjbb2005) 的所有线程迁移到同一个 NUMA 节点. 因为有时它们都在相同的几个页面上触发 NUMA Hinting Faults, 但是由于页面被 LOCKED 了, 所以每次只有持有页面的线程仍然可以运行, 然后该线程会被迁移到其首选的 NUMA 节点, 而由于其他进程都被 BLOCKED 了, 此时迁移并不会加剧不平衡. 最终造成所有的线程都依次被迁移到同一个节点上, 这种 NUMA 过度聚合的情况下有必要采取必要的手段**阻止 NUMA 过度向同一节点聚合**. v4.1 [commit 095bebf61a46 ("sched,numa: do not move past the balance point if unbalanced")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=095bebf61a460ad7f6a45bb17ddbf3a9df2b4397) 在 load_too_imbalanced() 中引入 move_load 流量限制, 通过对迁移负载 move_load 流量进行校验尝试解决 v3.16 可能引入的 NUMA 过度聚合的问题. 通过检查 NUMA Balancing Migration 的[净移动的方向和流量 [move_load](https://elixir.bootlin.com/linux/v4.1/source/kernel/sched/fair.c#L1243), 并拒绝 NUMA 移动, 如果它会导致系统移动超过平衡点. 在不平衡状态下, 只有使我们更接近平衡点的动作才被允许. 但是这种改动只能单点规避问题, 阻止任务向同一个 NUMA 节点中过度聚合. 类似的问题依旧有很多. 另外任务的分散程度不可控, 这个修改策略在一些期望聚合场景下, 可能会进一步**阻止 NUMA 聚合**, 造成任务过于分散, 而在一些期望均衡(分散)的场景下, 可能又显得稍微有点集中.
+而彼时 v3.16 刚引入 load_too_imbalance(), 这个允许在两个不均衡的 NUMA NODE 进行 NUMA Balancing Mirgarion. 在 task_numa_compare() 时只计算当前正在运行的任务, 但是如果页面被其他任务锁定, NUMA Hinting Faults 可能会导致任务阻塞. 这可能导致一个大型单一实例工作负载 (如 SPECjbb2005) 的所有线程迁移到同一个 NUMA 节点. 因为有时它们都在相同的几个页面上触发 NUMA Hinting Faults, 但是由于页面被 LOCKED 了, 所以每次只有持有页面的线程仍然可以运行, 然后该线程会被迁移到其首选的 NUMA 节点, 而由于其他进程都被 BLOCKED 了, 此时迁移并不会加剧不平衡. 最终造成所有的线程都依次被迁移到同一个节点上, 这种 NUMA 过度聚合的情况下有必要采取必要的手段 ** 阻止 NUMA 过度向同一节点聚合 **. v4.1 [commit 095bebf61a46 ("sched,numa: do not move past the balance point if unbalanced")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=095bebf61a460ad7f6a45bb17ddbf3a9df2b4397) 在 load_too_imbalanced() 中引入 move_load 流量限制, 通过对迁移负载 move_load 流量进行校验尝试解决 v3.16 可能引入的 NUMA 过度聚合的问题. 通过检查 NUMA Balancing Migration 的 [净移动的方向和流量 [move_load](https://elixir.bootlin.com/linux/v4.1/source/kernel/sched/fair.c#L1243), 并拒绝 NUMA 移动, 如果它会导致系统移动超过平衡点. 在不平衡状态下, 只有使我们更接近平衡点的动作才被允许. 但是这种改动只能单点规避问题, 阻止任务向同一个 NUMA 节点中过度聚合. 类似的问题依旧有很多. 另外任务的分散程度不可控, 这个修改策略在一些期望聚合场景下, 可能会进一步 ** 阻止 NUMA 聚合 **, 造成任务过于分散, 而在一些期望均衡(分散) 的场景下, 可能又显得稍微有点集中.
很快 v4.2 期间就发现上述这种粗暴的方式在系统负载没有过载的情况下又引入了性能回归, 特定工作负载集中在几个 NUMA 节点上, 而不是在整个系统中适当地分散. 这会导致可用内存带宽和可用 CPU 缓存的减少, 从而造成性能下降. 很明显, 造成这样的根本原因是 Load Balance 和 NUMA Balacning 之间的冲突和相互作用, 其中 Load Balance 关注的的短期负载与 NUMA Balacning 期望的基于的长期负载的统计不同. 因此如果过度聚合, 不合适. 如果分散, 那么分散到什么样的程度才比较合适的呢? v4.2 的 [numa,sched: resolve conflict between load balancing and NUMA balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=6f9aad0bc37286c0441b57f0ba8cffee50715426) 中 [sched/numa: Only consider less busy nodes as numa balancing destinations](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6f9aad0bc37286c0441b57f0ba8cffee50715426) 尝试对此问题进行了修复, 尝试在 numa_preferred_nid 过载时, 通过考虑一个负载较轻的节点作为 NUMA Balacning 的目的地, 来弥补 Load Balance 和 NUMA Balacning 之间的冲突, 而不管任务是试图移动到首选节点, 还是转移到另一个节点. 这个补丁又重新引入了对 numa_preferred_nid 节点 numa_has_capacity() 的检查, 显然也解决了 v3.17 [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a43455a1d572daf7b730fe12eb747d1e17411365) 所引入的那个无法聚合的问题, 当时就是因为去掉了 numa_preferred_nid 的 capacity 的检查后, 造成 过载后线程永远不会迁移到它所使用内存的附近. 有了这种看起来很棒的机制, 那自然就对迁移负载 move_load 流量校验的规避方式进行了回退 [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e4991b240c622f0441c21f4869e13209abc08c5e). Jirka 在几个系统上运行了许多性能测试: 单实例 SpecJBB 2005 在 4 节点系统上的性能提高了 7-15%, 在每个 SOCKET 上拥有更多 CPU 的系统上有更高的增益. 多实例情况下, 性能也没有下降.
@@ -2926,8 +2904,7 @@ static int task_numa_migrate(struct task_struct *p)
task_numa_find_cpu(&env, taskimp, groupimp);
// ......
if (env.best_cpu == -1 || (p->numa_group &&
- nodes_weight(p->numa_group->active_nodes) > 1)) {
- for_each_online_node(nid) {
+ nodes_weight(p->numa_group->active_nodes) > 1)) {for_each_online_node(nid) {
// ......
if (numa_has_capacity(&env))
task_numa_find_cpu(&env, taskimp, groupimp);
@@ -2956,7 +2933,7 @@ static void task_numa_compare(struct task_numa_env *env, long taskimp, long grou
{
balance:
// ......
- if (moveimp > imp && moveimp > env->best_imp) {
+ if (moveimp> imp && moveimp > env->best_imp) {
/*
* If the improvement from just moving env->p direction is
* better than swapping tasks around, check if a move is
@@ -2992,9 +2969,9 @@ assign:
v4.19 [Fixes for sched/numa_balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=b6a60cf36d497e7fbde9dd5b86fabd96850249f6) 进行了大量的修复, 统一各个子模块之间的相互关联, 防止各个策略之间冲突.
-其中主要对 task_numa_migrate() 的决策(是否迁移 load_too_imbalanced())以及迁移目的地的搜索(task_numa_find_cpu()) 做了较多的优化.
+其中主要对 task_numa_migrate() 的决策 (是否迁移 load_too_imbalanced()) 以及迁移目的地的搜索(task_numa_find_cpu()) 做了较多的优化.
-1. task_numa_compare() 辅助 task_numa_find_cpu() 选择移动或交换所选任务的最佳 CPU. 但是要实现此任务, 需要为节点中的每个 CPU 调用都执行 task_numa_compare(). 但是其实, 移动的决策基本上独立于 CPU的, 因此只需要每个 NUMA NODE 进行一次移动决策即可, 因此在 task_numa_compare() 引入 maymove 机制, task_numa_find_cpu() 中先通过 maymove = !load_too_imbalanced(src_load, dst_load, env) 决策是否倾向于迁移, 再遍历所有 CPU 进行 task_numa_compare() 寻找 best_cpu/best_task. 对于 maymove 的场景, 可以直接旁路 task_numa_compare() 中的部分重复逻辑, 对于单个 NUMA NODE 只需要决策一次 maymove, 这有效地降低了 task_numa_find_cpu() 的整体开销. 参见 [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=305c1fac3225dfa7eeb89bfe91b7335a6edd5172).
+1. task_numa_compare() 辅助 task_numa_find_cpu() 选择移动或交换所选任务的最佳 CPU. 但是要实现此任务, 需要为节点中的每个 CPU 调用都执行 task_numa_compare(). 但是其实, 移动的决策基本上独立于 CPU 的, 因此只需要每个 NUMA NODE 进行一次移动决策即可, 因此在 task_numa_compare() 引入 maymove 机制, task_numa_find_cpu() 中先通过 maymove = !load_too_imbalanced(src_load, dst_load, env) 决策是否倾向于迁移, 再遍历所有 CPU 进行 task_numa_compare() 寻找 best_cpu/best_task. 对于 maymove 的场景, 可以直接旁路 task_numa_compare() 中的部分重复逻辑, 对于单个 NUMA NODE 只需要决策一次 maymove, 这有效地降低了 task_numa_find_cpu() 的整体开销. 参见 [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=305c1fac3225dfa7eeb89bfe91b7335a6edd5172).
2. 在有了 [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=305c1fac3225dfa7eeb89bfe91b7335a6edd5172) 的修改后, [在 task_numa_find_cpu() 中直接通过 load_too_imbalanced() 来决策迁移和交换的可能性](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=305c1fac3225dfa7eeb89bfe91b7335a6edd5172). 而由于 load_too_imbalanced() 中已经提供了[类似于 numa_has_capacity() 的检查](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=5f95ba7a43057f28a349ea1f03ee8d04e0f445ea), 因此 task_numa_migrate() 中不再简单地[通过判断 numa_preferred_nid 容量不足(!numa_has_capacity()), 就阻止任务交换](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2d4056fafa196e1ab4e7161bae4df76f9602d56d), 而是通过 load_too_imbalanced() 来决策倾向于迁移 maymove 还是交换.
@@ -3002,11 +2979,11 @@ v4.19 [Fixes for sched/numa_balancing](https://git.kernel.org/pub/scm/linux/kern
当然影响 task_numa_migrate() 的是否迁移决策的关键除了 load_too_imbalanced() 还有 task_numa_compare() 中迁移收益的评估. load_too_imbalanced() 用于拒绝那么引入太多不平衡的迁移动作, task_numa_compare() 则具体评估迁移所能带来的具体收益, 迁移收益自然是越大越好. 因此紧随其后 [numabalancing patches](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=6fd98e775f24fd41520928d345f5db3ff52bb35d) 就针对 task_numa_compare() 进行了逻辑的修正和优化.
-1. 首先是 [commit a4739eca4456 ("sched/numa: Stop multiple tasks from moving to the CPU at the same time")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a4739eca4456e3d140cc656c5331d42b7465f91d) 阻止了同一个 RQ 上的 NUMA Balancing Task Placement 并发执行. 因为多个任务可能同时选择迁移到同一个 CPU. 这可能会导致任务频繁的迁移颠簸或者系统整体的不均衡. 这使用 per-RQ 的 numa_migrate_on 标记来检查对应 RQ上的是否正在进行 NUMA Balancing. 在搜索 best_cpu 时, 如果对应的 CPU 上正在执行 NUMA Balancing 则 [task_numa_compare()](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1604) 和 [task_numa_assigin()](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1530) 都直接返回, 否则 task_numa_assigin() 入口处会[将 numa_migrate_on 置位](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1530), 随后将当前 RQ 更新为 best_cpu, 并[清除旧的 bes_cpu 上的 numa_migrate_on 标记](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1539). 其他情况下都会[在迁移完成后, 再清除标记](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1853).
+1. 首先是 [commit a4739eca4456 ("sched/numa: Stop multiple tasks from moving to the CPU at the same time")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a4739eca4456e3d140cc656c5331d42b7465f91d) 阻止了同一个 RQ 上的 NUMA Balancing Task Placement 并发执行. 因为多个任务可能同时选择迁移到同一个 CPU. 这可能会导致任务频繁的迁移颠簸或者系统整体的不均衡. 这使用 per-RQ 的 numa_migrate_on 标记来检查对应 RQ 上的是否正在进行 NUMA Balancing. 在搜索 best_cpu 时, 如果对应的 CPU 上正在执行 NUMA Balancing 则 [task_numa_compare()](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1604) 和 [task_numa_assigin()](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1530) 都直接返回, 否则 task_numa_assigin() 入口处会[将 numa_migrate_on 置位](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1530), 随后将当前 RQ 更新为 best_cpu, 并[清除旧的 bes_cpu 上的 numa_migrate_on 标记](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1539). 其他情况下都会[在迁移完成后, 再清除标记](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1853).
-2. 其次 [commit 6fd98e775f24 ("sched/numa: Avoid task migration for small NUMA improvement")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6fd98e775f24fd41520928d345f5db3ff52bb35d) 阻止了那些迁移后带来的收益提升较小的迁移动作. [task_numa_finc_cpu() -=> task_numa_compare()](https://elixir.bootlin.com/linux/v4.18/source/kernel/sched/fair.c#L1731) 依次遍历所有的 CPU, 找到将进程迁移或者交换到后所能带来的[性能提升 moveimp(Move Improve) 最高(moveimp >= env->best_imp)的那个 CPU, 作为 env->best_cpu](https://elixir.bootlin.com/linux/v4.18/source/kernel/sched/fair.c#L1648). 但是却忽略了 moveimp 的量级, 如果能带来的改进 moveimp 非常小, 那么迁移本身没有带来多少提升, 反而可能由于成进程频繁地迁移颠簸或者迁移后的 cache miss 等, 造成性能劣化. 因此这个补丁引入了改阈值 SMALLIMP, 如果最终发现 NUMA 迁移或者交换所能带来的提升 imp 很有限 [(imp < SMALLIMP || imp <= env->best_imp + SMALLIMP / 2)](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1675), 则阻止向目标 CPU 的迁移.
+2. 其次 [commit 6fd98e775f24 ("sched/numa: Avoid task migration for small NUMA improvement")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6fd98e775f24fd41520928d345f5db3ff52bb35d) 阻止了那些迁移后带来的收益提升较小的迁移动作. [task_numa_finc_cpu() -=> task_numa_compare()](https://elixir.bootlin.com/linux/v4.18/source/kernel/sched/fair.c#L1731) 依次遍历所有的 CPU, 找到将进程迁移或者交换到后所能带来的 [性能提升 moveimp(Move Improve) 最高(moveimp>= env->best_imp) 的那个 CPU, 作为 env->best_cpu](https://elixir.bootlin.com/linux/v4.18/source/kernel/sched/fair.c#L1648). 但是却忽略了 moveimp 的量级, 如果能带来的改进 moveimp 非常小, 那么迁移本身没有带来多少提升, 反而可能由于成进程频繁地迁移颠簸或者迁移后的 cache miss 等, 造成性能劣化. 因此这个补丁引入了改阈值 SMALLIMP, 如果最终发现 NUMA 迁移或者交换所能带来的提升 imp 很有限 [(imp < SMALLIMP || imp <= env->best_imp + SMALLIMP / 2)](https://elixir.bootlin.com/linux/v4.19/source/kernel/sched/fair.c#L1675), 则阻止向目标 CPU 的迁移.
-Mel Gorman 在 Srikar Dronamraju 工作的基础上, 进一步优化了流式工作负载(STREAM workload)开启了 NUMA Balancing 后的性能回归, 流式工作负载有点特殊, 因为只有当任务固定到内存通道时, 它才能作为有效的基准. 否则, 它对基准的起始条件非常敏感. Srikar Dronamraju 最近的优化通过限制任务的 NUMA 迁移, 可防止过早地将工作负载分散到多个 NUMA NODE 上, 这对许多工作负载有利, 但对流式的工作负载没有好处.
+Mel Gorman 在 Srikar Dronamraju 工作的基础上, 进一步优化了流式工作负载 (STREAM workload) 开启了 NUMA Balancing 后的性能回归, 流式工作负载有点特殊, 因为只有当任务固定到内存通道时, 它才能作为有效的基准. 否则, 它对基准的起始条件非常敏感. Srikar Dronamraju 最近的优化通过限制任务的 NUMA 迁移, 可防止过早地将工作负载分散到多个 NUMA NODE 上, 这对许多工作负载有利, 但对流式的工作负载没有好处.
1. 早期内核通过使用迁移速率限制 NUMA Balancing 的频繁迁移, 但是彼时 automatic NUMA balancing 的迁移决策已经足够成熟, 因此 [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=efaffc5e40aeced0bcb497ed7a0a5b8c14abfcdf) 移除了迁移速率的限制.
@@ -3046,14 +3023,13 @@ static void task_numa_find_cpu(struct task_numa_env *env, long taskimp, long gro
static void task_numa_compare(struct task_numa_env *env, long taskimp, long groupimp, bool maymove)
{
// ......
- if (!cur) {
- if (maymove && moveimp >= env->best_imp) // IDLE 的 CPU 是一个很适合迁移的选择
+ if (!cur) {if (maymove && moveimp>= env->best_imp) // IDLE 的 CPU 是一个很适合迁移的选择
goto assign;
else
goto unlock;
}
// ......
- if (maymove && moveimp > imp && moveimp > env->best_imp) { // 如果迁移带来的收益 moveimp 比交换带来的收益 imp/env->best_imp, 同样倾向于迁移而不是交换
+ if (maymove && moveimp> imp && moveimp > env->best_imp) {// 如果迁移带来的收益 moveimp 比交换带来的收益 imp/env->best_imp, 同样倾向于迁移而不是交换
imp = moveimp;
cur = NULL;
goto assign;
@@ -3066,14 +3042,11 @@ static int task_numa_migrate(struct task_struct *p)
// ......
/* Try to find a spot on the preferred nid. */
task_numa_find_cpu(&env, taskimp, groupimp);
- if (env.best_cpu == -1 || (p->numa_group && p->numa_group->active_nodes > 1)) {
- for_each_online_node(nid) {
- task_numa_find_cpu(&env, taskimp, groupimp);
+ if (env.best_cpu == -1 || (p->numa_group && p->numa_group->active_nodes > 1)) {for_each_online_node(nid) {task_numa_find_cpu(&env, taskimp, groupimp);
}
}
// ......
- if (p->numa_group) {
- if (env.best_cpu == -1)
+ if (p->numa_group) {if (env.best_cpu == -1)
nid = env.src_nid;
else
nid = cpu_to_node(env.best_cpu);
@@ -3098,9 +3071,9 @@ v5.5 [Reworking CFS load balancing](https://lwn.net/Articles/793427) 合入后,
1. 首先是 NUMA Balancing 和 Load Balancing 之间使用相似的代码模式和逻辑, 两者从逻辑上实现了统一(adjust_numa_imbalance and load_too_imbalanced).
-类比 Load Balancing 路径下, 使用 load_avg 替代 runnable_load_avg 来用于 [load_balance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b0fb1eb4f04ae4768231b9731efb1134e22053a4) 以及 [BALANCE_WAKE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b0fb1eb4f04ae4768231b9731efb1134e22053a4) 路径下负载的计算和比较, [commit 6499b1b2dd1b ("sched/numa: Replace runnable_load_avg by load_avg")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6499b1b2dd1b8d404a16b9fbbf1af6b9b3c1d83d) 将NUMA Balancing 路径下也使用 load_avg 替换 runnable_load_avg 来比较负载. 同时跟 Load Balancing 的 enum group_type 分类方式类似, NUMA Balancing 也引入了 enum numa_type 以便更好地查看节点的当前状态, 同时 [struct numa_stats](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1508) 中也开始跟踪利用率 util, 正在运行的任务数 nr_running 以及当前 NUMA 状态 numa_type 等信息, 并通过 [update_numa_stats()](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1602) 和 [numa_classify()](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1557) 更新.
+类比 Load Balancing 路径下, 使用 load_avg 替代 runnable_load_avg 来用于 [load_balance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b0fb1eb4f04ae4768231b9731efb1134e22053a4) 以及 [BALANCE_WAKE](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b0fb1eb4f04ae4768231b9731efb1134e22053a4) 路径下负载的计算和比较, [commit 6499b1b2dd1b ("sched/numa: Replace runnable_load_avg by load_avg")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6499b1b2dd1b8d404a16b9fbbf1af6b9b3c1d83d) 将 NUMA Balancing 路径下也使用 load_avg 替换 runnable_load_avg 来比较负载. 同时跟 Load Balancing 的 enum group_type 分类方式类似, NUMA Balancing 也引入了 enum numa_type 以便更好地查看节点的当前状态, 同时 [struct numa_stats](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1508) 中也开始跟踪利用率 util, 正在运行的任务数 nr_running 以及当前 NUMA 状态 numa_type 等信息, 并通过 [update_numa_stats()](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1602) 和 [numa_classify()](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1557) 更新.
-[commit fb86f5b21192 ("sched/numa: Use similar logic to the load balancer for moving between domains with spare capacity")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fb86f5b2119245afd339280099b4e9417cc0b03a) 则避免了 NUMA Balancing 引入严重的不平衡问题. Load Balancing 通常尝试在 NUMA 域之间[保持正在运行的任务或空闲 CPU 的数量平衡](https://elixir.bootlin.com/linux/v5.6/source/kernel/sched/fair.c#L8727), 即 (busiest->sum_nr_running <= imbalance_min), 参见 [commit b396f52326de ("sched/fair: Allow a small load imbalance between low utilisation SD_NUMA domains")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b396f52326de20ec974471b7b19168867b365cbf), 但是 NUMA Balancing 在迁移时如果发现目标 NUMA NODE 有空闲容量, 就可能允许任务迁移. 因此这个补丁将策略修改为: 当[目标 NUMA NODE 上有足够的剩余 capactiy](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1918), 即 (env->dst_stats.node_type == node_has_spare), NUMA Balancing 和 Load Balancing 之间使用类似的逻辑 [adjust_numa_imbalance()](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1931), 始终保持保持正在运行的任务或空闲 CPU 的数量平衡, 而没有剩余 capacity 时 NUMA Balancing 依旧[使用 load_too_imbalanced() 来决策](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1951)是否迁移.
+[commit fb86f5b21192 ("sched/numa: Use similar logic to the load balancer for moving between domains with spare capacity")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fb86f5b2119245afd339280099b4e9417cc0b03a) 则避免了 NUMA Balancing 引入严重的不平衡问题. Load Balancing 通常尝试在 NUMA 域之间 [保持正在运行的任务或空闲 CPU 的数量平衡](https://elixir.bootlin.com/linux/v5.6/source/kernel/sched/fair.c#L8727), 即 (busiest->sum_nr_running <= imbalance_min), 参见 [commit b396f52326de ("sched/fair: Allow a small load imbalance between low utilisation SD_NUMA domains")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b396f52326de20ec974471b7b19168867b365cbf), 但是 NUMA Balancing 在迁移时如果发现目标 NUMA NODE 有空闲容量, 就可能允许任务迁移. 因此这个补丁将策略修改为: 当[目标 NUMA NODE 上有足够的剩余 capactiy](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1918), 即 (env->dst_stats.node_type == node_has_spare), NUMA Balancing 和 Load Balancing 之间使用类似的逻辑 [adjust_numa_imbalance()](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1931), 始终保持保持正在运行的任务或空闲 CPU 的数量平衡, 而没有剩余 capacity 时 NUMA Balancing 依旧[使用 load_too_imbalanced() 来决策](https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L1951) 是否迁移.
2. 其次是对 NUMA Balancing 的 dest_cpu 和 best_task 搜索优化和改进
@@ -3119,8 +3092,7 @@ v5.5 [Reworking CFS load balancing](https://lwn.net/Articles/793427) 合入后,
```cpp
static void task_numa_find_cpu(struct task_numa_env *env, long taskimp, long groupimp)
-{
- if (env->dst_stats.node_type == node_has_spare) { // 如果目标 NUMA NODE 仍有足够的 CAPACITY
+{if (env->dst_stats.node_type == node_has_spare) { // 如果目标 NUMA NODE 仍有足够的 CAPACITY
// ......
imbalance = adjust_numa_imbalance(imbalance, src_running); // 正在运行的任务或空闲 CPU 的数量平衡
/* Use idle CPU if there is no imbalance */
@@ -3136,8 +3108,7 @@ static void task_numa_find_cpu(struct task_numa_env *env, long taskimp, long gro
maymove = !load_too_imbalanced(src_load, dst_load, env); // 检查 NUMA 迁移是否能会引起较大的不平衡.
}
// ......
- for_each_cpu(cpu, cpumask_of_node(env->dst_nid)) {
- if (task_numa_compare(env, taskimp, groupimp, maymove))
+ for_each_cpu(cpu, cpumask_of_node(env->dst_nid)) {if (task_numa_compare(env, taskimp, groupimp, maymove))
break;
}
}
@@ -3148,7 +3119,7 @@ static void task_numa_find_cpu(struct task_numa_env *env, long taskimp, long gro
至此已经做了足够多的优化来处理 NUMA Balancing 和 Load Balancing 的冲突问题, 从最早的不允许在不平衡的 NUMA 之间迁移, 到引入 load_too_imbalanced() 以及后来的 numa_has_capacity() 开始, 直至 adjust_numa_imbalance() 和 load_too_imbalanced() 相辅相成的方式. 在这方面已经做了足够多的优化, NUMA Balancing 和 Load Balancing 的决策逻辑已经逐渐趋于统一. 那么是时候放开 NUMA 下不平衡迁移的限制了.
-当前的决策 node_has_spare 时, 使用 adjust_numa_imbalance() 来决策是否需要进行迁移, 它通过判断正在运行的任务或空闲 CPU 的数量来决策, 仅[当目标节点几乎完全空闲时(即 nr_running <= imbalance_min == 2)才允许出现不平衡](https://elixir.bootlin.com/linux/v5.10/source/kernel/sched/fair.c#L9001), 当前这种做法是非常保守的.
+当前的决策 node_has_spare 时, 使用 adjust_numa_imbalance() 来决策是否需要进行迁移, 它通过判断正在运行的任务或空闲 CPU 的数量来决策, 仅 [当目标节点几乎完全空闲时(即 nr_running <= imbalance_min == 2) 才允许出现不平衡](https://elixir.bootlin.com/linux/v5.10/source/kernel/sched/fair.c#L9001), 当前这种做法是非常保守的.
```cpp
// https://elixir.bootlin.com/linux/v5.7/source/kernel/sched/fair.c#L8931
@@ -3168,11 +3139,11 @@ static inline long adjust_numa_imbalance(int imbalance, int nr_running)
}
```
-在低负载情况下, 贸然追求 NUMA 之间的负载均衡是非常不值得的. 因此 v5.11-rc1 通过 [commit 7d2b5dd0bcc4 ("sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc48095651f1b85f751eef610b3e034) 允许 NUMA 之间一直保持这种不均衡, 直到系统达到 25% 的 CPU Utilisations. 这种修改并不见得比原来的做法(限制不平衡在 imbalance_min 个任务之间)更明智. 测试结果表明并不是所有的性能测试都看到了收益. 任何希望在有限的通信范围内尽可能广泛地扩展的基准测试都将倾向于旧的行为, 因为有更多的内存带宽. 而对大量成对通信的工作负载(如 netperf 或 tbench) 会带来好处. 当然对于作者的测试, 绝大多数工作负载都看到了性能收益. 因此这(似乎)依旧是一个值得的尝试.
+在低负载情况下, 贸然追求 NUMA 之间的负载均衡是非常不值得的. 因此 v5.11-rc1 通过 [commit 7d2b5dd0bcc4 ("sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc48095651f1b85f751eef610b3e034) 允许 NUMA 之间一直保持这种不均衡, 直到系统达到 25% 的 CPU Utilisations. 这种修改并不见得比原来的做法 (限制不平衡在 imbalance_min 个任务之间) 更明智. 测试结果表明并不是所有的性能测试都看到了收益. 任何希望在有限的通信范围内尽可能广泛地扩展的基准测试都将倾向于旧的行为, 因为有更多的内存带宽. 而对大量成对通信的工作负载 (如 netperf 或 tbench) 会带来好处. 当然对于作者的测试, 绝大多数工作负载都看到了性能收益. 因此这(似乎) 依旧是一个值得的尝试.
[commit 7d2b5dd0bcc4 ('sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc48095651f1b85f751eef610b3e034) 进一步放开了 adjust_numa_imbalance() 的平衡限制. 使用 allow_numa_imbalance() 来检查, 如果 NUMA 域内 BUSY CPU 的数量小于小于域内 CPU 数量的 25%, 则允许 NUMA 不平衡. 实现上直接用目标 NUMA 域上的可运行的任务数量 dst_running 近似表示了 BUSY CPU 的数量, 因此这个策略是一个模糊的策略, 因为可运行的任务的数量 numa_stat.nr_running 可能与繁忙 CPU 的数量无关.
-同样 allow_numa_imbalance() 的逻辑被用[到了 find_idlest_group() 路径](https://elixir.bootlin.com/linux/v5.11/source/kernel/sched/fair.c#L8927)下, 在本 NUMA 域仍有剩余 capacity(处于 group_has_spare 状态), 将正在运行的任务数将保持在阈值以下, 这样可以保证 BALANCE_FORK/BALANCE_WAKEUP 等路径下, 任务保持在唤醒源附近. 如果后期确实需要迁移, 那么定期的 Load Balancing 将解决这个问题.
+同样 allow_numa_imbalance() 的逻辑被用 [到了 find_idlest_group() 路径](https://elixir.bootlin.com/linux/v5.11/source/kernel/sched/fair.c#L8927) 下, 在本 NUMA 域仍有剩余 capacity(处于 group_has_spare 状态), 将正在运行的任务数将保持在阈值以下, 这样可以保证 BALANCE_FORK/BALANCE_WAKEUP 等路径下, 任务保持在唤醒源附近. 如果后期确实需要迁移, 那么定期的 Load Balancing 将解决这个问题.
```cpp
// https://elixir.bootlin.com/linux/v5.11/source/kernel/sched/fair.c#L8790
@@ -3182,8 +3153,7 @@ static inline long adjust_numa_imbalance(int imbalance, int nr_running)
* related to the number of busy CPUs due to sched_setaffinity.
*/
static inline bool allow_numa_imbalance(int dst_running, int dst_weight)
-{
- return (dst_running < (dst_weight >> 2));
+{return (dst_running < (dst_weight>> 2));
}
#define NUMA_IMBALANCE_MIN 2
@@ -3191,8 +3161,7 @@ static inline bool allow_numa_imbalance(int dst_running, int dst_weight)
// https://elixir.bootlin.com/linux/v5.11/source/kernel/sched/fair.c#L9031
static inline long adjust_numa_imbalance(int imbalance,
int dst_running, int dst_weight)
-{
- if (!allow_numa_imbalance(dst_running, dst_weight))
+{if (!allow_numa_imbalance(dst_running, dst_weight))
return imbalance;
/*
@@ -3208,8 +3177,8 @@ static inline long adjust_numa_imbalance(int imbalance,
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2020/11/20 | Mel Gorman | [Revisit NUMA imbalance tolerance and fork balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=23e6082a522e32232f7377540b4d42d8304253b8) | 解决一个负载平衡问题
之前解决 NUMA Balancing 和 Load Balancing 被调和时, 尝试允许在一定程度的不平衡, 但是也引入了诸多问题. 因此当时限制不平衡只允许在几乎空闲的 NUMA 域. 现在大多数问题都已经解决掉了, 现在[允许不平衡扩大一定的范围](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc48095651f1b85f751eef610b3e034). 同时该补丁还解决了 fork 时候 balance 的问题. 性能测试发现, 这个补丁可以提升约 1.5% unixbench 的跑分, 参见 [e7f28850ea: unixbench.score 1.5% improvement](https://lore.kernel.org/lkml/20201122150415.GJ2390@xsang-OptiPlex-9020) | v3 ☑✓ 5.11-rc1 | [LORE RRC,0/3](https://lore.kernel.org/lkml/20201117134222.31482-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v3,0/4](https://lore.kernel.org/all/20201120090630.3286-1-mgorman@techsingularity.net) |
-| 2021/12/01 | Mel Gorman | [Adjust NUMA imbalance for multiple LLCs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e496132ebedd870b67f1f6d2428f9bb9d7ae27fd) | [commit 7d2b5dd0bcc4 ("sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc4) 允许 NUMA 节点之间的不平衡, 这样通信任务不会被 load balance 分开. 当 LLC 和 node 之间有 1:1 的关系时, 这种方法可以很好地工作, 但是对于多个 LLC, 如果独立的任务过早地使用 CPU 共享缓存, 这种方法就不太理想了. 本系列解决了两个问题:
1. 调度程序域权重的使用不一致, 以及当每个 NUMA 节点有许多 LLC 时性能不佳. NUMA之间允许的不均衡的进程数目不再是一个固定的值 NUMA_IMBALANCE_MIN(2), 而是在 build_sched_domains() 中实际探测 NUMA 域下辖的 LLC 的数目, 作为 sd->imb_numa_nr. | v4 ☑✓ 5.18-rc1 | [PatchWork v3,0/2](https://lore.kernel.org/lkml/20211201151844.20488-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v4,0/2](https://lore.kernel.org/lkml/20211210093307.31701-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v6,0/2](https://lore.kernel.org/all/20220208094334.16379-1-mgorman@techsingularity.net) |
+| 2020/11/20 | Mel Gorman | [Revisit NUMA imbalance tolerance and fork balancing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=23e6082a522e32232f7377540b4d42d8304253b8) | 解决一个负载平衡问题
之前解决 NUMA Balancing 和 Load Balancing 被调和时, 尝试允许在一定程度的不平衡, 但是也引入了诸多问题. 因此当时限制不平衡只允许在几乎空闲的 NUMA 域. 现在大多数问题都已经解决掉了, 现在[允许不平衡扩大一定的范围](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc48095651f1b85f751eef610b3e034). 同时该补丁还解决了 fork 时候 balance 的问题. 性能测试发现, 这个补丁可以提升约 1.5% unixbench 的跑分, 参见 [e7f28850ea: unixbench.score 1.5% improvement](https://lore.kernel.org/lkml/20201122150415.GJ2390@xsang-OptiPlex-9020) | v3 ☑✓ 5.11-rc1 | [LORE RRC,0/3](https://lore.kernel.org/lkml/20201117134222.31482-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v3,0/4](https://lore.kernel.org/all/20201120090630.3286-1-mgorman@techsingularity.net) |
+| 2021/12/01 | Mel Gorman | [Adjust NUMA imbalance for multiple LLCs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e496132ebedd870b67f1f6d2428f9bb9d7ae27fd) | [commit 7d2b5dd0bcc4 ("sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc4) 允许 NUMA 节点之间的不平衡, 这样通信任务不会被 load balance 分开. 当 LLC 和 node 之间有 1:1 的关系时, 这种方法可以很好地工作, 但是对于多个 LLC, 如果独立的任务过早地使用 CPU 共享缓存, 这种方法就不太理想了. 本系列解决了两个问题:
1. 调度程序域权重的使用不一致, 以及当每个 NUMA 节点有许多 LLC 时性能不佳. NUMA 之间允许的不均衡的进程数目不再是一个固定的值 NUMA_IMBALANCE_MIN(2), 而是在 build_sched_domains() 中实际探测 NUMA 域下辖的 LLC 的数目, 作为 sd->imb_numa_nr. | v4 ☑✓ 5.18-rc1 | [PatchWork v3,0/2](https://lore.kernel.org/lkml/20211201151844.20488-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v4,0/2](https://lore.kernel.org/lkml/20211210093307.31701-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v6,0/2](https://lore.kernel.org/all/20220208094334.16379-1-mgorman@techsingularity.net) |
| 2022/05/11 | Mel Gorman | [Mitigate inconsistent NUMA imbalance behaviour](https://lore.kernel.org/all/20220511143038.4620-1-mgorman@techsingularity.net) | [Linux Patches Aim To Mitigate An Inconsistent Performance / NUMA Imbalancing Issue](https://www.phoronix.com/scan.php?page=news_item&px=Linux-Fix-Inconsistent-NUMA) | v1 ☐☑✓ | [LORE v1,0/4](https://lore.kernel.org/all/20220511143038.4620-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v2,0/4](https://lore.kernel.org/lkml/20220520103519.1863-1-mgorman@techsingularity.net) |
@@ -3221,7 +3190,7 @@ static inline long adjust_numa_imbalance(int imbalance,
v5.18 通过 [Adjust NUMA imbalance for multiple LLCs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e496132ebedd870b67f1f6d2428f9bb9d7ae27fd) 通过在 NUMA Balancing 时考虑到多个 LLC 的情况, 修复了这个问题, 从有效地提升性能. 参见 [2021/12/01, New Linux Scheduler Patches Can Improve AMD Zen Performance For Some Workloads](https://www.phoronix.com/news/Linux-Sched-NUMA-Imbalance-Zen), [2022/02/18, Linux 5.18 Scheduler Change To Further Boost AMD EPYC Performance For Some Workloads](https://www.phoronix.com/scan.php?page=news_item&px=AMD-Linux-5.18-Sched-Zen-LLC).
之前的逻辑: NUMA 域内负载不超过 25% 的时候, 则允许 NUMA 域间保持这种不平衡的状态, 而不会倾向于均衡. 为了方便比较, adjust_numa_imbalance() 中直接使用 nr_running 和 NUMA 域的 CPU 数量 group_weight 比较, 判定 NUMA 域的负载是否超过 25%.
-感知了 NUMA 域内 LLC 的数量后: NUMA 之间允许的不均衡的进程数目不再是一个固定的值整个 NUMA 域 CPU 数量 group_weight 的 25%(group_weight >> 2), 而是在 build_sched_domains() 中实际探测 NUMA 域下辖的 LLC 的数目 sd->imb_numa_nr.
+感知了 NUMA 域内 LLC 的数量后: NUMA 之间允许的不均衡的进程数目不再是一个固定的值整个 NUMA 域 CPU 数量 group_weight 的 25%(group_weight>> 2), 而是在 build_sched_domains() 中实际探测 NUMA 域下辖的 LLC 的数目 sd->imb_numa_nr.
在 AMD 平台测试, 感知了 NUMA 域内的 LLC 数量后, 性能得到了不小的优化:
@@ -3239,22 +3208,22 @@ v5.18 通过 [Adjust NUMA imbalance for multiple LLCs](https://git.kernel.org/pu
当前的调度程序代码只是检查本地组中的任务数是否小于允许的 NUMA 不平衡阈值. 该阈值以前是 25%, 但在 Mel 补丁集 "Adjust NUMA imbalance for multiple LLCs" 中 commit e496132ebedd ("sched/fair: Adjust the allowed NUMA imbalance when SD_NUMA spans multiple LLCs" 现在等于 NUMA 域中的 LLC 数目, 通常情况下这种机制运行良好.
-但是对于进程都通过 numactl/taskset PIN 到一组分散的 CPU 上的情况(比如每个 LLC 域中选一个 CPU), 任务的数量将始终在阈值内, 因此所有 8 个流线程将在第一个 SOCKET 上唤醒, 从而导致次优性能. 在最初的少量 CPU 上堆积之后, 虽然负载平衡器可以工作, 但是稳定的均衡状态, 并且需要频繁的迁移 PING PONG.
我们可以通过检查本地组中允许的 CPU 数量是否少于本地组中运行的任务数量来检测并避免这种堆积, 并使用此信息将本来会堆积的县城分散到下一个 SOCKET 中(毕竟, 这个慢路径的目标是在初始放置期间找到最空闲的组和最空闲的 CPU).
+但是对于进程都通过 numactl/taskset PIN 到一组分散的 CPU 上的情况(比如每个 LLC 域中选一个 CPU), 任务的数量将始终在阈值内, 因此所有 8 个流线程将在第一个 SOCKET 上唤醒, 从而导致次优性能. 在最初的少量 CPU 上堆积之后, 虽然负载平衡器可以工作, 但是稳定的均衡状态, 并且需要频繁的迁移 PING PONG.
我们可以通过检查本地组中允许的 CPU 数量是否少于本地组中运行的任务数量来检测并避免这种堆积, 并使用此信息将本来会堆积的县城分散到下一个 SOCKET 中(毕竟, 这个慢路径的目标是在初始放置期间找到最空闲的组和最空闲的 CPU).
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:----:|:---:|:----------:|:---:|
-| 2021/12/01 | Mel Gorman | [Adjust NUMA imbalance for multiple LLCs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e496132ebedd870b67f1f6d2428f9bb9d7ae27fd) | [commit 7d2b5dd0bcc4 ("sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc4) 允许 NUMA 节点之间的不平衡, 这样通信任务不会被 load balance 分开. 当 LLC 和 node 之间有 1:1 的关系时, 这种方法可以很好地工作, 但是对于多个 LLC, 如果独立的任务过早地使用 CPU 共享缓存, 这种方法就不太理想了. 本系列解决了两个问题:
1. 调度程序域权重的使用不一致, 以及当每个 NUMA 节点有许多 LLC 时性能不佳. NUMA 之间允许的不均衡的进程数目不再是一个固定的值整个 NUMA 域 CPU 数量 group_weight 的 25%(group_weight >> 2), 而是在 build_sched_domains() 中实际探测 NUMA 域下辖的 LLC 的数目, 作为 sd->imb_numa_nr. | v4 ☑✓ 5.18-rc1 | [PatchWork v3,0/2](https://lore.kernel.org/lkml/20211201151844.20488-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v4,0/2](https://lore.kernel.org/lkml/20211210093307.31701-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v6,0/2](https://lore.kernel.org/all/20220208094334.16379-1-mgorman@techsingularity.net) |
+| 2021/12/01 | Mel Gorman | [Adjust NUMA imbalance for multiple LLCs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e496132ebedd870b67f1f6d2428f9bb9d7ae27fd) | [commit 7d2b5dd0bcc4 ("sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc4) 允许 NUMA 节点之间的不平衡, 这样通信任务不会被 load balance 分开. 当 LLC 和 node 之间有 1:1 的关系时, 这种方法可以很好地工作, 但是对于多个 LLC, 如果独立的任务过早地使用 CPU 共享缓存, 这种方法就不太理想了. 本系列解决了两个问题:
1. 调度程序域权重的使用不一致, 以及当每个 NUMA 节点有许多 LLC 时性能不佳. NUMA 之间允许的不均衡的进程数目不再是一个固定的值整个 NUMA 域 CPU 数量 group_weight 的 25%(group_weight>> 2), 而是在 build_sched_domains() 中实际探测 NUMA 域下辖的 LLC 的数目, 作为 sd->imb_numa_nr. | v4 ☑✓ 5.18-rc1 | [PatchWork v3,0/2](https://lore.kernel.org/lkml/20211201151844.20488-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v4,0/2](https://lore.kernel.org/lkml/20211210093307.31701-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v6,0/2](https://lore.kernel.org/all/20220208094334.16379-1-mgorman@techsingularity.net) |
| 2022/05/20 | Mel Gorman | [Mitigate inconsistent NUMA imbalance behaviour](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=026b98a93bbdbefb37ab8008df84e38e2fedaf92) | TODO | v2 ☑✓ 6.0-rc1 | [LORE v1,0/4](https://lore.kernel.org/all/20220511143038.4620-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v2,0/4](https://lore.kernel.org/lkml/20220520103519.1863-1-mgorman@techsingularity.net) |
-| 2022/04/07 | K Prateek Nayak | [sched/fair: Consider cpu affinity when allowing NUMA imbalance in find_idlest_group](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=f5b2eeb49991047f8f64785e7a7857d6f219d574) | 当前的调度程序代码只是检查本地组中的任务数是否小于允许的 NUMA 不平衡阈值. 该阈值以前是 NUMA 域跨度的 25%), 但在 Mel 补丁集 "Adjust NUMA imbalance for multiple LLCs" 中 commit e496132ebedd ("sched/fair: Adjust the allowed NUMA imbalance when SD_NUMA spans multiple LLCs" 现在等于 NUMA 域中的 LLC 数目, 通常情况下这种机制运行良好.
但是对于进程都通过 numactl/taskset PIN 到一组分散的 CPU 上的情况(比如每个 LLC 域中选一个 CPU), 任务的数量将始终在阈值内, 因此所有 8 个流线程将在第一个 SOCKET 上唤醒, 从而导致次优性能. 在最初的少量 CPU 上堆积之后, 虽然负载平衡器可以工作, 但是稳定的均衡状态, 并且需要频繁的迁移 PING PONG.
我们可以通过检查本地组中允许的 CPU 数量是否少于本地组中运行的任务数量来检测并避免这种堆积, 并使用此信息将本来会堆积的县城分散到下一个 SOCKET 中(毕竟, 这个慢路径的目标是在初始放置期间找到最空闲的组和最空闲的 CPU). | v4 ☑✓ 6.0-rc1 | [LORE](https://lore.kernel.org/all/20220217055408.28151-1-kprateek.nayak@amd.com)
*-*-*-*-*-*-*-*
[LORE v7](https://lore.kernel.org/all/20220407111222.22649-1-kprateek.nayak@amd.com) |
+| 2022/04/07 | K Prateek Nayak | [sched/fair: Consider cpu affinity when allowing NUMA imbalance in find_idlest_group](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=f5b2eeb49991047f8f64785e7a7857d6f219d574) | 当前的调度程序代码只是检查本地组中的任务数是否小于允许的 NUMA 不平衡阈值. 该阈值以前是 NUMA 域跨度的 25%), 但在 Mel 补丁集 "Adjust NUMA imbalance for multiple LLCs" 中 commit e496132ebedd ("sched/fair: Adjust the allowed NUMA imbalance when SD_NUMA spans multiple LLCs" 现在等于 NUMA 域中的 LLC 数目, 通常情况下这种机制运行良好.
但是对于进程都通过 numactl/taskset PIN 到一组分散的 CPU 上的情况(比如每个 LLC 域中选一个 CPU), 任务的数量将始终在阈值内, 因此所有 8 个流线程将在第一个 SOCKET 上唤醒, 从而导致次优性能. 在最初的少量 CPU 上堆积之后, 虽然负载平衡器可以工作, 但是稳定的均衡状态, 并且需要频繁的迁移 PING PONG.
我们可以通过检查本地组中允许的 CPU 数量是否少于本地组中运行的任务数量来检测并避免这种堆积, 并使用此信息将本来会堆积的县城分散到下一个 SOCKET 中(毕竟, 这个慢路径的目标是在初始放置期间找到最空闲的组和最空闲的 CPU). | v4 ☑✓ 6.0-rc1 | [LORE](https://lore.kernel.org/all/20220217055408.28151-1-kprateek.nayak@amd.com)
*-*-*-*-*-*-*-*
[LORE v7](https://lore.kernel.org/all/20220407111222.22649-1-kprateek.nayak@amd.com) |
##### 4.6.5.3.7 Allow NUMA imbalance 总结
-------
-CPU 负载均衡器在不同的调度域之间进行平衡, 以分散负载, 并努力使所有的域都达到平等的平衡. 但是由于 NUMA 级别的迁移以及负载均衡开销较大, 需谨慎小心. 之前的负载均衡器并没有考虑这点. 即使在负载较轻的 NUMA 机器上, 两个在唤醒时拉在一起的通信任务(比如 pipeline 通信)本应一直在一个 NUMA 内运行, 但是却被负载均衡器分开. 这在一定程度上造成了性能的下降.
+CPU 负载均衡器在不同的调度域之间进行平衡, 以分散负载, 并努力使所有的域都达到平等的平衡. 但是由于 NUMA 级别的迁移以及负载均衡开销较大, 需谨慎小心. 之前的负载均衡器并没有考虑这点. 即使在负载较轻的 NUMA 机器上, 两个在唤醒时拉在一起的通信任务 (比如 pipeline 通信) 本应一直在一个 NUMA 内运行, 但是却被负载均衡器分开. 这在一定程度上造成了性能的下降.
-1. 因此 v5.6-rc2 [commit b396f52326de ("sched/fair: Allow a small load imbalance between low utilisation SD_NUMA domains")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b396f52326de20ec974471b7b19168867b365cbf) 在系统接近完全空闲时, 允许 NUMA 域上存在两个任务(busiest->sum_nr_running <= imbalance_min == 2)的不平衡. 此时这个逻辑只在 Load Balancing 逻辑 calculate_imbalance() 中生效, 还未扩展到 NUMA Balancing. 在大多数情况下, 这将有效地防止两个相互通信的任务因为负载均衡器被分开到两个 NUMA 域.
+1. 因此 v5.6-rc2 [commit b396f52326de ("sched/fair: Allow a small load imbalance between low utilisation SD_NUMA domains")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b396f52326de20ec974471b7b19168867b365cbf) 在系统接近完全空闲时, 允许 NUMA 域上存在两个任务 (busiest->sum_nr_running <= imbalance_min == 2) 的不平衡. 此时这个逻辑只在 Load Balancing 逻辑 calculate_imbalance() 中生效, 还未扩展到 NUMA Balancing. 在大多数情况下, 这将有效地防止两个相互通信的任务因为负载均衡器被分开到两个 NUMA 域.
2. 随后 v5.7-rc1 [commit fb86f5b21192 ("sched/numa: Use similar logic to the load balancer for moving between domains with spare capacity")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fb86f5b2119245afd339280099b4e9417cc0b03a) 在避免 NUMA Balancing 引入严重的不平衡问题. 将 NUMA 域之间允许的 Small Imbalance 逻辑封装成 adjust_numa_imbalance(), 并将此逻辑扩展到 NUMA Balancing 的 task_numa_compare() 中.
@@ -3313,7 +3282,7 @@ v4.13 引入 NUMA WAKE AFFINE 的时候测试发现, CPU 的空闲造成了 NAS
v3.0 版本 [sched: Reduce runqueue lock contention -v6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=bd8e7dded88a3e1c085c333f19ff31387616f71a) 对唤醒等流程做了 rq->lock LockLess 的优化, 将 try_to_wake_up() 分成了上下两半部分.
-1. 上半部分是不持有 rq->lock 的, 但是[持有 task_struct 的 pi_lock](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2680), 整个 task_struct 的状态检查以及[ select_task_rq()](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2721) 都在这个阶段. 引入了 [task_struct->on_rq](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2687) 以及 [task_struct->on_cpu](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2695) 标记进程的 RUNNABLE 以及 RUNNING 状态, TTWU 阶段通过监听和等待这些状态的更新与变化从而实现无锁化. 参见 [commit e4a52bcb9a18 ("sched: Remove rq->lock from the first half of ttwu()")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e4a52bcb9a18142d79e231b6733cabdbf2e67c1f)
+1. 上半部分是不持有 rq->lock 的, 但是[持有 task_struct 的 pi_lock](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2680), 整个 task_struct 的状态检查以及[select_task_rq()](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2721) 都在这个阶段. 引入了 [task_struct->on_rq](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2687) 以及 [task_struct->on_cpu](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2695) 标记进程的 RUNNABLE 以及 RUNNING 状态, TTWU 阶段通过监听和等待这些状态的更新与变化从而实现无锁化. 参见 [commit e4a52bcb9a18 ("sched: Remove rq->lock from the first half of ttwu()")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e4a52bcb9a18142d79e231b6733cabdbf2e67c1f)
2. 下半部分则持有 rq->lock, 这个阶段[通过 ttwu_queue() 真正完成任务唤醒(主要是任务入队)](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2728), 由于第一阶段已经在不持有任何 rq->lock 的情况下完成了 select_task_rq(), 因此我们可以确保在希望任务运行的实际 CPU 上远程完成唤醒. 引入了 [TTWU_QUEUE sched_features](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2646) 来控制这项工作, 它实际上通过 [ttwu_queue_remote(p, cpu)](https://elixir.bootlin.com/linux/v3.0/source/kernel/sched.c#L2603) 完成. 这避免了必须使用 rq->lock 并远程执行任务入队, 不光节省了大量的 cache remote access, 甚至可能还需要 double_rq_lock() 这种费时费力的操作. 参见 [commit 317f394160e9 ("sched: Move the second half of ttwu() to the remote cpu")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=317f394160e9beb97d19a84c39b7e5eb3d7815a8).
@@ -3325,7 +3294,7 @@ v3.0 版本 [sched: Reduce runqueue lock contention -v6](https://git.kernel.org/
| 2011/04/05 | Peter Zijlstra | [sched: Reduce runqueue lock contention -v6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=bd8e7dded88a3e1c085c333f19ff31387616f71a) | 缩短整个调度路径下 rq->lock 的持有范围, 减少对 rq->lock 锁的竞争. 引入了 task_struct->on_cpu 以及 task_struct->on_rq 标记进程的 RUNNING 以及 RUNNABLE 状态. | v6 ☑✓ 3.0-rc1 | [LORE v6,0/21](https://lore.kernel.org/all/20110405152338.692966333@chello.nl) |
| 2012/09/12 | Peter Zijlstra | [`sched: Remove __ARCH_WANT_INTERRUPTS_ON_CTXSW`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f3e947867478af9a12b9956bcd000ac7613a8a95) | TODO | v1 ☐☑✓ 3.7-rc1 | [LORE](http://lkml.kernel.org/n/tip-g9p2a1w81xxbrze25v9zpzbf@git.kernel.org) |
| 2013/08/09 | Oleg Nesterov | [sched: fix the theoretical signal_wake_up() vs schedule() race](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e0acd0a68ec7dbf6b7a81a87a867ebd7ac9b76c4) | 20130812170257.GA32358@redhat.com | v1 ☑✓ 3.11-rc6 | [LORE v1](https://lore.kernel.org/lkml/20130812170257.GA32358@redhat.com) |
-| 2015/08/03 | tip-bot for Peter Zijlstra | [sched: Introduce the 'trace_sched_waking' tracepoint](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fbd705a0c6184580d0e2fbcbd47a37b6e5822511) | NA | v1 ☑✓ 4.3-rc1 | [LORE](https://lore.kernel.org/all/tip-fbd705a0c6184580d0e2fbcbd47a37b6e5822511@git.kernel.org/) |
+| 2015/08/03 | tip-bot for Peter Zijlstra | [sched: Introduce the'trace_sched_waking'tracepoint](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=fbd705a0c6184580d0e2fbcbd47a37b6e5822511) | NA | v1 ☑✓ 4.3-rc1 | [LORE](https://lore.kernel.org/all/tip-fbd705a0c6184580d0e2fbcbd47a37b6e5822511@git.kernel.org/) |
| 2020/05/24 | Mel Gorman | [Optimise try_to_wake_up() when wakee is descheduling](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=2ebb17717550607bcd85fb8cf7d24ac870e9d762) | 唤醒时如果 wakee 进程正在睡眠或者调度(释放 CPU), 优化在 on_cpu 的自旋等待时间 | v1 ☑ 5.8-rc1 | [LORE 0/2](https://lore.kernel.org/lkml/20200524202956.27665-1-mgorman@techsingularity.net) |
| 2022/08/24 | Peng Wang | [sched/fair: select waker's cpu for wakee on sync wakeup](https://lore.kernel.org/all/1508aa17d1a169077c8d8d8c22d2bd529101af0e.1661313074.git.rocking@linux.alibaba.com) | TODO | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/1508aa17d1a169077c8d8d8c22d2bd529101af0e.1661313074.git.rocking@linux.alibaba.com) |
| 2022/09/16 | Chen Yu | [sched/fair: Choose the CPU where short task is running during wake up](https://lore.kernel.org/all/20220915165407.1776363-1-yu.c.chen@intel.com) | TODO | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20220915165407.1776363-1-yu.c.chen@intel.com)
*-*-*-*-*-*-*-*
[LORE v2,0/2](https://lore.kernel.org/all/cover.1666531576.git.yu.c.chen@intel.com/) |
@@ -3334,7 +3303,7 @@ v3.0 版本 [sched: Reduce runqueue lock contention -v6](https://git.kernel.org/
### 4.7.1.1 TTWU 中的内存屏障
-------
-[<奔跑吧 Linux 内核> 卷2--附录E 关于try_to_wake_up()里的内存屏障使用](https://blog.csdn.net/rlk8888/article/details/123352327)
+[<奔跑吧 Linux 内核> 卷 2-- 附录 E 关于 try_to_wake_up()里的内存屏障使用](https://blog.csdn.net/rlk8888/article/details/123352327)
try_to_wake_up() 中有 4 处内存屏障(Memory Barrier), 截至 v5.8 版本 [try_to_wake_up()](https://elixir.bootlin.com/linux/v5.8/source/kernel/sched/core.c#L2513) 中内存屏障如下所示:
@@ -3402,7 +3371,7 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
| 2009/04/28 | David Howells | [Document memory barriers implied by sleep/wake-up primitives](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=50fa610a3b6ba7cf91d7a92229177dfaff2b81a1) | NA | v1 ☑✓ 2.6.31-rc1 | [LORE](https://lore.kernel.org/all/20090428140138.1192.94723.stgit@warthog.procyon.org.uk) |
| 2018/07/16 | Paul E. McKenney | [sched/Documentation: Update wake_up() & co. memory-barrier guarantees](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7696f9910a9a40b8a952f57d3428515fabd2d889) | [Updates to the formal memory model](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=71b7ff5ebc9b1d5aa95eb48d6388234f1304fd19) 的其中一个补丁. | v1 ☑✓ 4.19-rc1 | [LORE v1,0/14](https://lore.kernel.org/all/20180716180605.16115-12-paulmck@linux.vnet.ibm.com) |
-整个唤醒阶段涉及两个进程(Waker/Wakee)之间的状态交互
+整个唤醒阶段涉及两个进程 (Waker/Wakee) 之间的状态交互
* Wakee 由于某个条件 CONDITION 不满足, 因此不得不阻塞. 这个是一个 {STORE wakee->state, LOAD CONDITION} 的序列.
@@ -3429,7 +3398,7 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
goto out;
```
-由于这两个流程 wakee->state 和 CONDITION 是没有明确的数据依赖关系的, 本地 CPU 上由硬件保证指令即使是乱序执行的, 也是顺序提交的, 不会出问题, 但是 多 CPU 并发场景, 部分架构下(比如 ARM/ARM64 等), 一个变量被 STORE 后, 它在不同 CPU 上的可见性可能并不能按照你所看到的代码(指令)顺序被保证. 不加内存屏障, 就不能假定 Waker 在 LOAD wakee->state 一定能看到 wakee->state 已经被设置为 !TASK_RUNNING. 这样 Wakee 正在睡去, 而 Waker 却误以为它没有阻塞, 这样将错失将其唤醒的机会, 造成 Wakee 永久性阻塞. 这种情况下可以通过加锁或者内存屏障的方式来解决.
+由于这两个流程 wakee->state 和 CONDITION 是没有明确的数据依赖关系的, 本地 CPU 上由硬件保证指令即使是乱序执行的, 也是顺序提交的, 不会出问题, 但是 多 CPU 并发场景, 部分架构下 (比如 ARM/ARM64 等), 一个变量被 STORE 后, 它在不同 CPU 上的可见性可能并不能按照你所看到的代码(指令) 顺序被保证. 不加内存屏障, 就不能假定 Waker 在 LOAD wakee->state 一定能看到 wakee->state 已经被设置为 !TASK_RUNNING. 这样 Wakee 正在睡去, 而 Waker 却误以为它没有阻塞, 这样将错失将其唤醒的机会, 造成 Wakee 永久性阻塞. 这种情况下可以通过加锁或者内存屏障的方式来解决.
[set_current_state()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/diff/include/linux/sched.h?id=b92b8b35a2e38bde319fd1d68ec84628c1f1b0fb) 通过 smp_store_mb() -=> smp_mb() 已经添加了 Wakee 端的内存屏障. 于是 [v2.6.31-rc1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=04e2f1741d235ba599037734878d72e57cb302b5) 在 try_to_wake_up() 函数的入口位置添加了一个内存屏障 [smp_wmb()](https://elixir.bootlin.com/linux/v2.6.25/source/kernel/sched.c#L1842).
@@ -3525,9 +3494,9 @@ v3.0 [commit 317f394160e9 ("sched: Move the second half of ttwu() to the remote
随后 v3.16 进一步减少了 TTWU 路径下的 IPIs.
-1. 首先每次 poll_idle 准备进入 polling 操作之前就通过 [current_set_polling_and_test()](https://elixir.bootlin.com/linux/v3.16/source/drivers/cpuidle/driver.c#L190) 把 TIF_POLLING_NRFLAG 设置, 然后 polling 结束后再通过 current_clr_polling() 将 TIF_POLLING_NRFLAG 标志位清掉. 这样通过[检查 TIF_POLLING_NRFLAG 标记](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=84c407084137d4e491b07ea5ff8665d19106a5ac)就可以知道 CPU 是否处于 polling 状态, 还没有进入 C-state. 这样的 IDLE CPU 是不需要发送 IPI 唤醒的.
+1. 首先每次 poll_idle 准备进入 polling 操作之前就通过 [current_set_polling_and_test()](https://elixir.bootlin.com/linux/v3.16/source/drivers/cpuidle/driver.c#L190) 把 TIF_POLLING_NRFLAG 设置, 然后 polling 结束后再通过 current_clr_polling() 将 TIF_POLLING_NRFLAG 标志位清掉. 这样通过 [检查 TIF_POLLING_NRFLAG 标记](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=84c407084137d4e491b07ea5ff8665d19106a5ac) 就可以知道 CPU 是否处于 polling 状态, 还没有进入 C-state. 这样的 IDLE CPU 是不需要发送 IPI 唤醒的.
-2. 这样唤醒路径下, ttwu_queue_remote() 中, 通过 set_nr_if_polling() 检查对应 wakee CPU 是否处在 polling 状态(直接检查 TIF_POLLING_NRFLAG 标志是否被设置即可)下, 如果是则不需要发送 IPI 去唤醒, 只需要设置抢占标记 nr(TIF_NEED_RESCHED) 即可.
+2. 这样唤醒路径下, ttwu_queue_remote() 中, 通过 set_nr_if_polling() 检查对应 wakee CPU 是否处在 polling 状态 (直接检查 TIF_POLLING_NRFLAG 标志是否被设置即可) 下, 如果是则不需要发送 IPI 去唤醒, 只需要设置抢占标记 nr(TIF_NEED_RESCHED) 即可.
3. 之前都是在 IPI_RESCHEDULE 的处理函数 scheduler_ipi() 中使用 sched_ttwu_pending() 来将本地 wake_list 上的 task 唤醒的, 现在 polling 的 CPU 并不会收到 IPI_RESCHEDULE, 因此 IDLE 的 loop 循环 cpu_idle_loop() 中也需要通过 [sched_ttwu_pending()](https://elixir.bootlin.com/linux/v3.16/source/kernel/sched/idle.c#L249) 来处理唤醒.
@@ -3596,7 +3565,7 @@ v3.0 [commit 317f394160e9 ("sched: Move the second half of ttwu() to the remote
| 时间 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----------:|:---:|
-| 2013/07/04 | Michael wang | [sched: smart wake-affine](https://lore.kernel.org/patchwork/cover/390846) | 引入wakee 翻转次数, 通过巧妙的启发式算法, 识别系统中 1:N/N:M 等唤醒模型, 作为是否进行 wake_affine 的依据 | v3 ☑ 3.12-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/390846)
*-*-*-*-*-*-*-*
[commit 1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=62470419e993f8d9d93db0effd3af4296ecb79a5), [commit2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d9ffa8961482232d964173cccba6e14d2d543b2) |
+| 2013/07/04 | Michael wang | [sched: smart wake-affine](https://lore.kernel.org/patchwork/cover/390846) | 引入 wakee 翻转次数, 通过巧妙的启发式算法, 识别系统中 1:N/N:M 等唤醒模型, 作为是否进行 wake_affine 的依据 | v3 ☑ 3.12-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/390846)
*-*-*-*-*-*-*-*
[commit 1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=62470419e993f8d9d93db0effd3af4296ecb79a5), [commit2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d9ffa8961482232d964173cccba6e14d2d543b2) |
| 2017/12/18 | Mel Gorman | [Reduce scheduler migrations due to wake_affine](https://lore.kernel.org/patchwork/cover/864391) | 优化 wake_affine 减少迁移次数 | | [PatchWork](https://lore.kernel.org/patchwork/cover/864391) |
| 2018/01/30 | Mel Gorman | [Reduce migrations and unnecessary spreading of load to multiple CPUs](https://lore.kernel.org/patchwork/cover/878789) | 减少不合理的迁移 | v1 ☑ 4.16-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/878789) |
| 2021/05/13 | Srikar Dronamraju | [sched/fair: wake_affine improvements](https://lore.kernel.org/patchwork/cover/1416963) | 通过根据 LLC 域内 idle CPU 的信息, 优化 wake_affine, 如果当前待选的 LLC 域没有空闲 CPU, 尝试从之前的 LLC 域中选择. | v3 ☐ | [PatchWork](https://lore.kernel.org/patchwork/cover/1428244) |
@@ -3631,7 +3600,7 @@ Mike Galbraith 调试发现, 触发这个问题的原因是因为 wake_affine_we
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2021/09/20 | Mel Gorman | [Scale wakeup granularity relative to nr_running](https://lore.kernel.org/lkml/20210920142614.4891-1-mgorman@techsingularity.net) | 在任务迁移或唤醒期间, 将决定是否抢占当前任务. 为了限制过度调度, 可以通过设置 sysctl_sched_wakeup_granularity 来延迟抢占, 以便在抢占之前允许至少一定的运行时间. 但是, 当任务堆叠而造成域严重过载时(例如 hackbench 测试), 过度调度的程度仍然很严重. 而且由于许多时间被调度器浪费在重新安排任务(切换等)上, 这会进一步延长过载状态. 这组补丁根据 CPU 上正在运行的任务数在 wakeup_gran() 中扩展唤醒粒度, 默认情况下最大可达 8ms. 其目的是允许任务在过载时运行更长时间, 以便某些任务可以更快地完成, 并降低域过载的程度. | v1 ☐ | [PatchWork v1](https://lore.kernel.org/lkml/20210920142614.4891-1-mgorman@techsingularity.net), [LKML](https://lkml.org/lkml/2021/9/20/478) |
+| 2021/09/20 | Mel Gorman | [Scale wakeup granularity relative to nr_running](https://lore.kernel.org/lkml/20210920142614.4891-1-mgorman@techsingularity.net) | 在任务迁移或唤醒期间, 将决定是否抢占当前任务. 为了限制过度调度, 可以通过设置 sysctl_sched_wakeup_granularity 来延迟抢占, 以便在抢占之前允许至少一定的运行时间. 但是, 当任务堆叠而造成域严重过载时 (例如 hackbench 测试), 过度调度的程度仍然很严重. 而且由于许多时间被调度器浪费在重新安排任务(切换等) 上, 这会进一步延长过载状态. 这组补丁根据 CPU 上正在运行的任务数在 wakeup_gran() 中扩展唤醒粒度, 默认情况下最大可达 8ms. 其目的是允许任务在过载时运行更长时间, 以便某些任务可以更快地完成, 并降低域过载的程度. | v1 ☐ | [PatchWork v1](https://lore.kernel.org/lkml/20210920142614.4891-1-mgorman@techsingularity.net), [LKML](https://lkml.org/lkml/2021/9/20/478) |
| 2021/10/28 | Mel Gorman | [Reduce stacking and overscheduling](https://lkml.org/lkml/2021/10/21/661) | Mike Galbraith 发现引起 CPU 上任务堆积的原因是 wake_affine_weight() 流程与 cpu_load() 更新路径的互不感知造成的, 因此进行了修复. | v1 ☐ | [2021/10/21 LKML 0/2](https://lkml.org/lkml/2021/10/21/661), [2021/10/28 LKML v4 0/2](https://lkml.org/lkml/2021/10/28/226),[LORE 1/1](https://lore.kernel.org/all/20211125151915.8628-1-mgorman@techsingularity.net/), [LORE v4,0/2](https://lore.kernel.org/lkml/20211028094834.1312-1-mgorman@techsingularity.net) |
### 4.7.3 WAKE_UP 选核
@@ -3667,18 +3636,18 @@ Mike Galbraith 调试发现, 触发这个问题的原因是因为 wake_affine_we
[Soft Affinity - When Hard Partitioning Is Too Much](https://blogs.oracle.com/linux/post/soft-affinity-when-hard-partitioning-is-too-much)
-Oracle 数据库具有类似的虚拟化功能, 称为 Oracle Multitenant, 其中根数据库可以作为容器数据库(CDB)并容纳多个轻量级可插拔数据库(PDB), 所有这些都在同一主机中运行. 这允许非常密集的数据库合并部署. 如果对所有数据库实例的 CPU affinity 不加限制, 允许所有实例在没有任何关联的情况下分布在整个系统中, 但是当所有实例都处于繁忙状态时, 这会受到跨套接字的缓存一致性损失. 在这种情况下, 在单个 NUMA 主机中运行工作负载的多个实例时, 最好对它们进行分区, 例如为每个数据库实例提供 NUMA 节点分区以获得最佳性能. 目前, Linux 内核为硬分区实例提供了两个接口: sched_setaffinity() 系统调用或 cpuset.cpus cgroup 接口. 但是这种 CPU affinity 的方式比较强硬, 不允许一个实例突增出其分区, 并在其他分区空闲时使用其潜在可用的 CPU.
+Oracle 数据库具有类似的虚拟化功能, 称为 Oracle Multitenant, 其中根数据库可以作为容器数据库 (CDB) 并容纳多个轻量级可插拔数据库(PDB), 所有这些都在同一主机中运行. 这允许非常密集的数据库合并部署. 如果对所有数据库实例的 CPU affinity 不加限制, 允许所有实例在没有任何关联的情况下分布在整个系统中, 但是当所有实例都处于繁忙状态时, 这会受到跨套接字的缓存一致性损失. 在这种情况下, 在单个 NUMA 主机中运行工作负载的多个实例时, 最好对它们进行分区, 例如为每个数据库实例提供 NUMA 节点分区以获得最佳性能. 目前, Linux 内核为硬分区实例提供了两个接口: sched_setaffinity() 系统调用或 cpuset.cpus cgroup 接口. 但是这种 CPU affinity 的方式比较强硬, 不允许一个实例突增出其分区, 并在其他分区空闲时使用其潜在可用的 CPU.
在通过 autonuma 无法解决问题之后, 因此 Oracle 想要实现一个 Soft Affinity 的方案. RFC 实现除了任务结构中现有的 cpu_allowed CPU 集之外, 还引入了新的 cpu_preferred CPU 集.
-然后对 wakeup 选核的路径做了优化, 在第一级搜索(wake_affine())期间, 期望使用 cpu_preferred 集来查找最后一级缓存的 LLC 域, 第二级在 LLC 域中, 首先搜索 cpu_preferred 集, 然后搜索 cpu_allowed 集中的其余 CPU.
+然后对 wakeup 选核的路径做了优化, 在第一级搜索 (wake_affine()) 期间, 期望使用 cpu_preferred 集来查找最后一级缓存的 LLC 域, 第二级在 LLC 域中, 首先搜索 cpu_preferred 集, 然后搜索 cpu_allowed 集中的其余 CPU.
-这只会更改 wakeup 路径, 但会保持 idle balance 不变. 这是有意为之的, 因为调度程序的一半将尝试从 cpu_preferred 中进行选择, 而另一半则会不加选择地窃取线程, 从而在亲和力中赋予整体"柔软度". 有了这样一个基本的实现, 与在双套接字系统上没有亲缘关系的情况下运行它们相比, 对两个 hackbench 实例和两个数据库实例的实验都显示出改进. 此外, 在只有一个实例运行时, 数据库的性能与没有亲缘关系类似, 但是在 hackbench 中可以看到大量的回归. 这表明在这种情况下, 软亲和力不够软, 因为系统中的所有CPU都没有被利用.
+这只会更改 wakeup 路径, 但会保持 idle balance 不变. 这是有意为之的, 因为调度程序的一半将尝试从 cpu_preferred 中进行选择, 而另一半则会不加选择地窃取线程, 从而在亲和力中赋予整体 "柔软度". 有了这样一个基本的实现, 与在双套接字系统上没有亲缘关系的情况下运行它们相比, 对两个 hackbench 实例和两个数据库实例的实验都显示出改进. 此外, 在只有一个实例运行时, 数据库的性能与没有亲缘关系类似, 但是在 hackbench 中可以看到大量的回归. 这表明在这种情况下, 软亲和力不够软, 因为系统中的所有 CPU 都没有被利用.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2019/06/26 | subhra mazumdar | [Scheduler Soft Affinity](https://lore.kernel.org/lkml/20190626224718.21973-1-subhra.mazumdar@oracle.com) | 为任务提供"软亲和力"的概念, 向调度程序指定在调度任务时首选一组 CPU, 但如果它们不全都繁忙, 则使用其他CPU. | RFC ☐ | [LORE RFC,0/3](https://lore.kernel.org/lkml/20190626224718.21973-1-subhra.mazumdar@oracle.com) |
+| 2019/06/26 | subhra mazumdar | [Scheduler Soft Affinity](https://lore.kernel.org/lkml/20190626224718.21973-1-subhra.mazumdar@oracle.com) | 为任务提供 "软亲和力" 的概念, 向调度程序指定在调度任务时首选一组 CPU, 但如果它们不全都繁忙, 则使用其他 CPU. | RFC ☐ | [LORE RFC,0/3](https://lore.kernel.org/lkml/20190626224718.21973-1-subhra.mazumdar@oracle.com) |
@@ -3707,16 +3676,16 @@ Oracle 数据库具有类似的虚拟化功能, 称为 Oracle Multitenant, 其
调度器最核心的工作就两个内容 :
-- [x] **选进程**: 选择下一个更合适的进程 **pick_next_task**
-- [x] **选核**: 为某个进程选择更合适的 CPU 运行 **select_task_rq**
+- [x] ** 选进程 **: 选择下一个更合适的进程 **pick_next_task**
+- [x] ** 选核 **: 为某个进程选择更合适的 CPU 运行 **select_task_rq**
所有其他的机制都是直接或者间接服务这两个终极任务的.
1. Linux 下各个调度类都实现了这两个接口, 各个调度类按照既定的算法和规则运行, 在选进程这方面, 各个调度类的算法很成熟, 而且经历的改动较小.
-2. 调度的目标是提升系统整体的性能或者降低功耗, 从这些目标上看, 在**选进程**算法既定的情况下, 第二个任务**选核**就会显的更重要也更复杂一些, 选核选的好, 不光能及早的投入运行, 而且在运行时能充分利用 cache 等硬件优势, 让进程飞一般的运行.
+2. 调度的目标是提升系统整体的性能或者降低功耗, 从这些目标上看, 在 ** 选进程 ** 算法既定的情况下, 第二个任务 ** 选核 ** 就会显的更重要也更复杂一些, 选核选的好, 不光能及早的投入运行, 而且在运行时能充分利用 cache 等硬件优势, 让进程飞一般的运行.
-3. 此外现在调度器还有一个附加功能, 为了提升系统整体的吞吐量和利用率, 大多数调度器都提供了 **load_balance 负载均衡** 的功能.
+3. 此外现在调度器还有一个附加功能, 为了提升系统整体的吞吐量和利用率, 大多数调度器都提供了 **load_balance 负载均衡 ** 的功能.
因此我们将这几个工作称为调度器的核心功能. 而调度器的性能优化也都围绕这几个方面来进行.
而其中对性能影响最大的, 也是最关键的任务就是 select_task_rq, 其次是 load_balance, 而 pick_next_task 的工作, 更多的是体现在公平性和扩展性方面.
@@ -3751,7 +3720,7 @@ Oracle 数据库具有类似的虚拟化功能, 称为 Oracle Multitenant, 其
每次为进程选择一个合适的 CPU 的时候, 较好的情况可以通过 wake_affine 等走快速路径, 但是最坏的情况下, 却不得不遍历当前 SD 查找一个 IDLE CPU 或者负载较小的 CPU.
这个查找是一项大工程, 在调度里面几乎是觉难以容忍的. 因此这里一直是性能优化的战场, 炮火味十足.
-2020 年 12 月 15 日, 调度的大 Maintainer Peter Zijlstra, 曾公开抨击选核的慢速流程里面[部分代码, "The thing is, the code as it exists today makes no sense what so ever. It's plain broken batshit."](https://lkml.org/lkml/2020/12/15/93).
+2020 年 12 月 15 日, 调度的大 Maintainer Peter Zijlstra, 曾公开抨击选核的慢速流程里面[部分代码,"The thing is, the code as it exists today makes no sense what so ever. It's plain broken batshit."](https://lkml.org/lkml/2020/12/15/93).
### 5.3.2 select_idle_sibling rework
-------
@@ -3759,32 +3728,30 @@ Oracle 数据库具有类似的虚拟化功能, 称为 Oracle Multitenant, 其
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:----:|:---:|:----------:|:---:|
-| 2016/05/06 | Peter Zijlstra | [sched: select_idle_siblings rewrite](https://lore.kernel.org/lkml/20160509104807.284575300@infradead.org) | 通过这组补丁, 将 select_idle_siblings 中对 sched_domain 上 CPU 的单次扫描替换为 3 个显式的扫描.
1. select_idle_core 在 LLC 域内搜索一个空闲的 CORE
2. select_idle_cpu 在 LLC 域内搜索一个空闲的 CPU.
3. select_idle_smt 在目标 CORE 中搜索一个空闲的 CPU.
select_idle_cpu 中需要遍历 sched_domain 中所有 CPU 查找 idle CPU. 这是一个非常耗时的过程, 因此维护了 sd->avg_scan_cost 类似于查找 idle CPU 的平均耗时. 如果当前 CPU 的 aavg_idle / 512) < avg_cost, 则直接跳过这个流程. | RFC ☑ 4.9-rc1 | [LORE 0/7](https://lore.kernel.org/patchwork/cover/677017), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git/commit/?id=10e2f1acd0106c05229f94c70a344ce3a2c8008b) |
+| 2016/05/06 | Peter Zijlstra | [sched: select_idle_siblings rewrite](https://lore.kernel.org/lkml/20160509104807.284575300@infradead.org) | 通过这组补丁, 将 select_idle_siblings 中对 sched_domain 上 CPU 的单次扫描替换为 3 个显式的扫描.
1. select_idle_core 在 LLC 域内搜索一个空闲的 CORE
2. select_idle_cpu 在 LLC 域内搜索一个空闲的 CPU.
3. select_idle_smt 在目标 CORE 中搜索一个空闲的 CPU.
select_idle_cpu 中需要遍历 sched_domain 中所有 CPU 查找 idle CPU. 这是一个非常耗时的过程, 因此维护了 sd->avg_scan_cost 类似于查找 idle CPU 的平均耗时. 如果当前 CPU 的 aavg_idle / 512) | [select_idle_sibling rework](https://lore.kernel.org/all/20180530142236.667774973@infradead.org) | 优化 select_idle_XXX 的性能. 核心扫描是在有空闲核心的情况下进行的, 它有一个最坏的情况, 我们总是扫描整个 LLC, 以确定在门控之前已经没有空闲核心了. CPU 扫描与剩余的平均空闲时间成正比. 由于 CPU 扫描可能实际上看不到我们自己的兄弟线程 (如果它们在 CPU 空间中很远的地方被枚举), 检查是否有空闲的兄弟线程. Rohit Jain 建议在一个比例搜索 `__select_idle_core()` 中完成所有这三件事. 它使用新的 SMT 拓扑位来执行 core/SMT 迭代. 并且依赖于 select_idle_cpu() 对 nr 的更改. 最总效果就是迭代 @nr 个 CPU, 并选择在任务关联掩码中繁忙线程数量最少的内核中的第一个空闲线程. | RFC ☐☑✓ | [LORE v1,0/11](https://lore.kernel.org/all/20180530142236.667774973@infradead.org) |
| 2019/7/1 | Subhra Mazumdar | [Improve scheduler scalability for fast path](https://lore.kernel.org/patchwork/cover/1094549) | select_idle_cpu 每次遍历 LLC 域查找空闲 CPU 的代价非常高, 因此通过限制搜索边界来减少搜索时间, 进一步通过保留 PER_CPU 的 next_cpu 变量来跟踪上次搜索边界, 来缓解此次优化引入的线程局部化问题 | v3 ☐ | [LWN](https://lwn.net/Articles/757379/), [PatchWork](https://lore.kernel.org/patchwork/cover/1094549/), [lkml](https://lkml.org/lkml/2019/7/1/450), [Blog](https://blogs.oracle.com/linux/linux-scheduler-scalabilty-like-a-boss) |
| 2018/01/30 | Mel Gorman | [Reduce migrations and unnecessary spreading of load to multiple CPUs](https://lore.kernel.org/patchwork/cover/878789) | 通过优化选核逻辑, 减少不必要的迁移 | | |
| 2019/1/21 | Srikar Dronamraju | [sched/fair: Optimize select_idle_core](https://lore.kernel.org/patchwork/patch/1163807) | | | |
| 2019/07/08 | Parth Shah | [Optimize the idle CPU search](https://lore.kernel.org/patchwork/patch/1098092) | 通过标记 idle_cpu 来降低 select_idle_sibling/select_idle_cpu 的搜索开销 | | |
| 2020/04/15 | Valentin Schneider | [sched: Streamline select_task_rq() & select_task_rq_fair()](https://lore.kernel.org/patchwork/patch/1224733) | 选核流程上的重构和优化, 当然除此之外还做了其他操作, 比如清理了 sd->flags 信息, 甚至 sysfs 接口都变成只读了 | v3 ☑ 5.8-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/1224733) |
-| 2021/03/26 | Rik van Riel | [Throttle select_idle_sibling when a target domain is overloaded](https://lore.kernel.org/patchwork/patch/1213189) | 这是 CPU/NUMA 负载平衡器协调的后续工作. 补丁中做了如下的优化
1. 补丁1-2 添加了 schedstats 来跟踪 select_idle_sibling() 的效率. 默认是禁用的
2. 补丁3 是一个细微的优化, 如果一个 CPU 已经找到, 避免清除部分 cpumask.
3. 补丁 4 跟踪在 select_idle_cpu() 期间域是否出现重载, 以便将来的扫描可以在必要时尽早终止. 这减少了在域超载时无用扫描的运行队列数量. | v2 ☐ | [PatchWork](https://lore.kernel.org/patchwork/patch/1213189) |
-| 2021/03/26 | Rik van Riel | [sched/fair: bring back select_idle_smt, but differently](https://lore.kernel.org/patchwork/patch/1402916) | Mel Gorman 上面的补丁在 9fe1f127b913("sched/fair: Merge select_idle_core/cpu()") 中做了一些出色的工作, 从而提高了内核查找空闲cpu的效率, 可以有效地降低任务等待运行的时间. 但是较多的均衡和迁移, 减少的局部性和相应的 L2 缓存丢失的增加会带来一些负面的效应. 这个补丁重新将 `select_idle_smt` 引入回来, 并做了优化, 修复了性能回归, 在搜索所有其他 CPU 之前, 检查 prev 的兄弟 CPU 是否空闲. | v2 ☐ | [PatchWork](https://lore.kernel.org/patchwork/patch/1402916) |
+| 2021/03/26 | Rik van Riel | [Throttle select_idle_sibling when a target domain is overloaded](https://lore.kernel.org/patchwork/patch/1213189) | 这是 CPU/NUMA 负载平衡器协调的后续工作. 补丁中做了如下的优化
1. 补丁 1-2 添加了 schedstats 来跟踪 select_idle_sibling() 的效率. 默认是禁用的 < br>2. 补丁 3 是一个细微的优化, 如果一个 CPU 已经找到, 避免清除部分 cpumask.
3. 补丁 4 跟踪在 select_idle_cpu() 期间域是否出现重载, 以便将来的扫描可以在必要时尽早终止. 这减少了在域超载时无用扫描的运行队列数量. | v2 ☐ | [PatchWork](https://lore.kernel.org/patchwork/patch/1213189) |
+| 2021/03/26 | Rik van Riel | [sched/fair: bring back select_idle_smt, but differently](https://lore.kernel.org/patchwork/patch/1402916) | Mel Gorman 上面的补丁在 9fe1f127b913("sched/fair: Merge select_idle_core/cpu()") 中做了一些出色的工作, 从而提高了内核查找空闲 cpu 的效率, 可以有效地降低任务等待运行的时间. 但是较多的均衡和迁移, 减少的局部性和相应的 L2 缓存丢失的增加会带来一些负面的效应. 这个补丁重新将 `select_idle_smt` 引入回来, 并做了优化, 修复了性能回归, 在搜索所有其他 CPU 之前, 检查 prev 的兄弟 CPU 是否空闲. | v2 ☐ | [PatchWork](https://lore.kernel.org/patchwork/patch/1402916) |
### 5.3.3 SIS_AVG_CPU
-------
-[commit 4c77b18cf8b7 sched/fair: Make select_idle_cpu() more aggressive](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4c77b18cf8b7ab37c7d5737b4609010d2ceec5f0) 增加了 SIS_AVG_CPU 开关. 在唤醒选核的快速路径上, 开启此开关, 在一定条件下, 可以跳过 select_idle_cpu(). 避免对 LLC 调度域的过度扫描. 这是一把双刃剑, 在一些场景, 可以让系统负载更均衡一些, 但是同时也引入了开销, 对唤醒延时和进程 cache 都有负面影响.
-
-> "When doing wakeups, attempt to limit superfluous scans of the LLC domain."
+[commit 4c77b18cf8b7 sched/fair: Make select_idle_cpu() more aggressive](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4c77b18cf8b7ab37c7d5737b4609010d2ceec5f0) 增加了 SIS_AVG_CPU 开关. 在唤醒选核的快速路径上, 开启此开关, 在一定条件下, 可以跳过 select_idle_cpu(). 避免对 LLC 调度域的过度扫描. 这是一把双刃剑, 在一些场景, 可以让系统负载更均衡一些, 但是同时也引入了开销, 对唤醒延时和进程 cache 都有负面影响.> "When doing wakeups, attempt to limit superfluous scans of the LLC domain."
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:----:|:---:|:----------:|:---:|
-| 2016/05/06 | Peter Zijlstra | [sched: select_idle_siblings rewrite](https://lore.kernel.org/lkml/20160509104807.284575300@infradead.org) | 通过这组补丁, 将 select_idle_siblings 中对 sched_domain 上 CPU 的单次扫描替换为 3 个显式的扫描.
当前关注 select_idle_cpu() 中为了限制 for_each_cpu_wrap 遍历的开销. 因此当 `avg_idle / 512) < avg_cost` 时直接返回 -1. 不再尝试查找 idle CPU. 这个条件对于 hackbench 等测试对这里是非常敏感的. | RFC ☑ 4.9-rc1 | [LORE 0/7](https://lore.kernel.org/patchwork/cover/677017), [关注 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git/commit/?id=10e2f1acd0106c05229f94c70a344ce3a2c8008b) |
-| 2016/12/08 | Vincent Guittot | [sched: improve spread of tasks during fork](https://lore.kernel.org/all/1481216215-24651-1-git-send-email-vincent.guittot@linaro.org) | select_idle_cpu() 中 `(avg_idle / 512) < avg_cost` 的条件, 引发了 hackbench 以及进程 fork 的性能回归. 1. hackbench 劣化的原因是因为这个条件导致了负载较小的 select_idle_cpu() 选核策略总是被跳过.
2. fork 劣化的原因则是因为这个条件跳过了 select_idle_cpu() 从而导致进程无法被分散到各个 CPU 上.
但是在 fork 过程中, task_util 在 fork 的过程中其实是没有参考意义的, 因此 find_idlest_group() 查询空余容量是是否满足 task_util(p) 是不合适的. 直接跳过这个流程. | v3 ☑ v4.11-rc2 | [LORE v3,0/2](https://lore.kernel.org/all/1481216215-24651-1-git-send-email-vincent.guittot@linaro.org), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f519a3f1c6b7a990e5aed37a8f853c6ecfdee945) |
-| 2017/03/01 | Peter Zijlstra | [sched/fair: Make select_idle_cpu() more aggressive](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4c77b18cf8b7ab37c7d5737b4609010d2ceec5f0) | 引入 SIS_AVG_CPU.
Kitsunyan 报告了他 Celeron 887 机器上的桌面延迟问题, 这是由 [commit 1b568f0aabf2 ("sched/core: Optimize SCHED_SMT")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1b568f0aabf2) 引起的, 尽管他的机器不会使用 SMT. 这个引起劣化的补丁引入 static_key sched_smt_present 在非 SMT 的机器上跳过了之前为 SMT 设计的选核路径. 导致这个问题的原因是在非 SMT 的机器上运行 SMT 代码的效果基本上类似于 select_idle_cpu() 的作用, 而 select_idle_cpu() 被平均 IDLE 时间检查的条件 `(avg_idle / 512) < avg_cost` 阻断了.
最终测试发现移除这个阻断条件 select_idle_cpu() 中的对 Kitsunyan 的这个场景有好处. 社区之前 facebook 也建议取消这个条件, 但是的确有一些其他工作负载对这个条件很友好. 因此引入 SIS_AVG_CPU 开关, 默认禁用它, 但是可以动态开启. | v1 ☑ v4.11-rc2 | [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4c77b18cf8b7ab37c7d5737b4609010d2ceec5f0) |
-| 2020/12/03 | Mel Gorman | [Reduce time complexity of select_idle_sibling](https://lore.kernel.org/patchwork/cover/1348877) | 通过自己完善的 schedstat 的统计信息, 发现 select_idle_XXX 中不合理的地方(提高了p->recent_used_cpu的命中率. 以减少扫描开销, 同时如果在扫描a时发现了一个候选, 那么补丁4将返回一个空闲的候选免费的核心等), 降低搜索开销 | RFC v3 ☐ | 这组补丁其实有很多名字, 作者发了几版本之后, 不断重构, 也改了名字
*-*-*-*-*-*-*-*
2020/12/03 [Reduce time complexity of select_idle_sibling RFC,00/10](https://lore.kernel.org/patchwork/cover/1348877)
*-*-*-*-*-*-*-*
2020/12/07 RFC [Reduce worst-case scanning of runqueues in select_idle_sibling 0/4](https://lore.kernel.org/patchwork/cover/1350248)
*-*-*-*-*-*-*-*
2020/12/08 [Reduce scanning of runqueues in select_idle_sibling 0/4](https://lore.kernel.org/patchwork/patch/1350876)
*-*-*-*-*-*-*-*
后面换标题名重发 [Scan for an idle sibling in a single pass](https://lore.kernel.org/patchwork/cover/1371921) |
-| 2020/12/08 | Mel Gorman | [Scan for an idle sibling in a single pass](https://lore.kernel.org/all/20210125085909.4600-1-mgorman@techsingularity.net) | 将上面一组补丁 [Reduce time complexity of select_idle_sibling](https://lore.kernel.org/patchwork/cover/1348877), 基于上面 Peter 的补丁的思路进行了重构, 减少 select_idle_XXX 的开销. 降低最坏情况下 select_idle_sibling 扫描运行队列的开销: 在选核时, 需要调用 select_idle_core() 和 select_idle_cpu() 分层扫描 SMT 和 core 等层次, 这两个层次覆盖的 CPU 有重复的, 优化扫描算法, 避免重复扫描 CPU, 降低开销.
1. 优化了 IDLE_CPU 扫描深度的计算方法
2. 减少了 CPU 的遍历次数, 重构了 sched_idle_XXX 函数
3. (前两个补丁)将空闲的核心扫描调节机制转换为 SIS_PROP, 删除了 SIS_PROP_CPU. [v5.12-rc1 合入](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=bae4ec13640b0915e7dd86da7e65c5d085160571) | v4 ☑ 5.12-rc1 | [LORE v4,0/4 Merged](https://lore.kernel.org/all/20210125085909.4600-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v5,0/4](https://lore.kernel.org/lkml/20210127135203.19633-1-mgorman@techsingularity.net) |
+| 2016/05/06 | Peter Zijlstra | [sched: select_idle_siblings rewrite](https://lore.kernel.org/lkml/20160509104807.284575300@infradead.org) | 通过这组补丁, 将 select_idle_siblings 中对 sched_domain 上 CPU 的单次扫描替换为 3 个显式的扫描.
当前关注 select_idle_cpu() 中为了限制 for_each_cpu_wrap 遍历的开销. 因此当 `avg_idle / 512) | [sched: improve spread of tasks during fork](https://lore.kernel.org/all/1481216215-24651-1-git-send-email-vincent.guittot@linaro.org) | select_idle_cpu() 中 `(avg_idle / 512) 2. fork 劣化的原因则是因为这个条件跳过了 select_idle_cpu() 从而导致进程无法被分散到各个 CPU 上.
但是在 fork 过程中, task_util 在 fork 的过程中其实是没有参考意义的, 因此 find_idlest_group() 查询空余容量是是否满足 task_util(p) 是不合适的. 直接跳过这个流程. | v3 ☑ v4.11-rc2 | [LORE v3,0/2](https://lore.kernel.org/all/1481216215-24651-1-git-send-email-vincent.guittot@linaro.org), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f519a3f1c6b7a990e5aed37a8f853c6ecfdee945) |
+| 2017/03/01 | Peter Zijlstra | [sched/fair: Make select_idle_cpu() more aggressive](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4c77b18cf8b7ab37c7d5737b4609010d2ceec5f0) | 引入 SIS_AVG_CPU.
Kitsunyan 报告了他 Celeron 887 机器上的桌面延迟问题, 这是由 [commit 1b568f0aabf2 ("sched/core: Optimize SCHED_SMT")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1b568f0aabf2) 引起的, 尽管他的机器不会使用 SMT. 这个引起劣化的补丁引入 static_key sched_smt_present 在非 SMT 的机器上跳过了之前为 SMT 设计的选核路径. 导致这个问题的原因是在非 SMT 的机器上运行 SMT 代码的效果基本上类似于 select_idle_cpu() 的作用, 而 select_idle_cpu() 被平均 IDLE 时间检查的条件 `(avg_idle / 512) 最终测试发现移除这个阻断条件 select_idle_cpu() 中的对 Kitsunyan 的这个场景有好处. 社区之前 facebook 也建议取消这个条件, 但是的确有一些其他工作负载对这个条件很友好. 因此引入 SIS_AVG_CPU 开关, 默认禁用它, 但是可以动态开启. | v1 ☑ v4.11-rc2 | [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4c77b18cf8b7ab37c7d5737b4609010d2ceec5f0) |
+| 2020/12/03 | Mel Gorman | [Reduce time complexity of select_idle_sibling](https://lore.kernel.org/patchwork/cover/1348877) | 通过自己完善的 schedstat 的统计信息, 发现 select_idle_XXX 中不合理的地方(提高了 p->recent_used_cpu 的命中率. 以减少扫描开销, 同时如果在扫描 a 时发现了一个候选, 那么补丁 4 将返回一个空闲的候选免费的核心等), 降低搜索开销 | RFC v3 ☐ | 这组补丁其实有很多名字, 作者发了几版本之后, 不断重构, 也改了名字
*-*-*-*-*-*-*-*
2020/12/03 [Reduce time complexity of select_idle_sibling RFC,00/10](https://lore.kernel.org/patchwork/cover/1348877)
*-*-*-*-*-*-*-*
2020/12/07 RFC [Reduce worst-case scanning of runqueues in select_idle_sibling 0/4](https://lore.kernel.org/patchwork/cover/1350248)
*-*-*-*-*-*-*-*
2020/12/08 [Reduce scanning of runqueues in select_idle_sibling 0/4](https://lore.kernel.org/patchwork/patch/1350876)
*-*-*-*-*-*-*-*
后面换标题名重发 [Scan for an idle sibling in a single pass](https://lore.kernel.org/patchwork/cover/1371921) |
+| 2020/12/08 | Mel Gorman | [Scan for an idle sibling in a single pass](https://lore.kernel.org/all/20210125085909.4600-1-mgorman@techsingularity.net) | 将上面一组补丁 [Reduce time complexity of select_idle_sibling](https://lore.kernel.org/patchwork/cover/1348877), 基于上面 Peter 的补丁的思路进行了重构, 减少 select_idle_XXX 的开销. 降低最坏情况下 select_idle_sibling 扫描运行队列的开销: 在选核时, 需要调用 select_idle_core() 和 select_idle_cpu() 分层扫描 SMT 和 core 等层次, 这两个层次覆盖的 CPU 有重复的, 优化扫描算法, 避免重复扫描 CPU, 降低开销.
1. 优化了 IDLE_CPU 扫描深度的计算方法
2. 减少了 CPU 的遍历次数, 重构了 sched_idle_XXX 函数
3. (前两个补丁)将空闲的核心扫描调节机制转换为 SIS_PROP, 删除了 SIS_PROP_CPU. [v5.12-rc1 合入](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=bae4ec13640b0915e7dd86da7e65c5d085160571) | v4 ☑ 5.12-rc1 | [LORE v4,0/4 Merged](https://lore.kernel.org/all/20210125085909.4600-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v5,0/4](https://lore.kernel.org/lkml/20210127135203.19633-1-mgorman@techsingularity.net) |
### 5.3.4 SIS_PROP
-------
@@ -3795,7 +3762,7 @@ Oracle 数据库具有类似的虚拟化功能, 称为 Oracle Multitenant, 其
|:----:|:----:|:----:|:---:|:----------:|:---:|
| 2017/05/17 | Peter Zijlstra | [sched/core: Implement new approach to scale select_idle_cpu()](https://lore.kernel.org/all/20170517105350.hk5m4h4jb6dfr65a@hirez.programming.kicks-ass.net) | [commit: c743f0a5c50f ("sched/fair, cpumask: Export for_each_cpu_wrap()")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c743f0a5c50f) 它修复了初始 for_each_cpu_wrap() 实现中的一个 BUG, 这个 BUG 使 select_idle_cpu() 更加昂贵. 错误在于当位掩码中的位是相应的时, 它会跳过 CPU. 虽然是个 BUG, 但是给了一个修复 select_idle_cpu() 的灵感, 旧的方案是在空闲扫描上使用悬崖边缘节流, 这个补丁引入了一种更渐进的方法, 增加了一个开关 SIS_PROP, 限制了扫描 cpu 的数量, 而不是像 SIS_AVG_CPU 那样完全停止扫描. 最初的基准测试显示, 它基本上恢复了 hackbench 和, 除了 Mason 的 schbench, 没有损害其他任何 benchmark 的性能. | v1 ☑ 4.13-rc1 | [LORE](https://lore.kernel.org/all/20170517105350.hk5m4h4jb6dfr65a@hirez.programming.kicks-ass.net), [关注 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git/commit/?id=1ad3aaf3fcd2444406628a19a9b9e0922b95e2d4) |
| 2020/12/14 | Peter Zijlstra | [select_idle_sibling() wreckage](https://lore.kernel.org/patchwork/cover/1353496) | 重构 SIS_PROP 的逻辑, 重新计算 CPU 的扫描成本, 同时归一 select_idle_XXX 中对 CPU 的遍历, 统一选核的搜索逻辑来降低开销, 提升性能 | RFC ☐ | [PatchWork](https://lore.kernel.org/patchwork/cover/1353496), [LKML](https://lkml.org/lkml/2020/12/14/560) |
-| 2020/12/08 | Mel Gorman | [Scan for an idle sibling in a single pass](https://lore.kernel.org/all/20210125085909.4600-1-mgorman@techsingularity.net) | 将上面一组补丁 [Reduce time complexity of select_idle_sibling](https://lore.kernel.org/patchwork/cover/1348877), 基于上面 Peter 的补丁的思路进行了重构, 减少 select_idle_XXX 的开销. 降低最坏情况下 select_idle_sibling 扫描运行队列的开销: 在选核时, 需要调用 select_idle_core() 和 select_idle_cpu() 分层扫描 SMT 和 core 等层次, 这两个层次覆盖的 CPU 有重复的, 优化扫描算法, 避免重复扫描 CPU, 降低开销.
1. 优化了 IDLE_CPU 扫描深度的计算方法
2. 将空闲的核心扫描调节机制转换为 SIS_PROP, 删除了 SIS_PROP_CPU.
3. [后两个补丁](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9fe1f127b913318c631d0041ecf71486e38c2c2d) 减少了 CPU 的遍历次数, 重构了 sched_idle_XXX 函数, 移除了 select_idle_smt(). select_idle_core() 和 select_idle_cpu() 都对同一个 cpumask 执行循环, 通过记录已经访问过的 CPU, 可以减少迭代次数. 只需要记住在扫描空闲核时遇到的任何非空闲 CPU. 这样每个 CPU 只遍历一次. | v4 ☑ 5.12-rc1 | [LORE v4,0/4 Merged](https://lore.kernel.org/all/20210125085909.4600-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v5,0/4](https://lore.kernel.org/lkml/20210127135203.19633-1-mgorman@techsingularity.net) |
+| 2020/12/08 | Mel Gorman | [Scan for an idle sibling in a single pass](https://lore.kernel.org/all/20210125085909.4600-1-mgorman@techsingularity.net) | 将上面一组补丁 [Reduce time complexity of select_idle_sibling](https://lore.kernel.org/patchwork/cover/1348877), 基于上面 Peter 的补丁的思路进行了重构, 减少 select_idle_XXX 的开销. 降低最坏情况下 select_idle_sibling 扫描运行队列的开销: 在选核时, 需要调用 select_idle_core() 和 select_idle_cpu() 分层扫描 SMT 和 core 等层次, 这两个层次覆盖的 CPU 有重复的, 优化扫描算法, 避免重复扫描 CPU, 降低开销.
1. 优化了 IDLE_CPU 扫描深度的计算方法
2. 将空闲的核心扫描调节机制转换为 SIS_PROP, 删除了 SIS_PROP_CPU.
3. [后两个补丁](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9fe1f127b913318c631d0041ecf71486e38c2c2d) 减少了 CPU 的遍历次数, 重构了 sched_idle_XXX 函数, 移除了 select_idle_smt(). select_idle_core() 和 select_idle_cpu() 都对同一个 cpumask 执行循环, 通过记录已经访问过的 CPU, 可以减少迭代次数. 只需要记住在扫描空闲核时遇到的任何非空闲 CPU. 这样每个 CPU 只遍历一次. | v4 ☑ 5.12-rc1 | [LORE v4,0/4 Merged](https://lore.kernel.org/all/20210125085909.4600-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v5,0/4](https://lore.kernel.org/lkml/20210127135203.19633-1-mgorman@techsingularity.net) |
| 2021/03/26 | Rik van Riel | [sched/fair: bring back select_idle_smt, but differently](https://lore.kernel.org/patchwork/patch/1402916) | Mel Gorman 上面的补丁在 9fe1f127b913("sched/fair: Merge select_idle_core/cpu()") 中做了一些出色的工作, 从而提高了内核查找空闲 CPU 的效率, 可以有效地降低任务等待运行的时间. 但是较多的均衡和迁移, 减少的局部性和相应的 L2 缓存丢失的增加会带来一些负面的效应. 这个补丁重新将 `select_idle_smt` 引入回来, 并做了优化, 修复了性能回归, 在搜索所有其他 CPU 之前, 检查 prev 的兄弟 CPU 是否空闲. | v2 ☑ v5.12-rc7 | [PatchWork](https://lore.kernel.org/patchwork/patch/1402916), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c722f35b513f807629603bbf24640b1a48be21b5) |
| 2021/07/26 | Mel Gorman | [Modify and/or delete SIS_PROP](https://lore.kernel.org/patchwork/cover/1467090) | NA | RFC | [PatchWork RFC,0/9](https://lore.kernel.org/patchwork/cover/1467090) |
| 2021/08/04 | Mel Gorman | [Reduce SIS scanning](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=56498cfb045d7147cdcba33795d19429afcd1d00) | 将 [Modify and/or delete SIS_PROP](https://lore.kernel.org/patchwork/cover/1467090) 拆开进行提交. | RFC ☐ | [PatchWork 0/2](https://lore.kernel.org/lkml/20210804115857.6253-1-mgorman@techsingularity.net) |
@@ -3815,7 +3782,7 @@ Oracle 数据库具有类似的虚拟化功能, 称为 Oracle Multitenant, 其
* sum_util 到 nr_scan 的映射(抛物线顶点坐标方程)
-随后[在 Peter 的建议](https://lore.kernel.org/lkml/20220207135253.GF23216@worktop.programming.kicks-ass.net)下, Chen Yu 在 V2 实现了一种 [util_avg 到扫描 CPU 数量 nr_idle_scan 的线性映射 f(x)](https://lore.kernel.org/all/20220310005228.11737-1-yu.c.chen@intel.com). 算法改进为了一种[基于 util_avg 来处理 SIS_PROP 的方法](https://lore.kernel.org/all/20220207034013.599214-1-yu.c.chen@intel.com), 其主要思想是用基于域的度量来代替平均 CPU 空闲时间. 选择平均 CPU 利用率 (util_avg) 作为候选者.
+随后 [在 Peter 的建议](https://lore.kernel.org/lkml/20220207135253.GF23216@worktop.programming.kicks-ass.net) 下, Chen Yu 在 V2 实现了一种 [util_avg 到扫描 CPU 数量 nr_idle_scan 的线性映射 f(x)](https://lore.kernel.org/all/20220310005228.11737-1-yu.c.chen@intel.com). 算法改进为了一种[基于 util_avg 来处理 SIS_PROP 的方法](https://lore.kernel.org/all/20220207034013.599214-1-yu.c.chen@intel.com), 其主要思想是用基于域的度量来代替平均 CPU 空闲时间. 选择平均 CPU 利用率 (util_avg) 作为候选者.
通常, 要扫描的 CPU 数量应该与该域中 util_avg 的总和成反比. 也就是说, util_avg 越低, select_idle_cpu() 应该扫描更多空闲 CPU, 反之亦然. 选择 util_avg 的好处是, 它是累计历史活动的度量, 似乎比瞬时度量 (如 rq->nr_running) 更准确. 此外, 还可以从周期性负载平衡中借用 util_avg, 这可以减轻 select_idle_cpu() 的开销.
@@ -3865,18 +3832,18 @@ y = (1 - \frac{pct^{2}}{10000^{2}} \times x^{2}) \times llc\_weight
不管是 SIS_AVG_CPU 还是 SIS_PROP 阻断和限制 select_idle_cpu() 的现实意义都是: 不要花比 CPU 空闲时间更多的时间来扫描空闲 CPU, 否则对性能不会有任何改观, 反而会造成进程相互之间争抢 CPU.
-早期 SIS_AVG_CPU/SIS_PROP 中 select_idle_cpu() 比较查询 IDLE CPU 的开销以及 CPU 空闲时间使用的是之前 [commit 1b9508f6831e ("sched: Rate-limit newidle")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1b9508f6831e10d53256825de8904caa22d1ca2c) 所引入的 CPU 平均 IDLE 时间 rq->avg_idle.这其实是非常不合适的. 因此 [commit 94aafc3ee31d ("sched/fair: Age the average idle time")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=94aafc3ee31dc199d1078ffac9edd976b7f47b3d) 为 wakeup 路径 select_idle_cpu() 重新计算了 CPU 的空闲时间 rq->wake_avg_idle, 这个时间刨去了 select_idle_cpu() 的耗时, 并每个 jiffies 衰减为原来的一半.
+早期 SIS_AVG_CPU/SIS_PROP 中 select_idle_cpu() 比较查询 IDLE CPU 的开销以及 CPU 空闲时间使用的是之前 [commit 1b9508f6831e ("sched: Rate-limit newidle")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1b9508f6831e10d53256825de8904caa22d1ca2c) 所引入的 CPU 平均 IDLE 时间 rq->avg_idle. 这其实是非常不合适的. 因此 [commit 94aafc3ee31d ("sched/fair: Age the average idle time")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=94aafc3ee31dc199d1078ffac9edd976b7f47b3d) 为 wakeup 路径 select_idle_cpu() 重新计算了 CPU 的空闲时间 rq->wake_avg_idle, 这个时间刨去了 select_idle_cpu() 的耗时, 并每个 jiffies 衰减为原来的一半.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:----:|:---:|:----------:|:---:|
-| 2021/06/15 | Peter Zijlstra | [sched/fair: Age the average idle time](https://lore.kernel.org/patchwork/patch/1446838) | Peter Zijlstra [RFC select_idle_sibling rework 00/11](https://lore.kernel.org/lkml/20180530143105.977759909@infradead.org) 的其中[一个补丁](https://lore.kernel.org/lkml/20180530142236.667774973@infradead.org), 被 Mel Gorman 重写后合入主线.
当前, select_idle_cpu() 中限制 CPU 遍历层数的比例方案借用的是 CPU 平均空闲等待时间 rq->avg_idle, 这在时间上是有挑战的. 当 CPU 完全不空闲时, rq->avg_idle 将不具代表性. 为了解决这个问题, 引入一个单独的平均空闲时间 wake_avg_idle 并对它进行定期的老化.
1. 总的目标是不要花比 CPU 空闲时间更多的时间来扫描空闲 CPU. 否则性能不会有任何改观. 这意味着我们需要考虑连续空闲期间所有唤醒的成本. 为了跟踪这一点, 扫描成本从估计的平均空闲时间中减去.
2. 这个补丁的影响与具有完全繁忙或过载域的工作负载有关. 如果没有补丁, 可能会由于 CPU 未达到空闲状态, 导致扫描深度过高. 当域几乎完全繁忙或过载时, 这个补丁则有明显作用, 此时搜索可能会失败, 但空闲不会老化, 因为 cpu 处于活动状态, 所以搜索深度太大而无用. 当有空闲 cpu 时, 它可能会显示回归, 而深度搜索是有益的. 这个 tbench 结果在一个 2 插槽宽井机部分说明了这个问题. | v1 ☑ v5.13-rc6 | [LORE v2](https://lore.kernel.org/all/20210615111611.GH30378@techsingularity.net), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=94aafc3ee31dc199d1078ffac9edd976b7f47b3d) |
+| 2021/06/15 | Peter Zijlstra | [sched/fair: Age the average idle time](https://lore.kernel.org/patchwork/patch/1446838) | Peter Zijlstra [RFC select_idle_sibling rework 00/11](https://lore.kernel.org/lkml/20180530143105.977759909@infradead.org) 的其中[一个补丁](https://lore.kernel.org/lkml/20180530142236.667774973@infradead.org), 被 Mel Gorman 重写后合入主线.
当前, select_idle_cpu() 中限制 CPU 遍历层数的比例方案借用的是 CPU 平均空闲等待时间 rq->avg_idle, 这在时间上是有挑战的. 当 CPU 完全不空闲时, rq->avg_idle 将不具代表性. 为了解决这个问题, 引入一个单独的平均空闲时间 wake_avg_idle 并对它进行定期的老化.
1. 总的目标是不要花比 CPU 空闲时间更多的时间来扫描空闲 CPU. 否则性能不会有任何改观. 这意味着我们需要考虑连续空闲期间所有唤醒的成本. 为了跟踪这一点, 扫描成本从估计的平均空闲时间中减去.
2. 这个补丁的影响与具有完全繁忙或过载域的工作负载有关. 如果没有补丁, 可能会由于 CPU 未达到空闲状态, 导致扫描深度过高. 当域几乎完全繁忙或过载时, 这个补丁则有明显作用, 此时搜索可能会失败, 但空闲不会老化, 因为 cpu 处于活动状态, 所以搜索深度太大而无用. 当有空闲 cpu 时, 它可能会显示回归, 而深度搜索是有益的. 这个 tbench 结果在一个 2 插槽宽井机部分说明了这个问题. | v1 ☑ v5.13-rc6 | [LORE v2](https://lore.kernel.org/all/20210615111611.GH30378@techsingularity.net), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=94aafc3ee31dc199d1078ffac9edd976b7f47b3d) |
### 5.3.6 分级搜索
-------
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2020/07/28 | Xi Wang | [sched: Make select_idle_sibling search domain configurable](https://lore.kernel.org/all/20200728070131.1629670-1-xii@google.com) | select_idle_sibling() 空闲 CPU 搜索的范围是 LLC 域. 这对于 AMD 的 CCX 架构来说是一个问题, 因为 sd_llc 只有 4 个核. 在多核机器上, 搜索范围太小, 无法达到令人满意的统计复用/有效利用短空闲时间片的水平. 、这个补丁, 空闲的兄弟搜索就可以从 LLC 中分离出来, 并且可以在运行时进行配置. 为了减少搜索和迁移开销, 添加了一个预搜索域(presearch domain). 在对"主搜索域(main search)"搜索之前, 会先在预搜索域内进行搜索, 例如: sysctl_sched_wake_idle_domain == 2 ("MC" 域, 即 LLC), sysctl_sched_wake_idle_presearch_domain == 1 ("DIE" 域), Presearch 将遍历一个 MC 域的 4 个核心. 如果在预搜索过程中没有找到空闲的 CPU, 则全搜索将遍历 DIE 域内 CPU的剩余内核. 包括 sd->avg_scan_cost 和 sds->have_idle_cores 在内的启发式算法只在主搜索时有效. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20200728070131.1629670-1-xii@google.com) |
+| 2020/07/28 | Xi Wang | [sched: Make select_idle_sibling search domain configurable](https://lore.kernel.org/all/20200728070131.1629670-1-xii@google.com) | select_idle_sibling() 空闲 CPU 搜索的范围是 LLC 域. 这对于 AMD 的 CCX 架构来说是一个问题, 因为 sd_llc 只有 4 个核. 在多核机器上, 搜索范围太小, 无法达到令人满意的统计复用 / 有效利用短空闲时间片的水平. 、这个补丁, 空闲的兄弟搜索就可以从 LLC 中分离出来, 并且可以在运行时进行配置. 为了减少搜索和迁移开销, 添加了一个预搜索域(presearch domain). 在对 "主搜索域(main search)" 搜索之前, 会先在预搜索域内进行搜索, 例如: sysctl_sched_wake_idle_domain == 2 ("MC" 域, 即 LLC), sysctl_sched_wake_idle_presearch_domain == 1 ("DIE" 域), Presearch 将遍历一个 MC 域的 4 个核心. 如果在预搜索过程中没有找到空闲的 CPU, 则全搜索将遍历 DIE 域内 CPU 的剩余内核. 包括 sd->avg_scan_cost 和 sds->have_idle_cores 在内的启发式算法只在主搜索时有效. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20200728070131.1629670-1-xii@google.com) |
@@ -3888,7 +3855,7 @@ y = (1 - \frac{pct^{2}}{10000^{2}} \times x^{2}) \times llc\_weight
在最后一级缓存中, 可以有多个 cluster, 每个 cluster 下的多个 CPU 有一些共享资源.
-例如 ARM64 机器(如 kunpeng920)和 x86 机器(如 Jacobsville)具有一定的硬件拓扑级别 cluster, 其中一些 CPU 核(通常为 4 核)共享 L3 tag 或二级缓存. cluster 之间分散这些任务将带来更多的内存带宽并减少缓存争用, 但是打包任务可能有助于减少缓存同步的延迟.
+例如 ARM64 机器 (如 kunpeng920) 和 x86 机器 (如 Jacobsville) 具有一定的硬件拓扑级别 cluster, 其中一些 CPU 核 (通常为 4 核) 共享 L3 tag 或二级缓存. cluster 之间分散这些任务将带来更多的内存带宽并减少缓存争用, 但是打包任务可能有助于减少缓存同步的延迟.
在 5.16 中引入了 Cluster Scheduling Domain, 让系统调度域感知 cluster 这一层次. 通过 Cluster Scheduling 可以减少对 cluster 资源 (例如 L2 缓存) 的争用, 从而获得更好的性能.
@@ -3910,9 +3877,9 @@ y = (1 - \frac{pct^{2}}{10000^{2}} \times x^{2}) \times llc\_weight
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:----:|:---:|:----------:|:---:|
-| 2021/04/20 | Barry Song | [scheduler: expose the topology of clusters and add cluster scheduler](https://lore.kernel.org/patchwork/cover/1415806) | 增加了 cluster 层次的 CPU select. 多个架构都是有 CLUSTER 域的概念的, 比如 Kunpeng 920 一个 NODE(DIE) 24个 CPU 分为 8 个 CLUSTER, 整个 DIE 共享 L3 tag, 但是一个 CLUSTER 使用一个 L3 TAG. 这种情况下对于有数据共享的进程, 在一个 cluster 上运行, 通讯的时延更低. | RFC v6 ☐ | [2020/12/01 PatchWork RFC,v2,0/2](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20201201025944.18260-1-song.bao.hua@hisilicon.com)
*-*-*-*-*-*-*-*
[2021/03/01 PatchWork RFC,v4,0/4](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20210301225940.16728-1-song.bao.hua@hisilicon.com)
*-*-*-*-*-*-*-*
[2021/03/19 PatchWork RFC,v5,0/4](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20210319041618.14316-1-song.bao.hua@hisilicon.com)
*-*-*-*-*-*-*-*
[2021/09/20 PatchWork v6,0/4](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20210420001844.9116-1-song.bao.hua@hisilicon.com) |
+| 2021/04/20 | Barry Song | [scheduler: expose the topology of clusters and add cluster scheduler](https://lore.kernel.org/patchwork/cover/1415806) | 增加了 cluster 层次的 CPU select. 多个架构都是有 CLUSTER 域的概念的, 比如 Kunpeng 920 一个 NODE(DIE) 24 个 CPU 分为 8 个 CLUSTER, 整个 DIE 共享 L3 tag, 但是一个 CLUSTER 使用一个 L3 TAG. 这种情况下对于有数据共享的进程, 在一个 cluster 上运行, 通讯的时延更低. | RFC v6 ☐ | [2020/12/01 PatchWork RFC,v2,0/2](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20201201025944.18260-1-song.bao.hua@hisilicon.com)
*-*-*-*-*-*-*-*
[2021/03/01 PatchWork RFC,v4,0/4](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20210301225940.16728-1-song.bao.hua@hisilicon.com)
*-*-*-*-*-*-*-*
[2021/03/19 PatchWork RFC,v5,0/4](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20210319041618.14316-1-song.bao.hua@hisilicon.com)
*-*-*-*-*-*-*-*
[2021/09/20 PatchWork v6,0/4](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20210420001844.9116-1-song.bao.hua@hisilicon.com) |
| 2021/06/15 | Peter Zijlstra | [Represent cluster topology and enable load balance between clusters](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=66558b730f2533cc2bf2b74d51f5f80b81e2bad0) | 第一个系列(series): 让拓扑域感知 cluster 的存在, 在 sysfs 接口中提供 cluster 的信息(包括 id 和 cpumask 等), 并添加 CONFIG_SCHED_CLUSTER, 可以在 cluster 之间实现负载平衡, 从而使大量工作负载受益. 测试表明, 在 Jacobsville 上增加 25.1% 的 SPECrate mcf, 在 kunpeng920 上增加 13.574% 的 mcf. 但是社区测试在 alder lake 上造成了一定的性能回归, [Linux 5.16's New Cluster Scheduling Is Causing Regression, Further Hurting Alder Lake](https://www.phoronix.com/scan.php?page=article&item=linux-516-regress&num=1), [Windows 11 Better Than Linux Right Now For Intel Alder Lake Performance](https://www.phoronix.com/scan.php?page=article&item=alderlake-windows-linux&num=1) | RFC ☑ [5.16-rc1](https://kernelnewbies.org/Linux_5.16#Add_cluster_scheduler_support_to_the_task_scheduler) | [2021/09/20 PatchWork 0/3](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20210820013008.12881-1-21cnbao@gmail.com), [2021/09/20 PatchWork RESEND,0/3](https://patchwork.kernel.org/project/linux-arm-kernel/cover/20210924085104.44806-1-21cnbao@gmail.com), [LKML](https://lkml.org/lkml/2021/9/24/178), [LWN](https://lwn.net/Articles/866914), [GIT PULL, 5.16-rc1](https://lore.kernel.org/lkml/163572864855.3357115.17938524897008353101.tglx@xen13/) |
-| 2021/12/03 | Tim Chen | [Make Cluster Scheduling Configurable](https://lkml.org/lkml/2021/12/3/891 ) | Cluster Scheduling 并不适用于所有场景, 因此这组补丁支持了在运行时和引导时可以动态配置 Cluster Scheduling. 可以通过启动参数 `sched_cluster={1|0}` 来在启动时开启和关闭, 也可以通过 `/proc/sys/kernel/sched_cluster` 接口在运行时动态开启和关闭.
当系统负载适中时, 值得做额外的负载平衡来平衡 cluster 之间的负载, 以减少 cluster 内资源的争用. 但是如果系统负载较大, 各个资源已经得到充分利用, cluster 之间的负载平衡不太可能有助于减少 cluster 的资源争用, 因为 cluster 内已经完全繁忙.
同时由于不感知性能异构的 CPU 类型, 造成了 Intel Alder Lake CPU 上性能退化, 参见 [Linux 5.16's New Cluster Scheduling Is Causing Regression, Further Hurting Alder Lake](https://www.phoronix.com/scan.php?page=article&item=linux-516-regress&num=3). 因此在 x86 hybrid 类型的 CPU 上禁用 Cluster Scheduling.
在一个有 24 个 Atom 内核的 Jacobsville 系统上 (每个 cluster 有 4 个 Atom CPU 核共享一个 L2), 在 24 个 CPU 的系统上运行 mcf 基准测试, 从非常低的负载 1 个基准测试副本到 24 个基准测试副本. 我们看到, 在中等负载时吞吐量得到了提高, 但当系统满负载时, Cluster Scheduling 几乎没有什么提升.
不过 Peter 最终直接选择在 x86 hybrid CPUs 上禁用 cluster. 参见 commit [cabdc3a8475b ("sched,x86: Don't use cluster topology for x86 hybrid CPUs")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cabdc3a8475b918e55744f43719b26a82dc8fa6b). | v1 ☐ | [LORE 0/5](https://lkml.kernel.org/lkml/cover.1638563225.git.tim.c.chen@linux.intel.com), [Peter Zijlstra COMMIT](https://lore.kernel.org/all/163899885798.11128.4032422680527135079.tip-bot2@tip-bot2) |
+| 2021/12/03 | Tim Chen | [Make Cluster Scheduling Configurable](https://lkml.org/lkml/2021/12/3/891) | Cluster Scheduling 并不适用于所有场景, 因此这组补丁支持了在运行时和引导时可以动态配置 Cluster Scheduling. 可以通过启动参数 `sched_cluster={1|0}` 来在启动时开启和关闭, 也可以通过 `/proc/sys/kernel/sched_cluster` 接口在运行时动态开启和关闭.
当系统负载适中时, 值得做额外的负载平衡来平衡 cluster 之间的负载, 以减少 cluster 内资源的争用. 但是如果系统负载较大, 各个资源已经得到充分利用, cluster 之间的负载平衡不太可能有助于减少 cluster 的资源争用, 因为 cluster 内已经完全繁忙.
同时由于不感知性能异构的 CPU 类型, 造成了 Intel Alder Lake CPU 上性能退化, 参见 [Linux 5.16's New Cluster Scheduling Is Causing Regression, Further Hurting Alder Lake](https://www.phoronix.com/scan.php?page=article&item=linux-516-regress&num=3). 因此在 x86 hybrid 类型的 CPU 上禁用 Cluster Scheduling.
在一个有 24 个 Atom 内核的 Jacobsville 系统上 (每个 cluster 有 4 个 Atom CPU 核共享一个 L2), 在 24 个 CPU 的系统上运行 mcf 基准测试, 从非常低的负载 1 个基准测试副本到 24 个基准测试副本. 我们看到, 在中等负载时吞吐量得到了提高, 但当系统满负载时, Cluster Scheduling 几乎没有什么提升.
不过 Peter 最终直接选择在 x86 hybrid CPUs 上禁用 cluster. 参见 commit [cabdc3a8475b ("sched,x86: Don't use cluster topology for x86 hybrid CPUs")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cabdc3a8475b918e55744f43719b26a82dc8fa6b). | v1 ☐ | [LORE 0/5](https://lkml.kernel.org/lkml/cover.1638563225.git.tim.c.chen@linux.intel.com), [Peter Zijlstra COMMIT](https://lore.kernel.org/all/163899885798.11128.4032422680527135079.tip-bot2@tip-bot2) |
| 2022/01/26 | Yicong Yang | [sched/fair: Scan cluster before scanning LLC in wake-up path](https://lore.kernel.org/all/20220822073610.27205-1-yangyicong@huawei.com) | v5 之前叫 [sched/fair: Wake task within the cluster when possible](https://lore.kernel.org/all/20220126080947.4529-1-yangyicong@hisilicon.com). 这个补丁集负责唤醒路径的 cluster 感知, 在扫描整个 LLC 之前, 先在同一集群中其他的 CPU 尝试一下, 以使这些任务能够相互通信.
1. 引入 SD_CLUSTER 标记 cluster 域, 使用 per_cpu(sd_cluster, cpu) 和 per_cpu(sd_share_id, cpu) 标记 CPU 所属的 cluster 及其 ID
2. 接着 select_idle_cpu() 试图在扫描整个 LLC 之前先通过 scan_cluster() 找到目标 CPU cluster 域 per_cpu(sd_cluster, target) 内空闲的 CPU, 以获得更低的延迟. | v2 ☐☑✓ | [LORE 0/2](https://lore.kernel.org/lkml/20211215041149.73171-1-yangyicong@hisilicon.com)
*-*-*-*-*-*-*-*
[LORE v2,0/2](https://lore.kernel.org/all/20220126080947.4529-1-yangyicong@hisilicon.com)
*-*-*-*-*-*-*-*
[LORE v3,0/2](https://lore.kernel.org/lkml/20220608095758.60504-1-yangyicong@hisilicon.com)
*-*-*-*-*-*-*-*
[LORE v4,0/2](https://lore.kernel.org/lkml/20220609120622.47724-1-yangyicong@hisilicon.com)
*-*-*-*-*-*-*-*
[LORE v5,0/2](https://lore.kernel.org/lkml/20220720081150.22167-1-yangyicong@hisilicon.com)
*-*-*-*-*-*-*-*
[LORE v6,0/2](https://lore.kernel.org/lkml/20220726074758.46686-1-yangyicong@huawei.com)
*-*-*-*-*-*-*-*
[LORE v7,0/2](https://lore.kernel.org/all/20220822073610.27205-1-yangyicong@huawei.com) |
@@ -3924,21 +3891,21 @@ y = (1 - \frac{pct^{2}}{10000^{2}} \times x^{2}) \times llc\_weight
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:----:|:---:|:----------:|:---:|
-| 2021/12/01 | Mel Gorman | [Adjust NUMA imbalance for multiple LLCs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e496132ebedd870b67f1f6d2428f9bb9d7ae27fd) | [commit 7d2b5dd0bcc4 ("sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc4) 允许 NUMA 节点之间的不平衡, 这样通信任务不会被 load balance 分开. 当 LLC 和 node 之间有 1:1 的关系时, 这种方法可以很好地工作, 但是对于多个 LLC, 如果独立的任务过早地使用 CPU 共享缓存, 这种方法就不太理想了. 本系列解决了两个问题:
1. 调度程序域权重的使用不一致, 以及当每个 NUMA 节点有许多 LLC 时性能不佳. NUMA之间允许的不均衡的进程数目不再是一个固定的值 NUMA_IMBALANCE_MIN(2), 而是在 build_sched_domains() 中实际探测 NUMA 域下辖的 LLC 的数目, 作为 sd->imb_numa_nr. | v4 ☑✓ 5.18-rc1 | [PatchWork v3,0/2](https://lore.kernel.org/lkml/20211201151844.20488-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v4,0/2](https://lore.kernel.org/lkml/20211210093307.31701-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v6,0/2](https://lore.kernel.org/all/20220208094334.16379-1-mgorman@techsingularity.net) |
+| 2021/12/01 | Mel Gorman | [Adjust NUMA imbalance for multiple LLCs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e496132ebedd870b67f1f6d2428f9bb9d7ae27fd) | [commit 7d2b5dd0bcc4 ("sched/numa: Allow a floating imbalance between NUMA nodes")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7d2b5dd0bcc4) 允许 NUMA 节点之间的不平衡, 这样通信任务不会被 load balance 分开. 当 LLC 和 node 之间有 1:1 的关系时, 这种方法可以很好地工作, 但是对于多个 LLC, 如果独立的任务过早地使用 CPU 共享缓存, 这种方法就不太理想了. 本系列解决了两个问题:
1. 调度程序域权重的使用不一致, 以及当每个 NUMA 节点有许多 LLC 时性能不佳. NUMA 之间允许的不均衡的进程数目不再是一个固定的值 NUMA_IMBALANCE_MIN(2), 而是在 build_sched_domains() 中实际探测 NUMA 域下辖的 LLC 的数目, 作为 sd->imb_numa_nr. | v4 ☑✓ 5.18-rc1 | [PatchWork v3,0/2](https://lore.kernel.org/lkml/20211201151844.20488-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v4,0/2](https://lore.kernel.org/lkml/20211210093307.31701-1-mgorman@techsingularity.net)
*-*-*-*-*-*-*-*
[LORE v6,0/2](https://lore.kernel.org/all/20220208094334.16379-1-mgorman@techsingularity.net) |
## 5.6 相关学术研究
-------
-### 5.6.1 [EuroSys '22, OS scheduling with nest](https://dl.acm.org/doi/10.1145/3492321.3519585)
+### 5.6.1 [EuroSys'22, OS scheduling with nest](https://dl.acm.org/doi/10.1145/3492321.3519585)
-------
-论文参照 [EuroSys '22, OS scheduling with nest](https://dl.acm.org/doi/10.1145/3492321.3519585), 并在 LPC-2022 上做了主题演讲 [OS Scheduling with Nest: Keeping Tasks Close Together on Warm Cores](https://lpc.events/event/16/contributions/1198)
+论文参照 [EuroSys'22, OS scheduling with nest](https://dl.acm.org/doi/10.1145/3492321.3519585), 并在 LPC-2022 上做了主题演讲 [OS Scheduling with Nest: Keeping Tasks Close Together on Warm Cores](https://lpc.events/event/16/contributions/1198)
-为了最好地支持高度并行的应用程序, 使系统的吞吐量最高, CFS 调度器总是倾向于在任务创建和唤醒时将任务尽可能均衡的分散到系统的各个 CPU 上. 然而, 这可能总是事与愿违的. 据观察, 在服务器环境中, 这种策略会导致任务不必要地放置在运行频率较低的长时间空闲的核心上, 而这些 IDLE 的 CPU 往往需要较长的时间才能唤醒, 从而降低了业务的性能, 而导致任务不必要地分布在各个 SCOKET 上, 也导致这些 SOCKET 不能进入低功耗模式, 从而导致功耗增加. 论文 [EuroSys '22, OS scheduling with nest: keeping tasks close together on warm cores, Julia Lawall](https://hal.inria.fr/hal-03612592/document?msclkid=ef0482efd02911ecac42ed2b3d62baa7) 中, 在 Linux 内核中实现了 Nest 调度器, 提出利用 CPU 核复用的原理, 通过构造一个多级 CPU 的集合, 使用这些集合的 priority 进行任务调度, 从而获得更高的频率和使用更少的 SOCKET. 对于高度并行的应用程序, 其性能和能耗与 CFS 不相上下, 但对于使用比核心更少任务的应用程序, Nest 调度器的的性能为原生 10% ~ 2 倍, 并且可以降低能耗.
+为了最好地支持高度并行的应用程序, 使系统的吞吐量最高, CFS 调度器总是倾向于在任务创建和唤醒时将任务尽可能均衡的分散到系统的各个 CPU 上. 然而, 这可能总是事与愿违的. 据观察, 在服务器环境中, 这种策略会导致任务不必要地放置在运行频率较低的长时间空闲的核心上, 而这些 IDLE 的 CPU 往往需要较长的时间才能唤醒, 从而降低了业务的性能, 而导致任务不必要地分布在各个 SCOKET 上, 也导致这些 SOCKET 不能进入低功耗模式, 从而导致功耗增加. 论文 [EuroSys'22, OS scheduling with nest: keeping tasks close together on warm cores, Julia Lawall](https://hal.inria.fr/hal-03612592/document?msclkid=ef0482efd02911ecac42ed2b3d62baa7) 中, 在 Linux 内核中实现了 Nest 调度器, 提出利用 CPU 核复用的原理, 通过构造一个多级 CPU 的集合, 使用这些集合的 priority 进行任务调度, 从而获得更高的频率和使用更少的 SOCKET. 对于高度并行的应用程序, 其性能和能耗与 CFS 不相上下, 但对于使用比核心更少任务的应用程序, Nest 调度器的的性能为原生 10% ~ 2 倍, 并且可以降低能耗.
-为进程维护了一个多级(从 WARM 到 COLD)的 CPU 集合, 用来在选核时作为参考, 类似于多级 CPU Cache 一样.
+为进程维护了一个多级 (从 WARM 到 COLD) 的 CPU 集合, 用来在选核时作为参考, 类似于多级 CPU Cache 一样.
| CPU 集合 | 描述 |
|:--------:|:---:|
@@ -3949,7 +3916,7 @@ y = (1 - \frac{pct^{2}}{10000^{2}} \times x^{2}) \times llc\_weight
其主体目标和之前的 [Soft Affinity](https://blogs.oracle.com/linux/post/soft-affinity-when-hard-partitioning-is-too-much) 有点类似, 甚至可以结合起来工作. 思路又类似于 [sched: Make select_idle_sibling search domain configurable](https://lore.kernel.org/all/20200728070131.1629670-1-xii@google.com) 分级搜索的思想.
-通过将进程集保持在一组 WARM 的 CPU 集合上, 从而让 CPU 理论用更高, 这些 CPU 可以在高频(甚至超频运行), 而其他的 CPU 可以整体处于低功耗状态, 从而整体吞吐量更高, 功耗更低. 而当系统整体负载又很大的情况下, 又可以把其他空闲的 CPU 冲突利用起来. 整体通过对 CPU (按照冷热)分级的来完成, 优先使用 WARM 的 CPU. 会通过系统整体的负载来调整各个 Nest 分级的 CPU 范围.
+通过将进程集保持在一组 WARM 的 CPU 集合上, 从而让 CPU 理论用更高, 这些 CPU 可以在高频 (甚至超频运行), 而其他的 CPU 可以整体处于低功耗状态, 从而整体吞吐量更高, 功耗更低. 而当系统整体负载又很大的情况下, 又可以把其他空闲的 CPU 冲突利用起来. 整体通过对 CPU (按照冷热) 分级的来完成, 优先使用 WARM 的 CPU. 会通过系统整体的负载来调整各个 Nest 分级的 CPU 范围.
> 该论文相关补丁以及实验环境:
>
@@ -4013,7 +3980,7 @@ y = (1 - \frac{pct^{2}}{10000^{2}} \times x^{2}) \times llc\_weight
通常情况下, 调度器会尽可能地保证系统整体的负载是均衡的, 不会让其中某些核太满, 也不会让另外一部分核太空. 所以即使是负载非常小的任务, 也会被均衡到各个核上去.
-因此有一种思路是, 当任务的负载都很小的时候, 比如某些核比较忙(>12.5%), 但是并不是特别满(<80%), 这时候与其新开一个核让系统跟均衡, 倒不如把那些小任务都搬移到一个核(可以是 ARM big.LITTLE 的大核或者被超频的核)上.
+因此有一种思路是, 当任务的负载都很小的时候, 比如某些核比较忙 (>12.5%), 但是并不是特别满(<80%), 这时候与其新开一个核让系统跟均衡, 倒不如把那些小任务都搬移到一个核(可以是 ARM big.LITTLE 的大核或者被超频的核) 上.
这样的好处是那些已经繁忙的 CPU 本身频率就比较高, 但是又不是非常满, 放上去的小任务会让这些 CPU 尽快跑满. 其他核就可以尽可能多的处在 IDLE 状态, 避免了频繁唤醒. 而相反如果使用原来的策略倾向于均衡, 各个核的负载又都不大, 会被频繁的唤醒.
@@ -4034,7 +4001,7 @@ y = (1 - \frac{pct^{2}}{10000^{2}} \times x^{2}) \times llc\_weight
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2013/10/18 | Vincent Guittot | [sched: packing tasks](https://lwn.net/Articles/520857) | 尝试在繁忙的内核上打包小负载的后台任务, 这样可以通过保持其他核空闲来节省电源. | v1 ☐ | [LKML v3 0/6](https://lkml.org/lkml/2013/3/22/183)
*-*-*-*-*-*-*-*
[LKML new PART1 v4 0/5 ](https://lkml.org/lkml/2014/4/11/137)
*-*-*-*-*-*-*-*
[LKML v5 00/14](https://lkml.org/lkml/2013/10/18/121), [LORE v5 00/14](https://lore.kernel.org/lkml/1382097147-30088-1-git-send-email-vincent.guittot@linaro.org/) |
+| 2013/10/18 | Vincent Guittot | [sched: packing tasks](https://lwn.net/Articles/520857) | 尝试在繁忙的内核上打包小负载的后台任务, 这样可以通过保持其他核空闲来节省电源. | v1 ☐ | [LKML v3 0/6](https://lkml.org/lkml/2013/3/22/183)
*-*-*-*-*-*-*-*
[LKML new PART1 v4 0/5](https://lkml.org/lkml/2014/4/11/137)
*-*-*-*-*-*-*-*
[LKML v5 00/14](https://lkml.org/lkml/2013/10/18/121), [LORE v5 00/14](https://lore.kernel.org/lkml/1382097147-30088-1-git-send-email-vincent.guittot@linaro.org/) |
| 2020/02/28 | Parth Shah | [[SchedulerTaskPacking] Small background task packing](https://lore.kernel.org/all/20200228090755.22829-1-parth@linux.ibm.com) | 最新的小任务封包的实践. 为了统一消耗系统资源, 当前系统中这种选择空闲 CPU 的假设是公平的. 但是, 并不是所有的任务都应该唤醒空闲的核, 因为这可能会降低功耗. 例如, 像小的后台任务唤醒一个空闲的核心, 只运行非常小的持续时间. 减少活动核的数量可以使繁忙的核提高频率, 从而节省电力, 也可以带来性能上的好处. 现有的唤醒路径没有机制来检测小的后台任务, 这些任务可以在更少的核上打包. | v1 ☐ | [LORE v1](https://lore.kernel.org/lkml/39cc4666-6355-fb9f-654d-e85e1852bc6f@linux.ibm.com) |
@@ -4063,10 +4030,10 @@ y = (1 - \frac{pct^{2}}{10000^{2}} \times x^{2}) \times llc\_weight
2009 年 来自 IBM 的 Gautham R Shenoy 提出了 [sched: Nominate a power-efficient ILB.](https://lwn.net/Articles/326909)
-在 Linaro 开发小任务封包的同时, 2012 年 Intel 的 Alex Shi 发起的讨论中, 提出了更高大上的概念[**能耗感知的调度器**](https://lkml.org/lkml/2012/8/13/139), 功耗和性能本身就是一个矛盾的统一体, 因此由于此特性节省的功耗和降低的性能不成正比, 因此在发到 v7 [PatchWork](https://lore.kernel.org/patchwork/cover/370834) 之后也寿终正寝.
+在 Linaro 开发小任务封包的同时, 2012 年 Intel 的 Alex Shi 发起的讨论中, 提出了更高大上的概念[** 能耗感知的调度器 **](https://lkml.org/lkml/2012/8/13/139), 功耗和性能本身就是一个矛盾的统一体, 因此由于此特性节省的功耗和降低的性能不成正比, 因此在发到 v7 [PatchWork](https://lore.kernel.org/patchwork/cover/370834) 之后也寿终正寝.
-功耗感知的调度器是如此的新颖, 以至于 2013 年 10 月, 致力于 ANDROID 调度器优化的 Morten Rasmussen [sched: Power scheduler design proposal](https://lore.kernel.org/patchwork/cover/391530) 也提出了自己的想法, 在发到了 [v2 PatchWork](https://lore.kernel.org/patchwork/cover/412619),在这之前他刚发出了他 HMP 的补丁.
+功耗感知的调度器是如此的新颖, 以至于 2013 年 10 月, 致力于 ANDROID 调度器优化的 Morten Rasmussen [sched: Power scheduler design proposal](https://lore.kernel.org/patchwork/cover/391530) 也提出了自己的想法, 在发到了 [v2 PatchWork](https://lore.kernel.org/patchwork/cover/412619), 在这之前他刚发出了他 HMP 的补丁.
然后再 2013 年, Intel 的开发者 Yuyang Du 也不甘示弱, 提出了一个适用于能耗调度器的负载统计算法 CPU ConCurrency, 参见 [A new CPU load metric for power-efficient scheduler: CPU ConCurrency](https://lore.kernel.org/all/1399832221-8314-1-git-send-email-yuyang.du@intel.com). CC(CPU ConCurrency) 是运行队列长度加权的 CPU 利用率(utilization). 由于 CFS 的模型化地完全公平调度器, CPU 就绪队列上的任务可以被视为并发运行, 并发度就是就绪队列的长度, 因此, CC(CPU ConCurrency) 使用任务并发度 concurrency 作为负载指示器.
@@ -4074,7 +4041,7 @@ $$ a = \sum_{1}^{n} \frac{concurrency \times time}{period} $$
如果 concurrency 一直是 1, 那么这个负载 a 就等价于 CPU 利用率(utilization).
-这组补丁最终没有合入主线, 但是用 runnable 数量来 RQ 的 PELT 负载, 的确能很好地反应 CFS_RQ 上的可运行压力, 因此主线在 [Reconcile NUMA balancing decisions with the load balancer v6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=a0f03b617c3b2644d3d47bf7d9e60aed01bd5b10) 补丁集中, 通过 [commit 9f68395333ad ("sched/pelt: Add a new runnable average signal")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9f68395333ad7f5bfe2f83473fed363d4229f11c) 实现了直接用 RQ 上 runnable 的数量来计算的 runnable_{sum|avg} 负载信息. 这个 runnable 负载计算方式只在意有多少进程在等待, 而不关心他们的 load_weight, 因此可以跟踪 RQ 上任务的等待压力, 有助于更好地定义 RQ 的状态. 这种计算方式与 load_{sum|avg} 的计算方式是类似的, 这样的好处是, 我们**可以直接将 runnable 的负载和 running 的负载进行比较**. 当任务竞争同一个 RQ时, 它们的可运行平均负载将高于 util_avg, 因为它将包含等待时间(不再包含之前的 load_weight 信息), 我们可以使用这个负载信息更好地对 CFS_RQ 进行分类.
+这组补丁最终没有合入主线, 但是用 runnable 数量来 RQ 的 PELT 负载, 的确能很好地反应 CFS_RQ 上的可运行压力, 因此主线在 [Reconcile NUMA balancing decisions with the load balancer v6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=a0f03b617c3b2644d3d47bf7d9e60aed01bd5b10) 补丁集中, 通过 [commit 9f68395333ad ("sched/pelt: Add a new runnable average signal")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9f68395333ad7f5bfe2f83473fed363d4229f11c) 实现了直接用 RQ 上 runnable 的数量来计算的 runnable_{sum|avg} 负载信息. 这个 runnable 负载计算方式只在意有多少进程在等待, 而不关心他们的 load_weight, 因此可以跟踪 RQ 上任务的等待压力, 有助于更好地定义 RQ 的状态. 这种计算方式与 load_{sum|avg} 的计算方式是类似的, 这样的好处是, 我们 ** 可以直接将 runnable 的负载和 running 的负载进行比较 **. 当任务竞争同一个 RQ 时, 它们的可运行平均负载将高于 util_avg, 因为它将包含等待时间(不再包含之前的 load_weight 信息), 我们可以使用这个负载信息更好地对 CFS_RQ 进行分类.
接着 2014 年, Preeti U Murthy 在总结了 Alex Shi 的经验之后, 接着完善了能耗感知调度器的设计, 但是由于缺少热度, 这个特性最终止步 v2 [Power Scheduler Design](https://lore.kernel.org/lkml/20140811113000.31956.52857.stgit@preeti.in.ibm.com) 版本.
@@ -4096,7 +4063,7 @@ $$ a = \sum_{1}^{n} \frac{concurrency \times time}{period} $$
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2014/05/26 | Nicolas Pitre | [sched: expel confusing usage of the term "power"](https://lore.kernel.org/all/1401142779-6633-1-git-send-email-nicolas.pitre@linaro.org) | TODO | v2 ☐☑✓ | [LORE v2,0/6](https://lore.kernel.org/all/1401142779-6633-1-git-send-email-nicolas.pitre@linaro.org) |
+| 2014/05/26 | Nicolas Pitre | [sched: expel confusing usage of the term"power"](https://lore.kernel.org/all/1401142779-6633-1-git-send-email-nicolas.pitre@linaro.org) | TODO | v2 ☐☑✓ | [LORE v2,0/6](https://lore.kernel.org/all/1401142779-6633-1-git-send-email-nicolas.pitre@linaro.org) |
| 2014/05/23 | Vincent Guittot | [sched: consolidation of cpu_power](https://lore.kernel.org/all/1400860385-14555-1-git-send-email-vincent.guittot@linaro.org) | TODO | v2 ☐☑✓ | [LORE v2,0/11](https://lore.kernel.org/all/1400860385-14555-1-git-send-email-vincent.guittot@linaro.org) |
### 7.2.2 IKS -> HMP -> EAS & CAS
@@ -4108,7 +4075,7 @@ ARM 的 Morten Rasmussen 一直致力于 ANDROID 调度器优化的:
1. 最初版本的 IKS 调度器, [ELC: In-kernel switcher for big.LITTLE](https://lwn.net/Articles/539840)
-2. 以及后来先进的 HMP 调度器 [LC-Asia: A big LITTLE MP update](https://lwn.net/Articles/541005), 虽然我们称呼他是一个调度器, 但是其实他的策略只是一个**进程放置(Task Placement, 请原谅我的这个翻译, 很抱歉我实在不知道翻译成什么好, 如果您有什么好的建议, 请联系我)** 的策略. [sched: Task placement for heterogeneous MP systems](https://lore.kernel.org/patchwork/cover/327745)
+2. 以及后来先进的 HMP 调度器 [LC-Asia: A big LITTLE MP update](https://lwn.net/Articles/541005), 虽然我们称呼他是一个调度器, 但是其实他的策略只是一个 ** 进程放置(Task Placement, 请原谅我的这个翻译, 很抱歉我实在不知道翻译成什么好, 如果您有什么好的建议, 请联系我)** 的策略. [sched: Task placement for heterogeneous MP systems](https://lore.kernel.org/patchwork/cover/327745)
3. 直到看到了能耗感知调度器, 忽然眼前有了光, Morten 充分借鉴了能耗感知调度器的思想, 提出了自己的想法[Another attempt at power-aware scheduling](https://lwn.net/Articles/600419), 最终发布到 v2 版本 [Power-aware scheduling v2](https://lore.kernel.org/patchwork/cover/412619).
@@ -4146,10 +4113,9 @@ ARM EAS 支持的主页: [Energy Aware Scheduling (EAS)](https://developer.arm.c
-------
-AOSP 4.4 版本, 唤醒路径使用 select_energy_cpu_brute()/find_best_target()/energy_diff().
+AOSP 4.4 版本, 唤醒路径使用 select_energy_cpu_brute()/find_best_target()/energy_diff(). 其中 energy_diff() 用于计算定量的 utilization 变化 util_delta 对系统整体的功耗影响. 通过比较前后的能效变化, select_energy_cpu_brute() 很容易为一个指定负载的 task 选择能效最优的 CPU.
-
-AOSP 4.9 版本, EAS 唤醒路径使用 select_energy_cpu_brute()/find_best_target()/select_energy_cpu_idx(). 其主要变更是对 4.4 原来的 energy_diff() 进行了优化重构.
+AOSP 4.9 版本, EAS 唤醒主流程为: select_energy_cpu_brute()/find_best_target()/select_energy_cpu_idx(). 其主要变更是对 4.4 原来的 energy_diff() 进行了优化重构.
struct energy_env 用于缓存 energy_diff() 计算中涉及的多个不同函数所需的值.
@@ -4178,40 +4144,44 @@ AOSP 4.14 版本, 唤醒路径使用 find_energy_efficient_cpu()/find_best_targe
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2016/03/30 | Morten Rasmussen | [ANDROID: sched/fair: Energy-aware wake-up task placement](https://github.com/aosp-mirror/kernel_common/commit/3308a3b6c01aecbbece0907333d7c85730e8f1ec) | 当系统没有被过载时, 通过 select_energy_cpu_brute() 把唤醒任务放在最节能的 CPU 上. 以前的尝试通过在咨询能量模型之前将任务利用率匹配到 CPU 容量来减少搜索空间, 因为这是一个昂贵的操作. 搜索启发式的工作不是很好, 没有任何更好的替代方案, 这个补丁采取蛮力路线, 并尝试所有潜在的目标. 这种方法开销较大, 因此扩展性不足, 但对于许多嵌入式应用程序来说, 它可能已经足够了, 同时还在继续研究可以最小化必要计算的启发式方法. | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/3308a3b6c01aecbbece0907333d7c85730e8f1ec) |
-| 2016/03/30 | Morten Rasmussen | [ANDROID: refactor select_task_rq_fair et al to be cleaner](https://github.com/aosp-mirror/kernel_common/commit/83717be34de070b165e4a7683a71be924ecf0679) | 重构能效感知的唤醒 select_energy_cpu_brute() 为 find_energy_efficient_cpu(), 使其更适合唤醒慢路径. 这样将更容易被推送到主线. | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/83717be34de070b165e4a7683a71be924ecf0679) |
-| 2016/03/30 | Morten Rasmussen | [ANDROID: Add find_best_target to minimise energy calculation overhead](https://github.com/aosp-mirror/kernel_common/commit/f240e44406558b17ff7765f252b0bcdcbc15126f) | 引入 find_best_target(). 如果开启 sched_feat(FIND_BEST_TARGET), 则使用 find_best_target() 来筛选候选 CPU 集合, 否则依旧使用选择剩余容量最大的 CPU 作为候选集合(随后 4.19 将此流程拆解为 select_max_spare_cap_cpus()/select_cpu_candidates()). | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/f240e44406558b17ff7765f252b0bcdcbc15126f) |
-| 2017/12/19 | atrick Bellasi | [ANDROID: sched/fair: re-factor energy_diff to use a single (extensible) energy_env](https://github.com/aosp-mirror/kernel_common/commit/60664914185bef21e3abb0a804777171bd488477) | 引入 select_energy_cpu_idx() 替代 energy_diff(). | v1 ☐☑✓ | [COMMIT1](ttps://github.com/aosp-mirror/kernel_common/commit/0df28983b8ef2e2a6e524933949fd9ad8a8799cf), [COMMIT2](https://github.com/aosp-mirror/kernel_common/commit/60664914185bef21e3abb0a804777171bd488477) |
+| 2017/12/19 | Chris Redpath | [ANDROID: refactor select_task_rq_fair et al to be cleaner](https://github.com/aosp-mirror/kernel_common/commit/83717be34de070b165e4a7683a71be924ecf0679) | 重构能效感知的唤醒 select_energy_cpu_brute() 为 find_energy_efficient_cpu(), 使其更适合唤醒慢路径. 这样将更容易被推送到主线. | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/83717be34de070b165e4a7683a71be924ecf0679) |
+| 2017/12/19 | Chris Redpath | [ANDROID: Add find_best_target to minimise energy calculation overhead](https://github.com/aosp-mirror/kernel_common/commit/f240e44406558b17ff7765f252b0bcdcbc15126f) | 引入 find_best_target(). 如果开启 sched_feat(FIND_BEST_TARGET), 则使用 find_best_target() 来筛选候选 CPU 集合, 否则依旧使用选择剩余容量最大的 CPU 作为候选集合(随后 4.19 将此流程拆解为 select_max_spare_cap_cpus()/select_cpu_candidates()). | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/f240e44406558b17ff7765f252b0bcdcbc15126f) |
+| 2017/12/19 | Chris Redpath | [ANDROID: sched/fair: re-factor energy_diff to use a single (extensible) energy_env](https://github.com/aosp-mirror/kernel_common/commit/60664914185bef21e3abb0a804777171bd488477) | 引入 select_energy_cpu_idx() 替代 energy_diff(). | v1 ☐☑✓ | [COMMIT1](ttps://github.com/aosp-mirror/kernel_common/commit/0df28983b8ef2e2a6e524933949fd9ad8a8799cf), [COMMIT2](https://github.com/aosp-mirror/kernel_common/commit/60664914185bef21e3abb0a804777171bd488477) |
AOSP 4.19 的版本, EAS 主流程 find_energy_efficient_cpu()/find_best_target()/select_max_spare_cap_cpus()/select_cpu_candidates().
相比较 4.14 的版本, 将 find_energy_efficient_cpu() 拆解为两个主流程:
-1. 首先 select_cpu_candidates() 在每个频域中寻找具有最大备用容量的 CPU, 将候选 cpumask 记录在 candidates.
+1. 首先 select_cpu_candidates() 在每个频域中寻找具有最大备用容量且 IDLE 状态最浅的 CPU, 将候选 cpumask 记录在 candidates.
2. 然后通过 compute_energy() 估计 candidates 中每个候选 CPU 对系统功耗的影响, 并于 prev CPU 比较. 从而选择全局能效最优的 CPU.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2016/03/30 | Morten Rasmussen | [ANDROID: sched/fair: Energy-aware wake-up task placement](https://github.com/aosp-mirror/kernel_common/commit/54655c9f85a92530929a49caccfa9ba51aabb638) | 如果能量模型 (EM) 可用, 并且系统没有过度利用, 则唤醒任务时使用能量感知的 find_energy_efficient_cpu() 为任务能效最有的 CPU. 这是通过估计将任务放置在每个性能域中具有最高剩余容量的 CPU 上对系统级功耗的影响来实现的. 该策略将任务分散在性能域中, 并避免过于激进的任务打包. 如果相对于 prev_CPU 节省了足够多的能量, 则选择最佳的 CPU 能量. | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/54655c9f85a92530929a49caccfa9ba51aabb638) |
-| 2016/03/30 | Morten Rasmussen | [ANDROID: sched/fair: Factor out CPU selection from find_energy_efficient_cpu](https://github.com/aosp-mirror/kernel_common/commit/9378697a9fb8443bd6406f7430bfee9321472270) | find_energy_efficient_cpu() 由两个步骤组成, 为了更容易实现其他 CPU 选择策略, 将两部分拆解开来: 首先 select_max_spare_cap_cpus() 在每个频域中寻找具有最大备用容量的 CPU, 将候选 cpumask 记录在 candidates, 然后通过 compute_energy() 估计 candidates 中每个候选 CPU 对系统功耗的影响, 并于 prev CPU 比较. 从而选择全局能效最优的 CPU. | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/9378697a9fb8443bd6406f7430bfee9321472270) |
-| 2016/03/30 | Morten Rasmussen | [ANDROID: Add find_best_target to minimise energy calculation overhead](https://github.com/aosp-mirror/kernel_common/commit/c27c56105dcaaae54ecc39ef33fbfac87a1486fc) | 引入 find_best_target(). 如果开启 sched_feat(FIND_BEST_TARGET), 则使用 find_best_target() 来筛选 candidates, 否则依旧使用旧的 select_max_spare_cap_cpus(). | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/c27c56105dcaaae54ecc39ef33fbfac87a1486fc) |
-| 2016/03/30 | Morten Rasmussen | [ANDROID: sched/fair: Make the EAS wake-up prefer-idle awared](https://github.com/aosp-mirror/kernel_common/commit/d0eb1f35140ee4159b2f9b6968b87f7b70a6e5d0) | select_max_spare_cap_cpus() 也增加 prefer-idle 的能力, 同时将其重命名为 select_cpu_candidates(). | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/d0eb1f35140ee4159b2f9b6968b87f7b70a6e5d0) |
+| 2018/10/16 | Quentin Perret | [ANDROID: sched/fair: Energy-aware wake-up task placement](https://github.com/aosp-mirror/kernel_common/commit/54655c9f85a92530929a49caccfa9ba51aabb638) | 如果能量模型 (EM) 可用, 并且系统没有过度利用, 则唤醒任务时使用能量感知的 find_energy_efficient_cpu() 为任务能效最有的 CPU. 这是通过估计将任务放置在每个性能域中具有最高剩余容量的 CPU 上对系统级功耗的影响来实现的. 该策略将任务分散在性能域中, 并避免过于激进的任务打包. 如果相对于 prev_CPU 节省了足够多的能量, 则选择最佳的 CPU 能量. | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/54655c9f85a92530929a49caccfa9ba51aabb638) |
+| 2018/08/31 | Quentin Perret | [ANDROID: sched/fair: Factor out CPU selection from find_energy_efficient_cpu](https://github.com/aosp-mirror/kernel_common/commit/9378697a9fb8443bd6406f7430bfee9321472270) | find_energy_efficient_cpu() 由两个步骤组成, 为了更容易实现其他 CPU 选择策略, 将两部分拆解开来: 首先 select_max_spare_cap_cpus() 在每个频域中寻找具有最大备用容量的 CPU, 将候选 cpumask 记录在 candidates, 然后通过 compute_energy() 估计 candidates 中每个候选 CPU 对系统功耗的影响, 并于 prev CPU 比较. 从而选择全局能效最优的 CPU. | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/9378697a9fb8443bd6406f7430bfee9321472270) |
+| 2017/12/19 | Chris Redpath | [ANDROID: Add find_best_target to minimise energy calculation overhead](https://github.com/aosp-mirror/kernel_common/commit/c27c56105dcaaae54ecc39ef33fbfac87a1486fc) | 引入 find_best_target(). 如果开启 sched_feat(FIND_BEST_TARGET), 则使用 find_best_target() 来筛选 candidates, 否则依旧使用旧的 select_max_spare_cap_cpus(). | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/c27c56105dcaaae54ecc39ef33fbfac87a1486fc) |
+| 2019/02/28 | Quentin Perret | [ANDROID: sched/fair: Make the EAS wake-up prefer-idle awared](https://github.com/aosp-mirror/kernel_common/commit/d0eb1f35140ee4159b2f9b6968b87f7b70a6e5d0) | select_max_spare_cap_cpus() 也增加 prefer-idle 的能力, 同时将其重命名为 select_cpu_candidates(). | v1 ☐☑✓ | [COMMIT](https://github.com/aosp-mirror/kernel_common/commit/d0eb1f35140ee4159b2f9b6968b87f7b70a6e5d0) |
随后 2018 年, Quentin Perret 等开发的 EAS 终于在 v5.0 版本合入主线.
[commit 732cd75b8c92 ("sched/fair: Select an energy-efficient CPU on task wake-up")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=732cd75b8c920d3727e69957b14faa7c2d7c3b75) 在调度器中添加了一个 find_energy_efficient_cpu() 的函数(简称 feec()); 它的工作是为给定的任务找到最佳位置(从能耗的角度来看). 其核心逻辑是找到每个 perf_domain 性能域 中最不繁忙的 CPU, 并估计将任务放在该 CPU 上所产生的能源成本(或节省). 最不繁忙的 CPU 最有可能保持低功耗状态, 因此它为一些额外工作提供了逻辑目标.
-由于, 将任务从一个 CPU 移动到另一个 CPU 是有代价的. 该任务可能会留下部分或全部内存缓存, 这会减慢其速度. 这会影响性能, 也不利于能源使用, 因此应尽可能避免使用. 为了防止 CPU 之间频繁地进程迁移, find_energy_efficient_cpu() 只有在结果是[至少节省了任务先前 CPU 所用能量的 6% 时](https://elixir.bootlin.com/linux/v5.0/source/kernel/sched/fair.c#L6576)才会迁移任务.
+由于, 将任务从一个 CPU 移动到另一个 CPU 是有代价的. 该任务可能会留下部分或全部内存缓存, 这会减慢其速度. 这会影响性能, 也不利于能源使用, 因此应尽可能避免使用. 为了防止 CPU 之间频繁地进程迁移, find_energy_efficient_cpu() 只有在结果是 [至少节省了任务先前 CPU 所用能量的 6% 时](https://elixir.bootlin.com/linux/v5.0/source/kernel/sched/fair.c#L6576) 才会迁移任务.
+
+| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
+|:----:|:----:|:---:|:---:|:----------:|:----:|
+| 2018/12/03 | Quentin Perret | [sched/fair: Select an energy-efficient CPU on task wake-up](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=732cd75b8c920d3727e69957b14faa7c2d7c3b75) | 能效感知的调度器 EAS | v10 ☑ 5.0-rc1 | [LORE v10,00/15](https://lore.kernel.org/lkml/20181203095628.11858-1-quentin.perret@arm.com) |
#### 7.2.3.2 Speed-up energy-aware wake-ups
-------
-但是, 最佳能效 CPU 的计算和搜索成本很高, 以至于给调度决策增加了不必要的延迟. 因此, Perret 在 2019 年的 v5.4 版本中对其进行了重新设计. 目的是以更低的CPU成本获得相同的结果. 参见 [commit eb92692b2544 ("sched/fair: Speed-up energy-aware wake-ups")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=eb92692b2544d3f415887dbbc98499843dfe568b) 补丁 COMMIT 说"没有功能更改(No functional changes intended.)". 然而, 事实证明, 有一个微妙的变化显然逃脱了审查: 6%规则现在与整个系统使用的能量进行了比较, 而不仅仅是运行任务的先前CPU. 这是一个相对较高的移动门槛, 在具有足够CPU的系统上, 任务可能无法满足.
+但是, 最佳能效 CPU 的计算和搜索成本很高, 以至于给调度决策增加了不必要的延迟. 因此, Perret 在 2019 年的 v5.4 版本中对其进行了重新设计. 目的是以更低的 CPU 成本获得相同的结果. 参见 [commit eb92692b2544 ("sched/fair: Speed-up energy-aware wake-ups")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=eb92692b2544d3f415887dbbc98499843dfe568b) 补丁 COMMIT 说 "没有功能更改(No functional changes intended.)". 然而, 事实证明, 有一个微妙的变化显然逃脱了审查: 6% 规则现在与整个系统使用的能量进行了比较, 而不仅仅是运行任务的先前 CPU. 这是一个相对较高的移动门槛, 在具有足够 CPU 的系统上, 任务可能无法满足.
即使在较小的系统上, 新规则在许多情况下也能有效地阻止任务移动. 在运行相对较多的小任务的情况下尤其如此, 这种情况经常出现在 Android 设备上, 其中能效是一个真正的问题. 如果它不再能够移动任务以节省能源, 则 find_energy_efficient_cpu() 完成的所有工作都将被浪费, 并且设备的运行效率低于其他方式.
@@ -4227,12 +4197,12 @@ AOSP 4.19 的版本, EAS 主流程 find_energy_efficient_cpu()/find_best_target(
[Removing the scheduler's energy-margin heuristic](https://lwn.net/Articles/899303)
-回退 v5.4 的算法优化可以很直接的解决问题, 但是社区对此争议颇多, 因为本身 6% 这个收益阈值就没有任何理论以及数据依据, 在 EAS 的早期版本这个数字一直是 1.5%, 直到它在 v4 中被提高到6%, 参见 [[RFC PATCH v4 00/12] Energy Aware Scheduling](https://lore.kernel.org/all/20180628114043.24724-1-quentin.perret%40arm.com) 中 "Changed energy threshold for migration to from 1.5% to 6%". 这个改动最直接的原因可能是因为 6% 可以通过右移操作近似获得. 因此, Donnefort 直接建议完全删除 6% 的阈值, 并在看起来迁移可以降低能耗时直接迁移任务.
+回退 v5.4 的算法优化可以很直接的解决问题, 但是社区对此争议颇多, 因为本身 6% 这个收益阈值就没有任何理论以及数据依据, 在 EAS 的早期版本这个数字一直是 1.5%, 直到它在 v4 中被提高到 6%, 参见 [[RFC PATCH v4 00/12] Energy Aware Scheduling](https://lore.kernel.org/all/20180628114043.24724-1-quentin.perret%40arm.com) 中 "Changed energy threshold for migration to from 1.5% to 6%". 这个改动最直接的原因可能是因为 6% 可以通过右移操作近似获得. 因此, Donnefort 直接建议完全删除 6% 的阈值, 并在看起来迁移可以降低能耗时直接迁移任务.
-参见 [feec() energy margin removal](https://lore.kernel.org/all/20220621090414.433602-1-vdonnefort@google.com), 根据补丁集发布时的测试数据表明, 系统确实获得了更好能效, 视频基准测试可降低5.6%, 在某些测试中, CPU 性能略有降低, 但变化似乎并不显著.
+参见 [feec() energy margin removal](https://lore.kernel.org/all/20220621090414.433602-1-vdonnefort@google.com), 根据补丁集发布时的测试数据表明, 系统确实获得了更好能效, 视频基准测试可降低 5.6%, 在某些测试中, CPU 性能略有降低, 但变化似乎并不显著.
Donnefort 称: 边距删除使内核能够充分利用能量模型, 任务更有可能放置在适合的位置, 这节省了大量的能量, 同时对性能的影响有限,
-这种变化的一个可能的缺点可能是 CPU 之间任务的反弹增加, 但 Donnefort 表示, 测试"没有显示任何问题".
+这种变化的一个可能的缺点可能是 CPU 之间任务的反弹增加, 但 Donnefort 表示, 测试 "没有显示任何问题".
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
@@ -4289,7 +4259,7 @@ EAS 按照能效进行选核等操作也是有一定开销的, 因此调度器
[commit 2802bf3cd936 ("sched/fair: Add over-utilization/tipping point indicator")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2802bf3cd936fe2c8033a696d375a4d9d3974de4) 引入了 root-domain 的 overutilized, 当一个 CPU 的利用率(util_avg) 超过一定阈值(默认为 80%) 的时, 就认为当前 CPU 过载了, 同时也会认为整个系统也是过载的.
-1. 当系统没有过载时, 通过 EAS 根据任务的实际利用率(util_avg)来进行任务的 SELECT TASK RQ, 在获得能效更高的任务分配的同时, 又不至于剥夺任何任务的执行机会. 此时将跳过 CFS 原生基于 load_avg 的 SMP NICE 的负载均衡器.
+1. 当系统没有过载时, 通过 EAS 根据任务的实际利用率 (util_avg) 来进行任务的 SELECT TASK RQ, 在获得能效更高的任务分配的同时, 又不至于剥夺任何任务的执行机会. 此时将跳过 CFS 原生基于 load_avg 的 SMP NICE 的负载均衡器.
2. 当系统过载时时, 则禁用 EAS, 使能 CFS Load Balancing, 根据附加了任务权重信息的 load_avg 来进行负载均衡, 将任务分布到尽可能多的 CPU 上, 以保持 SMP NICE.
@@ -4345,7 +4315,7 @@ EAS 主线合入的特性时间线: [EAS Development for Mainline Linux](https:/
| v4.15 | Frequency Invariant Engine (FIE) | NA |
| v4.17 | Idle CPU Per-Entity Load-Tracking (PELT) update | NA |
| v4.17 | Util(ization) Est(imated) | NA |
-| v4.20 | Misfit task, i.e. forcing migration of running tasks that do not fit on the CPU they are currently running on | [sched/fair: Migrate 'misfit' tasks on asymmetric capacity systems](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9c63e84db29bcf584040931ad97c2edd11e35f6c) |
+| v4.20 | Misfit task, i.e. forcing migration of running tasks that do not fit on the CPU they are currently running on | [sched/fair: Migrate'misfit'tasks on asymmetric capacity systems](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9c63e84db29bcf584040931ad97c2edd11e35f6c) |
| v4.20 | Runtime scheduler domain flag detection | [sched/topology: Set SD_ASYM_CPUCAPACITY flag automatically](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e1799a80a4f5a463f252b7325da8bb66dfd55471) |
| v5.0 | Per-cpu Energy Model (EM) and Energy Aware Scheduling (EAS) | [Energy Aware Scheduling](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=732cd75b8c920d3727e69957b14faa7c2d7c3b75) |
| v5.3 | Tracepoints (PELT and over-utilzation) | [sched: Add new tracepoints required for EAS testing, v3,0/6](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=a056a5bed7fa67706574b00cf1122c38596b2be1) |
@@ -4428,8 +4398,8 @@ sched_init_domains()
| 2016/10/17 | Juri Lelli | [CPUs capacity information for heterogeneous systems](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=be8f185d8af4dbd450023a42a48c6faa8cbcdfe6) | ARM64 支持 [DTS 解析 capacity-dmips-mhz 字段](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=be8f185d8af4dbd450023a42a48c6faa8cbcdfe6), 支持 big.LITTLE 大小核架构配置 CPU Capcity, 添加 [cpu_capacity](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=be8f185d8af4dbd450023a42a48c6faa8cbcdfe6) sysfs 接口, 用于显示 CPU Capacity. | v7 ☑✓ 4.10-rc1 | [LORE v7,0/9](https://lore.kernel.org/all/20161017154650.18779-1-juri.lelli@arm.com) |
| 2017/04/20 | Juri Lelli | [Fix issues and factorize arm/arm64 capacity information code](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=4ca4f26a9c66103ca158689b7554f07f4968a32c) | ARM 和 ARM64 topology.c 大量与解析容量信息相关的代码存在冗余. 将这些代码抽离出来形成一个架构无关通用的模块 `drivers/base/arch_topology.c`. | v4 ☑✓ 4.13-rc1 | [LORE v4,0/8](https://lore.kernel.org/all/20170420144316.15632-1-juri.lelli@arm.com), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=2ef7a2953c81ee6b341e3ffb33570adc894cf4a5). |
| 2018/07/20 | Morten Rasmussen | [sched/topology: Set SD_ASYM_CPUCAPACITY flag automatically](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e1799a80a4f5a463f252b7325da8bb66dfd55471) | 1532093554-30504-1-git-send-email-morten.rasmussen@arm.com | v1 ☑✓ 4.20-rc1 | [LORE v1,0/4](https://lore.kernel.org/all/1532093554-30504-1-git-send-email-morten.rasmussen@arm.com) |
-| 2019/10/23 | Valentin Schneider | [sched/topology: Asymmetric topologies fixes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e284df705cf1eeedb5ec3a66ed82d17a64659150) | 允许 sched_asym_cpucapacity 被 disable.
[sched_asym_cpucapacity 默认是关闭](https://elixir.bootlin.com/linux/v5.16/source/kernel/sched/topology.c#L651)的, 但是启动过程中 [build_sched_domains()](https://elixir.bootlin.com/linux/v5.16/source/kernel/sched/topology.c#L2271) 如果识别当前系统是大小核异构(比如 ARM big.LITTLE 等)的系统, 就会[标记 has_asym](https://elixir.bootlin.com/linux/v5.16/source/kernel/sched/topology.c#L2220), 然后把 STATIC_KEY sched_asym_cpucapacity 开启, 但一旦打开, 它将永远保持启用状态. 这意味着, 如果我们从一个非对称系统开始, 热插拔出足够多的 CPU, 最终得到一个 SMP 系统, sched_asym_cpucapacity 依旧将保持开启状态, 这显然是错误的. 应该检测到这一点, 并关闭不匹配迁移和容量感知唤醒等功能. 这个补丁就完成了这个功能. | v4 ☑✓ 5.4-rc6 | [LORE v4,0/2](https://lore.kernel.org/all/20191023153745.19515-1-valentin.schneider@arm.com) |
-| 2021/06/03 | Valentin Schneider | [Rework CPU capacity asymmetry detection](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=adf3c31e18b765ea24eba7b0c1efc076b8ee3d55) | 当前版本 asym_cpu_capacity_level 存在几个问题.
1. 只能支持到最低的拓扑级别, 对全局的拓扑域不可见.
2. 不支持 NUMA 级别的异构, 因为初始化 NUMA 级别的 sd_numa_mask 中不包含其他 NODE, 最终 sched_domain_span 是在构建调度域的时候进行的更新的.
这对于大多数现有的不对称设计很实用, 但是却不支持普适的性能异构架构.这可能不是最好的方法, 在一些领域可能看不到任何不对称. 这对于不合适的迁移和能量感知的安置可能会有问题. 因此, 对于受影响的平台, 它可能导致对唤醒和 CPU 选择路径的自定义更改.
这组补丁修改了执行非对称检测的方式, 允许将非对称拓扑级别固定在最低的拓扑级别上, 在最低的拓扑级别上, 给定调度域中的所有 CPU 都可以看到整个 CPU 容量范围. asym_cpu_capacity_level 还将跟踪那些观察到任何非对称范围的级别, 以使用 SD_ASYM_CPUCAPACITY 标志表示相应的调度域, 并为这些域启用不匹配迁移. 为了区分局部和全范围 CPU 容量不对称的调度域, 引入了新的调度域标志: SD_ASYM_CPUCAPACITY_FULL. | v7 ☑ 5.14-rc1 | [LORE v1](https://lore.kernel.org/lkml/1618578085-29584-1-git-send-email-beata.michalska@arm.com)
*-*-*-*-*-*-*-*
[LORE v7](https://lore.kernel.org/all/20210603140627.8409-1-beata.michalska@arm.com) |
+| 2019/10/23 | Valentin Schneider | [sched/topology: Asymmetric topologies fixes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=e284df705cf1eeedb5ec3a66ed82d17a64659150) | 允许 sched_asym_cpucapacity 被 disable.
[sched_asym_cpucapacity 默认是关闭](https://elixir.bootlin.com/linux/v5.16/source/kernel/sched/topology.c#L651)的, 但是启动过程中 [build_sched_domains()](https://elixir.bootlin.com/linux/v5.16/source/kernel/sched/topology.c#L2271) 如果识别当前系统是大小核异构 (比如 ARM big.LITTLE 等) 的系统, 就会[标记 has_asym](https://elixir.bootlin.com/linux/v5.16/source/kernel/sched/topology.c#L2220), 然后把 STATIC_KEY sched_asym_cpucapacity 开启, 但一旦打开, 它将永远保持启用状态. 这意味着, 如果我们从一个非对称系统开始, 热插拔出足够多的 CPU, 最终得到一个 SMP 系统, sched_asym_cpucapacity 依旧将保持开启状态, 这显然是错误的. 应该检测到这一点, 并关闭不匹配迁移和容量感知唤醒等功能. 这个补丁就完成了这个功能. | v4 ☑✓ 5.4-rc6 | [LORE v4,0/2](https://lore.kernel.org/all/20191023153745.19515-1-valentin.schneider@arm.com) |
+| 2021/06/03 | Valentin Schneider | [Rework CPU capacity asymmetry detection](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=adf3c31e18b765ea24eba7b0c1efc076b8ee3d55) | 当前版本 asym_cpu_capacity_level 存在几个问题.
1. 只能支持到最低的拓扑级别, 对全局的拓扑域不可见.
2. 不支持 NUMA 级别的异构, 因为初始化 NUMA 级别的 sd_numa_mask 中不包含其他 NODE, 最终 sched_domain_span 是在构建调度域的时候进行的更新的.
这对于大多数现有的不对称设计很实用, 但是却不支持普适的性能异构架构. 这可能不是最好的方法, 在一些领域可能看不到任何不对称. 这对于不合适的迁移和能量感知的安置可能会有问题. 因此, 对于受影响的平台, 它可能导致对唤醒和 CPU 选择路径的自定义更改.
这组补丁修改了执行非对称检测的方式, 允许将非对称拓扑级别固定在最低的拓扑级别上, 在最低的拓扑级别上, 给定调度域中的所有 CPU 都可以看到整个 CPU 容量范围. asym_cpu_capacity_level 还将跟踪那些观察到任何非对称范围的级别, 以使用 SD_ASYM_CPUCAPACITY 标志表示相应的调度域, 并为这些域启用不匹配迁移. 为了区分局部和全范围 CPU 容量不对称的调度域, 引入了新的调度域标志: SD_ASYM_CPUCAPACITY_FULL. | v7 ☑ 5.14-rc1 | [LORE v1](https://lore.kernel.org/lkml/1618578085-29584-1-git-send-email-beata.michalska@arm.com)
*-*-*-*-*-*-*-*
[LORE v7](https://lore.kernel.org/all/20210603140627.8409-1-beata.michalska@arm.com) |
| 2022/04/27 | Vincent Donnefort | [feec() energy margin removal](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log?id=b812fc9768e0048582c8e18d7b66559c1758dde1) | 20220427143304.3950488-1-vincent.donnefort@arm.com | v7 ☑✓ 6.0-rc1 | [LORE v7,0/7](https://lore.kernel.org/all/20220427143304.3950488-1-vincent.donnefort@arm.com)
*-*-*-*-*-*-*-*
[LORE v11,0/7](https://lore.kernel.org/all/20220621090414.433602-1-vdonnefort@google.com) |
@@ -4438,7 +4408,7 @@ sched_init_domains()
* asymmetric CPU capacity support for WAKEUP @4.9
-早期调度器目前并没有在 AMP 架构(比如 ARM big.LITTLE)上为提高性能做太多工作. v4.9 [sched: Clean-ups and asymmetric cpu capacity support](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=3273163c6775c4c21823985304c2364b08ca6ea2) 为调度器实现 Capacity Awareness. 这是一次最基础的尝试. 完成了 wakeup 路径的 capacityt aware. 允许 SD_ASYM_CPUCAPACITY 域内做 SD_BALANCE_WAKE, 并且 wake_affine 时引入了 wake_cap().
+早期调度器目前并没有在 AMP 架构 (比如 ARM big.LITTLE) 上为提高性能做太多工作. v4.9 [sched: Clean-ups and asymmetric cpu capacity support](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=3273163c6775c4c21823985304c2364b08ca6ea2) 为调度器实现 Capacity Awareness. 这是一次最基础的尝试. 完成了 wakeup 路径的 capacityt aware. 允许 SD_ASYM_CPUCAPACITY 域内做 SD_BALANCE_WAKE, 并且 wake_affine 时引入了 wake_cap().
引入 [SD_ASYM_CPUCAPACITY 标记](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1f6e6c7cb9bcd58abb5ee11243e0eefe6b36fc8e).
@@ -4450,18 +4420,18 @@ sched_init_domains()
接着 v4.10 [sched: Clean-ups and asymmetric cpu capacity support](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=893c5d2279041afeb593f1fa8edd9d02edf5b7cb) 为调度器实现 Capacity Awareness 的时候, 针对 load_balance 路径做了优化.
-在低利用率(low-utilization scenarios)的场景下, find_idlest_group() 中比较相对负载 [avg_load](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L5459) 和 [runnable_load](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L5461) 并不总是最优的选择. 在这些场景中, 如果系统组包含不同数量的 CPU 或不同计算能力的 CPU, 那么这时候考虑空闲容量, 系统的性能会明显优于只考虑相对负载的情况. 因此 [COMMIT2 6a0b19c0f39a("sched/fair: Consider spare capacity in find_idlest_group()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6a0b19c0f39a7a7b7fb77d3867a733136ff059a3) 实现了 find_idlest_group() 对剩余容量的考虑, 除了现有的基于负载的搜索之外, 如果有足够的空闲容量, 还会找到并选择一个[剩余容量最大的 sched_group most_spare_sg 作为备选](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L5489). 如果没有, 则保留现有的行为.
+在低利用率 (low-utilization scenarios) 的场景下, find_idlest_group() 中比较相对负载 [avg_load](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L5459) 和 [runnable_load](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L5461) 并不总是最优的选择. 在这些场景中, 如果系统组包含不同数量的 CPU 或不同计算能力的 CPU, 那么这时候考虑空闲容量, 系统的性能会明显优于只考虑相对负载的情况. 因此 [COMMIT2 6a0b19c0f39a("sched/fair: Consider spare capacity in find_idlest_group()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=6a0b19c0f39a7a7b7fb77d3867a733136ff059a3) 实现了 find_idlest_group() 对剩余容量的考虑, 除了现有的基于负载的搜索之外, 如果有足够的空闲容量, 还会找到并选择一个[剩余容量最大的 sched_group most_spare_sg 作为备选](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L5489). 如果没有, 则保留现有的行为.
struct sched_group_capacity 当前表示 sched_group 内所有 CPU 的计算容量之和. 即使用它除以 group_weight 来得到每个 CPU 的平均容量, 它也隐藏了 AMP 系统中 CPU capacity 的差异(例如高 RT/IRQ 负载或 ARM big.LITTLE 架构). 因此 [commit bf475ce0a3dd ("sched/fair: Add per-CPU min capacity to sched_group_capacity")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=bf475ce0a3dd75b5d1df6c6c14ae25168caa15ac) 通过扩展 struct sched_group_capacity, 添加 min_capacity 字段以指示组中 CPU 的最小容量. 可以更容易地找到针对给定任务负载的合适 sched_group, 从而可以让高负载的任务避免使用容量较少的 CPU.
-有这样一个假设: 应该优先使用 CPU capacity 高的 CPU, 而不是将进程单独放在具有较低 CPU capacity 的 sched_group 中运行, 这样一个前提下, 如果低 capacity 的 CPU 从 capacity 更高的非过载 CPU 中 PULL 任务出来, 吞吐量会适得其反. 通过使用 min_capacity, [commit 9e0994c0a1c1 ("sched/fair: Avoid pulling tasks from non-overloaded higher capacity groups")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9e0994c0a1c1f82c705f1f66388e1bcffcee8bb9) update_sd_pick_busiest() 中不再允许[任务比较少 sgs->sum_nr_running <= sgs->group_weight](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L7429) 但是 [CPU 容量较高](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L7429)的 sched_group 作为可能最繁忙的组, 否则可能会导致一系列失败的负载平衡尝试, 从而导致强制迁移.
+有这样一个假设: 应该优先使用 CPU capacity 高的 CPU, 而不是将进程单独放在具有较低 CPU capacity 的 sched_group 中运行, 这样一个前提下, 如果低 capacity 的 CPU 从 capacity 更高的非过载 CPU 中 PULL 任务出来, 吞吐量会适得其反. 通过使用 min_capacity, [commit 9e0994c0a1c1 ("sched/fair: Avoid pulling tasks from non-overloaded higher capacity groups")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9e0994c0a1c1f82c705f1f66388e1bcffcee8bb9) update_sd_pick_busiest() 中不再允许 [任务比较少 sgs->sum_nr_running <= sgs->group_weight](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L7429) 但是 [CPU 容量较高](https://elixir.bootlin.com/linux/v4.10/source/kernel/sched/fair.c#L7429) 的 sched_group 作为可能最繁忙的组, 否则可能会导致一系列失败的负载平衡尝试, 从而导致强制迁移.
* asymmetric CPU capacity WAKEUP @5.7
当前在 AMP 系统下, 目前[依靠 wake_cap() 来推动 select_task_rq_fair() 朝以下方向发展](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3273163c6775c4c21823985304c2364b08ca6ea2), 如果 prev 或者 waker CPU 对于唤醒任务的 capacity 太小, 不足以承载当前被唤醒的任务, 那么将走到选核心慢路径(find_idlest_cpu()), 否则就进入 wake_affine 的快速路径 select_idle_sibling().
-这种直接借助 wake_affine 的策略对于早期的 AMP 架构(比如 ARM big.LITTLE)工作的很好, 之前的系统上同一个 SD_LLC 域内各个 CPU 是同构的, 但是随着架构不断的演进, ARM DynamIQ 架构允许单个 LLC 域中容纳不同 capacity 的 CPU. 这种策略就不能很好的工作了.
+这种直接借助 wake_affine 的策略对于早期的 AMP 架构 (比如 ARM big.LITTLE) 工作的很好, 之前的系统上同一个 SD_LLC 域内各个 CPU 是同构的, 但是随着架构不断的演进, ARM DynamIQ 架构允许单个 LLC 域中容纳不同 capacity 的 CPU. 这种策略就不能很好的工作了.
因此 v4.10 [sched/fair: Capacity aware wakeup rework](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=000619680c3714020ce9db17eef6a4a7ce2dc28b) 就通过在选核快速路径 select_idle_sibling() 的显式使用 capacity aware CPU selector(select_idle_capacity()) 来替代原来 SD_BALANCE_WAKE + wake_cap()/wake_affine 的选核方式.
@@ -4513,19 +4483,19 @@ v5.13-rc1 [commit 4aed8aa41524 ("sched/fair: Introduce a CPU capacity comparison
* Migrate 'misfit' tasks on asymmetric capacity systems
-在 AMP(asymmetric CPU capacity systems) 系统上, 负载密集的任务最终可能会使用不适合其计算需求的 CPU. 在这种情况下, "不匹配的" 任务应该及时迁移到具有更高 capacity 的 CPU 上, 以确保更好的吞吐量. v4.20 [sched/fair: Migrate 'misfit' tasks on asymmetric capacity systems](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9c63e84db29bcf584040931ad97c2edd11e35f6c) 来使得负载均衡支持 Misfit Task.
+在 AMP(asymmetric CPU capacity systems) 系统上, 负载密集的任务最终可能会使用不适合其计算需求的 CPU. 在这种情况下, "不匹配的" 任务应该及时迁移到具有更高 capacity 的 CPU 上, 以确保更好的吞吐量. v4.20 [sched/fair: Migrate'misfit'tasks on asymmetric capacity systems](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9c63e84db29bcf584040931ad97c2edd11e35f6c) 来使得负载均衡支持 Misfit Task.
引入了 [group_misfit_task](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L7868) 表示这种场景. Misfit Balancing 只在每 CPU 容量较低的源组和计算容量较高的目标组之间有意义. 否则, 将忽略 misfit. group_misfit_task 具有[最低优先级](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L6964), 因此任何由于[过载造成的不平衡 group_overloaded](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L6966) 都将首先处理. Misfit 的不平衡值记录在 [rq->misfit_task_load](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L3724), 并在 update_sd_lb_stats() -=> update_sg_lb_stats() 时更新到 [struct sg_lb_stats 的 group_misfit_task_load](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L7947) 中.
-Misfit Task 对调度器**负载均衡**做了如下改造, 参见 [commit cad68e552e77 ("sched/fair: Consider misfit tasks when load-balancing")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cad68e552e7774b68ae6a2c5fedb792936098b72):
+Misfit Task 对调度器 ** 负载均衡 ** 做了如下改造, 参见 [commit cad68e552e77 ("sched/fair: Consider misfit tasks when load-balancing")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cad68e552e7774b68ae6a2c5fedb792936098b72):
-1. 只有在目标组具有[更高的容量和空闲容量](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L7991)时, 才选择包含不适合的任务的组作为最繁忙的组.
+1. 只有在目标组具有 [更高的容量和空闲容量](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L7991) 时, 才选择包含不适合的任务的组作为最繁忙的组.
-2. 对于 group_misfit_task 场景的负载均衡, find_busiest_queue() 只查询 "最大" 的不匹配任务, 将其所在 RQ 作为 busiest(即 src), 因此当当前查询的繁忙的 sched_group 是一个 "不适合" 的组时, 将直接跳过[标准负载均衡路径的平均负载和组容量检查](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L8521).
+2. 对于 group_misfit_task 场景的负载均衡, find_busiest_queue() 只查询" 最大 "的不匹配任务, 将其所在 RQ 作为 busiest(即 src), 因此当当前查询的繁忙的 sched_group 是一个 "不适合" 的组时, 将直接跳过[标准负载均衡路径的平均负载和组容量检查](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L8521).
3. calculate_imbalance 计算不平衡值 env->imbalance 时, 将 "misfit" 的不平衡值 env->imbalance [设置为足够高的平衡](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L8357), 以便将任务拉出, 忽略平均负载.
-4. 如果有多个 Misfit 发生, 那么 update_sd_pick_busiest() 会选择[不匹配最严重的(highest misfit load, 即 group_misfit_task_load 值最高)](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L8022)的 CPU 作为 busiest CPU(SRC)
+4. 如果有多个 Misfit 发生, 那么 update_sd_pick_busiest() 会选择 [不匹配最严重的(highest misfit load, 即 group_misfit_task_load 值最高)](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L8022) 的 CPU 作为 busiest CPU(SRC)
5. 如果 misfit 任务单独在源 CPU 上, 就[执行主动均衡 active load balance](https://elixir.bootlin.com/linux/v4.20/source/kernel/sched/fair.c#L8610).
@@ -4540,7 +4510,7 @@ Misfit Task 对调度器**负载均衡**做了如下改造, 参见 [commit cad68
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2018/03/15 | Morten Rasmussen | [sched/fair: Migrate 'misfit' tasks on asymmetric capacity systems](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9c63e84db29bcf584040931ad97c2edd11e35f6c) | misfit task 支持, 可以理解为 asymmetric aware 的 load balance, 在进程运行过程中, 如果当前 CPU capacity 已经不能满足当前进程, 则将进程迁移到拥有更合适 capacity 的 CPU 上. | v1 ☑ 4.20-rc1 | [LORE v4,00/12](https://lore.kernel.org/lkml/1530699470-29808-1-git-send-email-morten.rasmussen@arm.com) |
+| 2018/03/15 | Morten Rasmussen | [sched/fair: Migrate'misfit'tasks on asymmetric capacity systems](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=9c63e84db29bcf584040931ad97c2edd11e35f6c) | misfit task 支持, 可以理解为 asymmetric aware 的 load balance, 在进程运行过程中, 如果当前 CPU capacity 已经不能满足当前进程, 则将进程迁移到拥有更合适 capacity 的 CPU 上. | v1 ☑ 4.20-rc1 | [LORE v4,00/12](https://lore.kernel.org/lkml/1530699470-29808-1-git-send-email-morten.rasmussen@arm.com) |
| 2021/03/11 | Valentin Schneider | [sched/fair: misfit task load-balance tweaks](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=4aed8aa41524a1fc6439171881c2bb7ace197528) | 优化 misfit task 的一些逻辑, 随后被分成两个 PART 进行合入. | v3 ☐ | [LORE v3,0/7](https://lore.kernel.org/lkml/20210311120527.167870-1-valentin.schneider@arm.com) |
| 2021/04/07 | Valentin Schneider | [sched/fair: load-balance vs capacity margins](https://lore.kernel.org/all/20210407220628.3798191-1-valentin.schneider@arm.com/) | misfit task load-balance tweaks 的补丁被拆分重构, 这个是 Part 1 | v3 ☐ 5.13-rc1 | [LORE v5,0/3](https://lore.kernel.org/all/20210407220628.3798191-1-valentin.schneider@arm.com) |
| 2021/04/16 | Valentin Schneider | [sched/fair: (The return of) misfit task load-balance tweaks](https://lore.kernel.org/patchwork/cover/1414181) | misfit task load-balance tweaks 的补丁被拆分重构, 这个是 Part 2 | v1 ☐ 5.10-rc4 | [PatchWork](https://lore.kernel.org/patchwork/cover/1414181) |
@@ -4634,15 +4604,13 @@ v5.0 [EAS(Energy Aware Scheduling)](https://git.kernel.org/pub/scm/linux/kernel/
接着 v5.1 [Register an Energy Model for Arm reference platforms](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=a9a744dd5b82843a9c99d9f97794fb51bc2ed8dd) 允许 CPUFREQ 驱动通过 dev_pm_opp_of_register_em() 向 Energy Model Framework 注册能效模型. 与 智能功率分配器 (IPA) 热调节器框架类似, 这同样依赖于 DTS 的 `dynamic-power-coefficient` 字段进行功耗的估计. 之前 IPA 已经在热框架中实现了该估计方法. 参见 devfreq_cooling_get_requested_power(), 它同时计算了动态功耗 dyn_power 和静态功耗 get_static_power();
-这是内核支持能效模型框架 (Energy Model Framework) 的第一步, 在 PM_OPP 中引入一个辅助函数 dev_pm_opp_of_register_em(), CPUFreq 驱动程序可以使用该函数注册到 EM 框架中. 这将重复在 IPA 中进行的功率估计, 直到可以使用 EM 框架将其迁移到. 一旦 EM 框架至少支持 IPA 当前支持的所有平台, IPA 也将借助 Energy Model Framework 来进行功耗的估计和热管控.
-
-> 后来在 v5.15 时, [Add callback to register with energy model](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=37f188318ea3f1da75b32df3b1a19f45d9840652) dev_pm_opp_of_register_em() 使用了新的回调函数 register_em()/cpufreq_register_em_with_opp() 进行了包装. 使得直接在 CPUFREQ 框架层完成 Energy Model 的注册.
+这是内核支持能效模型框架 (Energy Model Framework) 的第一步, 在 PM_OPP 中引入一个辅助函数 dev_pm_opp_of_register_em(), CPUFreq 驱动程序可以使用该函数注册到 EM 框架中. 这将重复在 IPA 中进行的功率估计, 直到可以使用 EM 框架将其迁移到. 一旦 EM 框架至少支持 IPA 当前支持的所有平台, IPA 也将借助 Energy Model Framework 来进行功耗的估计和热管控.> 后来在 v5.15 时, [Add callback to register with energy model](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=37f188318ea3f1da75b32df3b1a19f45d9840652) dev_pm_opp_of_register_em() 使用了新的回调函数 register_em()/cpufreq_register_em_with_opp() 进行了包装. 使得直接在 CPUFREQ 框架层完成 Energy Model 的注册.
参见 [commit a4f342b9607d ("PM / OPP: Introduce a power estimation helper")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a4f342b9607d8c2034d3135cbbb11b4028be3678). 能效模型框架 (Energy Model Framework) 提供了一个 API `dev_pm_opp_of_register_em()`, 让 CPUFREQ 等驱动程序注册 CPU 的功耗信息. 驱动程序将提供一种回调方法 `_get_cpu_power()`, 用于估计 CPU 在每个 Capacity 性能级别上的功耗. 当然, 具体硬件设备可以按照自己的实际情况来实现这个回调. 对于 CPU 来说, 最传统的实现就是 Pdyn = dynamic-power-coefficient * V^2 * f.
* 其他设备支持 Energy Model @ v5.9
-接着 v5.9 [Add support for devices in the Energy Model](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=0e0ffa855d1590e54ec0033404a49e2e57e294fe) 允许其他设备(比如 GPU 等)向 Energy Model Framework 注册能效模型.
+接着 v5.9 [Add support for devices in the Energy Model](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=0e0ffa855d1590e54ec0033404a49e2e57e294fe) 允许其他设备 (比如 GPU 等) 向 Energy Model Framework 注册能效模型.
* Thermal DEVFREQ Cooling 使用 Energy Model @ v5.11
@@ -4665,7 +4633,7 @@ Energy Model Framework 统一了系统中所有能效的感知模块和设备,
#### 7.2.5.3 Energy Model Management Framework 的改进与优化
-------
-通过感知系统中关键设备的能效信息, 内核中的性能的几个关键子系统(比如调度器和热)都可以获益. 然而, 这些信息可以以不同的格式来自不同的来源(例如DT或固件), 因此在没有标准 API 的情况下很难利用它. 为了解决这个问题, 引入一个集中的能效模型管理框架, 该框架将驱动程序提供的功率值聚集到系统中每个性能域的表中. power cost tables 可以通过平台无关的 API 提供给任何对能效感兴趣的的模块(比如, 调度器和热).
+通过感知系统中关键设备的能效信息, 内核中的性能的几个关键子系统 (比如调度器和热) 都可以获益. 然而, 这些信息可以以不同的格式来自不同的来源(例如 DT 或固件), 因此在没有标准 API 的情况下很难利用它. 为了解决这个问题, 引入一个集中的能效模型管理框架, 该框架将驱动程序提供的功率值聚集到系统中每个性能域的表中. power cost tables 可以通过平台无关的 API 提供给任何对能效感兴趣的的模块(比如, 调度器和热).
v5.0 [EAS(Energy Aware Scheduling)](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=732cd75b8c920d3727e69957b14faa7c2d7c3b75) 合入主线的时候, 使用 Energy Model 来辅助调度器进行能效感知的决策. 其中 [commit 27871f7a8a34 ("PM: Introduce an Energy Model management framework")](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=27871f7a8a341ef5c636a337856369acf8013e4e) 实现了 Energy Model Management Framework. 内核文档参见 [Power Management » Energy Model of devices](https://www.kernel.org/doc/html/latest/power/energy-model.html)
@@ -4687,25 +4655,23 @@ v5.0 [EAS(Energy Aware Scheduling)](https://git.kernel.org/pub/scm/linux/kernel/
|:-----:|:---:|:----:|:---:|:---------:|:----:|
| 2018/12/03 | Quentin Perret | [PM: Introduce an Energy Model management framework](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=27871f7a8a341ef5c636a337856369acf8013e4e) | [Energy Aware Scheduling](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=732cd75b8c920d3727e69957b14faa7c2d7c3b75) 能效感知的调度器 EAS 的其中一个补丁, 实现了 Energy Model Management Framework. | v10 ☑ 5.0-rc1 | [LORE v10,00/15](https://lore.kernel.org/lkml/20181203095628.11858-1-quentin.perret@arm.com) |
| 2020/05/27 | Lukasz Luba | [PM / EM: update callback structure and add device pointer](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=d0351cc3b0f57214d157e4d589564730af2aedae) | [Add support for devices in the Energy Model](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=0e0ffa855d1590e54ec0033404a49e2e57e294fe) 能效模型支持各类其他设备时的其中几个补丁. 由于不再只是支持 CPU, 因此各类 API 中添加了对 struct device 的支持. | v8 ☑✓ 5.9-rc1 | [LORE v8,0/8](https://lore.kernel.org/all/20200527095854.21714-1-lukasz.luba@arm.com), [关注 commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=d0351cc3b0f57214d157e4d589564730af2aedae) |
-| 2020/11/03 | Lukasz Luba | [Clarify abstract scale usage for power values in Energy Model, EAS and IPA](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=b56a352c0d3ca4640c3c6364e592be360ac0d6d4) | 能效模型开始使用一个统一抽象的 scale 值来表示功耗的值.
不同的平台和设备之间计算功耗可能使用不同的 scale. 内核子系统可能需要检查所有能量模型 (EM) 设备是否使用相同的规模. 解决该问题并将每个设备的信息存储在 EM 中.
通过 em_dev_register_perf_domain() 最后一个参数"milliwatts"(毫瓦) 设置为功耗单位的标记, EAS、IPA 和 DTPM(新的混合 PowerCap 框架) 等核心子系统将使用新的标志来捕获设备注册时是否使用了不同功率等级. 任何使用 EM 的内核 子系统可能会依赖这个标志来检查所有的 EM 设备是否使用相同的刻度. 如果有不同的刻度, 这些子系统可能决定: 返回警告 / 错误, 停止工作或崩溃 (panic). | v4 ☑✓ 5.11-rc1 | [LORE 1/2](https://lore.kernel.org/linux-doc/20200929121610.16060-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v2,0/3]https://lore.kernel.org/all/20201002114426.31277-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v3,0/4](https://lore.kernel.org/all/20201019140601.3047-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v4,0/4](https://lore.kernel.org/all/20201103090600.29053-1-lukasz.luba@arm.com), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c250d50fe2ce627ca9805d9c8ac11cbbf922a4a6) |
+| 2020/11/03 | Lukasz Luba | [Clarify abstract scale usage for power values in Energy Model, EAS and IPA](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=b56a352c0d3ca4640c3c6364e592be360ac0d6d4) | 能效模型开始使用一个统一抽象的 scale 值来表示功耗的值.
不同的平台和设备之间计算功耗可能使用不同的 scale. 内核子系统可能需要检查所有能量模型 (EM) 设备是否使用相同的规模. 解决该问题并将每个设备的信息存储在 EM 中.
通过 em_dev_register_perf_domain() 最后一个参数"milliwatts"(毫瓦) 设置为功耗单位的标记, EAS、IPA 和 DTPM(新的混合 PowerCap 框架) 等核心子系统将使用新的标志来捕获设备注册时是否使用了不同功率等级. 任何使用 EM 的内核 子系统可能会依赖这个标志来检查所有的 EM 设备是否使用相同的刻度. 如果有不同的刻度, 这些子系统可能决定: 返回警告 / 错误, 停止工作或崩溃 (panic). | v4 ☑✓ 5.11-rc1 | [LORE 1/2](https://lore.kernel.org/linux-doc/20200929121610.16060-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v2,0/3]https://lore.kernel.org/all/20201002114426.31277-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v3,0/4](https://lore.kernel.org/all/20201019140601.3047-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v4,0/4](https://lore.kernel.org/all/20201103090600.29053-1-lukasz.luba@arm.com), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=c250d50fe2ce627ca9805d9c8ac11cbbf922a4a6) |
| 2021/06/25 | Lukasz Luba | [Improve EAS energy estimation and increase precision](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7fcc17d0cb12938d2b3507973a6f93fc9ed2c7a1) | 增加能耗的计算精度, 防止因为四舍五入等造成的误差. | v1 ☑✓ 5.15-rc1 | [LORE v1,0/3](https://lore.kernel.org/all/20210625152603.25960-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v2,0/1](https://lore.kernel.org/all/20210720094153.31097-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v3](https://lore.kernel.org/all/20210803102744.23654-1-lukasz.luba@arm.com) |
| 2021/09/08 | Vincent Donnefort | [Inefficient OPPs](https://lore.kernel.org/all/1631109930-290049-1-git-send-email-vincent.donnefort@arm.com) | TODO | v7 ☑✓ 5.16-rc1 | [LORE v7,0/9](https://lore.kernel.org/all/1631109930-290049-1-git-send-email-vincent.donnefort@arm.com)
*-*-*-*-*-*-*-*
[LORE v6,0/7](https://lore.kernel.org/all/1630405453-275784-1-git-send-email-vincent.donnefort@arm.com) |
| 2022/03/16 | Lukasz Luba | [Introduce support for artificial Energy Model](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=985a67709a66c456414182ed179544786e00321e) | TODO |v1 ☑✓ 5.19-rc1 | [LORE v1,0/8](https://lore.kernel.org/all/20220316235211.29370-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE RESEND,0/8](https://lore.kernel.org/all/20220321095729.20655-1-lukasz.luba@arm.com) |
| 2022/07/07 | Lukasz Luba | [Energy Model power in micro-Watts and SCMI v3.1 alignment](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=f3ac888fc5fbdeeec1e084327de06a2765542d56) | TODO | v3 ☑✓ 6.0-rc1 | [LORE 0/4](https://lore.kernel.org/all/20220622145802.13032-1-lukasz.luba@arm.com)
*-*-*-*-*-*-*-*
[LORE v3,0/4](https://lore.kernel.org/all/20220707071555.10085-1-lukasz.luba@arm.com) |
-
-
#### 7.2.5.4 Dynamic Energy Model to handle leakage power
-------
LPC-2022 [Dynamic Energy Model to handle leakage power](https://lpc.events/event/16/contributions/1341)
-能量模型(EM) 框架描述 CPU 功率模型, 用于任务调度决策或热控制. 它是在启动期间以受支持的方式之一设置的, 并且在正常运行期间不会修改. 测试发现: 首先芯片的功耗也受其温度的影响,首先同样的 CPU 核即使同一个频点, 在不同温度下, 其功耗也存在差异, 因此不同温度下, CPU 核的能效曲线不同(温度越高, 功耗越高, 能效越差). 其次不同芯片(微架构/工艺)对温度的敏感度也不同, 因此不同温度下, 不同 CPU 核(大核/小核)的能效曲线变化也存在差异.
+能量模型 (EM) 框架描述 CPU 功率模型, 用于任务调度决策或热控制. 它是在启动期间以受支持的方式之一设置的, 并且在正常运行期间不会修改. 测试发现: 首先芯片的功耗也受其温度的影响, 首先同样的 CPU 核即使同一个频点, 在不同温度下, 其功耗也存在差异, 因此不同温度下, CPU 核的能效曲线不同(温度越高, 功耗越高, 能效越差). 其次不同芯片(微架构 / 工艺) 对温度的敏感度也不同, 因此不同温度下, 不同 CPU 核 (大核 / 小核) 的能效曲线变化也存在差异.
-为了更好地解决诸如此类问题, ARM 提出希望允许在运行时修改EM. EM 运行时修改将引入新功能:
+为了更好地解决诸如此类问题, ARM 提出希望允许在运行时修改 EM. EM 运行时修改将引入新功能:
-1. 允许提供(启动后)每个 OPP 的总功率值, 不限于任何公式或 DTS 数据.
+1. 允许提供 (启动后) 每个 OPP 的总功率值, 不限于任何公式或 DTS 数据.
2. 为芯片不同的工艺和集成方式, 允许提供适合的 SoC 的功率值.
@@ -4713,9 +4679,15 @@ LPC-2022 [Dynamic Energy Model to handle leakage power](https://lpc.events/event
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:---:|:----:|:---:|:----:|:---------:|:----:|
-| 2021/08/11 | Viresh Kumar | [cpufreq: Auto-register with energy model](https://lore.kernel.org/all/cover.1628682874.git.viresh.kumar@linaro.org) | TODO | v2 ☐☑✓ | [LORE v1,0/8](https://lore.kernel.org/all/cover.1628579170.git.viresh.kumar@linaro.org)
*-*-*-*-*-*-*-*
[LORE v2,0/9](https://lore.kernel.org/all/cover.1628682874.git.viresh.kumar@linaro.org) |
+| 2021/08/11 | Viresh Kumar | [cpufreq: Auto-register wit
+ energy model](https://lore.kernel.org/all/cover.1628682874.git.viresh.kumar@linaro.org) | TODO | v2 ☐☑✓ | [LORE v1,0/8](https://lore.kernel.org/all/cover.1628579170.git.viresh.kumar@linaro.org)
*-*-*-*-*-*-*-*
[LORE v2,0/9](https://lore.kernel.org/all/cover.1628682874.git.viresh.kumar@linaro.org) |
+#### 7.2.5.5 em_cpu_energy
+-------
+
+为了预测性能状态, 将性能域中利用率最高的 CPU 的利用率映射到请求的频率, 如 schedutil。还考虑到实际频率可能设置得更低(由于热封顶)。因此, 在计算有效频率之前, 将最大利用率限制为允许的 CPU 容量。
+
### 7.2.6 IPA(Thermal 管控)
-------
@@ -4737,7 +4709,7 @@ LPC-2022 [Dynamic Energy Model to handle leakage power](https://lpc.events/event
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:-----:|:----:|:----:|:----:|:------------:|:----:|
| 2013/10/14 | Jacob Pan | [TMON thermal monitoring/tuning tool](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=94f69966faf8e70bd655ea25f9dd5b9400567b75) | 实现温控工具 tmon. | v1 ☑✓ 3.13-rc1 | [LORE v1](https://lore.kernel.org/lkml/1381791747-7458-1-git-send-email-jacob.jun.pan@linux.intel.com)
*-*-*-*-*-*-*-*
[LORE](https://lore.kernel.org/lkml/1381259024-25433-1-git-send-email-jacob.jun.pan@linux.intel.com)
*-*-*-*-*-*-*-*
[LORE v1](https://lore.kernel.org/all/1381791747-7458-1-git-send-email-jacob.jun.pan@linux.intel.com) |
-| 2022/04/20 | Daniel Lezcano | [tools/thermal: thermal library and tools](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=cb4487d2b4043bbe98f60f2628387b40fa4896f8) | Linaro 提出了一个与 Linux 内核的热框架接口的热库. 作为其中的一部分, 它也是一个用于用户空间的温度计实用程序, 用于监视热数据. 实现了 Netlink 通知机制, 以接收散热配置发现、跳变点更改和违规以及冷却设备更改通知. 这种抽象使用户空间更容易处理 Linux 内核的热框架. 在这个库之上构建的温控工具将允许从通过配置文件指定的一组热区域捕获温度. 这个低开销的工具可以很容易地捕获热数据, 然后集成到其他工具, 如 GNU Plot. 还提供了一个基本的 "散热" 守护程序. 参见 [New Thermal Library, "Thermometer" Tool Proposed For Linux](https://www.phoronix.com/scan.php?page=news_item&px=Linux-Thermometer-RFC), [New Thermal Library & Temperature Capture Tool Readied For Linux 5.19](https://www.phoronix.com/scan.php?page=news_item&px=Linux-5.19-New-Thermal-Lib-Tool) | v3 ☑✓ 5.19-rc1 | [LORE v1,0/4](https://lore.kernel.org/lkml/20220218125334.995447-1-daniel.lezcano@linaro.org)
*-*-*-*-*-*-*-*
[LORE RFC,v1,1/4](https://lore.kernel.org/lkml/20220214210446.255780-1-daniel.lezcano@linaro.org)
*-*-*-*-*-*-*-*
[LORE v3,0/4](https://lore.kernel.org/all/20220420160933.347088-1-daniel.lezcano@linaro.org) |
+| 2022/04/20 | Daniel Lezcano | [tools/thermal: thermal library and tools](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=cb4487d2b4043bbe98f60f2628387b40fa4896f8) | Linaro 提出了一个与 Linux 内核的热框架接口的热库. 作为其中的一部分, 它也是一个用于用户空间的温度计实用程序, 用于监视热数据. 实现了 Netlink 通知机制, 以接收散热配置发现、跳变点更改和违规以及冷却设备更改通知. 这种抽象使用户空间更容易处理 Linux 内核的热框架. 在这个库之上构建的温控工具将允许从通过配置文件指定的一组热区域捕获温度. 这个低开销的工具可以很容易地捕获热数据, 然后集成到其他工具, 如 GNU Plot. 还提供了一个基本的 "散热" 守护程序. 参见 [New Thermal Library,"Thermometer"Tool Proposed For Linux](https://www.phoronix.com/scan.php?page=news_item&px=Linux-Thermometer-RFC), [New Thermal Library & Temperature Capture Tool Readied For Linux 5.19](https://www.phoronix.com/scan.php?page=news_item&px=Linux-5.19-New-Thermal-Lib-Tool) | v3 ☑✓ 5.19-rc1 | [LORE v1,0/4](https://lore.kernel.org/lkml/20220218125334.995447-1-daniel.lezcano@linaro.org)
*-*-*-*-*-*-*-*
[LORE RFC,v1,1/4](https://lore.kernel.org/lkml/20220214210446.255780-1-daniel.lezcano@linaro.org)
*-*-*-*-*-*-*-*
[LORE v3,0/4](https://lore.kernel.org/all/20220420160933.347088-1-daniel.lezcano@linaro.org) |
#### 7.2.6.3 Thermal Pressure
-------
@@ -4761,7 +4733,7 @@ $Pdyn = C \times V^2 \times f = dynamic-power-coefficient \times V^2 \times f$
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2015/11/17 | Punit Agrawal | [Platform support for thermal management on Junoe](https://lore.kernel.org/all/1447761983-12415-1-git-send-email-punit.agrawal@arm.com) | 该系列增加了对 ARM Juno 开发平台上热管理的支持. 添加了最基础的公共设施, 以支持注册与电源分配器热调控器一起工作的 CPU cooling device. | v5 ☐☑✓ | [LORE 0/9](https://lore.kernel.org/all/1437573763-6525-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v2,00/10](https://lore.kernel.org/all/1438615378-14241-1-git-send-email-punit.agrawal@arm.com) |
-| 2015/11/17 | Punit Agrawal | [Dynamic power model from device tree](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=2f7e8a175db72bdaf377235962fd85796edb3fbc) | 该补丁集为 CPU 构建单系数动态功率模型提供了支持. CPU 冷却设备使用该模型来提供功耗的估计, 并将分配的功率转换为性能上限.
[补丁 1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3be3f8f36e7349006f19c8c8f0d686e98462a993) 扩展了 CPU DTS 节点, 增加可选的 dynamic-power-coefficient 字段用来提供动态功率系数, 该系数可用于为 CPU 创建动态功率模型. 当系统受到热管控时, 该模型用于限制设备的功耗(使用 power_allocator 调控器).
补丁 2-3 扩展了 cpufreq-dt 和 arm_big_little CPUFREQ 驱动程序, 在提供动态系数的情况下注册 CPU cooling device. | v5 ☑✓ 4.5-rc1 | [LORE 0/9](https://lore.kernel.org/all/1437573763-6525-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v2,00/10](https://lore.kernel.org/all/1438615378-14241-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v3,0/3](https://lore.kernel.org/all/1447090163-13700-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v4,0/3](https://lore.kernel.org/all/1447702225-13323-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v5,0/3](https://lore.kernel.org/all/1447761983-12415-1-git-send-email-punit.agrawal@arm.com) |
+| 2015/11/17 | Punit Agrawal | [Dynamic power model from device tree](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=2f7e8a175db72bdaf377235962fd85796edb3fbc) | 该补丁集为 CPU 构建单系数动态功率模型提供了支持. CPU 冷却设备使用该模型来提供功耗的估计, 并将分配的功率转换为性能上限.
[补丁 1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3be3f8f36e7349006f19c8c8f0d686e98462a993) 扩展了 CPU DTS 节点, 增加可选的 dynamic-power-coefficient 字段用来提供动态功率系数, 该系数可用于为 CPU 创建动态功率模型. 当系统受到热管控时, 该模型用于限制设备的功耗(使用 power_allocator 调控器).
补丁 2-3 扩展了 cpufreq-dt 和 arm_big_little CPUFREQ 驱动程序, 在提供动态系数的情况下注册 CPU cooling device. | v5 ☑✓ 4.5-rc1 | [LORE 0/9](https://lore.kernel.org/all/1437573763-6525-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v2,00/10](https://lore.kernel.org/all/1438615378-14241-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v3,0/3](https://lore.kernel.org/all/1447090163-13700-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v4,0/3](https://lore.kernel.org/all/1447702225-13323-1-git-send-email-punit.agrawal@arm.com)
*-*-*-*-*-*-*-*
[LORE v5,0/3](https://lore.kernel.org/all/1447761983-12415-1-git-send-email-punit.agrawal@arm.com) |
### 7.2.7 OPP(Operating Performance Points)
@@ -4783,7 +4755,7 @@ $Pdyn = C \times V^2 \times f = dynamic-power-coefficient \times V^2 \times f$
-------
-不管是服务器领域, 还是终端以及嵌入式 rtos 等场景, 性能与功耗都是一个永恒的话题. 因此我们经常把它们合在一起称为"性能, 功耗与热". 而这些都离不开调度器的参与. 调度器通过之前提到的两个核心功能: 选核和选进程, 提升系统的性能和吞吐量, 再或者在满足性能的前提下通过功耗感知的调度来降低功耗. 之前我们提到的手段都是围绕着调度核心功能的. 通过选核让更多的 CPU 能够处于 IDLE 状态是可以降低功耗的, EAS 的实现已经与 CPUIDLE 紧密结合. 但是别忘了, 我们还有 DVFS, 通过调压调频也可以降低功耗. 因此 EAS 也提供了一些手段能够让调度器感知 CPUFREQ 框架.
+不管是服务器领域, 还是终端以及嵌入式 rtos 等场景, 性能与功耗都是一个永恒的话题. 因此我们经常把它们合在一起称为 "性能, 功耗与热". 而这些都离不开调度器的参与. 调度器通过之前提到的两个核心功能: 选核和选进程, 提升系统的性能和吞吐量, 再或者在满足性能的前提下通过功耗感知的调度来降低功耗. 之前我们提到的手段都是围绕着调度核心功能的. 通过选核让更多的 CPU 能够处于 IDLE 状态是可以降低功耗的, EAS 的实现已经与 CPUIDLE 紧密结合. 但是别忘了, 我们还有 DVFS, 通过调压调频也可以降低功耗. 因此 EAS 也提供了一些手段能够让调度器感知 CPUFREQ 框架.
### 7.3.1 传统 CPU 调频策略
@@ -4832,7 +4804,7 @@ CPUFreq 驱动是处理和平台相关的逻辑, Governor 中实现了具体的
高通在自己基于 AOSP 的 GKI 中, 提供了一个 schedutil 类似的调频 GOVERNOR [CPUFREQ_WALT](https://source.codeaurora.cn/quic/la/kernel/msm-5.10/tree/kernel/sched/walt/cpufreq_walt.c?h=kernel.lnx.5.10.r1-rel), 与 WALT 地深度绑定和优化. 并通过 waltgov_tunables 提供了近似于 interactive 的少量参数, 允许用户态干预. 只是这里实现的 target_load 是通过 target_load_thresh 和 target_load_shift 映射得到的, 参见 [walt_map_util_freq()](https://source.codeaurora.cn/quic/la/kernel/msm-5.10/tree/kernel/sched/walt/cpufreq_walt.c?h=kernel.lnx.5.10.r1-rel#n204). 因此用户对于 target_load 的设置相比较原来 interactive 直接设置 target_loads 参数的方式更弱一些.
-小米在邮件列表发布了 [Provide USF for the portable equipment.](https://lore.kernel.org/all/cover.1596612536.git.yangdongdong@xiaomi.com) 在启用cpufreq上的调整,并按计划调整用户敏感系数。它特别适用于在屏幕上显示更多电源保护和快速响应要求的移动设备。
+小米在邮件列表发布了 [Provide USF for the portable equipment.](https://lore.kernel.org/all/cover.1596612536.git.yangdongdong@xiaomi.com) 在启用 cpufreq 上的调整, 并按计划调整用户敏感系数。它特别适用于在屏幕上显示更多电源保护和快速响应要求的移动设备。
### 7.3.5 其他 governor
-------
@@ -4842,7 +4814,7 @@ CPUFreq 驱动是处理和平台相关的逻辑, Governor 中实现了具体的
| 时间 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----------:|:---:|
-| 2015/10/27 | Bálint Czobor | [cpufreq: interactive: New 'interactive' governor](https://lore.kernel.org/all/1445967059-6897-1-git-send-email-czoborbalint@gmail.com) | TODO | v1 ☐☑✓ | [LORE v1,0/70](https://lore.kernel.org/all/1445967059-6897-1-git-send-email-czoborbalint@gmail.com) |
+| 2015/10/27 | Bálint Czobor | [cpufreq: interactive: New'interactive'governor](https://lore.kernel.org/all/1445967059-6897-1-git-send-email-czoborbalint@gmail.com) | TODO | v1 ☐☑✓ | [LORE v1,0/70](https://lore.kernel.org/all/1445967059-6897-1-git-send-email-czoborbalint@gmail.com) |
## 7.4 Frequency Invariance Engine
@@ -4868,7 +4840,7 @@ v4.4 [Compute capacity invariant load/utilization tracking](https://git.kernel.o
| 时间 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:------:|:---:|
| 2012/8/23 | [consolidation of CPU capacity and usage](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=dfbca41f347997e57048a53755611c8e2d792924) | CPU 调频会导致 CPU capacity 的变化, 在支持 DVFS 的系统还用最大 capacity 计算负载是不合理的, 因此 PELT 需要感知 capacity 的变化, 即 FIE(Frequency Invariance Engine). [使得 sched entity usage tracking(即 running_avg_sum 与 running_avg 等) 感知 DVFS](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=0c1dc6b27dac883ee78392189c8e20e764d79bfa). 通过借助 scale_freq = arch_scale_freq_capacity(NULL, cpu) 来实现. | v10 ☑ 4.1 | [LORE v10,00/11](https://lore.kernel.org/all/1425052454-25797-1-git-send-email-vincent.guittot@linaro.org), [LKML](https://lkml.org/lkml/2015/2/27/309) |
-| 2015/8/14 | [Compute capacity invariant load/utilization tracking](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=98d8fd8126676f7ba6e133e65b2ca4b17989d32c) | PELT 支持 Capacity Invariant Engine. PELT 只感知频率的变化是不够的, 同架构但是不同微架构(比如 big.LITTLE 的小核和大核虽然都使用 ARM 架构, 但是是性能异构的)的 CPU 即使处于相同频点下, 所能提供的计算能力 capacity 也是不同的. 因此 PELT 也需要感知对不同微架构 CPU capacity 的差异. 通过借助 scale_cpu = arch_scale_cpu_capacity(NULL, cpu) 来实现. | v1 ☑4.4 | [LWN](https://lwn.net/Articles/531853), [LORE 0/6](https://lore.kernel.org/patchwork/cover/590249), [LKML](https://lkml.org/lkml/2015/8/14/296) |
+| 2015/8/14 | [Compute capacity invariant load/utilization tracking](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=98d8fd8126676f7ba6e133e65b2ca4b17989d32c) | PELT 支持 Capacity Invariant Engine. PELT 只感知频率的变化是不够的, 同架构但是不同微架构 (比如 big.LITTLE 的小核和大核虽然都使用 ARM 架构, 但是是性能异构的) 的 CPU 即使处于相同频点下, 所能提供的计算能力 capacity 也是不同的. 因此 PELT 也需要感知对不同微架构 CPU capacity 的差异. 通过借助 scale_cpu = arch_scale_cpu_capacity(NULL, cpu) 来实现. | v1 ☑4.4 | [LWN](https://lwn.net/Articles/531853), [LORE 0/6](https://lore.kernel.org/patchwork/cover/590249), [LKML](https://lkml.org/lkml/2015/8/14/296) |
| 2019/01/16 | [sched/fair: update scale invariance of PELT](https://lore.kernel.org/patchwork/cover/1034952) | v9 ☑ 5.1-rc1 | [v3](https://lore.kernel.org/patchwork/patch/784059)
*-*-*-*-*-*-*-*
[v9](https://lore.kernel.org/patchwork/cover/1034952) |
@@ -4900,7 +4872,7 @@ v4.4 [Compute capacity invariant load/utilization tracking](https://git.kernel.o
### 7.4.2 ARMv8.4 Activity Monitors support
-------
-在 5.7 之前, 对于 arm 和 arm64 平台, 这个[比例因子 freq_scale](https://elixir.bootlin.com/linux/v5.6/source/drivers/base/arch_topology.c#L32) 是根据当前频率和 cpufreq 策略记录的最大支持频率之间的比值得到的. 这个比例因子的设置由 cpufreq 驱动程序通过调用 arch_set_freq_scale() 来获取的. 当前在内核在计算时使用的频率是调频 Governor 所要求设置的频率, 但它可能不是由平台实现的频率. 这个校正因子也可以由硬件使用[一个核心计数器 SYS_AMEVCNTR0_CORE_EL0](https://elixir.bootlin.com/linux/v5.7/source/arch/arm64/kernel/topology.c#L275)和[一个常数计数器 SYS_AMEVCNTR0_CONST_EL0](https://elixir.bootlin.com/linux/v5.7/source/arch/arm64/kernel/topology.c#L274) 来获得在一段时间内的[基于频率的性能信息来获得](https://elixir.bootlin.com/linux/v5.7/source/arch/arm64/kernel/topology.c#L297). 这种方式与当前由软件获取的方式相比, 将更准确地反映 CPU 的实际当前频率.
+在 5.7 之前, 对于 arm 和 arm64 平台, 这个 [比例因子 freq_scale](https://elixir.bootlin.com/linux/v5.6/source/drivers/base/arch_topology.c#L32) 是根据当前频率和 cpufreq 策略记录的最大支持频率之间的比值得到的. 这个比例因子的设置由 cpufreq 驱动程序通过调用 arch_set_freq_scale() 来获取的. 当前在内核在计算时使用的频率是调频 Governor 所要求设置的频率, 但它可能不是由平台实现的频率. 这个校正因子也可以由硬件使用[一个核心计数器 SYS_AMEVCNTR0_CORE_EL0](https://elixir.bootlin.com/linux/v5.7/source/arch/arm64/kernel/topology.c#L275) 和[一个常数计数器 SYS_AMEVCNTR0_CONST_EL0](https://elixir.bootlin.com/linux/v5.7/source/arch/arm64/kernel/topology.c#L274) 来获得在一段时间内的[基于频率的性能信息来获得](https://elixir.bootlin.com/linux/v5.7/source/arch/arm64/kernel/topology.c#L297). 这种方式与当前由软件获取的方式相比, 将更准确地反映 CPU 的实际当前频率.
但是可能并不是所有的 CPU 都是支持 AMU 的. 为此, 需要注册一个 [late_initcall_sync()](https://elixir.bootlin.com/linux/v5.7/source/arch/arm64/kernel/topology.c#L254) 来触发策略的验证工作 [init_amu_fie()](https://elixir.bootlin.com/linux/v5.7/source/arch/arm64/kernel/topology.c#L212), 使用 amu_fie_cpus 存储了所有支持 AMU 的 cpumask. 如果 cpumask 不为 NULL, 则会使能 static key amu_fie_key 来启用基于 AMU 的 PIE 功能. 注意内核如果没有启用 CONFIG_CPU_FREQ, 则只有在所有可能的 cpu 正确支持 AMU 时, 才会在所有 CPU 上启用 AMU 计数器.
@@ -4908,9 +4880,9 @@ v4.4 [Compute capacity invariant load/utilization tracking](https://git.kernel.o
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
-| 2018/12/07 | Kristina Martsenko | [arm64: ARMv8.4 Activity Monitors support](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=c265861af2af0f667e88b1b70acc234f8c61e0ae) | ARM64 AMU 支持以及基于 AMU 的 PIE 支持.
这些补丁引入了对活动监视器单元 (Activity Monitors Unit, AMU) CPU 扩展的支持, 这是 ARMv8.4 的扩展. 这提供了用于系统管理的性能计数器. 然后使用其中的两个计数器来计算实现频率不变性所需的频率刻度校正因子. 通过 CONFIG_ARM64_AMU_EXTN 使用.
需要注意的是, 当固件运行在呈现活动监视器扩展的 CPU 上时, 必须实现 AMU 支持: 允许从较低的异常级别访问寄存器, 启用计数器, 实现保存和恢复功能. 更多细节可以在文档中找到.
考虑到活动计数器会通知 CPU 上的活动, 并且不是所有的 CPU 都可能实现扩展, 出于功能和安全的原因, [禁用了用户空间 (EL0)](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=87a1f063464afd934f0f22aac710ca65bef77af3) 和 [KVM guest](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4fcdf106a4330bb5c2306a1efbb3af3b7c0db537) 对 AMU 寄存器的访问.
在补丁 6/7 中, 两个 AMU 计数器用于计算调度器中实现信号频率不变性[所需的频率比例因子](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cd0ed03a8903a0b0c6fc36e32d133d1ddfe70cd6), 其基础是增加了一个接口来支持基于计数器的频率不变性 - arch_scale_freq_tick. 基于计数器的频率比例因子的接口和更新点是基于 x86 [1] 中引入频率不变性的补丁中的类似方法, 首先通过 [cpufreq_get_hw_max_freq()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=bbce8eaa603236bf958b0d24e6377b3f3b623991) 获取. | v8 ☑ 5.7-rc1 | [LORE v2,0/6](https://lore.kernel.org/lkml/20191218182607.21607-1-ionela.voinescu@arm.com)
*-*-*-*-*-*-*-*
[LORE v3,0/7](https://lore.kernel.org/lkml/20200211184542.29585-1-ionela.voinescu@arm.com)
*-*-*-*-*-*-*-*
[LORE v6,0/7](https://lore.kernel.org/lkml/20200305090627.31908-1-ionela.voinescu@arm.com) |
+| 2018/12/07 | Kristina Martsenko | [arm64: ARMv8.4 Activity Monitors support](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=c265861af2af0f667e88b1b70acc234f8c61e0ae) | ARM64 AMU 支持以及基于 AMU 的 PIE 支持.
这些补丁引入了对活动监视器单元 (Activity Monitors Unit, AMU) CPU 扩展的支持, 这是 ARMv8.4 的扩展. 这提供了用于系统管理的性能计数器. 然后使用其中的两个计数器来计算实现频率不变性所需的频率刻度校正因子. 通过 CONFIG_ARM64_AMU_EXTN 使用.
需要注意的是, 当固件运行在呈现活动监视器扩展的 CPU 上时, 必须实现 AMU 支持: 允许从较低的异常级别访问寄存器, 启用计数器, 实现保存和恢复功能. 更多细节可以在文档中找到.
考虑到活动计数器会通知 CPU 上的活动, 并且不是所有的 CPU 都可能实现扩展, 出于功能和安全的原因, [禁用了用户空间 (EL0)](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=87a1f063464afd934f0f22aac710ca65bef77af3) 和 [KVM guest](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4fcdf106a4330bb5c2306a1efbb3af3b7c0db537) 对 AMU 寄存器的访问.
在补丁 6/7 中, 两个 AMU 计数器用于计算调度器中实现信号频率不变性[所需的频率比例因子](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cd0ed03a8903a0b0c6fc36e32d133d1ddfe70cd6), 其基础是增加了一个接口来支持基于计数器的频率不变性 - arch_scale_freq_tick. 基于计数器的频率比例因子的接口和更新点是基于 x86 [1] 中引入频率不变性的补丁中的类似方法, 首先通过 [cpufreq_get_hw_max_freq()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=bbce8eaa603236bf958b0d24e6377b3f3b623991) 获取. | v8 ☑ 5.7-rc1 | [LORE v2,0/6](https://lore.kernel.org/lkml/20191218182607.21607-1-ionela.voinescu@arm.com)
*-*-*-*-*-*-*-*
[LORE v3,0/7](https://lore.kernel.org/lkml/20200211184542.29585-1-ionela.voinescu@arm.com)
*-*-*-*-*-*-*-*
[LORE v6,0/7](https://lore.kernel.org/lkml/20200305090627.31908-1-ionela.voinescu@arm.com) |
| 2020/11/07 | Ionela Voinescu | [arm64: cppc: add FFH support using AMUs](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=68c5debcc06d6d24f15dbf978780fc5efc147d5e) | 通过 AMU 实现了 ARM64 CPPC 的 cpc_read_ffh(). 用来获取 CPU 频率. | v4 ☑ 5.11-rc1 | [LORE v4,0/3](https://lore.kernel.org/all/20201106125334.21570-1-ionela.voinescu@arm.com), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=68c5debcc06d6d24f15dbf978780fc5efc147d5e) |
-| 2016/02/19 | Viresh Kumar | [arm64: topology: improvements](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=abedf8e2419fb873d919dd74de2e84b510259339) | 如果 CPUFREQ 驱动程序作为模块构建, AMU 计数器今天将不会使用, 因为 AMU 内核要求在初始化后期准备好所有内容.通过注册 CPUFREQ 策略通知来修复此问题. 请注意, 在第一次为所有 CPU 调用 CPUFREQ_CREATE_POLICY 通知之后, AMU 不再和 CPUFREQ 有任何依赖关系.因此
1. 我们不需要在 CPUFREQ_REMOVE_POLICY 通知上执行任何操作.
2. 出于同样的原因, 我们在 amu_fie_setup() 的开头检查 CPU 是否已经被解析, 如果是, 则跳过. | v4 ☑ 5.12-rc1 | [LKML v4,0/3](https://lore.kernel.org/all/cover.1610104461.git.viresh.kumar@linaro.org), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a5f1b187cd24f7da35eb7a48fc50839c554d52a2) |
+| 2016/02/19 | Viresh Kumar | [arm64: topology: improvements](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=abedf8e2419fb873d919dd74de2e84b510259339) | 如果 CPUFREQ 驱动程序作为模块构建, AMU 计数器今天将不会使用, 因为 AMU 内核要求在初始化后期准备好所有内容. 通过注册 CPUFREQ 策略通知来修复此问题. 请注意, 在第一次为所有 CPU 调用 CPUFREQ_CREATE_POLICY 通知之后, AMU 不再和 CPUFREQ 有任何依赖关系. 因此
1. 我们不需要在 CPUFREQ_REMOVE_POLICY 通知上执行任何操作.
2. 出于同样的原因, 我们在 amu_fie_setup() 的开头检查 CPU 是否已经被解析, 如果是, 则跳过. | v4 ☑ 5.12-rc1 | [LKML v4,0/3](https://lore.kernel.org/all/cover.1610104461.git.viresh.kumar@linaro.org), [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a5f1b187cd24f7da35eb7a48fc50839c554d52a2) |
### 7.4.3 Frequency Invariance 框架
@@ -4926,7 +4898,7 @@ v4.4 [Compute capacity invariant load/utilization tracking](https://git.kernel.o
第一次合入 [cpufreq: CPPC: Add support for frequency invariance](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=4c38f2df71c8).
-随后 Revert [Revert "cpufreq: CPPC: Add support for frequency invariance"](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=771fac5e26c17845de8c679e6a947a4371e86ffc)
+随后 Revert [Revert"cpufreq: CPPC: Add support for frequency invariance"](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=771fac5e26c17845de8c679e6a947a4371e86ffc)
第二次合入 [关键 COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1eb5dde674f57b1a1918dab33f09e35cdd64eb07)
@@ -4934,16 +4906,16 @@ v4.4 [Compute capacity invariant load/utilization tracking](https://git.kernel.o
## 7.5 uclamp
-------
-[Linux Kernel Utilization Clamping简介](https://blog.csdn.net/feelabclihu/article/details/111714164)
+[Linux Kernel Utilization Clamping 简介](https://blog.csdn.net/feelabclihu/article/details/111714164)
-Android Kernel 5.4 以前, 一直存在一个 schedtune 的特性, 可以同 cgroup 一起使用, 对一组进程设定 util/freq 的加权. 从而限制不同分组的进程对 cpuutil 和 cpufreq 的影响. 但是由于存在诸多缺陷, 因此一直没能进入主线. 最终, uclamp 作为 schedtune 的替代方案, 弥补了 schedtune 种种不足, 使得 uclamp 最终合入mainline kernel.
+Android Kernel 5.4 以前, 一直存在一个 schedtune 的特性, 可以同 cgroup 一起使用, 对一组进程设定 util/freq 的加权. 从而限制不同分组的进程对 cpuutil 和 cpufreq 的影响. 但是由于存在诸多缺陷, 因此一直没能进入主线. 最终, uclamp 作为 schedtune 的替代方案, 弥补了 schedtune 种种不足, 使得 uclamp 最终合入 mainline kernel.
schedtune 与 uclamp 都是由 ARM 公司的 Patrick Bellasi 主导开发.
| 比较 | schedtune | uclamp |
|:---:|:---------:|:------:|
| mainline | NA | kernel 5.4 |
-| interface | 仅支持 cgroup v1
限定了 cgroups 的数目 | 同事支持 cgroup v1, v2
不限定 cgroups 的数量
基于 procfs 的全局接口
基于 syscall 的 per-task 接口 |
+| interface | 仅支持 cgroup v1
限定了 cgroups 的数目 | 同事支持 cgroup v1, v2
不限定 cgroups 的数量
基于 procfs 的全局接口
基于 syscall 的 per-task 接口 |
| boost 设定 | 基于 SPC 算法, tunning 比较困难 | 直接限定 [min_util, max_util] 的阈值, 简单明了 |
| 低时延设定 | 通过 prefer-idle 设置 | 通过 latency_sensitive 设定 |
| RT TASK | NA | 支持 |
@@ -4984,9 +4956,9 @@ v5.15 合入的 [Add support for 32-bit tasks on asymmetric AArch32 systems](htt
2. 为进程引入了 [task_cpu_possible_mask()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=d82158fa6df4237c9859b27d719c53b4fe09e69e) 来标记进程能运行的 cpumask. 对于系统中的 32 位程序来说, 就是 system_32bit_el0_cpumask. 同时进程中[新增 task_struct::user_cpus_ptr](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b90ca8badbd11488e5f762346b028666808164e7), 随后将 cpuset 和 cpu affinity 等都感知到了进程 affinity 的这些变更.
-3. 这种架构下, 执行 execve() 的 CPU 可能与新的应用程序映像不兼容(比如在不支持 32 位的应用的 CPU 上通过 execve() 执行了一个 32位的应用程序). 这种情况下, 需要限制任务的关联掩码, 并确保[在兼容的 CPU 上加载并启动](https://elixir.bootlin.com/linux/v5.15/source/arch/arm64/kernel/process.c#L608)新的程序镜像. 从用户空间的角度来看, 这看起来就像不兼容的 CPU 在任务的关联掩码中被热插拔一样. 类似地, 如果后续的 execve() 恢复为兼容映像, 则[旧的 CPU 亲和性就需要恢复](https://elixir.bootlin.com/linux/v5.15/source/arch/arm64/kernel/process.c#L610). 比如在不支持 32 位应用的系统上执行 32 位任务时, 则通过 [force_compatible_cpus_allowed_ptr()](https://elixir.bootlin.com/linux/v5.15/source/kernel/sched/core.c#L2919) 确保进程在能够实际运行它的 CPU 上启动. 类似地, 在这样的系统上再次执行 64 位任务时, 如果以前受到限制, 请尝试通过 [relax_compatible_cpus_allowed_ptr()](https://elixir.bootlin.com/linux/v5.15/source/kernel/sched/core.c#L2969) 从 user_cpus_ptr 恢复进程的 cpumask.
+3. 这种架构下, 执行 execve() 的 CPU 可能与新的应用程序映像不兼容 (比如在不支持 32 位的应用的 CPU 上通过 execve() 执行了一个 32 位的应用程序). 这种情况下, 需要限制任务的关联掩码, 并确保[在兼容的 CPU 上加载并启动](https://elixir.bootlin.com/linux/v5.15/source/arch/arm64/kernel/process.c#L608) 新的程序镜像. 从用户空间的角度来看, 这看起来就像不兼容的 CPU 在任务的关联掩码中被热插拔一样. 类似地, 如果后续的 execve() 恢复为兼容映像, 则[旧的 CPU 亲和性就需要恢复](https://elixir.bootlin.com/linux/v5.15/source/arch/arm64/kernel/process.c#L610). 比如在不支持 32 位应用的系统上执行 32 位任务时, 则通过 [force_compatible_cpus_allowed_ptr()](https://elixir.bootlin.com/linux/v5.15/source/kernel/sched/core.c#L2919) 确保进程在能够实际运行它的 CPU 上启动. 类似地, 在这样的系统上再次执行 64 位任务时, 如果以前受到限制, 请尝试通过 [relax_compatible_cpus_allowed_ptr()](https://elixir.bootlin.com/linux/v5.15/source/kernel/sched/core.c#L2969) 从 user_cpus_ptr 恢复进程的 cpumask.
-4. 同时 [CPUHOTPLUG 也要做类似的修正](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=df950811f4a884d08f05e22a8e0089d54bb4ba70), 如果我们想支持 32 位应用程序, 但是在这种异构的系统中, 当我们确定了存在一个 CPU 不支持 32 位应用支持时, 我们必须确保系统始终拥有一个 online 的支持 32 位应用的 CPU. 这对于调度程序很重要, 如果没有支持 32 位 CPU 可用, 则由于 HOTPLUG 事件而导致的强制迁移将挂起. enable_mismatched_32bit_el0 中用 lucky_winner 标记了系统发现的一个支持 32为应用的 CPU, 将其 offline_disabled 设置为 true, 禁止其下线.
+4. 同时 [CPUHOTPLUG 也要做类似的修正](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=df950811f4a884d08f05e22a8e0089d54bb4ba70), 如果我们想支持 32 位应用程序, 但是在这种异构的系统中, 当我们确定了存在一个 CPU 不支持 32 位应用支持时, 我们必须确保系统始终拥有一个 online 的支持 32 位应用的 CPU. 这对于调度程序很重要, 如果没有支持 32 位 CPU 可用, 则由于 HOTPLUG 事件而导致的强制迁移将挂起. enable_mismatched_32bit_el0 中用 lucky_winner 标记了系统发现的一个支持 32 为应用的 CPU, 将其 offline_disabled 设置为 true, 禁止其下线.
5. 在 [sysfs 中提供 `/sys/devices/system/cpu/aarch32_el0`](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7af33504d1c8077b40121294b5eb6e680a859468), 向用户空间公布具有 32 位功能支持的 CPU 集 system_32bit_el0_cpumask(). 同时提供了一个内核启动参数 [allow_mismatched_32bit_el0 来开启](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ead7de462ae56b2d2e56fb5a414f6e916dddc4c9). 只有添加了该启动参数, [sysfs 接口](https://elixir.bootlin.com/linux/v5.15/source/arch/arm64/kernel/cpufeature.c#L1343)才会提供. HOTPLUG 也才会限制.
@@ -5007,13 +4979,13 @@ v5.15 合入的 [Add support for 32-bit tasks on asymmetric AArch32 systems](htt
## 7.8 关联线程组 RTG
-------
-RTG(Related Thread Group) 是高通为 ANDROID 提供的芯片解决方案中的一个调度关键特性, 提供了对一组线程进行(精准)资源供给(大小核, 频率等)的能力.
+RTG(Related Thread Group) 是高通为 ANDROID 提供的芯片解决方案中的一个调度关键特性, 提供了对一组线程进行 (精准) 资源供给 (大小核, 频率等) 的能力.
-参见 [微信公众号-内核工匠-调度器分支之 RTG](https://mp.weixin.qq.com/s/SOAmKof5xiDJ-OFx7Zqh-g)
+参见 [微信公众号 - 内核工匠 - 调度器分支之 RTG](https://mp.weixin.qq.com/s/SOAmKof5xiDJ-OFx7Zqh-g)
最新 msm-5.10 合入 [commit d3b261dbd232 ("sched/walt: Introduce WALT as a module")](https://source.codeaurora.cn/quic/la/kernel/msm-5.10/diff/kernel/sched/walt/walt.c?h=kernel.lnx.5.10.r1-rel&id=d3b261dbd2324c313bc4892bd6fba69bb8b50cc2).
-ANDROID 上很多实际应用场景, 比如说绘帧等, 往往是由多个线程(这些线程可能分属不同的进程)共同协同完成的, 但是不管是 PELT/WALT 的 Load Tracking 还是 schedutil 调频, 都是针对 per-task 或者 per-rq 的. 这就造成系统(主要是内核)并不感知这些之间的关联, 更不感知一帧的实际的负载. 可见系统中的线程不是孤立的, 它们之间或多或少存在各种依赖关系, 正是他们相互依赖共同协同才完成了特定的工作.那从不管是调度的角度讲、还是从动态调频 DCVS 的角度, 都不能忽视这种存在.
+ANDROID 上很多实际应用场景, 比如说绘帧等, 往往是由多个线程 (这些线程可能分属不同的进程) 共同协同完成的, 但是不管是 PELT/WALT 的 Load Tracking 还是 schedutil 调频, 都是针对 per-task 或者 per-rq 的. 这就造成系统 (主要是内核) 并不感知这些之间的关联, 更不感知一帧的实际的负载. 可见系统中的线程不是孤立的, 它们之间或多或少存在各种依赖关系, 正是他们相互依赖共同协同才完成了特定的工作. 那从不管是调度的角度讲、还是从动态调频 DCVS 的角度, 都不能忽视这种存在.
由此 RTG 就应运而生, 它依赖于 WALT 的能力.
@@ -5030,7 +5002,7 @@ ANDROID 上很多实际应用场景, 比如说绘帧等, 往往是由多个线
终端场景下, 中大核的能效比比较差, 因此必要的时候如果能提供必要的隔离功能, 对整个系统的能效的管控和优化将是非常有效地.
-1. 在系统负载较小的时候, 把中大核(特别是大核)给隔离出来, 不再允许线程 RUNNING ON. 保证系统的功耗.
+1. 在系统负载较小的时候, 把中大核 (特别是大核) 给隔离出来, 不再允许线程 RUNNING ON. 保证系统的功耗.
2. 在系统负载较高的时候, 按照策略逐步放开中大核, 保证系统的性能.
@@ -5051,7 +5023,7 @@ ANDROID 上很多实际应用场景, 比如说绘帧等, 往往是由多个线
CONFIG_SCHED_CORE_CTL 的方案, 不光通过 do_isolation_work_cpu_stop() 支持迁移任务, 还通过 hrtimer_quiesce_cpu() 和 timer_quiesce_cpu() 完成了对 timer 的迁移. 一直到 MSM-5.4, CPU_ISOLATION & CORE_CTRL 的方案都运行良好.
-但是 msm-5.10 引入了 GKI 框架之后, CPU_ISOLATION 引入 cpu_isolation_mask 的方式, 在原生的调度等路径下需要感知 cpu_isolated(), 这种方式需要对原生内核增加较多的侵入式修改, 不被 AOSP 所接受. 因此 ARM 的开发者为 AOSP 引入了 pause_cpus/resume_cpus(), 借助 CPU_HOTPLUG 的框架实现快速地, pause_cpus 可以使 CPU 处于空闲状态, resume_cpus 则期望尽可能快地恢复, 同时对系统造成尽可能少的破坏. 由于全量的 CPU_HOTPLUG 流程太慢. 从调度器的角度来看, 暂停(pause)的 CPU 只是去激活(deactivated). 这对应于热插拔的第一步. 每个暂停操作仍然需要一些较重的同步, 因此 pause_cpus() 允许一次暂停多个 CPU 从而缓解这个问题.
+但是 msm-5.10 引入了 GKI 框架之后, CPU_ISOLATION 引入 cpu_isolation_mask 的方式, 在原生的调度等路径下需要感知 cpu_isolated(), 这种方式需要对原生内核增加较多的侵入式修改, 不被 AOSP 所接受. 因此 ARM 的开发者为 AOSP 引入了 pause_cpus/resume_cpus(), 借助 CPU_HOTPLUG 的框架实现快速地, pause_cpus 可以使 CPU 处于空闲状态, resume_cpus 则期望尽可能快地恢复, 同时对系统造成尽可能少的破坏. 由于全量的 CPU_HOTPLUG 流程太慢. 从调度器的角度来看, 暂停 (pause) 的 CPU 只是去激活(deactivated). 这对应于热插拔的第一步. 每个暂停操作仍然需要一些较重的同步, 因此 pause_cpus() 允许一次暂停多个 CPU 从而缓解这个问题.
# 8 实时性 linux PREEMPT_RT
@@ -5059,13 +5031,12 @@ CONFIG_SCHED_CORE_CTL 的方案, 不光通过 do_isolation_work_cpu_stop() 支
[The 2022 embedded Linux update](https://lwn.net/Articles/899742)
-[实时 Linux 内核调度器 | Real-Time Linux Kernel Scheduler
-](https://rtoax.blog.csdn.net/article/details/113728859)
+[实时 Linux 内核调度器 | Real-Time Linux Kernel Scheduler](https://rtoax.blog.csdn.net/article/details/113728859)
## 8.1 抢占支持(preemption)
-------
-**2.6 时代开始支持** (首次在2.5.4版本引入[37](#refer-anchor-37), 感谢知友 [@costa](https://www.zhihu.com/people/78ceb98e7947731dc06063f682cf9640) 考证! 关于 Linux 版本规则, 可看我文章[4](#refer-anchor-4).
+**2.6 时代开始支持 ** (首次在 2.5.4 版本引入[37](#refer-anchor-37), 感谢知友 [@costa](https://www.zhihu.com/people/78ceb98e7947731dc06063f682cf9640) 考证! 关于 Linux 版本规则, 可看我文章[4](#refer-anchor-4).
可抢占性, 对一个系统的调度延时具有重要意义. 2.6 之前, 一个进程进入内核态后, 别的进程无法抢占, 只能等其完成或退出内核态时才能抢占, 这带来严重的延时问题, 2.6 开始支持内核态抢占.
@@ -5104,7 +5075,7 @@ NOHZ 社区测试用例 [frederic/dynticks-testing.git](https://git.kernel.org/p
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
-| 2007/02/16 | Thomas Gleixner | [New hrtimers/dynticks patches](https://www.lkml.org/lkml/2007/1/29/30) | 引入 CONFIG_TICK_ONESHOT 和 CONFIG_NO_HZNO_HZ, 以支持在 CPU 空闲的时候停掉 tick, 进入 NOHZ 模式.
所有进入 NO_HZ 的 CPU 被标记在 [nohz_cpu_mask](https://elixir.bootlin.com/linux/v2.6.21/source/kernel/time/tick-sched.c#L211) 中, 直到
1.当进入 [cpu_idle()](https://elixir.bootlin.com/linux/v2.6.21/source/arch/i386/kernel/process.c#L177)已经[中断退出](https://elixir.bootlin.com/linux/v2.6.21/source/kernel/softirq.c#L309)却不需要 RESCHED 时, 则通过 通过 [tick_nohz_stop_sched_tick()](https://elixir.bootlin.com/linux/v2.6.21/source/kernel/time/tick-sched.c#L151).
停掉 tick.
2. 当 CPU 从 IDLE 状态被唤醒时, 在 cpu_idle() 中[退出 idle 循环触发重新调度](https://elixir.bootlin.com/linux/v2.6.21/source/arch/i386/kernel/process.c#L196)之前, 再次通过 [tick_nohz_restart_sched_tick()](https://elixir.bootlin.com/linux/v2.6.21/source/kernel/time/tick-sched.c#L262) 重启 tick. | v1 ☑ 2.6.21-rc1 | [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=906568c9c668), [COMMIT2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f8381cba04ba), [COMMIT3](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=79bf2bb335b8) |
+| 2007/02/16 | Thomas Gleixner | [New hrtimers/dynticks patches](https://www.lkml.org/lkml/2007/1/29/30) | 引入 CONFIG_TICK_ONESHOT 和 CONFIG_NO_HZNO_HZ, 以支持在 CPU 空闲的时候停掉 tick, 进入 NOHZ 模式.
所有进入 NO_HZ 的 CPU 被标记在 [nohz_cpu_mask](https://elixir.bootlin.com/linux/v2.6.21/source/kernel/time/tick-sched.c#L211) 中, 直到
1. 当进入 [cpu_idle()](https://elixir.bootlin.com/linux/v2.6.21/source/arch/i386/kernel/process.c#L177)已经 [中断退出](https://elixir.bootlin.com/linux/v2.6.21/source/kernel/softirq.c#L309) 却不需要 RESCHED 时, 则通过 通过 [tick_nohz_stop_sched_tick()](https://elixir.bootlin.com/linux/v2.6.21/source/kernel/time/tick-sched.c#L151).
停掉 tick.
2. 当 CPU 从 IDLE 状态被唤醒时, 在 cpu_idle() 中 [退出 idle 循环触发重新调度](https://elixir.bootlin.com/linux/v2.6.21/source/arch/i386/kernel/process.c#L196) 之前, 再次通过 [tick_nohz_restart_sched_tick()](https://elixir.bootlin.com/linux/v2.6.21/source/kernel/time/tick-sched.c#L262) 重启 tick. | v1 ☑ 2.6.21-rc1 | [COMMIT1](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=906568c9c668), [COMMIT2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=f8381cba04ba), [COMMIT3](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=79bf2bb335b8) |
| 2008/07/11 | Heiko Carstens | [nohz: don't stop idle tick if softirqs are pending](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=857f3fd7a496) | NA | v1 ☑ [2.6.27-rc1](https://lore.kernel.org/lkml/20130505110351.GA4768@gmail.com/) | [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=857f3fd7a496) |
| 2008/07/18 | Thomas Gleixner | [nohz: prevent tick stop outside of the idle loop](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b8f8c3cf0a4a) | NA | v1 ☑ [2.6.27-rc1](https://lore.kernel.org/lkml/20130505110351.GA4768@gmail.com/) | [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b8f8c3cf0a4a) |
| 2012/03/21 | Joel Fernandes (Google)" | [Nohz cpusets v2 (adaptive tickless kernel)](https://lwn.net/Articles/487599) | NA | v1 ☐ | [LWN](https://lwn.net/Articles/487599) |
@@ -5140,7 +5111,7 @@ NOHZ 社区测试用例 [frederic/dynticks-testing.git](https://git.kernel.org/p
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2015/06/11 | Frederic Weisbecker | [nohz: Bunch of fixes](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=594493594373) | NA | v1 ☑ 4.3-rc1 | [LKML 0/2](https://lkml.org/lkml/2013/5/3/374) |
| 2017/12/21 | Peter Zijlstra | [sched: On remote stats updates](https://lore.kernel.org/lkml/20171221102139.177253391@infradead.org) | 引入 update_nohz_stats(), 通过其他 CPU 更新 nohz CPU 的 blocked_averages. | v1 ☑ 4.17-rc1 | [LORE 0/5](https://lore.kernel.org/lkml/20171221102139.177253391@infradead.org), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=e022e0d38ad475fc650f22efa3deb2fb96e62542) |
-| 2018/02/21 | FFrederic Weisbecker | [isolation: 1Hz residual tick offloading v7](https://lore.kernel.org/lkml/1519186649-3242-1-git-send-email-frederic@kernel.org) | 当CPU在full dynticks模式下运行时, 一个1Hz的滴答保持, 以保持调度器的统计状态活着. 然而, 对于那些根本无法忍受任何中断或想要最小化中断的裸金属任务来说, 这种残留的滴答是一种负担. 这组补丁将这个 1HZ 的 TICK 也从 CPU 上卸载掉. | v7 ☑ 4.17-rc1 | [PatchWork](https://lore.kernel.org/lkml/1519186649-3242-1-git-send-email-frederic@kernel.org) |
+| 2018/02/21 | FFrederic Weisbecker | [isolation: 1Hz residual tick offloading v7](https://lore.kernel.org/lkml/1519186649-3242-1-git-send-email-frederic@kernel.org) | 当 CPU 在 full dynticks 模式下运行时, 一个 1Hz 的滴答保持, 以保持调度器的统计状态活着. 然而, 对于那些根本无法忍受任何中断或想要最小化中断的裸金属任务来说, 这种残留的滴答是一种负担. 这组补丁将这个 1HZ 的 TICK 也从 CPU 上卸载掉. | v7 ☑ 4.17-rc1 | [PatchWork](https://lore.kernel.org/lkml/1519186649-3242-1-git-send-email-frederic@kernel.org) |
@@ -5182,8 +5153,8 @@ https://lore.kernel.org/all/1509419914-16179-1-git-send-email-frederic@kernel.or
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2017/11/27 | Frederic Weisbecker | [housekeeping: Move housekeeping related code to its own file](https://lore.kernel.org/patchwork/patch/845141) | housekeepin 的代码目前与 nohz 绑定在了一起. 先把他们拆分出来, 后期计划将两个功能拆开 | v1 ☑ 4.15-rc4 | [PatchWork](https://lore.kernel.org/patchwork/cover/845141) |
| 2017/12/14 | Frederic Weisbecker | [sched/isolation: Make NO_HZ_FULL select CPU_ISOLATION](https://lore.kernel.org/patchwork/patch/863225) | 增加 cpu_capacity 的跟踪点 | v1 ☑ 4.15-rc4 | [PatchWork](https://lore.kernel.org/patchwork/cover/863225) |
-| 2018/02/21 | FFrederic Weisbecker | [isolation: 1Hz residual tick offloading v7](https://lore.kernel.org/lkml/1519186649-3242-1-git-send-email-frederic@kernel.org) | 当CPU在full dynticks模式下运行时, 一个1Hz的滴答保持, 以保持调度器的统计状态活着. 然而, 对于那些根本无法忍受任何中断或想要最小化中断的裸金属任务来说, 这种残留的滴答是一种负担. 这组补丁将这个 1HZ 的 TICK 也从 CPU 上卸载掉. | v7 ☑ 4.17-rc1 | [PatchWork](https://lore.kernel.org/lkml/1519186649-3242-1-git-send-email-frederic@kernel.org) |
-| 2020/12/27 | Frederic Weisbecker | [context_tracking: Flatter archs not using exception_enter/exit() v2](https://lore.kernel.org/patchwork/patch/1327311) | 为了能够在运行时打开/关闭 nohz_full 所做的准备, 需要 arch 放弃在任务堆栈上保存上下文跟踪状态, 因为这将迫使上下文跟踪在整个系统范围内运行, 即使是在没有启用 nohz_full 的 CPU 上 | v2 ☑ 5.11-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/1327311) |
+| 2018/02/21 | FFrederic Weisbecker | [isolation: 1Hz residual tick offloading v7](https://lore.kernel.org/lkml/1519186649-3242-1-git-send-email-frederic@kernel.org) | 当 CPU 在 full dynticks 模式下运行时, 一个 1Hz 的滴答保持, 以保持调度器的统计状态活着. 然而, 对于那些根本无法忍受任何中断或想要最小化中断的裸金属任务来说, 这种残留的滴答是一种负担. 这组补丁将这个 1HZ 的 TICK 也从 CPU 上卸载掉. | v7 ☑ 4.17-rc1 | [PatchWork](https://lore.kernel.org/lkml/1519186649-3242-1-git-send-email-frederic@kernel.org) |
+| 2020/12/27 | Frederic Weisbecker | [context_tracking: Flatter archs not using exception_enter/exit() v2](https://lore.kernel.org/patchwork/patch/1327311) | 为了能够在运行时打开 / 关闭 nohz_full 所做的准备, 需要 arch 放弃在任务堆栈上保存上下文跟踪状态, 因为这将迫使上下文跟踪在整个系统范围内运行, 即使是在没有启用 nohz_full 的 CPU 上 | v2 ☑ 5.11-rc1 | [PatchWork](https://lore.kernel.org/patchwork/cover/1327311) |
| 2021/10/27 | Paul Gortmaker | [bind rcu offload (nohz_full/isolation) into cpuset](https://lkml.org/lkml/2021/10/27/1053) | NA | v1 ☐ | [LKML 0/2](https://lkml.org/lkml/2021/10/27/1053) |
| 2020/11/17 | Thomas Gleixner | [tick: Cleanups and reduce jiffies_seq held times](https://lore.kernel.org/lkml/20201117131942.515430545@linutronix.de) | 减少 nohz_full 情况下 jiffies_seq 序列计数器的争用. | v1 ☑ 5.11-rc1 | [LORE 0/7](https://lore.kernel.org/lkml/20201117131942.515430545@linutronix.de), [commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=94ad2e3cedb82af034f6d97c58022f162b669f9b) |
@@ -5235,13 +5206,13 @@ Tosatti 的 patch set 增加了一组新的 prctl() 命令来解决这个问题.
内核看到需要进入 isolation 模式的时候, 就会立即执行之前推迟的所有 vmstat 工作, 这样内核就不会在以后不方便清理的时候再做这个工作了. 在 isolation mode 中, 任何一次系统调用结束的时候都会触发这个 deferred-work 要完成的 cleanup 动作. 因为这些系统调用很可能总会触发一些 delayed work, 这样在应用程序代码运行时情况不会被弄得更加混乱.
-这个改动的意图明显是希望使这类功能更加普遍适用, 也就是保证任何一个 delayed work 都要得以立即执行. 这导致其他人(包括 Nicolás Sáenz)的质疑, 认为这种采用单一的 mode 来控制那些各种不同的内核操作是不对的. 他说, 将各种行为分割开来, 后续就可以将一些决策动作转移到用户空间. 经过反反复复的讨论, Tosatti 同意修改接口, 让用户空间可以明确控制每个可能会用到的 isolation 功能. 因此 v2 实现该 API, 它增加了一个新的操作(PR_ISOL_FEAT), 用于查询 isolation 模式激活时可以被静默掉的那些 action.
+这个改动的意图明显是希望使这类功能更加普遍适用, 也就是保证任何一个 delayed work 都要得以立即执行. 这导致其他人 (包括 Nicolás Sáenz) 的质疑, 认为这种采用单一的 mode 来控制那些各种不同的内核操作是不对的. 他说, 将各种行为分割开来, 后续就可以将一些决策动作转移到用户空间. 经过反反复复的讨论, Tosatti 同意修改接口, 让用户空间可以明确控制每个可能会用到的 isolation 功能. 因此 v2 实现该 API, 它增加了一个新的操作(PR_ISOL_FEAT), 用于查询 isolation 模式激活时可以被静默掉的那些 action.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:---:|:----------:|:----:|
| 2010/12/20 | Frederic Weisbecker | [Nohz task support](https://lwn.net/Articles/420490) | 标记进程进入 NO_HZ 模式. | v2 ☐ | [LWN](https://lwn.net/Articles/420490) |
-| 2020/11/23 | Alex Belits | [support "task_isolation" mode](https://lwn.net/Articles/816298) | NO_HZ_FULL 的进一步优化, 进一步降低 tick 等对隔离核的影响 | v5 ☐ | [2016 Chris Metcalf v16](https://lore.kernel.org/patchwork/cover/847460)
*-*-*-*-*-*-*-*
[Alex Belits 2020 LWN](https://lwn.net/Articles/813804), [PatchWork](https://lore.kernel.org/patchwork/cover/1344134), [lkml](https://lkml.org/lkml/2020/11/23/1380) |
+| 2020/11/23 | Alex Belits | [support"task_isolation"mode](https://lwn.net/Articles/816298) | NO_HZ_FULL 的进一步优化, 进一步降低 tick 等对隔离核的影响 | v5 ☐ | [2016 Chris Metcalf v16](https://lore.kernel.org/patchwork/cover/847460)
*-*-*-*-*-*-*-*
[Alex Belits 2020 LWN](https://lwn.net/Articles/813804), [PatchWork](https://lore.kernel.org/patchwork/cover/1344134), [lkml](https://lkml.org/lkml/2020/11/23/1380) |
| 2021/07/30 | Marcelo Tosatti | [extensible prctl task isolation interface and vmstat sync](https://lwn.net/Articles/864603) | 添加 prctl 来控制 task isolation 模式. 依赖于之前 "task isolation mode" 的基础代码实现, 内核看到需要进入 isolation 模式的时候, 就会立即执行之前推迟的所有 vmstat 工作, 这样内核就不会在以后不方便清理的时候再做这个工作了. 目前借助这个特性优化了 vmstat 的干扰. | v2 ☐ | [2021/07/27 Chris Metcalf 0/4](https://lore.kernel.org/patchwork/cover/1468441)
*-*-*-*-*-*-*-*
[2021/07/30 PatchWork v2, 0/4](https://lore.kernel.org/patchwork/cover/1470296)
*-*-*-*-*-*-*-*
|
## 8.4 RCU NOCBS
@@ -5252,21 +5223,21 @@ Tosatti 的 patch set 增加了一组新的 prctl() 命令来解决这个问题.
## 8.5 更精确的调度时钟(HRTICK)
-------
-2.6.25(2008年4月发布)
+2.6.25(2008 年 4 月发布)
-CPU的周期性调度, 和基于时间片的调度, 是要基于时钟中断来触发的.一个典型的 1000 HZ 机器, 每秒钟产生 1000 次时间中断, 每次中断到来后, 调度器会看看是否需要调度.
+CPU 的周期性调度, 和基于时间片的调度, 是要基于时钟中断来触发的.一个典型的 1000 HZ 机器, 每秒钟产生 1000 次时间中断, 每次中断到来后, 调度器会看看是否需要调度.
-然而, 对于调度时间粒度为微秒(10^-6)级别的精度来说, 这每秒 1000 次的粒度就显得太粗糙了.
+然而, 对于调度时间粒度为微秒 (10^-6) 级别的精度来说, 这每秒 1000 次的粒度就显得太粗糙了.
-2.6.25 引入了所谓的**高清嘀哒(High Resolution Tick)**, 以提供更精确的调度时钟中断.这个功能是基于**高精度时钟(High Resolution Timer)框架**, 这个框架让内核支持可以提供纳秒级别的精度的硬件时钟(将会在时钟子系统里讲).
+2.6.25 引入了所谓的 ** 高清嘀哒 (High Resolution Tick)**, 以提供更精确的调度时钟中断.这个功能是基于 ** 高精度时钟(High Resolution Timer) 框架 **, 这个框架让内核支持可以提供纳秒级别的精度的硬件时钟(将会在时钟子系统里讲).
## 8.6 混乱的 RT 优先级(RT 进程优先级管控)
-------
-Linux 内核会将大量(并且在不断增加中)工作放置在内核线程中, 这些线程是在内核地址空间中运行的特殊进程. 大多数内核线程运行在 SCHED_NORMAL 类中, 必须与普通用户空间进程争夺CPU时间. 但是有一些内核线程它的开发者们认为它们非常特殊, 应该比用户空间进程要有更高优先级. 因此也会把这些内核线程放到 SCHED_FIFO 中去.
+Linux 内核会将大量 (并且在不断增加中) 工作放置在内核线程中, 这些线程是在内核地址空间中运行的特殊进程. 大多数内核线程运行在 SCHED_NORMAL 类中, 必须与普通用户空间进程争夺 CPU 时间. 但是有一些内核线程它的开发者们认为它们非常特殊, 应该比用户空间进程要有更高优先级. 因此也会把这些内核线程放到 SCHED_FIFO 中去.
那么问题来了, 某个内核线程的实时优先级到底该设为多少呢?
@@ -5278,13 +5249,11 @@ Linux 内核会将大量(并且在不断增加中)工作放置在内核线程中
* 另外一种情况, 内核开发人员觉得自己的线程是那么的重要, 因此给他一个比较高的实时优先级;
-最近大神 Peter Zijlstra 又看到有内核开发者随便给内核线程设置优先级, 终于看不下去了, 指责这种把内核线程放入SCHED_FIFO的做法毫无意义:
+最近大神 Peter Zijlstra 又看到有内核开发者随便给内核线程设置优先级, 终于看不下去了, 指责这种把内核线程放入 SCHED_FIFO 的做法毫无意义:
-"the kernel has no clue what actual priority it should use for various things, so it is useless (or worse, counter productive) to even try"
+"the kernel has no clue what actual priority it should use for various things, so it is useless (or worse, counter productive) to even try"所以他发了一个系列 [[PATCH 00/23] sched: Remove FIFO priorities from modules](https://lore.kernel.org/patchwork/cover/1229354) 把设置内核线程优先级的接口干脆都给删了, 省得再有人瞎搞. 这个 PatchSet 主要做了下面几件事情:
-所以他发了一个系列 [[PATCH 00/23] sched: Remove FIFO priorities from modules](https://lore.kernel.org/patchwork/cover/1229354) 把设置内核线程优先级的接口干脆都给删了, 省得再有人瞎搞. 这个 PatchSet 主要做了下面几件事情:
-
-1. 不再导出原有的sched_setschedule() / sched_setattr() 接口
+1. 不再导出原有的 sched_setschedule() / sched_setattr() 接口
2. 增加了 sched_set_fifo(p) / sched_set_fifo_low(p) / sched_set_normal(p, nice)
@@ -5292,7 +5261,7 @@ Linux 内核会将大量(并且在不断增加中)工作放置在内核线程中
对于需求不那么迫切的线程, sched_set_fifo_low()将优先级设置为最低值(1).
而调用 sched_set_normal() 会将线程返回给定好的值 SCHED_NORMAL 类.
-通过只留下这三个接口可以避免开发者们再不停地去随机选取内核线程优先级, 因为这样本来毫无意义, 当然如果需要的话系统管理员还是可以按需调整不同进/线程的优先级.
+通过只留下这三个接口可以避免开发者们再不停地去随机选取内核线程优先级, 因为这样本来毫无意义, 当然如果需要的话系统管理员还是可以按需调整不同进 / 线程的优先级.
这个特性最终在 5.9-rc1 的时候合入主线.
@@ -5322,7 +5291,7 @@ Linux 内核会将大量(并且在不断增加中)工作放置在内核线程中
PREEMPT-RT PATCH 的核心思想是最小化内核中不可抢占部分的代码, 同时将为支持抢占性必须要修改的代码量最小化. 对临界区、中断处理函数、关中断等代码序列进行抢占改进. 重点改动参见 : [Linux 优化 - Preempt RT 关键点](https://blog.csdn.net/jackailson/article/details/51045796), [PREEMPT-RT](https://blog.csdn.net/Binp0209/article/details/41241703). 目前(2021 年) PREEMPT_RT 的特性正在逐步往社区主线合并, 在完全合入之前, 所有的补丁都可以在 [PatchSet 镜像地址](https://mirrors.edge.kernel.org/pub/linux/kernel/projects/rt) 找到.
-1. 可抢占支持(临界区可抢占, 中断处理函数可抢占, "关中断" 代码序列可抢占).
+1. 可抢占支持(临界区可抢占, 中断处理函数可抢占," 关中断 "代码序列可抢占).
2. rt lock 改动, 锁支持优先级继承.
@@ -5331,9 +5300,9 @@ PREEMPT-RT PATCH 的核心思想是最小化内核中不可抢占部分的代码
[PREEMPT_RT Linux & Open-Source News](https://www.phoronix.com/search/PREEMPT_RT)
-自从英特尔在 2022 年 2 月份收购 Linutronix 以来, 让Linux实时工作 upstream 的隧道尽头看到了曙光》 将 PREEMPT_RT补丁上游已经非常接近, 至 2022 年 7 月底的状态只剩下两个障碍. 甚至有望在 v6.0 版本(本来可能叫 v5.20)合入. 参见 [PREEMPT_RT Might Be Ready To Finally Land In Linux 5.20](https://www.phoronix.com/news/520-Maybe-Real-Time-PREEMPT_RT).
+自从英特尔在 2022 年 2 月份收购 Linutronix 以来, 让 Linux 实时工作 upstream 的隧道尽头看到了曙光》 将 PREEMPT_RT 补丁上游已经非常接近, 至 2022 年 7 月底的状态只剩下两个障碍. 甚至有望在 v6.0 版本 (本来可能叫 v5.20) 合入. 参见 [PREEMPT_RT Might Be Ready To Finally Land In Linux 5.20](https://www.phoronix.com/news/520-Maybe-Real-Time-PREEMPT_RT).
-[Real-Time "PREEMPT_RT" Work Down To Just 50 Patches Atop Linux 6.0-rc1](https://www.phoronix.com/news/Linux-6.0-RT-Patches)
+[Real-Time"PREEMPT_RT"Work Down To Just 50 Patches Atop Linux 6.0-rc1](https://www.phoronix.com/news/Linux-6.0-RT-Patches)
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
@@ -5347,15 +5316,15 @@ PREEMPT-RT PATCH 的核心思想是最小化内核中不可抢占部分的代码
| 日期 | LWN | 翻译 | 描述 |
|:---:|:----:|:---:|:---:|
-| 2020/11/09 | [Migration disable for the mainline](https://lwn.net/Articles/836503/) | [LWN:在mainline中关闭task migration!](https://blog.csdn.net/Linux_Everything/article/details/109831266) | 讲述了 Migrate Disable 背景和合入的往事. |
+| 2020/11/09 | [Migration disable for the mainline](https://lwn.net/Articles/836503/) | [LWN:在 mainline 中关闭 task migration!](https://blog.csdn.net/Linux_Everything/article/details/109831266) | 讲述了 Migrate Disable 背景和合入的往事. |
#### 8.7.1.1 migrate disable
-------
-内核中通过使用 per-CPU 数据来优化扩展性的问题. 全系统级别的锁(system-wide locking)是保护共享数据的一种很有效的方式, 但因为多种原因, 它会损害性能, 哪怕这个锁本身没有多少争抢也一样. 任何只被单个 CPU 访问的数据结构都不需要全系统级别的锁保护, 从而避免了这个问题. 举例来说, 内存分配器(memory allocator)会维护每个 CPU 的可用内存区域的列表 PCP, 在分配的时候就可以不受系统上其他 CPU 的干扰了.
+内核中通过使用 per-CPU 数据来优化扩展性的问题. 全系统级别的锁 (system-wide locking) 是保护共享数据的一种很有效的方式, 但因为多种原因, 它会损害性能, 哪怕这个锁本身没有多少争抢也一样. 任何只被单个 CPU 访问的数据结构都不需要全系统级别的锁保护, 从而避免了这个问题. 举例来说, 内存分配器 (memory allocator) 会维护每个 CPU 的可用内存区域的列表 PCP, 在分配的时候就可以不受系统上其他 CPU 的干扰了.
-但是, 内核代码只有在独占 CPU 的情况下才能安全地操作 per-CPU 数据, 如果这时其他进程有渠道可以插进来执行, 那么它可能会看到(或导致)产生不一致的 per-CPU 数据结构. 要防止这种情况的话, 正常来说就是在必要的时候禁用抢占, 这个操作开销非常小(本质上来说就是设置一个标志而已), 这样就能确保一个给定的任务在完成工作之前不会被中断.
+但是, 内核代码只有在独占 CPU 的情况下才能安全地操作 per-CPU 数据, 如果这时其他进程有渠道可以插进来执行, 那么它可能会看到 (或导致) 产生不一致的 per-CPU 数据结构. 要防止这种情况的话, 正常来说就是在必要的时候禁用抢占, 这个操作开销非常小(本质上来说就是设置一个标志而已), 这样就能确保一个给定的任务在完成工作之前不会被中断.
禁用抢占, 这是 realtime 开发者不喜欢看到的, 他们已经进行了大量的工作来确保任何 task 都可以在更高优先级的 task 需要 CPU 时被中断. PREEMPT_RT 优化的一个重要事务是优化和减少 preemption-disabled 的区域以及范围, 开发者们观察到, 通常情况下, 真正需要的是防止 task 在访问 per-CPU 数据时在 CPU 之间移动, 而不是暴力的直接关抢占. 例如, 参见 kmap_local() 的工作(https://lwn.net/Articles/836144). 禁用迁移的话, 仍然可以允许进程被抢占, 所以它不会破坏 realtime project 的目标, 或者说那些开发者希望能够达到这个目的.
@@ -5364,9 +5333,9 @@ PREEMPT-RT PATCH 的核心思想是最小化内核中不可抢占部分的代码
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
-| 2007/07/05 | Mathieu Desnoyers | [Thread Migration Preemption](https://lore.kernel.org/all/20070705215152.GA4865@Krystal) | 这个补丁增加了保护关键逻辑不迁移到另一个 CPU 而不是直接禁用抢占的能力.
这将有助于最小化 PREEMPT_RT 的抢占禁用量. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20070705215152.GA4865@Krystal)
*-*-*-*-*-*-*-*
[LORE v2](https://lore.kernel.org/all/20070711044915.GA4025@Krystal)
*-*-*-*-*-*-*-*
[LORE v3](https://lore.kernel.org/all/20070714184035.GH6975@Krystal)
*-*-*-*-*-*-*-*
[LORE v4](https://lore.kernel.org/all/20070714184237.GI6975@Krystal) |
+| 2007/07/05 | Mathieu Desnoyers | [Thread Migration Preemption](https://lore.kernel.org/all/20070705215152.GA4865@Krystal) | 这个补丁增加了保护关键逻辑不迁移到另一个 CPU 而不是直接禁用抢占的能力.
这将有助于最小化 PREEMPT_RT 的抢占禁用量. | v1 ☐☑✓ | [LORE](https://lore.kernel.org/all/20070705215152.GA4865@Krystal)
*-*-*-*-*-*-*-*
[LORE v2](https://lore.kernel.org/all/20070711044915.GA4025@Krystal)
*-*-*-*-*-*-*-*
[LORE v3](https://lore.kernel.org/all/20070714184035.GH6975@Krystal)
*-*-*-*-*-*-*-*
[LORE v4](https://lore.kernel.org/all/20070714184237.GI6975@Krystal) |
| 2020/09/11 | Peter Zijlstra | [sched: migrate_disable() preparations](https://lore.kernel.org/all/20200911081745.214686199@infradead.org) | TODO | v1 ☐☑✓ | [LORE v1,0/2](https://lore.kernel.org/all/20200911081745.214686199@infradead.org) |
-| 2020/09/17 | Thomas Gleixner | [sched: Migrate disable support for RT](https://lore.kernel.org/patchwork/cover/1307272) | 在启用 PREEMPT_RT 的内核上, 包括spin/rw锁持有部分在内的大部分代码都是可抢占的, 也使得任务可以迁移. 这违反了每个CPU的约束. 因此, PREEMPT_RT 需要一种独立于抢占的机制来控制迁移. | v1 ☐ | [LORE 00/10](https://lore.kernel.org/all/20200917094202.301694311@linutronix.de) |
+| 2020/09/17 | Thomas Gleixner | [sched: Migrate disable support for RT](https://lore.kernel.org/patchwork/cover/1307272) | 在启用 PREEMPT_RT 的内核上, 包括 spin/rw 锁持有部分在内的大部分代码都是可抢占的, 也使得任务可以迁移. 这违反了每个 CPU 的约束. 因此, PREEMPT_RT 需要一种独立于抢占的机制来控制迁移. | v1 ☐ | [LORE 00/10](https://lore.kernel.org/all/20200917094202.301694311@linutronix.de) |
| 2020/10/23 | Peter Zijlstra | [sched: Migrate disable support](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=12fa97c64dce2f3c2e6eed5dc618bb9046e40bf0) | Peter 自己实现的 Migrate disable. 当前依赖于 PREEMPT_RT. | v4 ☑ 5.11-rc1 | [2020/09/21 LORE 0/9](https://lore.kernel.org/lkml/20200921163557.234036895@infradead.org)
*-*-*-*-*-*-*-*
[2020/10/23 LORE v4,00/19](https://lore.kernel.org/all/20201023101158.088940906@infradead.org) |
| 2021/01/16 | Peter Zijlstra | [sched: Fix hot-unplug regressions](https://lore.kernel.org/patchwork/cover/1366383) | 修复 Migrate Disable 合入后导致的 CRASH 问题 | v3 ☑ 5.11-rc1 | [021/01/16 V1](https://lore.kernel.org/patchwork/cover/1366383)
*-*-*-*-*-*-*-*
[2021/01/21 V2](https://lore.kernel.org/patchwork/cover/1368710) |
@@ -5389,7 +5358,7 @@ PREEMPT-RT PATCH 的核心思想是最小化内核中不可抢占部分的代码
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
| 2020/09/17 | Thomas Gleixner | [mm/highmem: Preemptible variant of kmap_atomic & friends](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=7e015a279853e747f5d4f957855ec5310848c501) | 此处填写补丁描述 | v4 ☑ 5.11-rc1 | [LORE v3,00/37](https://lore.kernel.org/lkml/20201103092712.714480842@linutronix.de/)
*-*-*-*-*-*-*-*
[LORE v4,0/8](https://lore.kernel.org/all/20201118194838.753436396@linutronix.de) |
-| 2021/01/12 | Thomas Gleixner | [mm/highmem: Fix fallout from generic kmap_local conversions](https://lore.kernel.org/patchwork/cover/1364171) | 此处填写补丁描述| v1 ☐ | [v4 PatchWork](https://lore.kernel.org/patchwork/cover/1364171) |
+| 2021/01/12 | Thomas Gleixner | [mm/highmem: Fix fallout from generic kmap_local conversions](https://lore.kernel.org/patchwork/cover/1364171) | 此处填写补丁描述 | v1 ☐ | [v4 PatchWork](https://lore.kernel.org/patchwork/cover/1364171) |
| 2022/07/18 | Fabio M. De Francesco | [module: Replace kmap() with kmap_local_page()](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=554694ba120b87e39cf732ed632e6a0c52fafb7c) | module 模块使用 kmap_local_page() 替代 kmap() | v1 ☑✓ 6.0-rc1 | [LORE](https://lore.kernel.org/all/20220718002645.28817-1-fmdefrancesco@gmail.com) |
后来主线上 Dexuan Cui 报 Migrate Disable 合入后引入了问题, [5.10: sched_cpu_dying() hits BUG_ON during hibernation: kernel BUG at kernel/sched/core.c:7596!](https://lkml.org/lkml/2020/12/22/141). Valentin Schneider 怀疑是有些 kworker 线程在 CPU 下线后又选到了下线核上运行, 因此建议去测试这组补丁 [workqueue: break affinity initiatively](https://lkml.org/lkml/2020/12/18/406). Dexuan Cui 测试以后可以解决这个问题, 但是会有其他 WARN. Peter Zijlstra 的 解决方案如下 [sched: Fix hot-unplug regression](https://lore.kernel.org/patchwork/cover/1368710).
@@ -5413,7 +5382,7 @@ PREEMPT-RT PATCH 的核心思想是最小化内核中不可抢占部分的代码
|:----:|:----:|:---:|:----:|:---------:|:----:|
| 2009/3/23 | Thomas Gleixner | [Add support for threaded interrupt handlers - V3](https://lkml.org/lkml/2009/3/23/344) | 线程化中断的支持, 这组补丁提供一个能力, 驱动可以通过 request_threaded_irq 申请一个线程化的 IRQ. kernel 会为中断的底版本创建一个名字为 irq/%d-%s 的线程, %d 对应着中断号. 其中上半部(硬中断) handler 在做完必要的处理工作之后, 会返回 IRQ_WAKE_THREAD, 之后 kernel 会唤醒 irq/%d-%s 线程, 而该 kernel 线程会调用 thread_fn 函数, 因此, 该线程处理中断下半部. 该机制目前在 kernel 中使用已经十分广泛, 可以认为是继 softirq(含 tasklet) 和 workqueue 之后的又一大中断下半部方式. | v3 ☑ 2.6.30-rc1 | [PatchWork V5,00/72](https://lkml.org/lkml/2009/3/23/344), [关键 commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=3aa551c9b4c40018f0e261a178e3d25478dc04a9) |
| 2009/8/15 | Thomas Gleixner | [genirq: Support nested threaded irq handlinge](https://lkml.org/lkml/2009/8/15/130) | 中断线程化支持 nested/oneshot 以及 buslock 等. | v1 ☑ [2.6.32-rc1](https://kernelnewbies.org/Linux_2_6_32#Various_core_changes) | [LKML](https://lkml.org/lkml/2009/8/15/130), [关键 commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=399b5da29b9f851eb7b96e2882097127f003e87c) |
-| 2011/2/23 | Thomas Gleixner | [genirq: Forced threaded interrupt handlers](https://lkml.org/lkml/2011/2/23/510) | 引入 CONFIG_IRQ_FORCED_THREADING, 增加了命令行参数 ["threadirqs"](https://elixir.bootlin.com/linux/v2.6.39/source/kernel/irq/manage.c#L28), 强制所有中断(除了标记为 IRQF_NO_THREAD 的中断)包括软中断[均以线程方式运行](https://elixir.bootlin.com/linux/v2.6.39/source/Documentation/kernel-parameters.txt#L2474), 这主要是一个调试选项, 允许从崩溃的中断处理程序中检索更好的调试数据. 如果在内核命令行上没有启用 "threadirqs", 那么对中断热路径没有影响. 架构代码需要在标记了不能被线程化的中断 IRQF_NO_THREAD 之后选择 CONFIG_IRQ_FORCED_THREADING. 所有设置了 IRQF_TIMER 的中断都是隐式标记的 IRQF_NO_THREAD. 所有的 PER_CPU 中断也被排除在外.
当启用它时, 可能会降低一些速度, 但对于调试中断代码中的问题, 这是一个合理的惩罚, 因为当中断处理程序有 bug 时, 它不会立即崩溃和烧毁机器. | v1 ☑ [2.6.39-rc1](https://kernelnewbies.org/Linux_2_6_39#Core) | [LKML](https://lkml.org/lkml/2011/2/23/510), [LWN](https://lwn.net/Articles/429690), [关键 commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8d32a307e4faa8b123dc8a9cd56d1a7525f69ad3) |
+| 2011/2/23 | Thomas Gleixner | [genirq: Forced threaded interrupt handlers](https://lkml.org/lkml/2011/2/23/510) | 引入 CONFIG_IRQ_FORCED_THREADING, 增加了命令行参数 ["threadirqs"](https://elixir.bootlin.com/linux/v2.6.39/source/kernel/irq/manage.c#L28), 强制所有中断 (除了标记为 IRQF_NO_THREAD 的中断) 包括软中断[均以线程方式运行](https://elixir.bootlin.com/linux/v2.6.39/source/Documentation/kernel-parameters.txt#L2474), 这主要是一个调试选项, 允许从崩溃的中断处理程序中检索更好的调试数据. 如果在内核命令行上没有启用 "threadirqs", 那么对中断热路径没有影响. 架构代码需要在标记了不能被线程化的中断 IRQF_NO_THREAD 之后选择 CONFIG_IRQ_FORCED_THREADING. 所有设置了 IRQF_TIMER 的中断都是隐式标记的 IRQF_NO_THREAD. 所有的 PER_CPU 中断也被排除在外.
当启用它时, 可能会降低一些速度, 但对于调试中断代码中的问题, 这是一个合理的惩罚, 因为当中断处理程序有 bug 时, 它不会立即崩溃和烧毁机器. | v1 ☑ [2.6.39-rc1](https://kernelnewbies.org/Linux_2_6_39#Core) | [LKML](https://lkml.org/lkml/2011/2/23/510), [LWN](https://lwn.net/Articles/429690), [关键 commit](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=8d32a307e4faa8b123dc8a9cd56d1a7525f69ad3) |
| 2021/8/22 | Thomas Gleixner | [softirq: Introduce SOFTIRQ_FORCED_THREADING](https://lkml.org/lkml/2021/8/22/417) | CONFIG_IRQ_FORCED_THREADING 中强制软中断也做了线程化, 作者认为这不合理, 因此引入 SOFTIRQ_FORCED_THREADING 单独控制软中断的线程化.
1. 中断退出时是否执行 softirq 由 IRQ_FORCED_THREADING 控制, 这是不合理的. 应该将其拆分, 并允许其单独生效.
2. 同时, 当中断退出时, 我们应该增加 ksoftirqd 的优先级, 作者参考了 PREEMPT_RT 的实现, 认为它是合理的. | v1 ☐ | [PatchWork](https://lore.kernel.org/lkml/1629689583-25324-1-git-send-email-wangqing@vivo.com), [LKML](https://lkml.org/lkml/2021/8/22/417) |
@@ -5465,7 +5434,7 @@ PREEMPT-RT PATCH 的核心思想是最小化内核中不可抢占部分的代码
传统的调度器倾向于为每个进程提供公平份额的可用 CPU 时间, 同时尊重 CPU 关联性, 避免进程从其缓存内存内容中迁移出来, 并使系统中的所有 CPU 保持忙碌.
-但是即使这样, 如果特定进程不能快速获得其CPU份额, 也无法满足用户的需求;例如
+但是即使这样, 如果特定进程不能快速获得其 CPU 份额, 也无法满足用户的需求; 例如
1. 多年来关于桌面响应能力的争论.
@@ -5553,7 +5522,7 @@ Xen 的 CPU 调度算法主要有 3 种: BVT(borrowed virtual time)调度算法
业务场景中总存在一些对时延敏感但是负载很小的在线任务, 和一些时延不敏感但是负载很大的离线任务. 单独使用 isolation 等为时延敏感的业务分配 CPU 是比较浪费 CPU 资源的, 因此这些业务往往混部在一起. 然而, 现有的实现在混部后在线业务的服务质量下降严重.
-虽然内核提供了 SCHED_BATCH 和 SCHED_IDLE 两种优先级比较低的调度算法, 但它们仍然和CFS共用相同的实现, 尤其是在负载均衡时是未做区分的, 它们是没有完全的和CFS隔离开来, 所以效果上面介绍的通用方案存在类似的问题.
+虽然内核提供了 SCHED_BATCH 和 SCHED_IDLE 两种优先级比较低的调度算法, 但它们仍然和 CFS 共用相同的实现, 尤其是在负载均衡时是未做区分的, 它们是没有完全的和 CFS 隔离开来, 所以效果上面介绍的通用方案存在类似的问题.
其实, 在大家看来, 专门为这些应用新增一个调度类也是一个不错的想法, 通过各个调度类的优先级次序, 原生可以保证在线任务直接抢占离线任务, 保证在线任务的唤醒时延等.
@@ -5561,7 +5530,7 @@ Xen 的 CPU 调度算法主要有 3 种: BVT(borrowed virtual time)调度算法
- 一种思路是为时延敏感的在线任务, 新增一个优先级比 CFS 高的调度类.
- 暂且称作 background 调度类, 这样在选择 idle 的调度类之前, background 可以兜底了. 各个厂商也都做过类型的尝试. 比如腾讯曾经发往邮件列表的 [BT scheduling class](https://lore.kernel.org/patchwork/cover/1092086), 不过这个版本不完善, 存在诸多问题, 如果大家关注的话, 可以查考查阅 TencentOS-kernel 的 商用版本 [离线调度算法bt](https://github.com/Tencent/TencentOS-kernel#离线调度算法bt).
+ 暂且称作 background 调度类, 这样在选择 idle 的调度类之前, background 可以兜底了. 各个厂商也都做过类型的尝试. 比如腾讯曾经发往邮件列表的 [BT scheduling class](https://lore.kernel.org/patchwork/cover/1092086), 不过这个版本不完善, 存在诸多问题, 如果大家关注的话, 可以查考查阅 TencentOS-kernel 的 商用版本 [离线调度算法 bt](https://github.com/Tencent/TencentOS-kernel# 离线调度算法 bt).
- 另外一种思路是为时延不敏感的离线任务, 新增一个优先级比 CFS 低的调度类.
@@ -5576,7 +5545,7 @@ Xen 的 CPU 调度算法主要有 3 种: BVT(borrowed virtual time)调度算法
#### 8.9.3.2 Group Identity(云场景)
-------
-在业务的混合部署(延迟敏感型和计算型任务混合部署在同一台实例)场景中, Linux 内核调度器需要为高优先级任务赋予更多的调度机会以最小化调度延迟, 并需要把低优先级任务对内核调度带来的影响降到最低.
+在业务的混合部署 (延迟敏感型和计算型任务混合部署在同一台实例) 场景中, Linux 内核调度器需要为高优先级任务赋予更多的调度机会以最小化调度延迟, 并需要把低优先级任务对内核调度带来的影响降到最低.
基于该场景, Alibaba Cloud Linux 2 提供了 Group Identity 功能, 为 CPU cgroup 新增了配置调度优先级的接口, 且不同优先级的任务具有以下特点:
@@ -5590,7 +5559,7 @@ Xen 的 CPU 调度算法主要有 3 种: BVT(borrowed virtual time)调度算法
Group Identity 功能可以对每一个 CPU cgroup 设置身份标识, 以区分 cgroup 中的任务优先级. Group Identity 核心是双红黑树设计, 在 CFS(Completely Fair Scheduler)调度队列的单红黑树基础上, 新增了一颗低优先级的红黑树, 用于存放低优先级任务.
-[Alibaba Cloud Linux/内核功能与接口/Group Identity 功能说明](https://help.aliyun.com/document_detail/338407.html)
+[Alibaba Cloud Linux / 内核功能与接口 / Group Identity 功能说明](https://help.aliyun.com/document_detail/338407.html)
#### 8.9.3.3 HUAWEI VIP Thread(终端场景)
-------
@@ -5628,7 +5597,7 @@ CONFIG_HUAWEI_SCHED_VIP 被标记为 vip_prio, 为 VIP 线程提供了近似于
| 2019/08/05 | Pratik Rajesh Sampat | [cpuidle: teo: Allow tick to be stopped if PM QoS is used](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=cab09f3d2d2a0a6cb3dfb678660d67a2c3764f50) | NA| v1 ☑✓ | [LORE v1,0/2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=cab09f3d2d2a0a6cb3dfb678660d67a2c3764f50) |
| 2021/08/03 | Pratik Rajesh Sampat | [cpuidle: teo: Fix alternative idle state lookup](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=4adae7dd10db10f20f51833dc11b3cf7a342ad38) | NA| v1 ☑✓ 5.14-rc5 | [LORE v1,0/2](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=4adae7dd10db10f20f51833dc11b3cf7a342ad38) |
| 2021/06/02 | Rafael J. Wysocki | [cpuidle: teo: Rework the idle state selection logic](https://lore.kernel.org/all/1867445.PYKUYFuaPT@kreacher) | 1867445.PYKUYFuaPT@kreacher | v1 ☐☑✓ 5.14-rc1 | [LORE v1,0/5](https://lore.kernel.org/all/1867445.PYKUYFuaPT@kreacher) |
-| 2021/04/07 | Rafael J. Wysocki | [cpuidle: Take possible negative "sleep length" values into account](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=060e3535adf5c961b01421b9fdaddab8dd43ba85) | 1867445.PYKUYFuaPT@kreacher | v1 ☐☑✓ 5.13-rc1 | [LORE v1,0/5](https://lkml.org/lkml/2021/3/29/1834) |
+| 2021/04/07 | Rafael J. Wysocki | [cpuidle: Take possible negative"sleep length"values into account](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=060e3535adf5c961b01421b9fdaddab8dd43ba85) | 1867445.PYKUYFuaPT@kreacher | v1 ☐☑✓ 5.13-rc1 | [LORE v1,0/5](https://lkml.org/lkml/2021/3/29/1834) |
| 2020/05/11 | Pratik Rajesh Sampat | [Alternate history mechanism for the TEO governor](https://lore.kernel.org/all/20200511141055.43029-1-psampat@linux.ibm.com) | 20200511141055.43029-2-psampat@linux.ibm.com | v1 ☐☑✓ | [LORE v1,0/1](https://lore.kernel.org/all/20200511141055.43029-1-psampat@linux.ibm.com) |
| 2022/11/02 | Kajetan Puchalski | [cpuidle: teo: Introduce util-awareness](https://lore.kernel.org/all/20221102152808.2978590-1-kajetan.puchalski@arm.com) | TODO | v4 ☐☑✓ | [LORE v4,0/2](https://lore.kernel.org/all/20221102152808.2978590-1-kajetan.puchalski@arm.com) |
@@ -5669,21 +5638,21 @@ Intel 的 [Wult/Wake Up Latency Tracer](https://github.com/intel/wult) 一个在
### 10.1.2 shared page tables
-------
-对 shared page tables 的研究由来已久, Dave McCracken提出了一种共享页面表的方法[Implement shared page tables](https://lore.kernel.org/patchwork/cover/42673), 可以参见 [Shared Page Tables Redux](https://www.kernel.org/doc/ols/2006/ols2006v2-pages-125-130.pdf). 但从未进入内核.
+对 shared page tables 的研究由来已久, Dave McCracken 提出了一种共享页面表的方法[Implement shared page tables](https://lore.kernel.org/patchwork/cover/42673), 可以参见 [Shared Page Tables Redux](https://www.kernel.org/doc/ols/2006/ols2006v2-pages-125-130.pdf). 但从未进入内核.
-随后 2021 年, 我们相信, 随着现代应用程序和fork的现代用例(如快照)内存消耗的增加, fork上下文中的共享页表方法值得探索.
+随后 2021 年, 我们相信, 随着现代应用程序和 fork 的现代用例 (如快照) 内存消耗的增加, fork 上下文中的共享页表方法值得探索.
-在我们的研究工作中[https://dl.acm.org/doi/10.1145/3447786.3456258], 我们已经确定了一种方法, 对于大型应用程序(即几百 MBs 及以上), 该方法可以显著加快 fork 系统调用. 目前, fork系统调用完成所需的时间与进程分配内存的大小成正比, 在我们的实验中, 我们的设计将 fork 调用的速度提高了 270 倍(50GB).
其设计是, 在 fork 调用期间, 我们不复制整个分页树, 而是让子进程和父进程共享同一组最后一级的页表, 这些表将被引用计数. 为了保留写时复制语义, 我们在 fork 中的 PMD 条目中禁用写权限, 并根据需要在页面错误处理程序中复制 PTE 表.
+在我们的研究工作中[https://dl.acm.org/doi/10.1145/3447786.3456258], 我们已经确定了一种方法, 对于大型应用程序(即几百 MBs 及以上), 该方法可以显著加快 fork 系统调用. 目前, fork 系统调用完成所需的时间与进程分配内存的大小成正比, 在我们的实验中, 我们的设计将 fork 调用的速度提高了 270 倍(50GB).
其设计是, 在 fork 调用期间, 我们不复制整个分页树, 而是让子进程和父进程共享同一组最后一级的页表, 这些表将被引用计数. 为了保留写时复制语义, 我们在 fork 中的 PMD 条目中禁用写权限, 并根据需要在页面错误处理程序中复制 PTE 表.
-另一方面, http://lkml.iu.edu/hypermail/linux/kernel/0508.3/1623.html, https://www.kernel.org/doc/ols/2006/ols2006v2-pages-125-130.pdf], 但从未进入内核. 我们相信, 随着现代应用程序和fork的现代用例(如快照)内存消耗的增加, fork上下文中的共享页表方法值得探索.
+另一方面, http://lkml.iu.edu/hypermail/linux/kernel/0508.3/1623.html, https://www.kernel.org/doc/ols/2006/ols2006v2-pages-125-130.pdf], 但从未进入内核. 我们相信, 随着现代应用程序和 fork 的现代用例 (如快照) 内存消耗的增加, fork 上下文中的共享页表方法值得探索.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
-| 2006/04/10 | Dave McCracken | [Implement shared page tables](https://patchwork.kernel.org/project/linux-mm/patch/20210701134618.18376-1-zhao776@purdue.edu) | 这组补丁为跨越整个页表页的所有共享内存区域实现页表共享(CONFIG_PTSHARE). 它支持在多个页面级别(PTSHARE_PTE/PTSHARE_PMD/PTSHARE_PUD/PTSHARE_HUGEPAGE)上共享, 具体取决于体系结构.
共享页表的主要目的是提高在多个进程之间共享大内存区域的大型应用程序的性能.
它消除了冗余页表, 并显著减少了次要页错误的数量. 测试表明, 大型数据库应用程序(包括使用大型页面的应用程序)的性能有了显著提高. 对于小流程, 没有可测量的性能下降. | RFC ☐ | [2002/10/02 PatchWork](https://lore.kernel.org/patchwork/cover/9505)
*-*-*-*-*-*-*-*
[2005/08/30 PatchWork 1/1](https://lore.kernel.org/patchwork/cover/42673)
*-*-*-*-*-*-*-*
[2006/01/05 PatchWork RFC](https://lore.kernel.org/patchwork/cover/49324)
*-*-*-*-*-*-*-*
[2006/04/10 PatchWork RFC](https://lore.kernel.org/patchwork/cover/55396) |
+| 2006/04/10 | Dave McCracken | [Implement shared page tables](https://patchwork.kernel.org/project/linux-mm/patch/20210701134618.18376-1-zhao776@purdue.edu) | 这组补丁为跨越整个页表页的所有共享内存区域实现页表共享 (CONFIG_PTSHARE). 它支持在多个页面级别(PTSHARE_PTE/PTSHARE_PMD/PTSHARE_PUD/PTSHARE_HUGEPAGE) 上共享, 具体取决于体系结构.
共享页表的主要目的是提高在多个进程之间共享大内存区域的大型应用程序的性能.
它消除了冗余页表, 并显著减少了次要页错误的数量. 测试表明, 大型数据库应用程序 (包括使用大型页面的应用程序) 的性能有了显著提高. 对于小流程, 没有可测量的性能下降. | RFC ☐ | [2002/10/02 PatchWork](https://lore.kernel.org/patchwork/cover/9505)
*-*-*-*-*-*-*-*
[2005/08/30 PatchWork 1/1](https://lore.kernel.org/patchwork/cover/42673)
*-*-*-*-*-*-*-*
[2006/01/05 PatchWork RFC](https://lore.kernel.org/patchwork/cover/49324)
*-*-*-*-*-*-*-*
[2006/04/10 PatchWork RFC](https://lore.kernel.org/patchwork/cover/55396) |
| 2021/07/06 | Kaiyang Zhao | [Shared page tables during fork](https://patchwork.kernel.org/project/linux-mm/patch/20210701134618.18376-1-zhao776@purdue.edu) | 引入 read_ti_thread_flags() 规范对 thread_info 中 flag 的访问. 其中默认使用了 READ_ONCE. 防止开发者忘记了这样做. | RFC ☐ | [PatchWork v4,00/10](https://lore.kernel.org/patchwork/cover/1471548) |
-| 2022/01/18 | Khalid Aziz | [Add support for shared PTEs across processes](https://patchwork.kernel.org/project/linux-mm/cover/cover.1642526745.git.khalid.aziz@oracle.com) | 内核中的页表会消耗一些内存, 只要要维护的映射数量足够小, 那么页表所消耗的空间是可以接受的. 当进程之间共享的内存页很少时, 要维护的页表条目(PTE)的数量主要受到系统中内存页的数量的限制. 但是随着共享页面的数量和共享页面的次数的增加, 页表所消耗的内存数量开始变得非常大.
比如在一些实际业务中, 通常会看到非常多的进程共享内存页面. 在 x86_64 上, 每个页面页面在每个进程空间都需要占用一个只有 8Byte 大小的 PTE, 共享此页面的进程数目越多, 占用的内存会非常的大. 如果这些 PTE 可以共享, 那么节省的内存数量将非常可观.
这组补丁在内核中实现一种机制, 允许用户空间进程选择共享 PTE. 一个进程可以通过 通过 mshare() 和 mshare_unlink() syscall 来创建一个 mshare 区域(mshare'd region), 这个区域可以被其他进程使用共享 PTE 映射相同的页面. 其他进程可以通过 mashare() 使用共享 PTE 将共享页面映射到它们的地址空间. 然后还可以通过 mshare_unlink() syscall 来结束对共享页面的访问. 当最后一个访问 mshare'd region 的进程调用 mshare_unlink() 时, mshare'd region 就会被销毁, 所使用的内存也会被释放. | RFC ☐ | [LKML RFC,0/6](https://patchwork.kernel.org/project/linux-mm/cover/cover.1642526745.git.khalid.aziz@oracle.com) |
+| 2022/01/18 | Khalid Aziz | [Add support for shared PTEs across processes](https://patchwork.kernel.org/project/linux-mm/cover/cover.1642526745.git.khalid.aziz@oracle.com) | 内核中的页表会消耗一些内存, 只要要维护的映射数量足够小, 那么页表所消耗的空间是可以接受的. 当进程之间共享的内存页很少时, 要维护的页表条目 (PTE) 的数量主要受到系统中内存页的数量的限制. 但是随着共享页面的数量和共享页面的次数的增加, 页表所消耗的内存数量开始变得非常大.
比如在一些实际业务中, 通常会看到非常多的进程共享内存页面. 在 x86_64 上, 每个页面页面在每个进程空间都需要占用一个只有 8Byte 大小的 PTE, 共享此页面的进程数目越多, 占用的内存会非常的大. 如果这些 PTE 可以共享, 那么节省的内存数量将非常可观.
这组补丁在内核中实现一种机制, 允许用户空间进程选择共享 PTE. 一个进程可以通过 通过 mshare() 和 mshare_unlink() syscall 来创建一个 mshare 区域(mshare'd region), 这个区域可以被其他进程使用共享 PTE 映射相同的页面. 其他进程可以通过 mashare() 使用共享 PTE 将共享页面映射到它们的地址空间. 然后还可以通过 mshare_unlink() syscall 来结束对共享页面的访问. 当最后一个访问 mshare'd region 的进程调用 mshare_unlink() 时, mshare'd region 就会被销毁, 所使用的内存也会被释放. | RFC ☐ | [LKML RFC,0/6](https://patchwork.kernel.org/project/linux-mm/cover/cover.1642526745.git.khalid.aziz@oracle.com) |
### 10.1.3 进程退出
@@ -5706,14 +5675,14 @@ linux 下, reaper 线程用于释放已经执行结束的线程所占用的资
2. 否则, 如果有一个父亲的祖先(中间没有 pidns 级别变化), 同时它有 PR_SET_CHILD_SUBREAPER 设置, 这个祖先将是一个 reaper.
-3. 否则, 父亲的祖先将成为孩子们的 reaper.
+3. 否则, 父亲的祖先将成为孩子们的 reaper.
### 10.1.4 进程冻结与恢复
-------
-CRIU 是一个在 Linux 用户空间 (userspace) 上实现了 checkpoint/restore 功能的软件工具.
+CRIU 是一个在 Linux 用户空间 (userspace) 上实现了 checkpoint/restore 功能的软件工具.
Checkpoint/Restore In Userspace 或者 CRIU 是一个软件工具, 通过使用这个工具, 你可以冻结或者部分冻结一个应用程序的执行, 并将其执行状态保存到磁盘中一系列文件中. 你可以使用这些文件来恢复继续运行这个应用程序, 从之前被冻结的点上开始执行. 与其他软件不同的是 CRIU 最大的特点是在用户空间中执行.
@@ -5728,11 +5697,11 @@ c. 在多个进程之间共享(例如进程会话).
对于这样的资源, CRIU 恢复需要重新创建这样的进程创建顺序, 同时创建所需的进程树拓扑并允许继承所有资源.
-当进程重养育涉及到子-子-收割者时, 可以在进程树中大量混合进程, 这样就不容易明显地恢复一切正确.
+当进程重养育涉及到子 - 子 - 收割者时, 可以在进程树中大量混合进程, 这样就不容易明显地恢复一切正确.
所以我们引入 CABD(最近的在世后代) 来帮助 CRIU 克服这个问题:
-我们希望将流程放到另一个树中——CABA树. 这棵树不会以任何方式影响重新养育或进程创建, 只是向 CRIU 提供了一个新信息, 以便我们可以了解重新养育的子进程是从哪里被重新养育的. 尽管原来的父进程已经死亡, 可能也是父进程的父进程, 但我们仍然可以获得关于仍然活着的进程的信息, 它最初是进程序列(已经死亡的进程)的父进程, 它通向我们—— CABA.
+我们希望将流程放到另一个树中——CABA 树. 这棵树不会以任何方式影响重新养育或进程创建, 只是向 CRIU 提供了一个新信息, 以便我们可以了解重新养育的子进程是从哪里被重新养育的. 尽管原来的父进程已经死亡, 可能也是父进程的父进程, 但我们仍然可以获得关于仍然活着的进程的信息, 它最初是进程序列 (已经死亡的进程) 的父进程, 它通向我们—— CABA.
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
@@ -5747,9 +5716,9 @@ c. 在多个进程之间共享(例如进程会话).
[User-level Real-Time Network System on Microkernel-based Operating Systems]()
-早在 1991 年, Richard P. Draves 等开发者就使用 Continuation 机制优化了内部线程和进程间 RPC, 从而改进 Mach 3.0 操作系统的性能. 与以前版本的 Mach 3.0 相比, 我们的新系统每线程占用的空间减少了85%. 跨地址空间远程过程调用的执行速度提高了 14%. 异常处理运行速度提高了 60% 以上. 参见 ACM 论文 [Using Continuations to Implement Thread Management and Communication in Operating Systems](https://dl.acm.org/doi/10.1145/121132.121155) 以及 [User-level Real-Time Network System on Microkernel-based Operating Systems](https://keio.pure.elsevier.com/en/publications/user-level-real-time-network-system-on-microkernel-based-operatin/fingerprints). 随后 IOS XNU-Drawin 的内核集成了 Mach 3.0, 从而继承了这一功能.
+早在 1991 年, Richard P. Draves 等开发者就使用 Continuation 机制优化了内部线程和进程间 RPC, 从而改进 Mach 3.0 操作系统的性能. 与以前版本的 Mach 3.0 相比, 我们的新系统每线程占用的空间减少了 85%. 跨地址空间远程过程调用的执行速度提高了 14%. 异常处理运行速度提高了 60% 以上. 参见 ACM 论文 [Using Continuations to Implement Thread Management and Communication in Operating Systems](https://dl.acm.org/doi/10.1145/121132.121155) 以及 [User-level Real-Time Network System on Microkernel-based Operating Systems](https://keio.pure.elsevier.com/en/publications/user-level-real-time-network-system-on-microkernel-based-operatin/fingerprints). 随后 IOS XNU-Drawin 的内核集成了 Mach 3.0, 从而继承了这一功能.
-以一个 client 向 server IPC 请求数据为例, 当前 linix 上传统的 IPC 需要经历 3 次切换(包括进程/线程切换以及线程的栈切换).
+以一个 client 向 server IPC 请求数据为例, 当前 linix 上传统的 IPC 需要经历 3 次切换(包括进程 / 线程切换以及线程的栈切换).
1. client 通过系统调用进入内核, 内核栈切换成 client 的内核栈.
@@ -5769,7 +5738,7 @@ c. 在多个进程之间共享(例如进程会话).
可以看到使用了 Continuation 的 IPC:
-1. server 线程直接被 client 唤醒, 不需要走调度(WAKE_UP + PICK_NEXT + SCHED_IN)流程, 完成了 DIRECTLY SWITCH_TO server, 降低了整个唤醒时延.
+1. server 线程直接被 client 唤醒, 不需要走调度 (WAKE_UP + PICK_NEXT + SCHED_IN) 流程, 完成了 DIRECTLY SWITCH_TO server, 降低了整个唤醒时延.
2. server 线程唤醒后直接借助 client 的内核栈执行, server 和 client 都使用了 client 的内核栈, 不需要再进行数据传递, 直接调用 server 的 Continuation 返回到用户态执行.
@@ -5778,7 +5747,7 @@ c. 在多个进程之间共享(例如进程会话).
-------
-[Google 手册--使用 Binder IPC](https://source.android.com/devices/architecture/hidl/binder-ipc)
+[Google 手册 -- 使用 Binder IPC](https://source.android.com/devices/architecture/hidl/binder-ipc)
ANDROID 8 实现了 BINDER 对实时优先级传递的支持. 但是经过测试发现, 对部分场景性能存在负面影响, 因此社区并未合入.
@@ -5799,7 +5768,7 @@ ANDROID 8 实现了 BINDER 对实时优先级传递的支持. 但是经过测试
|:----:|:----:|:---:|:----:|:---------:|:----:|
| 2016/03/10 | Tejun Heo | [sched: define and use CPU_PRI_* enums for cpu notifier priorities](https://lore.kernel.org/patchwork/cover/201980) | 重构 migration_call 的 通知方式 | v1 ☑ 2.6.36-rc1 | 注意补丁有 UPATE, [UPDATE](https://lore.kernel.org/patchwork/cover/202907) |
| 2016/03/10 | Thomas Gleixner | [sched: Migrate disable support](https://lore.kernel.org/patchwork/cover/657710) | 将 CPU 下线时 MIGRATE 的操作放到了 sched_cpu_dying() 中进行 | v1 ☑ 4.7-rc1 | [2020/09/11 preparations](https://lore.kernel.org/patchwork/cover/657710) |
-| 2020/10/23 | Peter Zijlstra | [sched: Migrate disable support](https://lkml.org/lkml/2019/9/14/64) | 在启用 PREEMPT_RT 的内核上, 包括spin/rw锁持有部分在内的大部分代码都是可抢占的, 也使得任务可以迁移. 这违反了每个CPU的约束. 因此, PREEMPT_RT 需要一种独立于抢占的机制来控制迁移. 此特性移除了 sched_cpu_dying(), 改为 balance_push 来完成这个操作 | v4 ☑ 5.11-rc1 | [2020/09/11 preparations](https://lore.kernel.org/all/CAHk-=whej3MMKJBHKWp66djfEP5=kyncX7FoqJacYtmBXB6v9w@mail.gmail.com) |
+| 2020/10/23 | Peter Zijlstra | [sched: Migrate disable support](https://lkml.org/lkml/2019/9/14/64) | 在启用 PREEMPT_RT 的内核上, 包括 spin/rw 锁持有部分在内的大部分代码都是可抢占的, 也使得任务可以迁移. 这违反了每个 CPU 的约束. 因此, PREEMPT_RT 需要一种独立于抢占的机制来控制迁移. 此特性移除了 sched_cpu_dying(), 改为 balance_push 来完成这个操作 | v4 ☑ 5.11-rc1 | [2020/09/11 preparations](https://lore.kernel.org/all/CAHk-=whej3MMKJBHKWp66djfEP5=kyncX7FoqJacYtmBXB6v9w@mail.gmail.com) |
@@ -5815,7 +5784,7 @@ ANDROID 8 实现了 BINDER 对实时优先级传递的支持. 但是经过测试
#### 11.2.1.1 Directly Switch To
-------
-[FUTEX_SWAP补丁分析-SwitchTo 如何大幅度提升切换性能?](https://mp.weixin.qq.com/s/dDg5WKb8vqo5WfArAuav9Q)
+[FUTEX_SWAP 补丁分析 - SwitchTo 如何大幅度提升切换性能?](https://mp.weixin.qq.com/s/dDg5WKb8vqo5WfArAuav9Q)
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:---:|:----:|:---------:|:----:|
@@ -5824,7 +5793,7 @@ ANDROID 8 实现了 BINDER 对实时优先级传递的支持. 但是经过测试
### 11.2.1.2 ghOSt
-------
-谷歌的 Ghost 作为从用户空间和或eBPF程序控制 Linux 内核调度程序的一种手段. Ghost 提供了一个广泛的 API, 因此开发人员可以从用户空间或 eBPF 更改内核的调度程序行为, 并根据系统首选项微调调度行为.
+谷歌的 Ghost 作为从用户空间和或 eBPF 程序控制 Linux 内核调度程序的一种手段. Ghost 提供了一个广泛的 API, 因此开发人员可以从用户空间或 eBPF 更改内核的调度程序行为, 并根据系统首选项微调调度行为.
[Google's Ghost Look Very Appealing For Kernel Scheduling From User-Space & eBPF Programs](https://www.phoronix.com/news/Google-Ghost-Linux-Scheduling)
@@ -5849,14 +5818,14 @@ UMCG 的思想来源于 1992 年讲述 SA 的论文 [Scheduler activations: effe
* UMCG(User-managed concurrency groups)
-UMCG 要求多线程应用程序将自己划分为"服务线程 Server"和"工作线程 Worker", 其中系统上的每个 CPU 可能有一个服务线程 Server. 服务线程 Server 做出调度决策, 而工作人员根据这些决策运行并完成实际工作. UMCG 的优势在于, 调度可以快速发生, 并且内核的开销很小.
+UMCG 要求多线程应用程序将自己划分为 "服务线程 Server" 和 "工作线程 Worker", 其中系统上的每个 CPU 可能有一个服务线程 Server. 服务线程 Server 做出调度决策, 而工作人员根据这些决策运行并完成实际工作. UMCG 的优势在于, 调度可以快速发生, 并且内核的开销很小.
-据 Google 公开资料透露, UMCG 在 Google 用于 2 个场景: 安全沙箱和用户空间调度(比如协程框架等). 参见 [Google Makes New Attempt At "UMCG" As Part Of Their Open-Sourcing Effort Around Fibers](https://www.phoronix.com/scan.php?page=news_item&px=Google-UMCG-0.2-Fibers) 以及 [Google Working On Open-Sourcing Their Fibers User-Space Scheduling Framework](https://www.phoronix.com/scan.php?page=news_item&px=Google-Fibers-Toward-Open).
+据 Google 公开资料透露, UMCG 在 Google 用于 2 个场景: 安全沙箱和用户空间调度(比如协程框架等). 参见 [Google Makes New Attempt At"UMCG"As Part Of Their Open-Sourcing Effort Around Fibers](https://www.phoronix.com/scan.php?page=news_item&px=Google-UMCG-0.2-Fibers) 以及 [Google Working On Open-Sourcing Their Fibers User-Space Scheduling Framework](https://www.phoronix.com/scan.php?page=news_item&px=Google-Fibers-Toward-Open).
| 使用场景 | 描述 | 解决问题 |
|:-------:|:---:|:-------:|
| 安全沙箱 | 快速的 X-process 上下文切换将为更多用例打开一堆轻量级的安全工具, 例如 gVisor 或 Tor Project 的 Shadow 模拟器. | NA |
-| 用户态调度 | Google 广泛使用进程内用户空间调度, 为各种工作负载提供延迟控制和隔离保证, 同时保持高 CPU 利用率. | 1. 使用协程等, 可以很好的处理用户态 wait 等语义, 但是如果协程实际的载体进程/线程因为系统调用或者 IO 等阻塞, 协程库无法及时感知, 从而造成其他协程也不能执行. 通过 UMCG 提供的 upcall 机制, 可以在协程的执行线程 Worker 阻塞后, 通过 UMCG Server 拉起新的执行线程 Worker 来执行.
2. 此外可以把 Worker 的调度策略也放到用户态, 每次协程甚至是 Worker 的 PICK NEXT, 都可以交给用户态调度策略来完成. |
+| 用户态调度 | Google 广泛使用进程内用户空间调度, 为各种工作负载提供延迟控制和隔离保证, 同时保持高 CPU 利用率. | 1. 使用协程等, 可以很好的处理用户态 wait 等语义, 但是如果协程实际的载体进程 / 线程因为系统调用或者 IO 等阻塞, 协程库无法及时感知, 从而造成其他协程也不能执行. 通过 UMCG 提供的 upcall 机制, 可以在协程的执行线程 Worker 阻塞后, 通过 UMCG Server 拉起新的执行线程 Worker 来执行.
2. 此外可以把 Worker 的调度策略也放到用户态, 每次协程甚至是 Worker 的 PICK NEXT, 都可以交给用户态调度策略来完成. |
Google 的 Peter Oskolkov 发布了[最早的 RFC v0.1 补丁](https://lore.kernel.org/lkml/20210520183614.1227046-1-posk@google.com), 并持续工作到 [v0.9.1](https://lore.kernel.org/lkml/20211122211327.5931-1-posk@google.com). 但是社区对此特性一直没有达成一致意见.
@@ -5868,7 +5837,7 @@ Google 的 Peter Oskolkov 发布了[最早的 RFC v0.1 补丁](https://lore.kern
|:----:|:----:|:---:|:----:|:---------:|:----:|
| 2021/12/14 | Peter Oskolkov / | [sched,mm,x86/uaccess: implement User Managed Concurrency Groups](https://lore.kernel.org/patchwork/cover/1433967) | UMCG (User-Managed Concurrency Groups) | [PatchWork RFC,v0.1,0/9](https://lore.kernel.org/patchwork/cover/1433967)
*-*-*-*-*-*-*-*
[2021/07/08 PatchWork RFC,0/3,v0.2](https://lore.kernel.org/patchwork/cover/1455166)
*-*-*-*-*-*-*-*
[2021/07/16 PatchWork RFC,0/4,v0.3](https://lore.kernel.org/patchwork/cover/1461708)
*-*-*-*-*-*-*-*
[2021/08/01 PatchWork 0/4,v0.4](https://lore.kernel.org/patchwork/cover/1470650)
*-*-*-*-*-*-*-*
[2021/08/01 LWN 0/4,v0.5](https://lore.kernel.org/patchwork/cover/1470650)
*-*-*-*-*-*-*-*
[2021/10/12 PatchWork v0.7,0/5](https://patchwork.kernel.org/project/linux-mm/cover/20211012232522.714898-1-posk@google.com)
*-*-*-*-*-*-*-*
[2021/11/04 PatchWork v0.8,0/6](https://patchwork.kernel.org/project/linux-mm/cover/20211104195804.83240-1-posk@google.com)
*-*-*-*-*-*-*-*
[2021/11/21 PatchWork v0.9,0/6](https://patchwork.kernel.org/project/linux-mm/cover/20211121212040.8649-1-posk@google.com)
*-*-*-*-*-*-*-*
[2021/11/23 PatchWork v0.9.1,0/6](https://patchwork.kernel.org/project/linux-mm/cover/20211122211327.5931-1-posk@google.com) |
| 2022/01/20 | Paul Gortmaker | [sched: User Managed Concurrency Groups](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=abedf8e2419fb873d919dd74de2e84b510259339) | Peter Zijlstra 对 UMCG 的重新实现. | v9 ☑ 4.6-rc1 | [PatchWork RFC,0/3](https://patchwork.kernel.org/project/linux-mm/cover/20211214204445.665580974@infradead.org)
*-*-*-*-*-*-*-*
[PatchWork RFC,v2,0/5](https://patchwork.kernel.org/project/linux-mm/cover/20220120155517.066795336@infradead.org) |
-| 2022/10/19 | Andrei Vagin | [seccomp: add the synchronous mode for seccomp_unotify](https://lore.kernel.org/all/20221020011048.156415-1-avagin@gmail.com) | seccomp_unotify 允许特权更大的进程代表特权更小的进程执行操作. 在许多情况下, 工作流是完全同步的. 它意味着一个目标进程触发一个系统调用, 并将控制传递给一个主管进程, 后者处理系统调用并将控制返回给目标进程. 在这个上下文中, "同步"意味着只有一个进程在运行, 另一个正在等待.
新的 WF_CURRENT_CPU 标志建议调度器将唤醒对象移动到当前 CPU. 对于这样的同步工作流, 它使上下文切换速度提高了几倍. 测试发现, 原来每个相互作用需要 12µs, 借助这个补丁这个过程只需要 3µs. | v2 ☐☑✓ | [LORE v2,0/5](https://lore.kernel.org/all/20221020011048.156415-1-avagin@gmail.com) |
+| 2022/10/19 | Andrei Vagin | [seccomp: add the synchronous mode for seccomp_unotify](https://lore.kernel.org/all/20221020011048.156415-1-avagin@gmail.com) | seccomp_unotify 允许特权更大的进程代表特权更小的进程执行操作. 在许多情况下, 工作流是完全同步的. 它意味着一个目标进程触发一个系统调用, 并将控制传递给一个主管进程, 后者处理系统调用并将控制返回给目标进程. 在这个上下文中, "同步" 意味着只有一个进程在运行, 另一个正在等待.
新的 WF_CURRENT_CPU 标志建议调度器将唤醒对象移动到当前 CPU. 对于这样的同步工作流, 它使上下文切换速度提高了几倍. 测试发现, 原来每个相互作用需要 12µs, 借助这个补丁这个过程只需要 3µs. | v2 ☐☑✓ | [LORE v2,0/5](https://lore.kernel.org/all/20221020011048.156415-1-avagin@gmail.com) |
### 11.2.2 基于 eBPF 的可编程调度框架
@@ -5885,14 +5854,14 @@ CFS 调度器为用户和开发人员提供了非常多的调试接口和参数
1. 不同的工作量需要不同的策略, 能够为每个工作负载配置策略可能会很有用.
-2. 一个工作负载从自己不被抢占中受益, 仍然可以从抢占(低优先级)后台系统任务中受益.
+2. 一个工作负载从自己不被抢占中受益, 仍然可以从抢占 (低优先级) 后台系统任务中受益.
-3. 在生产中快速(且安全地)试验不同的策略是有用的, 而不必关闭应用程序或重新启动系统, 以确定不同工作负载的策略应该是什么.
+3. 在生产中快速 (且安全地) 试验不同的策略是有用的, 而不必关闭应用程序或重新启动系统, 以确定不同工作负载的策略应该是什么.
4. 只有少数任务的工作量足够大和敏感, 值得他们自己调整策略. CFS 本身就足以解决其他问题, 我们可能不希望政策调整取代 CFS 所做的任何事情.
-BPF 钩子(它已经成功地用于各种内核子系统)为外部代码(安全地)更改一些内核决策提供了一种方法, BPF 工具使这变得非常容易, 部署 BPF 脚本的开发者已经非常习惯于为新的内核版本更新它们.
+BPF 钩子 (它已经成功地用于各种内核子系统) 为外部代码 (安全地) 更改一些内核决策提供了一种方法, BPF 工具使这变得非常容易, 部署 BPF 脚本的开发者已经非常习惯于为新的内核版本更新它们.
#### 11.2.2.1 Facebook 的尝试
@@ -5901,7 +5870,7 @@ BPF 钩子(它已经成功地用于各种内核子系统)为外部代码(安全
[当 BPF 邂逅 CPU 调度器](https://www.ebpf.top/post/cfs_scheduler_bpf)
-Roman Gushchin 在邮件列表发起了 BPF 对调度器的潜在应用的讨论, 它提交的 patchset 旨在为调度器提供一些非常基本的 BPF 基础设施, 以便向调度器添加新的 BPF钩子、一组最小的有用助手以及相应的 libbpf 更改等等. 他们在 CFS 中使用 BPF 的第一次实验看起来非常有希望. 虽然还处于非常早期的阶段, 但在 Facebook 的主网页工作量已经获得了不错的延迟和约 1% 的 RPS. 参见 [LWN: Controlling the CPU scheduler with BPF](https://lwn.net/Articles/873244), 以及 [Early Patches Bring BPF To The Linux Scheduler](https://www.phoronix.com/scan.php?page=news_item&px=Linux-BPF-Scheduler).
+Roman Gushchin 在邮件列表发起了 BPF 对调度器的潜在应用的讨论, 它提交的 patchset 旨在为调度器提供一些非常基本的 BPF 基础设施, 以便向调度器添加新的 BPF 钩子、一组最小的有用助手以及相应的 libbpf 更改等等. 他们在 CFS 中使用 BPF 的第一次实验看起来非常有希望. 虽然还处于非常早期的阶段, 但在 Facebook 的主网页工作量已经获得了不错的延迟和约 1% 的 RPS. 参见 [LWN: Controlling the CPU scheduler with BPF](https://lwn.net/Articles/873244), 以及 [Early Patches Bring BPF To The Linux Scheduler](https://www.phoronix.com/scan.php?page=news_item&px=Linux-BPF-Scheduler).
作者提供了一个用户空间部分的示例 [github/rgushchin/atc](https://github.com/rgushchin/atc), 它加载了一些简单的钩子. 它非常简单, 只是为了简化使用所提供的内核补丁.
@@ -5921,7 +5890,7 @@ Roman Gushchin 在邮件列表发起了 BPF 对调度器的潜在应用的讨论
3. 使用 BPF 加速 ghOSt 内核调度器
-这与谷歌的 ghOSt 非常类似, 但是 ghOSt 比 BPF 的方式要激进很多, ghOSt 的目标是将调度代码转移到用户空间. 它们的核心动机似乎有些相似:使调度器更改更容易开发、验证和部署. 尽管他们的方法不同, 他们也使用 BPF 来加速一些热点路径. 但是作者认为使用 BPF 的方式也可以达到他们的目的. 参见 [eBPF in CPU Scheduler](https://linuxplumbersconf.org/event/11/contributions/954/attachments/776/1463/eBPF%20in%20CPU%20Scheduler.pdf)
+这与谷歌的 ghOSt 非常类似, 但是 ghOSt 比 BPF 的方式要激进很多, ghOSt 的目标是将调度代码转移到用户空间. 它们的核心动机似乎有些相似: 使调度器更改更容易开发、验证和部署. 尽管他们的方法不同, 他们也使用 BPF 来加速一些热点路径. 但是作者认为使用 BPF 的方式也可以达到他们的目的. 参见 [eBPF in CPU Scheduler](https://linuxplumbersconf.org/event/11/contributions/954/attachments/776/1463/eBPF%20in%20CPU%20Scheduler.pdf)
@@ -5967,7 +5936,7 @@ LPC-2016 的议题 [Patching of scheduler functions](http://blog.linuxplumbersco
[Plugsched —— Linux 内核调度器热升级](https://openanolis.cn/sig/Cloud-Kernel/doc/614810558709245780)
-B 站 Plugsched 介绍视频 [纯干货解读:Plugsched, 首次实现 Linux kernel 调度器热升级|龙蜥大讲堂18期](https://www.bilibili.com/video/BV1cW4y1y76c).
+B 站 Plugsched 介绍视频 [纯干货解读:Plugsched, 首次实现 Linux kernel 调度器热升级 | 龙蜥大讲堂 18 期](https://www.bilibili.com/video/BV1cW4y1y76c).
基于 Plugsched 实现的调度器热升级, 不修改现有内核代码, 就能获得较好的可修改能力, 天然支持线上的老内核版本. 如果提前在内核调度器代码的关键数据结构中加入 Reserve 字段, 可以额外获得修改数据结构的能力, 进一步提升可修改能力.
@@ -5980,12 +5949,12 @@ B 站 Plugsched 介绍视频 [纯干货解读:Plugsched, 首次实现 Linux ke
-------
-识别进程时计算密集型还是访存密集型等一直时调度器领域研究的一个重点, 学术界以及工业界都有不少的探索和实践. ARCHLINUX 的开发者 [hamadmarri](https://github.com/hamadmarri) 为 linux 开发和移植了很多调度器, 并开源在了其 github, 其中更多的思路就是自动识别进程的类型, 以供调度器更好地进行调度. 参见 [CSDN-小众调度器](https://blog.csdn.net/qq_23662505/article/details/126253590).
+识别进程时计算密集型还是访存密集型等一直时调度器领域研究的一个重点, 学术界以及工业界都有不少的探索和实践. ARCHLINUX 的开发者 [hamadmarri](https://github.com/hamadmarri) 为 linux 开发和移植了很多调度器, 并开源在了其 github, 其中更多的思路就是自动识别进程的类型, 以供调度器更好地进行调度. 参见 [CSDN - 小众调度器](https://blog.csdn.net/qq_23662505/article/details/126253590).
| 调度器 | 描述 |
|:-----:|:----:|
-| [CacULE CPU Scheduler](https://github.com/hamadmarri/cacule-cpu-scheduler) | 是基于交互性评分机制(CacULE Interactivity Score)的 CFS 补丁集. 交互性分数的灵感来自FreeBSD 的 ULE 调度器, 可以增强系统响应能力/延迟. ARCHLINUX 的开发者 ptr1337, 同样移植了 [CacULE Scheduler](https://github.com/ptr1337/linux-cacule), [CachyOS/linux-cachyos](https://github.com/CachyOS/linux-cachyos).使用 calc_interactivity(), calc_cache_score(), calc_starve_score() 分别计算任务的交互性评分(Interactivity Score), 缓存亲和性评分(Cache Score)以及饥饿评分(Starve Score), 然后将 CFS 的选取下一个任务机制 pick_next_task_fair 更改为 ULE 的评分机制, 以便选取要运行的下一个任务. |
-| [Task Type(TT) CPU Scheduler](https://github.com/hamadmarri/TT-CPU-Scheduler) | 根据任务的行为检测并识别任务类型, 并根据其类型控制调度. 基于任务类型的好处是允许调度程序进行更多控制, 并选择接下来在 CPU 中运行的最佳任务. 当前有5种类型: 实时(REALTIME), 交互(INTERACTIVE), 无类型(NO_TYPE), 计算密集型(CPU_BOUND), 批处理(BATCH). 调度器通过 detect_type() 周期性地探测应用的 task_type. |
+| [CacULE CPU Scheduler](https://github.com/hamadmarri/cacule-cpu-scheduler) | 是基于交互性评分机制 (CacULE Interactivity Score) 的 CFS 补丁集. 交互性分数的灵感来自 FreeBSD 的 ULE 调度器, 可以增强系统响应能力 / 延迟. ARCHLINUX 的开发者 ptr1337, 同样移植了 [CacULE Scheduler](https://github.com/ptr1337/linux-cacule), [CachyOS/linux-cachyos](https://github.com/CachyOS/linux-cachyos). 使用 calc_interactivity(), calc_cache_score(), calc_starve_score() 分别计算任务的交互性评分 (Interactivity Score), 缓存亲和性评分(Cache Score) 以及饥饿评分(Starve Score), 然后将 CFS 的选取下一个任务机制 pick_next_task_fair 更改为 ULE 的评分机制, 以便选取要运行的下一个任务. |
+| [Task Type(TT) CPU Scheduler](https://github.com/hamadmarri/TT-CPU-Scheduler) | 根据任务的行为检测并识别任务类型, 并根据其类型控制调度. 基于任务类型的好处是允许调度程序进行更多控制, 并选择接下来在 CPU 中运行的最佳任务. 当前有 5 种类型: 实时(REALTIME), 交互(INTERACTIVE), 无类型(NO_TYPE), 计算密集型(CPU_BOUND), 批处理(BATCH). 调度器通过 detect_type() 周期性地探测应用的 task_type. |
| [Baby-CPU-Scheduler](https://github.com/hamadmarri/Baby-CPU-Scheduler) | 一个非常基本, 轻量级但性能非常高的调度器 Basic Scheduler (BS). 可以将其用作 Linux 上的基本调度程序进行学习 |
#### 11.2.5.2 User Sensitive Factors for Scheduler
@@ -6008,7 +5977,7 @@ B 站 Plugsched 介绍视频 [纯干货解读:Plugsched, 首次实现 Linux ke
[AMD Aims To Squeeze More EPYC Performance Out Of Linux With User-Space Hinting For Tasks](https://www.phoronix.com/news/AMD-User-Space-Hiting-Linux)
-[AMD Posts "P-State EPP" Driver As New Attempt To Improve Performance-Per-Watt On Linux](https://www.phoronix.com/news/AMD-P-State-EPP-Linux)
+[AMD Posts"P-State EPP"Driver As New Attempt To Improve Performance-Per-Watt On Linux](https://www.phoronix.com/news/AMD-P-State-EPP-Linux)
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:---:|:----:|:---:|:----:|:---------:|:----:|
@@ -6020,7 +5989,7 @@ B 站 Plugsched 介绍视频 [纯干货解读:Plugsched, 首次实现 Linux ke
[关于 Coroutine(协程)、Continuation(接续)的参考资料](https://blog.csdn.net/zoomdy/article/details/89704634)
-[微信公众号-极客重生--深入理解协程 | 业界设计和实现的决策分析](https://mp.weixin.qq.com/s/JZUSQk-FnO1WVc85H3CqVQ)
+[微信公众号 - 极客重生 -- 深入理解协程 | 业界设计和实现的决策分析](https://mp.weixin.qq.com/s/JZUSQk-FnO1WVc85H3CqVQ)
[有栈协程与无栈协程](https://mthli.xyz/stackful-stackless)
@@ -6030,7 +5999,7 @@ B 站 Plugsched 介绍视频 [纯干货解读:Plugsched, 首次实现 Linux ke
| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:---:|:----:|:---:|:----:|:---------:|:----:|
-| 2022/09/08 | Waiman Long | [sched: Persistent user requested affinity](https://lore.kernel.org/all/20220908194121.858462-1-longman@redhat.com) | COMMIT b90ca8badbd1 ("sched: Introduce task_struct::user_cpus_ptr to track requested affinity") 引入了 user_cpus_ptr (狭义地)来保持 CPU 的亲和性不受非对称 CPU 设置的影响.
该补丁集扩展了 user_cpus_ptr, 通过 sched_setaffinity() API 存储用户请求的 CPU 亲和性. 有了这些可用的信息, 它将使 cpuset 和 set_cpus_allowed_ptr() 的其他调用者(如 HOTPLUG)能够在当前 cpuset 的 CPUs 约束内保持 CPU 的亲和性尽可能接近用户想要的. 否则, CPU 层次结构的更改或热插拔事件可能会将受影响 CPU 集中的任务的 cpumask 重置为默认的 cpuset cpus 值, 即使这些任务具有用户之前显式设置的 CPU 亲和性.
这还意味着, 成功调用 sched_setaffinity() 之后, user_cpus_ptr 将继续分配, 直到任务退出, 除非在一些罕见的情况下. | v8 ☐☑✓ | [LORE v8,0/7](https://lore.kernel.org/all/20220908194121.858462-1-longman@redhat.com)
*-*-*-*-*-*-*-*
[LORE v9,0/7](https://lore.kernel.org/all/20220916183217.1172225-1-longman@redhat.com)
*-*-*-*-*-*-*-*
[LORE v10,0/5](https://lore.kernel.org/all/20220922180041.1768141-1-longman@redhat.com) |
+| 2022/09/08 | Waiman Long | [sched: Persistent user requested affinity](https://lore.kernel.org/all/20220908194121.858462-1-longman@redhat.com) | COMMIT b90ca8badbd1 ("sched: Introduce task_struct::user_cpus_ptr to track requested affinity") 引入了 user_cpus_ptr (狭义地)来保持 CPU 的亲和性不受非对称 CPU 设置的影响.
该补丁集扩展了 user_cpus_ptr, 通过 sched_setaffinity() API 存储用户请求的 CPU 亲和性. 有了这些可用的信息, 它将使 cpuset 和 set_cpus_allowed_ptr() 的其他调用者 (如 HOTPLUG) 能够在当前 cpuset 的 CPUs 约束内保持 CPU 的亲和性尽可能接近用户想要的. 否则, CPU 层次结构的更改或热插拔事件可能会将受影响 CPU 集中的任务的 cpumask 重置为默认的 cpuset cpus 值, 即使这些任务具有用户之前显式设置的 CPU 亲和性.
这还意味着, 成功调用 sched_setaffinity() 之后, user_cpus_ptr 将继续分配, 直到任务退出, 除非在一些罕见的情况下. | v8 ☐☑✓ | [LORE v8,0/7](https://lore.kernel.org/all/20220908194121.858462-1-longman@redhat.com)
*-*-*-*-*-*-*-*
[LORE v9,0/7](https://lore.kernel.org/all/20220916183217.1172225-1-longman@redhat.com)
*-*-*-*-*-*-*-*
[LORE v10,0/5](https://lore.kernel.org/all/20220922180041.1768141-1-longman@redhat.com) |
## 11.5 其他
@@ -6063,26 +6032,26 @@ B 站 Plugsched 介绍视频 [纯干货解读:Plugsched, 首次实现 Linux ke
调度器中的调试信息实在太少, 很多微观的信息, 比如负载均衡, 选核路径, 进程负载等信息没有有效的调试信息. 很多开发者一直希望能够在调度器中添加一些调试信息. 但是作为对系统性能影响最大的内核核心模块, 调度的代码调用频率一直非常频繁, 添加调试信息必然对调度器的 overhead. 另外调度的 Maintainer Peter 一直对在调度中添加 tracepoint 等这种调试信息有较大的意见, 单纯的添加调试信息对性能分析的作用并不大.
-| 时间 | 作者 |特性 | 描述 | 是否合入主线 | 链接 |
+| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:--:|:----:|:---------:|:----:|
| 2017/03/28 | Dietmar Eggemann | [CFS load tracking trace events](https://lore.kernel.org/patchwork/cover/774154) | 增加 PELT 的跟踪点 | v1 ☐ | [PatchWork](https://lore.kernel.org/patchwork/cover/774154) |
| 2018/12/14 | Benjamin | [sched/debug: Add tracepoint for RT throttling](https://lore.kernel.org/patchwork/patch/1024902) | RT throttle 的 tracepoint | v1 ☐ | [PatchWork](https://lore.kernel.org/patchwork/patch/1024902) |
另外一方面, 在内核开发过程中, 开发者们又苦于无法针对修改内容进行一些量化或者可视化结果的测量, 而无感. 特别是调度的分析和可视化, 显得那么重要, 却一直没有更好的手段.
-ARM & Linaro 的内核团队针对 Android/linux 等做了大量的调度的优化, 比如 EAS 等. 终端场景的性能优化最重要的就是保供给, 排在首位的就是(前台应用)的调度和调频, 为了分析和跟踪终端场景的调度信息. Android 提供了 systrace, perfetto 等工具. 而 ARM 则推出了 [LISA(Linux Interactive System Analysis)](https://github.com/ARM-software/lisa). LISA 是一个 Linux 环境下用于回归测试和对于各种 workload 进行交互测试的工具集. 目前 LISA 主要专注于 scheduler、power management 和 thermal 框架的分析. 不仅于此, LISA 提供一个框架且可以轻松扩展到其他用途. LISA 提供一些列 API 用于测试条例编写和回归测试条例开发. 参见 [LISA 介绍及其使用方法](https://www.cnblogs.com/arnoldlu/p/6214879.html).
+ARM & Linaro 的内核团队针对 Android/linux 等做了大量的调度的优化, 比如 EAS 等. 终端场景的性能优化最重要的就是保供给, 排在首位的就是 (前台应用) 的调度和调频, 为了分析和跟踪终端场景的调度信息. Android 提供了 systrace, perfetto 等工具. 而 ARM 则推出了 [LISA(Linux Interactive System Analysis)](https://github.com/ARM-software/lisa). LISA 是一个 Linux 环境下用于回归测试和对于各种 workload 进行交互测试的工具集. 目前 LISA 主要专注于 scheduler、power management 和 thermal 框架的分析. 不仅于此, LISA 提供一个框架且可以轻松扩展到其他用途. LISA 提供一些列 API 用于测试条例编写和回归测试条例开发. 参见 [LISA 介绍及其使用方法](https://www.cnblogs.com/arnoldlu/p/6214879.html).
为了测试和分析 EAS 调度的微观行为, ARM 的开发者提供了一种新的思路, 通过注册 tracepoint hook 点, 但是把实现 tracepoint 的工作交给驱动模块来做, 这种更灵活的方案, 更适应 LISA 的灵活. 参见 [sched: Add new tracepoints required for EAS testing](https://lore.kernel.org/lkml/1598605249-72651-1-git-send-email-vincent.donnefort@arm.com).
-在某种意义上, 这些新引入的 tracepoint 其实是空的, 它们不跟踪中的任何信息. 使用它们的预期方法是加载一个驱动模块, 这个模块将注册到这些 tracepoint 点, 然后提取(或者输出)用户空间测试所需的信息.
+在某种意义上, 这些新引入的 tracepoint 其实是空的, 它们不跟踪中的任何信息. 使用它们的预期方法是加载一个驱动模块, 这个模块将注册到这些 tracepoint 点, 然后提取 (或者输出) 用户空间测试所需的信息.
通过驱动模块实现和注册 tracepoint 的方法参见 [`tracepoints-helpers`](https://github.com/auldp/tracepoints-helpers.git)
随后 Redhat 的 Phil Auld 增加了对 rq->nr_running 的跟踪, 这对分析系统中的在负载均衡状况非常有用. Auld 同时提供了一个工具 [`plot-nr-running`](https://github.com/jirvoz/plot-nr-running) 可以分析系统的不均衡状态, 并通过 PLOT 绘制成图, 帮助可视化. 参见 [COMMIT 9d246053a691](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9d246053a69196c7c27068870e9b4b66ac536f68).
-| 时间 | 作者 |特性 | 描述 | 是否合入主线 | 链接 |
+| 时间 | 作者 | 特性 | 描述 | 是否合入主线 | 链接 |
|:----:|:----:|:--:|:----:|:---------:|:----:|
-| 2019/06/04 | Qais Yousef | [sched: Add new tracepoints required for EAS testing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=a056a5bed7fa67706574b00cf1122c38596b2be1) | 增加 PELT 的跟踪点.
新引入了 `trace_pelt_{cfs|rt|dl|irq}_tp` 等 tracepoint 点跟踪 RQ 的负载信息, 以及 `trace_pelt_se_tp` 等 sched_entity 级别的负载跟踪点, 还提供了 `trace_sched_overutilized_tp` 记录 RQ 和 SD 的 overutilized 状态. 主要是为了跟踪 PELT 的内容, 这是 EAS 做出决策时使用的信息. 了解 PELT 的变化, LISA 可以根据模拟不同场景的综合测试来验证 EAS 是否在做正确的事情. 除了 EAS 之外, 新的 tracepoint 点还可以帮助研究 CFS 负载均衡器和 CFS 任务组处理. | v2 ☑ 5.3-rc1 | [LORE v3,0/6](https://lore.kernel.org/lkml/1598605249-72651-1-git-send-email-vincent.donnefort@arm.com) |
+| 2019/06/04 | Qais Yousef | [sched: Add new tracepoints required for EAS testing](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/log/?id=a056a5bed7fa67706574b00cf1122c38596b2be1) | 增加 PELT 的跟踪点.
新引入了 `trace_pelt_{cfs|rt|dl|irq}_tp` 等 tracepoint 点跟踪 RQ 的负载信息, 以及 `trace_pelt_se_tp` 等 sched_entity 级别的负载跟踪点, 还提供了 `trace_sched_overutilized_tp` 记录 RQ 和 SD 的 overutilized 状态. 主要是为了跟踪 PELT 的内容, 这是 EAS 做出决策时使用的信息. 了解 PELT 的变化, LISA 可以根据模拟不同场景的综合测试来验证 EAS 是否在做正确的事情. 除了 EAS 之外, 新的 tracepoint 点还可以帮助研究 CFS 负载均衡器和 CFS 任务组处理. | v2 ☑ 5.3-rc1 | [LORE v3,0/6](https://lore.kernel.org/lkml/1598605249-72651-1-git-send-email-vincent.donnefort@arm.com) |
| 2020/06/19 | Phil Auld | [Sched: Add a tracepoint to track rq->nr_running](https://lore.kernel.org/patchwork/patch/1258690) | 增加 nr_running 的跟踪点. 通过 | v1 ☑ 5.9-rc1 | [PatchWork](https://lore.kernel.org/patchwork/patch/1258690), [COMMIT](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=9d246053a69196c7c27068870e9b4b66ac536f68)