1
struct task_struct {
2
    // ...
3
    const struct sched_class *sched_class;  // 调度类
4
    struct sched_entity      se;            // CFS 调度实体
5
    struct sched_rt_entity   rt;            // 实时调度实体
6
    struct sched_dl_entity   dl;            // Deadline 调度实体
7
    int                      prio;          // 动态优先级
8
    // ...
9
};

1
// kernel/sched/fair.c（简化）
2
static void update_curr(struct cfs_rq *cfs_rq)
3
{
4
    struct sched_entity *curr = cfs_rq->curr;
5
    u64 now = rq_clock_task(rq_of(cfs_rq));
6
    u64 delta_exec;
7

8
    delta_exec = now - curr->exec_start;  // 本次运行的实际时间
9
    curr->sum_exec_runtime += delta_exec;  // 累加实际运行时间
10

11
    // 核心公式：vruntime 增量 = 实际时间 × (NICE_0_LOAD / 权重)
12
    curr->vruntime += calc_delta_fair(delta_exec, curr);
13
}

1
static u64 calc_delta_fair(u64 delta, struct sched_entity *se)
2
{
3
    if (unlikely(se->load.weight != NICE_0_LOAD))
4
        delta = __calc_delta(delta, NICE_0_LOAD, &se->load);
5
    return delta;
6
}

1
// kernel/sched/fair.c（简化）
2
static void place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
3
{
4
    u64 vruntime = cfs_rq->min_vruntime;
5

6
    if (initial) {
7
        // 新创建的进程：给一点"优惠"，但不会太多
8
        vruntime += sched_vslice(cfs_rq, se);
9
    } else {
10
        // 唤醒的进程：给少量优惠以提升响应性
11
        vruntime -= sysctl_sched_wakeup_granularity;
12
        if (vruntime < cfs_rq->min_vruntime)
13
            vruntime = cfs_rq->min_vruntime;
14
    }
15

16
    se->vruntime = max(se->vruntime, vruntime);
17
}

1
static void update_min_vruntime(struct cfs_rq *cfs_rq)
2
{
3
    u64 vruntime = cfs_rq->min_vruntime;
4

5
    if (cfs_rq->curr)
6
        vruntime = cfs_rq->curr->vruntime;
7

8
    if (cfs_rq->rb_leftmost) {
9
        struct sched_entity *se = __node_2_se(cfs_rq->rb_leftmost);
10
        vruntime = min(vruntime, se->vruntime);
11
    }
12

13
    // 单调递增：只增不减
14
    cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime);
15
}

1
static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
2
{
3
    unsigned int nr_running = cfs_rq->nr_running;
4
    u64 slice;
5

6
    slice = __sched_period(nr_running + !!se->on_rq);
7

8
    // 按权重比例分配
9
    slice = __calc_delta(slice, se->load.weight, &cfs_rq->load);
10

11
    return max_t(u64, slice, sysctl_sched_min_granularity);
12
}

1
// 设置 SCHED_FIFO 调度策略
2
struct sched_param param = { .sched_priority = 50 };  // 实时优先级 50
3
sched_setscheduler(getpid(), SCHED_FIFO, &param);

1
# 查看 SCHED_RR 时间片
2
cat /proc/sys/kernel/sched_rr_timeslice_ms
3
# 输出：100
4

5
# 设置为 50ms
6
echo 50 | sudo tee /proc/sys/kernel/sched_rr_timeslice_ms

1
# 默认配置：在 1 秒周期内，实时任务最多占用 0.95 秒
2
cat /proc/sys/kernel/sched_rt_period_us    # 1000000 (1秒)
3
cat /proc/sys/kernel/ssched_rt_runtime_us  # 950000  (0.95秒)

1
// 设置 SCHED_DEADLINE
2
struct sched_attr attr = {
3
    .size = sizeof(attr),
4
    .sched_policy = SCHED_DEADLINE,
5
    .sched_runtime  = 10 * 1000000,   // 10ms 运行时间
6
    .sched_deadline = 30 * 1000000,   // 30ms 截止时间
7
    .sched_period   = 30 * 1000000,   // 30ms 周期
8
};
9
sched_setattr(getpid(), &attr, 0);

1
// arch/x86/entry/entry_64.S（简化）
2
// 从内核态返回用户态时的抢占检查
3
ENTRY(ret_from_fork)
4
    // ...
5
    call schedule_tail
6
    // 检查 TIF_NEED_RESCHED
7
    testl $_TIF_NEED_RESCHED, TI_flags(%r12)
8
    jnz schedule
9
    // ...

1
// kernel/sched/core.c（简化）
2
static __always_inline struct rq *
3
context_switch(struct rq *rq, struct task_struct *prev,
4
               struct task_struct *next, struct rq_flags *rf)
5
{
6
    // 第一步：切换地址空间（mm_struct）
7
    switch_mm_irqs_off(prev->active_mm, next->mm, next);
8

9
    // 第二步：切换处理器状态（寄存器、栈指针）
10
    switch_to(prev, next, prev);
11

12
    // 第三步：屏障，确保编译器不会重排
13
    barrier();
14

15
    return finish_task_switch(prev);
16
}

