一、简介：为什么必须理解调度子系统架构？

Linux 调度器是操作系统最核心的子系统之一，直接决定进程/线程何时获得 CPU 资源、运行多长时间。随着实时 Linux（PREEMPT_RT）在工业控制、自动驾驶、机器人等领域的广泛应用，调度器的架构设计、优先级决策机制成为系统性能与实时性的关键瓶颈。

掌握调度子系统架构的价值：

应用场景核心价值
学术论文深入分析 CFS 公平调度算法、EDF 实时调度理论的形式化验证
工业实时系统为 ROS2/PLC/运动控制器配置最优调度策略，确保任务 deadlines
内核开发编写新的调度类（如 GPU 调度、AI 推理调度），扩展现有框架
性能优化定位调度延迟、上下文切换开销，优化多核负载均衡
安全认证IEC 61508/SIL 认证中，证明调度器的可预测性与确定性

本文基于 Linux 6.13 内核源码，从模块化设计视角拆解调度子系统，建立完整的认知框架。

二、核心概念：调度子系统的 5 层架构

2.1 调度子系统整体架构图

┌─────────────────────────────────────────┐
│  用户空间：sched_setscheduler() 系统调用   │
├─────────────────────────────────────────┤
│  系统调用层：kernel/sched/core.c          │
│  sys_sched_setscheduler() → __sched_setscheduler() │
├─────────────────────────────────────────┤
│  调度类层（Scheduling Classes）          │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐     │
│  │  stop   │ │ deadline│ │   rt    │     │
│  │sched_class│ │sched_class│ │sched_class│  │
│  └─────────┘ └─────────┘ └─────────┘     │
│  ┌─────────┐ ┌─────────┐                  │
│  │   cfs   │ │  idle   │                  │
│  │sched_class│ │sched_class│               │
│  └─────────┘ └─────────┘                  │
├─────────────────────────────────────────┤
│  核心调度器：pick_next_task()            │
│  负载均衡：load_balance() / migrate_task()│
├─────────────────────────────────────────┤
│  底层抽象：sched_entity / task_struct      │
│  时间记账：update_curr() / scheduler_tick()│
└─────────────────────────────────────────┘

2.2 五大调度类详解

调度类优先级范围核心算法应用场景
Stop最高（-1）无（强制抢占）CPU 热插拔、负载均衡的迁移线程
Deadline0-99EDF（最早截止时间优先）实时视频编解码、工业控制
RT0-99FIFO/RR硬实时任务，如 ROS2 控制循环
CFS100-139红黑树 + vruntime普通进程，Web 服务器、数据库
Idle最低（140）无空闲任务，节能

2.3 关键术语

术语定义源码位置
sched_class调度类抽象结构体，定义 12 个回调函数kernel/sched/sched.h
task_struct进程描述符，包含 sched_class 指针include/linux/sched.h
sched_entityCFS 调度实体，维护 vruntimekernel/sched/sched.h
sched_dl_entityDeadline 调度实体，维护 deadlines同上
rq（Run Queue）每个 CPU 的运行队列kernel/sched/sched.h

三、环境准备：搭建内核源码分析环境

3.1 硬件需求

  • x86_64 多核处理器（建议 8 核以上，便于观察负载均衡）

  • 16 GB 内存（编译内核需要）

  • 100 GB 磁盘空间

3.2 软件环境

组件版本用途
Linux 内核源码6.13源码分析对象
GCC12+编译内核与测试程序
QEMU/KVM6.2+安全地测试调度器修改
BCC/bpftrace0.17+动态追踪调度事件
perf6.13性能分析与火焰图

3.3 一键下载与分析环境配置

#!/bin/bash
# setup_sched_analysis.sh
# 创建调度子系统分析环境

set -e

KERNEL_VERSION="6.13"
WORK_DIR="$HOME/sched-analysis"
mkdir -p "$WORK_DIR" && cd "$WORK_DIR"

# 1. 下载内核源码
echo "=== 下载 Linux $KERNEL_VERSION 源码 ==="
wget -q https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-${KERNEL_VERSION}.tar.xz
tar -xf linux-${KERNEL_VERSION}.tar.xz
cd linux-${KERNEL_VERSION}

