深入解析 CFS 与 BFS：从内核原理到 2026 年 AI 原生时代的性能调优实战

2026-02-02 09:46:08 0条评论 2次阅读 0人点赞

在前置知识中，我们已经了解了 CPU 调度 的基础。作为一名深耕内核开发多年的工程师，我见证了 Linux 调度器从简单的 O(n) 设计演进到极度复杂的 CFS，再到现在面对异构计算和 AI 负载的挑战。在这篇文章中，我们将深入探讨完全公平调度器（CFS）和大脑损伤调度器（BFS）的底层机制，并结合我们在 2026 年的最新实践，看看如何将这些经典原理应用到现代 AI 原生应用的开发中。

进程调度概览

当程序作为进程加载到 RAM（内存）中后，CPU 会根据各进程的优先级来执行它们。这不仅仅是关于“运行代码”，更是关于如何在毫秒级的时间窗口内，平衡系统响应速度与吞吐量。让我们思考一下这个场景：你的 IDE 正在编译大型项目，同时浏览器正在播放 4K 视频流，后台还有一个 LLM 推理任务。如何让它们互不干扰？这就是调度器的艺术。

1. 完全公平调度器 (CFS)

CFS（Completely Fair Scheduler）是 Linux 内核从 2.6.23 版本开始的默认调度器。它基于“旋转楼梯截止时间调度器”（RSDL）设计，旨在解决传统调度器在处理不同负载类型时的不公平问题。它能够优雅地处理 I/O 密集型和 CPU 密集型进程。

#### 理想公平调度 (IFS) 模型

顾名思义，CFS 旨在公平地或平等地在所有进程之间划分 CPU 时间。在深入理解 CFS 之前，让我们先来看看 N 个进程的 理想公平调度 (IFS) 是怎样的。如果在就绪队列中有 N 个进程，根据 IFS，每个进程将获得 (100/N)% 的 CPU 时间。

让我们假设有四个进程在就绪队列中等待执行，它们的突发时间如下表所示：

进程

突发时间 (毫秒)

—

—

A

10

B

6

C

14

D

6假设我们有一个 4ms 的时间片。最初，有四个进程在就绪队列中等待执行，根据理想公平调度，每个进程都会获得同等公平的执行时间（时间片 / N）。

所以 4/4=1，意味着在第一个时间片中，每个进程都获得 1ms 的执行时间。在完成了六个时间片后，进程 B 和 D 已经完全执行完毕，剩下的进程是 A 和 C，它们已经执行了 6ms，剩余时间分别为 A=4ms 和 C=8ms。

在第七个时间片中，只有 A 和 C 会执行（因为只剩下两个进程，所以 4/2=2ms）。这就是理想公平调度，无论进程的优先级如何，每个进程都获得同等份额的时间片。

#### CFS 的核心机制：红黑树与虚拟运行时间

CFS 与基于理想的调度类似，但它根据每个进程的“虚拟运行时间”来确定优先级。你可能会问，为什么不直接用时间片？因为硬件时钟中断的不确定性和优先级的复杂性，硬性切割时间片效率极低。

核心思想如下：

  • 虚拟时间：每个可运行的进程在 PCB（进程控制块）中都有一个关联的虚拟时间 vruntime。
  • 动态记账：每当发生上下文切换时（或在每个调度点），当前运行进程的虚拟时间会增加：virtualruntime_currprocess += delta_exec * weight。
    // 伪代码：展示虚拟运行时间的更新逻辑
    // 这是我们在阅读内核源码时常见的基本逻辑
    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 = now - curr->exec_start;
        
        if (unlikely(delta_exec > ULONG_MAX))
            return;
            
        curr->exec_start = now;
        
        // 关键点：根据权重的缩放更新 vruntime
        // 实际内核中 calc_delta_fair 会涉及位运算优化
        curr->vruntime += calc_delta_fair(delta_exec, curr);
        
        // 更新最小运行时间，用于判断是否需要抢占
        update_min_vruntime(cfs_rq);
    }
  • 红黑树实现：CFS 使用 红黑树 来管理所有可运行进程，而不是简单的链表队列。

