CPU核心的上下文切换

static void __sched __schedule(bool preempt) {
    struct task_struct *prev, *next;
    struct rq *rq;
    int cpu;

    cpu = smp_processor_id();
    rq = cpu_rq(cpu);
    prev = rq->curr;

    // 1. 选择下一个任务
    next = pick_next_task(rq, prev);

    // 2. 执行上下文切换
    if (likely(prev != next)) {
        rq->nr_switches++;
        rq->curr = next;
        ++*switch_count;

        // 调用架构相关的上下文切换函数
        context_switch(rq, prev, next);
    }
}

`context_switch()`函数

context_switch()是实际执行上下文切换的函数，定义在kernel/sched/core.c中。

static __always_inline struct rq *
context_switch(struct rq *rq, struct task_struct *prev,
               struct task_struct *next) {
    struct mm_struct *mm, *oldmm;

    // 1. 切换地址空间
    mm = next->mm;
    oldmm = prev->active_mm;
    if (unlikely(!mm)) {
        next->active_mm = oldmm;
        atomic_inc(&oldmm->mm_count);
        enter_lazy_tlb(oldmm, next);
    } else
        switch_mm(oldmm, mm, next);

    // 2. 切换寄存器状态
    switch_to(prev, next, prev);

    return rq;
}

`switch_to()`函数

switch_to()是架构相关的上下文切换函数，以x86架构为例，其实现位于arch/x86/include/asm/switch_to.h。

#define switch_to(prev, next, last) \
do { \
    /* 保存prev任务的上下文 */ \
    asm volatile("pushq %%rbp\n\t" \
                 "movq %%rsp,%0\n\t" /* 保存栈指针 */ \
                 "movq %2,%%rsp\n\t" /* 加载next任务的栈指针 */ \
                 "leaq 1f(%%rip),%%rax\n\t" \
                 "movq %%rax,%1\n\t" /* 保存返回地址 */ \
                 "pushq %3\n\t" \
                 "jmp __switch_to\n\t" /* 跳转到__switch_to函数 */ \
                 "1:\t" \
                 "popq %%rbp\n\t" \
                 : "=m" (prev->thread.sp), \
                   "=m" (prev->thread.ip) \
                 : "m" (next->thread.sp), \
                   "m" (next->thread.ip), \
                   "D" (prev), "S" (next) \
                 : "memory", "cc", "rax"); \
    last = prev; \
} while (0)

`__switch_to()`函数

__switch_to()是实际的上下文切换逻辑，定义在arch/x86/kernel/process_64.c中。

__visible __notrace_funcgraph struct task_struct *
__switch_to(struct task_struct *prev_p, struct task_struct *next_p) {
    // 保存prev任务的FPU状态
    if (prev_p->thread.fpu.has_fpu)
        fpu__save(&prev_p->thread.fpu);

    // 加载next任务的FPU状态
    if (next_p->thread.fpu.has_fpu)
        fpu__restore(&next_p->thread.fpu);

    // 切换调试寄存器
    loaddebug(&next_p->thread);

    // 返回next任务
    return prev_p;
}

4. 上下文切换的流程总结

选择下一个任务：调度器从就绪队列中选择优先级最高的任务。
切换地址空间：如果需要，切换虚拟地址空间（页表）。
切换寄存器状态：保存当前任务的寄存器状态，加载新任务的寄存器状态。
切换FPU和调试状态：保存和恢复浮点运算单元（FPU）和调试寄存器的状态。

5. 性能优化

上下文切换是开销较大的操作，Linux内核通过以下方式优化：

1. 惰性FPU切换（Lazy FPU Switching）

问题背景

浮点运算单元（FPU）状态（如x86架构中的XMM寄存器）的保存和恢复开销较大。如果在每次上下文切换时都保存和恢复FPU状态，会导致不必要的性能损失。

优化方式

Linux内核采用惰性FPU切换策略：

延迟保存：在上下文切换时，不立即保存FPU状态，而是标记当前任务的FPU状态为“脏”（Dirty）。
延迟恢复：当新任务首次使用FPU时，触发FPU状态恢复。
内核实现：
- 在__switch_to()函数中，FPU状态的保存和恢复被延迟。
- 当任务首次使用FPU时，内核会捕获FPU异常（如#NM异常），并在异常处理程序中恢复FPU状态。

代码示例

// arch/x86/kernel/fpu/core.c
void fpu__save(struct fpu *fpu) {
    if (fpu->has_fpu) {
        copy_fpregs_to_fpstate(fpu);
        fpu->has_fpu = 0;
    }
}

void fpu__restore(struct fpu *fpu) {
    if (!fpu->has_fpu) {
        copy_fpstate_to_fpregs(fpu);
        fpu->has_fpu = 1;
    }
}

性能收益

减少了不必要的FPU状态保存和恢复操作。
对于不频繁使用FPU的任务，显著降低了上下文切换的开销。

2. 快速路径优化（Fast Path Optimization）

问题背景

上下文切换的完整路径包括地址空间切换、寄存器状态保存和恢复等操作。如果两个任务共享相同的地址空间（如线程），则可以跳过地址空间切换。