# 2. 安装依赖
echo "=== 安装编译依赖 ==="
sudo apt-get update
sudo apt-get install -y \
    build-essential libncurses-dev bison flex \
    libssl-dev libelf-dev bc dwarves \
    bpftrace linux-tools-common linux-tools-generic

# 3. 生成 tags 文件，便于代码跳转
echo "=== 生成 ctags ==="
make tags

# 4. 创建分析目录结构
mkdir -p "$WORK_DIR/analysis-scripts"
mkdir -p "$WORK_DIR/experiments"
mkdir -p "$WORK_DIR/reports"

echo "=== 环境准备完成 ==="
echo "源码位置: $WORK_DIR/linux-${KERNEL_VERSION}"
echo "分析脚本位置: $WORK_DIR/analysis-scripts"

3.4 关键源码文件索引

# 调度子系统核心文件
kernel/sched/core.c          # 调度器入口、系统调用实现
kernel/sched/fair.c          # CFS 完全公平调度器
kernel/sched/rt.c            # RT 实时调度器
kernel/sched/deadline.c      # EDF 截止时间调度器
kernel/sched/stop_task.c     # Stop 调度类
kernel/sched/idle.c          # Idle 调度类
kernel/sched/sched.h         # 核心数据结构定义
kernel/sched/topology.c      # NUMA/多核拓扑与负载均衡
include/linux/sched.h        # task_struct 定义

四、应用场景：自动驾驶实时控制系统的调度架构

在自动驾驶域控制器中，调度子系统的架构设计直接影响功能安全与实时性。典型场景包含三类关键任务：

感知融合任务（Deadline 类）：激光雷达点云处理周期 10ms，截止时间 8ms，使用 SCHED_DEADLINE 确保 EDF 调度，错过 deadline 触发安全降级。

车辆控制任务（RT 类）：横向/纵向控制循环 2ms，优先级 99，使用 SCHED_FIFO，禁止被抢占，确保控制指令确定性输出。

日志与诊断任务（CFS 类）：系统状态记录、远程诊断，nice 值 10，在感知与控制任务空闲时运行，不影响实时性。

通过 Linux 6.13 的模块化调度类架构，三类任务共存于同一系统，Stop 类处理 CPU 热插拔事件，Idle 类在空闲时节能。调度器的优先级层级确保高优先级任务始终优先，负载均衡在多核间分配任务，避免单核过载导致的 deadline miss。

五、实际案例与步骤：源码级深度分析

5.1 调度类结构体定义：sched_class

// kernel/sched/sched.h (Linux 6.13)
// 调度类抽象接口，所有调度类必须实现这 12 个回调

struct sched_class {
    /* 下一级调度类，形成优先级链表 */
    const struct sched_class *next;

    /* 将任务加入运行队列 */
    void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
    
    /* 从运行队列移除任务 */
    void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
    
    /* 任务主动放弃 CPU 时调用 */
    void (*yield_task)   (struct rq *rq);
    bool (*yield_to_task)(struct rq *rq, struct task_struct *p);

    /* 检查当前任务是否需要被抢占 */
    void (*check_preempt_curr)(struct rq *rq, struct task_struct *p, int flags);

    /* 选择下一个运行的任务，调度器核心 */
    struct task_struct *(*pick_next_task)(struct rq *rq);

    /* 任务切换后的回调 */
    void (*put_prev_task)(struct rq *rq, struct task_struct *p);

    /* 设置下一个任务的上下文 */
    void (*set_next_task)(struct rq *rq, struct task_struct *p, bool first);

    /* 任务切换时的记账 */
    void (*task_tick)(struct rq *rq, struct task_struct *p, int queued);

    /* 任务状态变更回调 */
    void (*task_fork)(struct task_struct *p);
    void (*task_dead)(struct task_struct *p);

    /* SMP 相关：任务迁移、负载计算 */
    void (*switched_from)(struct rq *rq, struct task_struct *p);
    void (*switched_to)  (struct rq *rq, struct task_struct *p);
    void (*prio_changed) (struct rq *rq, struct task_struct *p, int oldprio);

    /* 获取动态优先级 */
    unsigned int (*get_rr_interval)(struct rq *rq, struct task_struct *p);

    /* 更新任务负载 */
    void (*update_curr)(struct rq *rq);
};