1
// arch/x86/mm/tlb.c（简化）
2
void switch_mm_irqs_off(struct mm_struct *prev, struct mm_struct *next,
3
                        struct task_struct *tsk)
4
{
5
    // 加载新进程的页表基址到 CR3 寄存器
6
    write_cr3(next->pgd);
7

8
    // 刷新 TLB（Translation Lookaside Buffer）
9
    // 现代 x86 使用 PCID 减少不必要的 TLB 刷新
10
    // ...
11

12
    // 更新 CPU 的 active_mm
13
    this_cpu_write(cpu_tlbstate.active_mm, next);
14
}

1
// arch/x86/include/asm/switch_to.h（简化）
2
#define switch_to(prev, next, last)                          \
3
do {                                                         \
4
    /* 保存旧进程的 RSP、RBP 等寄存器 */                     \
5
    save_regs(prev);                                         \
6
    /* 切换栈指针到新进程的内核栈 */                          \
7
    __switch_to(prev, next);                                 \
8
    /* 恢复新进程的寄存器 */                                  \
9
    restore_regs(next);                                      \
10
} while (0)

1
__switch_to:
2
    /* 保存 callee-saved 寄存器到 prev 的栈帧 */
3
    push    %rbp
4
    push    %rbx
5
    push    %r12
6
    push    %r13
7
    push    %r14
8
    push    %r15
9

10
    /* 保存 prev 的栈指针到 task_struct->thread.sp */
11
    movq    %rsp, TASK_thread_sp(%rdi)
12

13
    /* 加载 next 的栈指针 */
14
    movq    TASK_thread_sp(%rsi), %rsp
15

16
    /* 恢复 next 的 callee-saved 寄存器 */
17
    pop     %r15
18
    pop     %r14
19
    pop     %r13
20
    pop     %r12
21
    pop     %rbx
22
    pop     %rbp
23

24
    /* 更新 GS 基址（per-CPU 数据） */
25
    swapgs
26
    wrmsr
27

28
    ret

1
系统调度域层次（以 2-socket × 4-core × 2-thread 为例）：
2

3
NUMA 域（socket 间）
4
├── MC 域（socket 0）
5
│   ├── SMT 域（core 0：CPU 0, CPU 8）
6
│   ├── SMT 域（core 1：CPU 1, CPU 9）
7
│   ├── SMT 域（core 2：CPU 2, CPU 10）
8
│   └── SMT 域（core 3：CPU 3, CPU 11）
9
└── MC 域（socket 1）
10
    ├── SMT 域（core 4：CPU 4, CPU 12）
11
    ├── SMT 域（core 5：CPU 5, CPU 13）
12
    ├── SMT 域（core 6：CPU 6, CPU 14）
13
    └── SMT 域（core 7：CPU 7, CPU 15）

1
#define _GNU_SOURCE
2
#include <sched.h>
3

4
cpu_set_t mask;
5
CPU_ZERO(&mask);
6
CPU_SET(2, &mask);  // 绑定到 CPU 2
7
CPU_SET(3, &mask);  // 和 CPU 3
8
sched_setaffinity(getpid(), sizeof(mask), &mask);

1
# 将进程 1234 绑定到 CPU 0 和 CPU 2
2
taskset -pc 0,2 1234
3

4
# 在 CPU 1 上启动新进程
5
taskset -c 1 ./my_program

1
# 格式：max_quota period
2
# 示例：在 100ms 周期内最多使用 50ms CPU 时间（即 50% CPU）
3
echo "50000 100000" > /sys/fs/cgroup/mygroup/cpu.max
4

5
# 不限制（默认）
6
echo "max 100000" > /sys/fs/cgroup/mygroup/cpu.max

1
# 设置 cgroup A 的权重为 200，cgroup B 的权重为 100
2
echo 200 > /sys/fs/cgroup/A/cpu.weight
3
echo 100 > /sys/fs/cgroup/B/cpu.weight
4
# 结果：A 获得 2/3 的 CPU 时间，B 获得 1/3

1
# 创建一个受限的 cgroup
2
mkdir /sys/fs/cgroup/container1
3
echo $$ > /sys/fs/cgroup/container1/cgroup.procs  # 将当前 shell 加入
4
echo "20000 100000" > /sys/fs/cgroup/container1/cpu.max  # 限制为 20% CPU
5

6
# 验证：运行一个 CPU 密集型任务，观察 CPU 使用率
7
dd if=/dev/zero bs=1M | md5sum &
8
# 在另一个终端用 top 观察，CPU 使用率应被限制在 ~20%

1
# 以 nice 值 10 启动命令（降低优先级）
2
nice -n 10 ./my_batch_job
3

4
# 以 nice 值 -5 启动命令（提高优先级，需要 root）
5
nice -n -5 ./my_important_task