优化方式

Linux内核通过快速路径优化减少不必要的操作：

共享地址空间：如果prev和next任务共享相同的地址空间（mm_struct），则跳过页表切换。
内核实现：
- 在context_switch()函数中，检查prev->mm和next->mm是否相同。
- 如果相同，则跳过switch_mm()调用。

代码示例

// kernel/sched/core.c
static __always_inline struct rq *
context_switch(struct rq *rq, struct task_struct *prev,
               struct task_struct *next) {
    struct mm_struct *mm, *oldmm;

    mm = next->mm;
    oldmm = prev->active_mm;
    if (unlikely(!mm)) {
        next->active_mm = oldmm;
        atomic_inc(&oldmm->mm_count);
        enter_lazy_tlb(oldmm, next);
    } else
        switch_mm(oldmm, mm, next); // 仅在地址空间不同时调用
}

性能收益

对于线程切换或共享地址空间的任务，减少了页表切换的开销。
提高了线程切换的效率。

3. CPU亲和性（CPU Affinity）

问题背景

频繁的跨核心迁移会导致缓存失效和TLB（Translation Lookaside Buffer，用于缓存虚拟地址到物理地址的映射）失效，增加上下文切换的开销。

优化方式

Linux内核支持将任务绑定到特定的CPU核心（CPU Affinity）：

绑定任务：通过sched_setaffinity()系统调用将任务绑定到特定的CPU核心。
减少迁移：绑定后，任务只能在指定的核心上运行，减少了跨核心迁移的开销。

代码示例

// kernel/sched/core.c
long sched_setaffinity(pid_t pid, const struct cpumask *in_mask) {
    // 设置任务的CPU亲和性
    set_cpus_allowed_ptr(p, new_mask);
}

性能收益

减少了缓存失效和TLB失效的开销。
提高了缓存命中率，尤其适用于缓存敏感型任务。

4. 调度域和负载均衡优化

问题背景

在多核系统中，负载均衡是调度器的核心任务之一。频繁的负载均衡可能导致不必要的上下文切换。

优化方式

Linux内核通过调度域（Scheduling Domains）和负载均衡优化减少不必要的上下文切换：

调度域：将CPU核心划分为多个调度域，每个域内的核心共享缓存或内存带宽。
负载均衡：仅在调度域内进行负载均衡，避免跨域迁移。

性能收益

减少了跨NUMA节点或跨插槽的迁移开销。
提高了缓存和内存访问的局部性。

CPU调度域：CPU调度域-CSDN博客

5. RCU（Read-Copy-Update）优化

问题背景

在上下文切换时，内核需要确保任务的数据结构（如task_struct）不会被其他核心访问。

优化方式

Linux内核使用RCU机制来减少锁竞争：

RCU保护：在上下文切换时，使用RCU机制保护任务数据结构。
延迟释放：任务的资源释放被延迟到所有核心不再引用该任务时。

代码示例

// kernel/sched/core.c
void put_task_struct(struct task_struct *t) {
    if (atomic_dec_and_test(&t->usage))
        __put_task_struct(t); // 延迟释放
}

性能收益

减少了锁竞争和上下文切换的开销。
提高了多核系统的可扩展性。

6. 内核抢占优化

问题背景

内核抢占（Kernel Preemption）允许高优先级任务抢占正在内核态运行的低优先级任务，但频繁的内核抢占会增加上下文切换的开销。

优化方式

Linux内核通过以下方式优化内核抢占：

可抢占区域：在内核代码中标记不可抢占的区域（如自旋锁保护的临界区）。
抢占延迟：在高负载场景下，适当延迟抢占以减少上下文切换频率。

性能收益

减少了不必要的内核抢占和上下文切换。
提高了内核代码的执行效率。

7. 任务唤醒优化

问题背景

任务唤醒（如I/O完成或信号到达）可能导致上下文切换，但并非所有唤醒都需要立即切换。

优化方式

Linux内核通过以下方式优化任务唤醒：

延迟唤醒：将任务唤醒延迟到调度器运行时。
批量唤醒：将多个任务唤醒合并为一次上下文切换。

代码示例

// kernel/sched/core.c
void try_to_wake_up(struct task_struct *p, int wake_flags) {
    // 延迟唤醒或批量唤醒
    ttwu_queue(p, cpu, wake_flags);
}

性能收益

减少了不必要的上下文切换。
提高了任务唤醒的效率。

6. 总结

上下文内容：包括通用寄存器、程序计数器、栈指针、标志寄存器、浮点寄存器、控制寄存器和MMU上下文等。
上下文切换实现：Linux内核通过__schedule()、context_switch()和switch_to()等函数实现上下文切换。
性能影响：上下文切换是开销较大的操作，通过惰性FPU切换、快速路径优化、CPU亲和性、调度域优化、RCU机制、内核抢占优化和任务唤醒优化等多种方式，显著减少了上下文切换的开销。这些优化手段在高并发和高负载场景下尤为重要，能够有效提高系统的整体性能和可扩展性。