分析要点：next 指针形成调度类优先级链表，Stop → Deadline → RT → CFS → Idle，调度器从高到低遍历选择任务。

5.2 五大调度类的优先级链表初始化

// kernel/sched/core.c
// 调度类优先级顺序：stop > deadline > rt > fair > idle

extern const struct sched_class stop_sched_class;      // stop_task.c
extern const struct sched_class dl_sched_class;          // deadline.c
extern const struct sched_class rt_sched_class;          // rt.c
extern const struct sched_class fair_sched_class;        // fair.c (CFS)
extern const struct sched_class idle_sched_class;        // idle.c

// 调度类链表定义（优先级从高到低）
#define sched_class_highest (&stop_sched_class)
#define for_each_class(class) \
    for (class = sched_class_highest; class; class = class->next)

// 实际链表连接（以 stop_sched_class 为例）
// kernel/sched/stop_task.c
const struct sched_class stop_sched_class = {
    .next           = &dl_sched_class,    // 指向 deadline
    .enqueue_task   = enqueue_task_stop,
    .dequeue_task   = dequeue_task_stop,
    .pick_next_task = pick_next_task_stop,
    // ... 其他回调
};

5.3 核心调度决策：pick_next_task()

// kernel/sched/core.c
// 调度器主循环：选择下一个运行的任务

static inline struct task_struct *
pick_next_task(struct rq *rq, struct task_struct *prev, struct rq_flags *rf)
{
    const struct sched_class *class;
    struct task_struct *p;

    /*
     * 优化：如果当前任务仍是最高优先级，快速路径返回
     */
    if (likely(prev->sched_class == &fair_sched_class &&
               rq->nr_running == 1)) {
        p = fair_sched_class.pick_next_task(rq);
        if (likely(p))
            return p;
    }

    /*
     * 标准路径：按优先级遍历所有调度类
     */
    for_each_class(class) {
        p = class->pick_next_task(rq);
        if (p) {
            /*
             * 找到可运行任务，设置调度类上下文
             */
            if (unlikely(p == RETRY_TASK))
                goto again;
            
            /* 记录调度类用于后续记账 */
            rq->prev_sched_class = class;
            
            return p;
        }
        /*
         * 当前调度类无任务，继续检查下一级（更低优先级）
         */
    }

    /*
     * 所有调度类都无任务，运行 idle 任务
     * 理论上不会到达这里，因为 idle_sched_class 总有任务
     */
    BUG();
}

关键洞察：遍历顺序即优先级顺序，Stop 类只要有任务必定被选中，确保关键操作（如迁移线程）不被延迟。

5.4 CFS 调度实体：sched_entity 与 vruntime

// kernel/sched/sched.h
// CFS 调度实体，嵌入在 task_struct 中

struct sched_entity {
    /* 用于 CFS 红黑树 */
    struct load_weight      load;           /* 权重，与 nice 值相关 */
    struct rb_node        run_node;       /* 红黑树节点 */
    struct list_head      group_node;       /* 组调度链表 */
    unsigned int          on_rq;            /* 是否在运行队列 */

    /* 虚拟运行时间：CFS 公平调度的核心 */
    u64                   exec_start;       /* 本次运行开始时间 */
    u64                   sum_exec_runtime; /* 总运行时间 */
    u64                   vruntime;         /* 虚拟运行时间 */
    u64                   prev_sum_exec_runtime; /* 上次运行时间 */

    /* 组调度相关 */
    u64                   nr_migrations;    /* 迁移次数统计 */

    /* 负载追踪（用于负载均衡） */
    struct sched_avg      avg;              /* PELT 算法负载估计 */
};

// CFS 运行队列
struct cfs_rq {
    struct load_weight    load;             /* 队列总权重 */
    unsigned int          nr_running;       /* 可运行任务数 */
    unsigned int          h_nr_running;     /* 包含组调度的总数 */

    u64                   exec_clock;       /* 运行时钟 */
    u64                   min_vruntime;     /* 队列最小 vruntime */

    struct rb_root_cached tasks_timeline;   /* 红黑树根，按 vruntime 排序 */
    struct sched_entity   *curr;            /* 当前运行任务 */
    struct sched_entity   *next;            /* 下一个候选任务 */
    struct sched_entity   *last;            /* 上次运行任务 */
};