在 C++ 中，我们可以使用 STL 中的 INLINECODE509629da 或 INLINECODE19e8da13 来模拟这一结构，因为它们底层也是通过红黑树实现的。

    // 模拟 CFS 调度器的 C++ 示例
    #include 
    #include 
    #include 
    #include 

    struct Process {
        std::string name;
        uint64_t vruntime; // 虚拟运行时间，作为排序的 key
        int id;
    };

    // 仿函数：用于红黑树排序，vruntime 越小越靠左（优先级越高）
    struct CompareVRuntime {
        bool operator()(const Process& lhs, const Process& rhs) const {
            return lhs.vruntime < rhs.vruntime;
        }
    };

    class CFSSimulator {
    private:
        // 模拟红黑树存储的进程队列
        // 在内核中，这对应于 struct cfs_rq 中的 rb_root_cached
        std::map run_queue;

    public:
        void add_process(Process p) {
            run_queue.insert({p, p.id});
            std::cout << "[System] Process " << p.name 
                      << " added with vruntime: " << p.vruntime << std::endl;
        }

        void schedule() {
            if (run_queue.empty()) {
                std::cout << "[Idle] No processes to run." <first;
            
            std::cout << "[Scheduler] Picked process: " << next_task.name 
                      << " | vruntime: " << next_task.vruntime << std::endl;

            // 模拟进程运行：增加 vruntime
            uint64_t runtime_slice = 10; // 假设运行了 10ms
            // 从 map 中移除，更新后再插入，以保持红黑树平衡
            run_queue.erase(it);
            next_task.vruntime += runtime_slice;
            run_queue.insert({next_task, next_task.id});
        }
    };

#### CFS 时间复杂度与优化

  • 红黑树的插入操作耗时 O(logn)。
  • 查找具有最小虚拟时间的节点耗时 O(1)，因为我们可以维护一个指针指向最左侧的节点（内核中的 rb_leftmost）。
因此，总体时间复杂度为 O(logn)

使用红黑树的另一个优点是，如果某个进程是 I/O 密集型的，它经常会休眠等待 I/O。当它醒来时，其 vruntime 会非常小（因为在睡眠期间没有累加），这使得它作为红黑树的最左侧节点出现，从而优先被执行。因此，CFS 能够轻松识别出哪些是 I/O 密集型进程，并给予它们更高的优先级，从而有效避免了饥饿现象。

2. 大脑损伤调度器 (BFS)

与 CFS 的复杂设计不同，BFS（Brain Fuck Scheduler）—— 这个名字虽然听起来有些粗俗，但实际上反映了对复杂度的反叛 —— 是一个由 Con Kolivas 开发的 O(n) 调度器。它主要面向桌面用户，设计理念是“简单即美”。

#### BFS 的核心设计：全局队列与链表

BFS 使用被视为队列的双向链表。

  • 时间复杂度：在上下文切换时选择新进程的最坏情况可能达到 O(n)，因为可能需要扫描整个链表。但是，进程的插入操作是 O(1)。
  • 全局运行队列：它使用一个全局运行队列，以便所有 CPU 都能访问它（通常配合自旋锁）。

在上下文切换期间，队列会被扫描，直到找到具有最高优先级（通常是动态优先级，基于虚拟截止时间或交互性评分）的最佳进程，然后执行该进程。

// 模拟 BFS 的双链表实现思路
// 注意：这是简化版，实际 BFS 还涉及查找 bitmap 来加速跳过空闲优先级
struct TaskNode {
    int pid;
    int priority; // 0-140, 数值越大优先级越高
    TaskNode* next;
    TaskNode* prev;
};

void bfs_schedule(TaskNode* head) {
    TaskNode* curr = head;
    TaskNode* best_task = nullptr;
    int max_prio = -1;

    // O(n) 扫描整个队列寻找最高优先级
    while (curr != nullptr) {
        if (curr->priority > max_prio) {
            max_prio = curr->priority;
            best_task = curr;
        }
        curr = curr->next;
    }

    if (best_task) {
        // 执行 best_task
        run_task(best_task);
    }
}

3. 2026年视角下的技术演进与 AI 时代的调度挑战

既然我们已经了解了这两种截然不同的调度器，让我们思考一下在 2026 年，随着 Agentic AI（自主 AI 代理）和 Vibe Coding（氛围编程）的兴起，这些技术如何影响我们的开发决策。

#### AI 原生应用对调度器的冲击

在当下的工作中，我们经常遇到这样的情况：一个基于 Rust 编写的 AI 推理服务，在处理高并发请求时，延迟偶尔会出现巨大的毛刺。你可能已经注意到了，传统的 CFS 倾向于“公平”地分配 CPU，但 AI 推理任务往往需要极高的吞吐量和连续的 L3 缓存命中率。

  • EEVDF 的引入：在 Linux 6.6+ 内核中，CFS 已经被 EEVDF（Earliest Eligible Virtual Deadline First）调度器所取代或增强。它不再是单纯比较 vruntime，而是引入了“虚拟截止时间”。这对于我们在构建 AI 原生应用 时至关重要，因为它能更好地处理突发性的高优先级任务，比如 Agentic AI 在执行规划步骤时的 CPU 抢占。

#### 调试与可观测性：AI 辅助工作流

过去，我们需要手动分析 /proc/sched_debug 的输出来诊断调度延迟。现在，利用 LLM 驱动的调试 工具（如集成了 AI 分析的 eBPF 透视工具），我们可以更快地定位问题。

# 一个简单的 BCC 工具脚本概念，用于测量运行队列延迟
# 我们现在可以让 AI 帮助我们编写和解释这种复杂的脚本
# sudo ./runqlat
# Tracing run queue latency... Hit Ctrl-C to end.

我们的经验是： 如果你使用 Cursor 或 Windsurf 等 AI IDE，你可以直接向 AI 提问：“分析这个火焰图，告诉我为什么我的 BFS 调度器在低负载下比 CFS 更快？”AI 会迅速通过比对上下文切换的开销（CFS 的树操作 vs BFS 的简单扫描）给出答案。这种 多模态开发 方式极大地降低了内核调优的门槛。

#### 云原生与 Serverless 的影响

在 Serverless 和 边缘计算 场景中，冷启动是最大的敌人。CFS 的公平性可能会导致刚刚启动的容器进程（冷启动）在 CPU 密集型宿主机上等待过长的时间。在这种场景下，我们可能会倾向于调优 sched_min_granularity_ns 或者在边缘节点上使用类 BFS 的简化调度策略，以保证首个请求的响应速度。

4. 决策经验与最佳实践

在什么时候选择哪种策略？或者更准确地说，在 2026 年，我们该如何配置 Linux 内核参数？

  • 高性能计算 (HPC) 与 后端服务：绝大多数情况下，保留默认的 CFS (EEVDF)。它的红黑树结构在大规模并行处理（N 很大）时表现稳健，且对 NUMA 架构支持更好。
    # 针对 CPU 密集型任务的 sysctl.conf 调优建议
    # 减少 vruntime 的倾斜，避免 I/O 任务过度饥饿
    vm.sched_min_granularity_ns = 10000000
    vm.sched_wakeup_granularity_ns = 15000000
  • 桌面交互与低延迟：BFS（及其后继者 MuQSS）虽然未能进入主线内核，但在某些对延迟极度敏感的嵌入式或老旧桌面发行版中仍有其地位。对于现代桌面，我们建议使用 CFS 并开启 CONFIG_SCHED_AUTOGROUP，这能提供类似 BFS 的交互体验，同时保持内核兼容性。
  • 实时系统：如果这就是你遇到的情况，无论 CFS 还是 BFS 都不是最佳选择。你应该使用 INLINECODE4d20cf5c 补丁集，配合 INLINECODE071c4d41 或 SCHED_RR 策略。

结语

从 2007 年 CFS 的诞生，到 BFS 的争议，再到今天 EEVDF 的普及，操作系统调度的核心始终没有变：在有限的资源下做最优的权衡。作为开发者，我们不应只满足于应用层的开发，深入理解这些底层机制，结合 AI 辅助的现代工具链，将帮助我们在面对极端性能需求时，做出更明智的技术选型。在未来的项目中，让我们更多地关注这些底层的“隐形推手”，利用可观测性工具，让我们的应用跑得更快、更稳。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/21472.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年