1
# 将 PID 1234 的 nice 值改为 5
2
renice -n 5 -p 1234
3

4
# 将用户 alice 的所有进程 nice 值改为 10
5
renice -n 10 -u alice
6

7
# 将进程组 5678 的 nice 值改为 -3
8
renice -n -3 -g 5678

1
# 查看进程的调度策略和优先级
2
chrt -p 1234
3

4
# 以 SCHED_FIFO 优先级 50 运行
5
chrt -f -p 50 ./realtime_task
6

7
# 以 SCHED_RR 优先级 30 运行
8
chrt -r -p 30 ./round_robin_task
9

10
# 以 SCHED_DEADLINE 运行（runtime=10ms, deadline=30ms, period=30ms）
11
chrt -d --runtime 10000000 --deadline 30000000 --period 30000000 ./dl_task
12

13
# 将运行中的进程改为 SCHED_FIFO 优先级 80
14
chrt -f -p 80 1234
15

16
# 将进程改回普通调度策略
17
chrt -o -p 0 1234

1
# 查看当前 shell 的调度信息
2
cat /proc/$$/sched

1
bash (1234, #threads: 1)
2
-------------------------------------------------------------------
3
se.exec_start                                :   1234567890.123456  # 上次执行开始时间
4
se.vruntime                                  :   567890.123456      # 虚拟运行时间
5
se.sum_exec_runtime                          :   1234.567890        # 实际运行总时间
6
se.load.weight                               :   1048576            # 权重（nice 0 = 1048576）
7
nr_switches                                  :   456                # 上下文切换总次数
8
nr_voluntary_switches                        :   345                # 自愿切换次数
9
nr_involuntary_switches                      :   111                # 非自愿切换次数
10
prio                                         :   120                # 动态优先级（120 = nice 0）
11
policy                                       :   0                  # 调度策略（0=SCHED_NORMAL）

1
# 终端 1：启动两个 CPU 密集型任务，一个 nice 0，一个 nice 10
2
nice -n 0  dd if=/dev/zero bs=1M | md5sum &
3
nice -n 10 dd if=/dev/zero bs=1M | md5sum &
4

5
# 终端 2：观察 CPU 使用率
6
top -H
7
# 你会发现 nice 0 的进程获得的 CPU 时间约为 nice 10 进程的 ~2.5 倍
8

9
# 清理
10
killall dd md5sum

1
# 实验：SCHED_FIFO 进程的不可抢占性
2

3
# 终端 1：以 SCHED_FIFO 优先级 1 运行一个死循环（危险！）
4
sudo chrt -f 1 bash -c 'while true; do :; done'
5
# 注意：此时该终端会被完全占用，系统可能变慢但不会完全卡死
6
# 因为 Linux 的 RT throttling 会保留 5% CPU 给普通进程
7

8
# 终端 2：查看 RT throttling 状态
9
cat /proc/sys/kernel/sched_rt_runtime_us
10
cat /proc/sys/kernel/sched_rt_period_us
11

12
# 终端 3：以更高优先级抢占
13
sudo chrt -f 2 bash -c 'echo "I can preempt!" && sleep 1'
14
# 这个进程会抢占优先级 1 的 SCHED_FIFO 进程

1
# 将进程绑定到 CPU 0
2
taskset -pc 0 $$
3
cat /proc/$$/status | grep Cpus_allowed
4
# 输出：Cpus_allowed:   00000001
5

6
# 启动一个 CPU 密集型任务并绑定到 CPU 1
7
taskset -c 1 dd if=/dev/zero bs=1M | md5sum &
8

9
# 观察：只有 CPU 1 的使用率接近 100%
10
mpstat -P ALL 1
11

12
# 清理
13
killall dd md5sum

1
# 确保 cgroup v2 已挂载
2
mount | grep cgroup2
3

4
# 创建测试 cgroup
5
sudo mkdir /sys/fs/cgroup/test-cpu
6
echo $$ | sudo tee /sys/fs/cgroup/test-cpu/cgroup.procs
7

8
# 限制为 20% CPU
9
echo "20000 100000" | sudo tee /sys/fs/cgroup/test-cpu/cpu.max
10

11
# 运行 CPU 密集型任务
12
dd if=/dev/zero bs=1M | md5sum &
13

14
# 在另一个终端观察 CPU 使用率
15
top -p $!
16
# CPU 使用率应被限制在 ~20%
17

18
# 清理
19
kill %1
20
sudo rmdir /sys/fs/cgroup/test-cpu

1
# 使用 perf 观察调度事件
2
sudo perf sched record -- sleep 5
3
sudo perf sched latency
4
# 输出各进程的调度延迟统计
5

6
# 使用 vmstat 观察上下文切换频率
7
vmstat 1
8
# cs 列显示每秒上下文切换次数
9

10
# 使用 /proc/stat 观察全局上下文切换计数
11
cat /proc/stat | grep ctxt
12
# ctxt 123456789
13

14
# 使用 pidstat 观察特定进程的上下文切换
15
pidstat -w -p ALL 1