5.5 EDF 实时调度：sched_dl_entity

// kernel/sched/sched.h
// Deadline 调度实体，实现最早截止时间优先（EDF）

struct sched_dl_entity {
    struct rb_node          rb_node;        /* EDF 红黑树节点 */

    /*
     * 任务参数：周期、运行时间、截止时间
     */
    u64                     dl_runtime;     /* 每个周期需要的运行时间 */
    u64                     dl_deadline;    /* 相对截止时间 */
    u64                     dl_period;      /* 任务周期 */

    /*
     * 动态状态
     */
    s64                     runtime;        /* 当前周期剩余运行时间 */
    u64                     deadline;       /* 绝对截止时间 */
    unsigned int            flags;          /* 状态标志 */

    /*
     * 带宽管理：确保系统总利用率 ≤ 100%
     */
    struct hrtimer          dl_timer;       /* 周期定时器 */
    struct hrtimer          dl_period_timer; /* 补充运行时间的定时器 */

    /*
     * 继承与阻塞管理
     */
    struct task_struct      *pi_task;       /* 优先级继承任务 */
    struct rb_root_cached   *rq_leftmost;   /* 指向运行队列最左节点 */
};

// Deadline 运行队列
struct dl_rq {
    struct rb_root_cached   root;           /* EDF 红黑树，按 deadline 排序 */
    unsigned long           dl_nr_running; /* 可运行任务数 */

    u64                     earliest_dl;    /* 最早截止时间 */
    u64                     min_deadline;   /* 队列最小 deadline */
};

5.6 调试脚本：实时观察调度决策

#!/bin/bash
# trace_sched_decisions.sh
# 使用 ftrace 追踪调度器决策过程

# 需要 root 权限
[ "$EUID" -ne 0 ] && echo "请使用 sudo 运行" && exit 1

# 挂载 debugfs
mount -t debugfs none /sys/kernel/debug 2>/dev/null || true

# 设置追踪
cd /sys/kernel/debug/tracing

# 启用调度事件
echo 0 > tracing_on
echo > trace

# 启用关键事件
echo 1 > events/sched/sched_switch/enable
echo 1 > events/sched/sched_wakeup/enable
echo 1 > events/sched/sched_migrate_task/enable

# 设置过滤：只追踪特定 PID（可选）
# echo "pid == 1234" > events/sched/sched_switch/filter

echo 1 > tracing_on

echo "追踪已启动，按 Ctrl+C 停止..."
sleep 30

echo 0 > tracing_on

# 输出结果
cat trace > /tmp/sched_trace.txt
echo "追踪结果已保存到 /tmp/sched_trace.txt"

# 生成摘要
echo "=== 调度事件摘要 ==="
grep -c "sched_switch:" /tmp/sched_trace.txt | xargs echo "上下文切换次数:"
grep -c "sched_wakeup:" /tmp/sched_trace.txt | xargs echo "任务唤醒次数:"
grep -c "sched_migrate_task:" /tmp/sched_trace.txt | xargs echo "任务迁移次数:"

5.7 BPF 程序：动态监控调度延迟

// sched_latency.bpf.c
// 使用 eBPF 监控调度延迟，适合论文数据收集

#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>

#define MAX_ENTRIES 10240

struct event {
    u32 pid;
    u32 tgid;
    u64 delay_ns;       /* 唤醒到运行的延迟 */
    u64 wake_time;      /* 唤醒时间戳 */
    u64 run_time;       /* 开始运行时间戳 */
    char comm[16];
};

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, MAX_ENTRIES);
    __type(key, u32);           /* pid */
    __type(value, u64);         /* wake timestamp */
} wake_times;

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);
} rb;

SEC("tp/sched/sched_wakeup")
int trace_sched_wakeup(struct trace_event_raw_sched_wakeup *ctx)
{
    u32 pid = ctx->pid;
    u64 ts = bpf_ktime_get_ns();
    
    bpf_map_update_elem(&wake_times, &pid, &ts, BPF_ANY);
    return 0;
}

SEC("tp/sched/sched_switch")
int trace_sched_switch(struct trace_event_raw_sched_switch *ctx)
{
    u32 pid = ctx->next_pid;
    u64 *wake_ts, run_ts, delay;
    struct event *e;
    
    /* 查找唤醒时间 */
    wake_ts = bpf_map_lookup_elem(&wake_times, &pid);
    if (!wake_ts)
        return 0;
    
    run_ts = bpf_ktime_get_ns();
    delay = run_ts - *wake_ts;
    
    /* 提交事件到 ringbuf */
    e = bpf_ringbuf_reserve(&rb, sizeof(*e), 0);
    if (!e)
        goto cleanup;
    
    e->pid = pid;
    e->tgid = bpf_get_current_pid_tgid() >> 32;
    e->delay_ns = delay;
    e->wake_time = *wake_ts;
    e->run_time = run_ts;
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
    
    bpf_ringbuf_submit(e, 0);

cleanup:
    bpf_map_delete_elem(&wake_times, &pid);
    return 0;
}

char LICENSE[] SEC("license") = "GPL";

编译与运行：

#!/bin/bash
# build_and_run_bpf.sh

# 安装依赖
sudo apt-get install -y clang llvm libbpf-dev linux-headers-$(uname -r)

# 编译
clang -O2 -g -target bpf -c sched_latency.bpf.c -o sched_latency.bpf.o

# 使用 bpftool 加载
sudo bpftool prog load sched_latency.bpf.o /sys/fs/bpf/sched_latency

# 附加到 tracepoint
sudo bpftool prog attach /sys/fs/bpf/sched_latency \
    tracepoint sched:sched_wakeup
sudo bpftool prog attach /sys/fs/bpf/sched_latency \
    tracepoint sched:sched_switch

# 读取结果
sudo cat /sys/kernel/debug/tracing/trace_pipe | grep "sched_latency"

# 卸载
# sudo rm /sys/fs/bpf/sched_latency

5.8 用户空间实验：创建不同调度类任务

// sched_class_demo.c
// 创建 5 种调度类的任务，观察调度行为

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sched.h>
#include <sys/syscall.h>
#include <linux/sched.h>

#define gettid() syscall(SYS_gettid)

/* 设置线程为 CFS，指定 nice 值 */
void set_cfs_nice(int nice_val) {
    int ret = setpriority(PRIO_PROCESS, 0, nice_val);
    if (ret < 0) perror("setpriority");
    printf("[TID %ld] CFS nice = %d\n", gettid(), nice_val);
}

/* 设置线程为 RT，指定 SCHED_FIFO/SCHED_RR 和优先级 */
void set_rt_policy(int policy, int prio) {
    struct sched_param param = { .sched_priority = prio };
    int ret = pthread_setschedparam(pthread_self(), policy, &param);
    if (ret != 0) {
        fprintf(stderr, "pthread_setschedparam failed: %s\n", strerror(ret));
        return;
    }
    const char *name = (policy == SCHED_FIFO) ? "FIFO" : "RR";
    printf("[TID %ld] RT %s, priority = %d\n", gettid(), name, prio);
}

/* 设置线程为 DEADLINE（需要 root 和内核支持） */
void set_dl_policy(u64 runtime_ns, u64 deadline_ns, u64 period_ns) {
    struct sched_attr attr = {
        .size = sizeof(attr),
        .sched_policy = SCHED_DEADLINE,
        .sched_runtime = runtime_ns,
        .sched_deadline = deadline_ns,
        .sched_period = period_ns,
    };
    
    int ret = syscall(__NR_sched_setattr, 0, &attr, 0);
    if (ret < 0) {
        perror("sched_setattr (DEADLINE)");
        printf("提示: 需要 root 权限和 CONFIG_SCHED_DEADLINE 内核选项\n");
        return;
    }
    printf("[TID %ld] DEADLINE runtime=%lu deadline=%lu period=%lu\n",
           gettid(), runtime_ns, deadline_ns, period_ns);
}

/* 工作负载：模拟计算 */
void* workload(void* arg) {
    const char* name = (const char*)arg;
    volatile unsigned long counter = 0;
    
    printf("[%s] TID=%ld 开始运行\n", name, gettid());
    
    for (int i = 0; i < 5; i++) {
        /* 消耗 CPU 约 100ms */
        for (int j = 0; j < 100000000; j++) counter++;
        
        struct timespec ts;
        clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
        printf("[%s] 迭代 %d, CPU时间=%ld.%09ld\n", 
               name, i, ts.tv_sec, ts.tv_nsec);
    }
    
    printf("[%s] 完成\n", name);
    return NULL;
}

int main(int argc, char *argv[]) {
    pthread_t t_cfs_high, t_cfs_low, t_rt_fifo, t_rt_rr, t_dl;
    
    printf("=== Linux 调度类演示 ===\n");
    printf("当前进程 PID=%d\n", getpid());
    printf("查看调度信息: chrt -p %d 或 ps -eo pid,class,rtprio,ni,comm\n\n", 
           getpid());
    
    /* CFS nice -10 (较高优先级) */
    pthread_create(&t_cfs_high, NULL, workload, "CFS_HIGH");
    pthread_setname_np(t_cfs_high, "CFS_HIGH");
    
    /* CFS nice 10 (较低优先级) */
    pthread_create(&t_cfs_low, NULL, workload, "CFS_LOW");
    pthread_setname_np(t_cfs_low, "CFS_LOW");
    
    /* RT FIFO 优先级 50 */
    pthread_create(&t_rt_fifo, NULL, workload, "RT_FIFO");
    pthread_setname_np(t_rt_fifo, "RT_FIFO");
    
    /* RT RR 优先级 50 */
    pthread_create(&t_rt_rr, NULL, workload, "RT_RR");
    pthread_setname_np(t_rt_rr, "RT_RR");
    
    /* DEADLINE (可能失败，需要特殊配置) */
    pthread_create(&t_dl, NULL, workload, "DEADLINE");
    pthread_setname_np(t_dl, "DEADLINE");
    
    /* 在主线程设置各线程的调度策略 */
    sleep(1);  /* 等待线程创建完成 */
    
    /* 注意：实际设置应在线程函数内或使用 pthread_attr_t 预设 */
    
    pthread_join(t_cfs_high, NULL);
    pthread_join(t_cfs_low, NULL);
    pthread_join(t_rt_fifo, NULL);
    pthread_join(t_rt_rr, NULL);
    pthread_join(t_dl, NULL);
    
    printf("\n=== 演示完成 ===\n");
    printf("使用以下命令观察实际调度类:\n");
    printf("  ps -eo pid,tid,class,rtprio,ni,comm | grep %d\n", getpid());
    printf("  watch -n 0.5 'cat /proc/%d/task/*/sched'\n", getpid());
    
    return 0;
}

编译与运行：

gcc -o sched_class_demo sched_class_demo.c -pthread
sudo ./sched_class_demo

六、常见问题与解答

6.1 如何确认内核支持 SCHED_DEADLINE？

# 检查内核配置
grep CONFIG_SCHED_DEADLINE /boot/config-$(uname -r)
# 应输出: CONFIG_SCHED_DEADLINE=y

# 检查运行时支持
cat /proc/sys/kernel/sched_rt_period_us
# 存在即支持

6.2 为什么设置 RT 优先级失败？

  • 原因：普通用户无 CAP_SYS_NICE 能力。

  • 解决：使用 sudo，或配置 /etc/security/limits.conf：

    *    soft    rtprio    99
*    hard    rtprio    99

6.3 如何观察任务的实际调度类？

# 方法 1: ps 命令
ps -eo pid,tid,class,rtprio,ni,comm --sort=class

# 方法 2: /proc 接口
cat /proc/<pid>/task/<tid>/sched | grep policy

# 方法 3: chrt 命令
chrt -p <pid>

6.4 CFS 的 vruntime 如何计算？

// kernel/sched/fair.c (简化版)
static void update_curr(struct cfs_rq *cfs_rq)
{
    struct sched_entity *curr = cfs_rq->curr;
    u64 now = rq_clock_task(rq_of(cfs_rq));
    u64 delta_exec;
    
    if (unlikely(!curr))
        return;
    
    /* 计算本次运行时间 */
    delta_exec = now - curr->exec_start;
    if (unlikely((s64)delta_exec <= 0))
        return;
    
    curr->exec_start = now;
    curr->sum_exec_runtime += delta_exec;
    
    /* 计算虚拟运行时间: vruntime += delta_exec * NICE_0_LOAD / load.weight */
    curr->vruntime += calc_delta_fair(delta_exec, curr);
    
    /* 更新队列最小 vruntime */
    update_min_vruntime(cfs_rq);
}

6.5 如何调试调度器死锁？

# 启用 lockdep
echo 1 > /proc/sys/kernel/lockup_detector

# 查看调度器状态
cat /proc/sched_debug > /tmp/sched_debug.txt

# 分析每个 CPU 的运行队列
grep -A 20 "cpu#0" /tmp/sched_debug.txt

七、实践建议与最佳实践

7.1 学术论文数据收集

研究主题推荐工具关键指标
CFS 公平性分析sched_class_demo.c + trace_sched_decisions.shvruntime 分布、周转时间
RT 调度可预测性sched_latency.bpf.c唤醒延迟、调度抖动
EDF 带宽利用率rt-app 工具deadline miss 率、CPU 利用率
负载均衡效率perf sched任务迁移次数、远程内存访问

7.2 内核开发调试技巧

# 1. 使用 QEMU 安全测试调度器修改
qemu-system-x86_64 \
    -kernel arch/x86/boot/bzImage \
    -append "console=ttyS0 nokaslr sched_debug" \
    -nographic

# 2. 启用调度器调试输出
echo 1 > /sys/kernel/debug/sched_verbose

# 3. 使用 kgdb 断点调试
echo ttyS0 > /sys/module/kgdboc/parameters/kgdboc
echo g > /proc/sysrq-trigger  # 进入 kgdb

7.3 性能优化检查清单

  • [ ] 确认 CONFIG_PREEMPT 或 CONFIG_PREEMPT_RT 已启用

  • [ ] 实时任务使用 isolcpus 隔离 CPU，减少抖动

  • [ ] 检查 sched_rt_runtime_us 不为 0（避免 RT 任务饿死 CFS）

  • [ ] 使用 numactl 绑定 NUMA 节点，减少跨节点内存访问

  • [ ] 启用 CONFIG_SCHED_SMT 优化超线程调度

八、总结与应用场景

本文基于 Linux 6.13 内核源码，系统拆解了调度子系统的五大调度类架构：

层级核心机制关键源码
调度类抽象sched_class 接口与优先级链表kernel/sched/sched.h
Stop 类最高优先级，强制抢占kernel/sched/stop_task.c
Deadline 类EDF 算法，带宽管理kernel/sched/deadline.c
RT 类FIFO/RR，静态优先级kernel/sched/rt.c
CFS 类红黑树 + vruntime，公平调度kernel/sched/fair.c
Idle 类节能，最低优先级kernel/sched/idle.c
核心决策pick_next_task() 遍历选择kernel/sched/core.c

应用场景：

  • 学术研究：基于本文源码分析，可撰写 CFS 公平性证明、EDF 可调度性分析、多核负载均衡算法比较等论文。

  • 工业实时系统：为 PLC、机器人控制器、自动驾驶域控制器配置最优调度策略，通过 IEC 61508 认证。

  • 内核开发：扩展新的调度类（如 AI 推理加速器调度、GPU 任务调度），贡献至主线内核。

掌握 Linux 调度子系统的架构全景，你就拥有了优化任何 Linux 系统性能与实时性的底层能力。立即下载 Linux 6.13 源码，运行本文的实验脚本，生成你的第一张调度延迟分布图——真正的内核级优化，从这里开始！

# linux # 系统架构 # 运维 # 服务器 # dubbo # 大数据 # 操作系统
Logo
openvela

openvela 操作系统专为 AIoT 领域量身定制，以轻量化、标准兼容、安全性和高度可扩展性为核心特点。openvela 以其卓越的技术优势，已成为众多物联网设备和 AI 硬件的技术首选，涵盖了智能手表、运动手环、智能音箱、耳机、智能家居设备以及机器人等多个领域。

更多推荐

cover

Arm Ethos‑U65：YOLOv8n 模型准备与 Vela 编译

avatar openvela
cover

开源新纪元：深度解析小米 MiMo Code 的技术架构与实战应用

avatar openvela

UniAD_v2 模型NPU适配

参考github网址：https://github.com/OpenDriveLab/UniAD/tree/v2.0参考readme：https://gitcode.com/Ascend/DrivingSDK/blob/master/model_examples/UniAD/README.md。

avatar openvela