for_each_task(p) {
    if (p->counter > max_counter)
        next = p;
}

struct prio_array {
    unsigned int nr_active;            // 活跃任务总数
    unsigned long bitmap[BITMAP_SIZE]; // 优先级位图
    struct list_head queue[MAX_PRIO];  // 140 个优先级链表
};

vruntime_delta = delta_exec * (NICE_0_LOAD / weight)

// kernel/sched/sched.h:2500
struct sched_class {
    void (*enqueue_task)(struct rq *rq, struct task_struct *p, int flags);
    bool (*dequeue_task)(struct rq *rq, struct task_struct *p, int flags);
    void (*yield_task)(struct rq *rq);
    bool (*yield_to_task)(struct rq *rq, struct task_struct *p);
    void (*wakeup_preempt)(struct rq *rq, struct task_struct *p, int flags);
    int  (*balance)(struct rq *rq, struct task_struct *prev, struct rq_flags *rf);
    struct task_struct *(*pick_task)(struct rq *rq, struct rq_flags *rf);
    struct task_struct *(*pick_next_task)(struct rq *rq, struct task_struct *prev,
                                          struct rq_flags *rf);
    void (*put_prev_task)(struct rq *rq, struct task_struct *p, struct task_struct *next);
    void (*set_next_task)(struct rq *rq, struct task_struct *p, bool first);
    int  (*select_task_rq)(struct task_struct *p, int task_cpu, int flags);
    void (*migrate_task_rq)(struct task_struct *p, int new_cpu);
    void (*task_woken)(struct rq *this_rq, struct task_struct *task);
    void (*set_cpus_allowed)(struct task_struct *p, struct affinity_context *ctx);
    void (*rq_online)(struct rq *rq);
    void (*rq_offline)(struct rq *rq);
    struct rq *(*find_lock_rq)(struct task_struct *p, struct rq *rq);
    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);
    void (*switching_from)(struct rq *this_rq, struct task_struct *task);
    void (*switched_from)(struct rq *this_rq, struct task_struct *task);
    void (*switching_to)(struct rq *this_rq, struct task_struct *task);
    void (*switched_to)(struct rq *this_rq, struct task_struct *task);
    u64  (*get_prio)(struct rq *this_rq, struct task_struct *task);
    void (*prio_changed)(struct rq *this_rq, struct task_struct *task, u64 oldprio);
    void (*reweight_task)(struct rq *this_rq, struct task_struct *task,
                          const struct load_weight *lw);
    unsigned int (*get_rr_interval)(struct rq *rq, struct task_struct *task);
    void (*update_curr)(struct rq *rq);
    // ...
};

// kernel/sched/sched.h:2718-2722
extern const struct sched_class stop_sched_class;
extern const struct sched_class dl_sched_class;
extern const struct sched_class rt_sched_class;
extern const struct sched_class fair_sched_class;
extern const struct sched_class idle_sched_class;

// kernel/sched/core.c:5943-5962
restart:
    prev_balance(rq, prev, rf);

    for_each_active_class(class) {
        if (class->pick_next_task) {
            p = class->pick_next_task(rq, prev, rf);
            if (unlikely(p == RETRY_TASK))
                goto restart;
            if (p)
                return p;
        } else {
            p = class->pick_task(rq, rf);
            if (unlikely(p == RETRY_TASK))
                goto restart;
            if (p) {
                put_prev_set_next_task(rq, prev, p);
                return p;
            }
        }
    }

// kernel/sched/core.c:5927-5941
if (likely(!sched_class_above(prev->sched_class, &fair_sched_class) &&
           rq->nr_running == rq->cfs.h_nr_queued)) {

    p = pick_next_task_fair(rq, prev, rf);
    if (unlikely(p == RETRY_TASK))
        goto restart;

    /* Assume the next prioritized class is idle_sched_class */
    if (!p) {
        p = pick_task_idle(rq, rf);
        put_prev_set_next_task(rq, prev, p);
    }

    return p;
}

// kernel/sched/core.c:6975-6988
asmlinkage __visible void __sched schedule(void)
{
    struct task_struct *tsk = current;

    if (!task_is_running(tsk))
        sched_submit_work(tsk);
    __schedule_loop(SM_NONE);
    sched_update_worker(tsk);
}

// kernel/sched/core.c:6835-6836
pick_again:
    next = pick_next_task(rq, rq->donor, &rf);
    rq_set_donor(rq, next);

schedule() → __schedule() → pick_next_task() → pick_next_task_fair()
  → pick_task_fair() → pick_next_entity() → pick_eevdf()

// kernel/sched/sched.h:1124
struct rq {
    /* ... */
};

// kernel/sched/sched.h:1133-1150
unsigned int        nr_running;           // 运行队列上的任务总数
unsigned int        ttwu_pending;         // 待处理的唤醒操作数
unsigned long       cpu_capacity;         // CPU 算力（用于负载均衡）

struct task_struct __rcu *donor;          // 调度上下文（被选中的任务）
struct task_struct __rcu *curr;           // 执行上下文（实际运行的任务）
struct task_struct  *idle;                // 该 CPU 的 idle 任务

// kernel/sched/sched.h:1158
raw_spinlock_t      __lock;               // 运行队列自旋锁

// kernel/sched/sched.h:1176-1184
struct cfs_rq        cfs;                 // CFS/EEVDF 子队列
struct rt_rq         rt;                  // 实时调度子队列
struct dl_rq         dl;                  // 截止期调度子队列
struct scx_rq        scx;                 // sched_ext 子队列（可选）
struct sched_dl_entity fair_server;       // 公平调度的 DL server

// kernel/sched/sched.h:1213-1219
u64      clock_task ____cacheline_aligned; // 任务时钟（不含 IRQ 时间）
u64      clock_pelt;                       // PELT 时钟（不含 idle 时间）
u64      clock;                            // 运行队列主时钟
unsigned long lost_idle_time;              // 累计丢失的 idle 时间
u64      clock_pelt_idle;                  // PELT idle 累计
u64      clock_idle;                       // idle 状态的时间戳

// kernel/sched/sched.h:678
struct cfs_rq {
    struct load_weight  load;              // 总负载权重
    unsigned int        nr_queued;         // 队列中的任务数
    unsigned int        h_nr_queued;       // 层级队列数（含子组）
    unsigned int        h_nr_runnable;     // 层级可运行数
    unsigned int        h_nr_idle;         // 层级 idle 数

    s64                 sum_w_vruntime;    // 加权 vruntime 总和
    u64                 sum_weight;        // 权重总和

    u64                 zero_vruntime;     // vruntime 基准点

    struct rb_root_cached tasks_timeline;  // 增强红黑树

    struct sched_entity *curr;             // 当前运行的调度实体
    struct sched_entity *next;             // 下一个 buddy（延迟优化）

    struct sched_avg    avg;               // PELT 负载追踪
    // ...
};

// kernel/sched/sched.h:685-686
s64      sum_w_vruntime;     // Σ(key_i * weight_i)
u64      sum_weight;          // Σ weight_i

// kernel/sched/fair.c:715-749
u64 avg_vruntime(struct cfs_rq *cfs_rq)
{
    struct sched_entity *curr = cfs_rq->curr;
    long weight = cfs_rq->sum_weight;
    s64 delta = 0;

    if (curr && !curr->on_rq)
        curr = NULL;

    if (weight) {
        s64 runtime = cfs_rq->sum_w_vruntime;

        if (curr) {
            unsigned long w = scale_load_down(curr->load.weight);
            runtime += entity_key(cfs_rq, curr) * w;
            weight += w;
        }

        /* sign flips effective floor / ceiling */
        if (runtime < 0)
            runtime -= (weight - 1);

        delta = div_s64(runtime, weight);
    } else if (curr) {
        delta = curr->vruntime - cfs_rq->zero_vruntime;
    }

    update_zero_vruntime(cfs_rq, delta);

    return cfs_rq->zero_vruntime;
}

// kernel/sched/sched.h:694
struct rb_root_cached  tasks_timeline;     // 增强红黑树

// kernel/sched/fair.c:884-909
static inline bool min_vruntime_update(struct sched_entity *se, bool exit)
{
    u64 old_min_vruntime = se->min_vruntime;
    u64 old_min_slice = se->min_slice;
    u64 old_max_slice = se->max_slice;
    struct rb_node *node = &se->run_node;

    se->min_vruntime = se->vruntime;
    __min_vruntime_update(se, node->rb_right);
    __min_vruntime_update(se, node->rb_left);

    se->min_slice = se->slice;
    __min_slice_update(se, node->rb_right);
    __min_slice_update(se, node->rb_left);

    se->max_slice = se->slice;
    __max_slice_update(se, node->rb_right);
    __max_slice_update(se, node->rb_left);

    return se->min_vruntime == old_min_vruntime &&
           se->min_slice == old_min_slice &&
           se->max_slice == old_max_slice;
}

RB_DECLARE_CALLBACKS(static, min_vruntime_cb, struct sched_entity,
                     run_node, min_vruntime, min_vruntime_update);

// include/linux/sched.h:575
struct sched_entity {
    /* For load-balancing: */
    struct load_weight      load;          // 任务权重
    struct rb_node          run_node;      // 红黑树节点
    u64                     deadline;      // EEVDF 虚拟截止期
    u64                     min_vruntime;  // 子树最小 vruntime（增强信息）
    u64                     min_slice;     // 子树最小 slice（增强信息）
    u64                     max_slice;     // 子树最大 slice（增强信息）

    struct list_head        group_node;    // 任务组链表节点
    unsigned char           on_rq;         // 是否在运行队列上
    unsigned char           sched_delayed; // 是否被延迟出队
    unsigned char           rel_deadline;  // deadline 是否为相对值
    unsigned char           custom_slice;  // 是否使用自定义 slice

    u64                     exec_start;    // 本次运行开始时间
    u64                     sum_exec_runtime;       // 累计执行时间
    u64                     prev_sum_exec_runtime;  // 上次统计时的累计执行时间
    u64                     vruntime;      // 虚拟运行时间

    s64                     vlag;          // 虚拟滞后量（EEVDF）
    u64                     vprot;         // 保护的截止期（slice 保护）
    u64                     slice;         // 时间配额（时间片）

    u64                     nr_migrations; // 迁移次数

#ifdef CONFIG_FAIR_GROUP_SCHED
    int                     depth;         // 在 cgroup 层级中的深度
    struct sched_entity     *parent;       // 父调度实体
    struct cfs_rq           *cfs_rq;       // 所属的 cfs_rq
    struct cfs_rq           *my_q;         // 拥有的子 cfs_rq（任务组）
    unsigned long           runnable_weight; // 可运行权重缓存
#endif

    struct sched_avg        avg;           // PELT 负载追踪数据
};

struct load_weight  load;    // 包含 .weight 和 .inv_weight

// kernel/sched/core.c:10271-10280
const int sched_prio_to_weight[40] = {
 /* -20 */     88761,     71755,     56483,     46273,     36291,
 /* -15 */     29154,     23254,     18705,     14949,     11916,
 /* -10 */      9548,      7620,      6100,      4904,      3906,
 /*  -5 */      3121,      2501,      1991,      1586,      1277,
 /*   0 */      1024,       820,       655,       526,       423,
 /*   5 */       335,       272,       215,       172,       137,
 /*  10 */       110,        87,        70,        56,        45,
 /*  15 */        36,        29,        23,        18,        15,
};

u64  vruntime;    // 虚拟运行时间

// kernel/sched/fair.c:1301
curr->vruntime += calc_delta_fair(delta_exec, curr);

// kernel/sched/fair.c:290-296
static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se)
{
    if (unlikely(se->load.weight != NICE_0_LOAD))
        delta = __calc_delta(delta, NICE_0_LOAD, &se->load);

    return delta;
}

u64  deadline;    // EEVDF 虚拟截止期
u64  slice;       // 时间配额

deadline = vruntime + calc_delta_fair(slice, se)

s64  vlag;    // 虚拟滞后量

vlag = avg_vruntime(cfs_rq) - se->vruntime

// kernel/sched/fair.c:767-778
static void update_entity_lag(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
    u64 max_slice = cfs_rq_max_slice(cfs_rq) + TICK_NSEC;
    s64 vlag, limit;

    WARN_ON_ONCE(!se->on_rq);

    vlag = avg_vruntime(cfs_rq) - se->vruntime;
    limit = calc_delta_fair(max_slice, se);

    se->vlag = clamp(vlag, -limit, limit);
}

struct rb_node  run_node;         // 红黑树节点

// kernel/sched/fair.c:914-921
static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
    sum_w_vruntime_add(cfs_rq, se);
    se->min_vruntime = se->vruntime;
    se->min_slice = se->slice;
    rb_add_augmented_cached(&se->run_node, &cfs_rq->tasks_timeline,
                            __entity_less, &min_vruntime_cb);
}

// kernel/sched/fair.c:848-851
static inline bool __entity_less(struct rb_node *a, const struct rb_node *b)
{
    return entity_before(__node_2_se(a), __node_2_se(b));
}

// kernel/sched/fair.c:582-590
static inline bool entity_before(const struct sched_entity *a,
                                 const struct sched_entity *b)
{
    return vruntime_cmp(a->deadline, "<", b->deadline);
}

// kernel/sched/fair.c:1281-1327
static void update_curr(struct cfs_rq *cfs_rq)
{
    struct sched_entity *curr = cfs_rq->curr;
    struct rq *rq = rq_of(cfs_rq);
    s64 delta_exec;
    bool resched;

    if (unlikely(!curr))
        return;

    delta_exec = update_se(rq, curr);
    if (unlikely(delta_exec <= 0))
        return;

    curr->vruntime += calc_delta_fair(delta_exec, curr);
    resched = update_deadline(cfs_rq, curr);

    if (entity_is_task(curr)) {
        dl_server_update(&rq->fair_server, delta_exec);
    }

    account_cfs_rq_runtime(cfs_rq, delta_exec);

    if (cfs_rq->nr_queued == 1)
        return;

    if (resched || !protect_slice(curr)) {
        resched_curr_lazy(rq);
        clear_buddies(cfs_rq, curr);
    }
}

// kernel/sched/fair.c:79-80
unsigned int sysctl_sched_base_slice           = 700000ULL;  // 0.7ms
static unsigned int normalized_sysctl_sched_base_slice = 700000ULL;

// kernel/sched/fair.c:1112-1135
static bool update_deadline(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
    if (vruntime_cmp(se->vruntime, "<", se->deadline))
        return false;

    if (!se->custom_slice)
        se->slice = sysctl_sched_base_slice;

    /*
     * EEVDF: vd_i = ve_i + r_i / w_i
     */
    se->deadline = se->vruntime + calc_delta_fair(se->slice, se);
    avg_vruntime(cfs_rq);

    return true;
}

// kernel/sched/fair.c:5274-5337
enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
    bool curr = cfs_rq->curr == se;

    if (curr)
        place_entity(cfs_rq, se, flags);

    update_curr(cfs_rq);

    update_load_avg(cfs_rq, se, UPDATE_TG | DO_ATTACH);
    se_update_runnable(se);
    update_cfs_group(se);

    if (!curr)
        place_entity(cfs_rq, se, flags);

    account_entity_enqueue(cfs_rq, se);

    if (flags & ENQUEUE_MIGRATED)
        se->exec_start = 0;

    check_schedstat_required();
    update_stats_enqueue_fair(cfs_rq, se, flags);
    if (!curr)
        __enqueue_entity(cfs_rq, se);
    se->on_rq = 1;

    if (cfs_rq->nr_queued == 1) {
        check_enqueue_throttle(cfs_rq);
        list_add_leaf_cfs_rq(cfs_rq);
    }
}

// kernel/sched/fair.c:5160-5265
place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
    u64 vslice, vruntime = avg_vruntime(cfs_rq);
    s64 lag = 0;

    if (!se->custom_slice)
        se->slice = sysctl_sched_base_slice;
    vslice = calc_delta_fair(se->slice, se);

    if (sched_feat(PLACE_LAG) && cfs_rq->nr_queued && se->vlag) {
        // ... lag 保存与补偿逻辑（详见下节）...
        lag = se->vlag;
        load = cfs_rq->sum_weight;
        if (curr && curr->on_rq)
            load += scale_load_down(curr->load.weight);

        lag *= load + scale_load_down(se->load.weight);
        if (WARN_ON_ONCE(!load))
            load = 1;
        lag = div_s64(lag, load);
    }

    se->vruntime = vruntime - lag;

    // ...

    se->deadline = se->vruntime + vslice;
}

// kernel/sched/fair.c:1027-1032 (pick_eevdf 中)
if (sched_feat(PICK_BUDDY) &&
    cfs_rq->next && entity_eligible(cfs_rq, cfs_rq->next)) {
    WARN_ON_ONCE(cfs_rq->next->sched_delayed);
    return cfs_rq->next;
}

         Σ (v_i × w_i)
V(t) = ────────────────
            Σ w_i

lag_i = w_i × (V(t) - v_i)

vd_i = v_i + r_i / w_i

L_max ≈ Σ(r_j / w_j) × w_i / W

// kernel/sched/fair.c:797-811
static int vruntime_eligible(struct cfs_rq *cfs_rq, u64 vruntime)
{
    struct sched_entity *curr = cfs_rq->curr;
    s64 avg = cfs_rq->sum_w_vruntime;
    long load = cfs_rq->sum_weight;

    if (curr && curr->on_rq) {
        unsigned long weight = scale_load_down(curr->load.weight);

        avg += entity_key(cfs_rq, curr) * weight;
        load += weight;
    }

    return avg >= vruntime_op(vruntime, "-", cfs_rq->zero_vruntime) * load;
}

lag_i = S - s_i = w_i × (V - v_i)

         Σ (v_j - zero) × w_j
V = ───────────────────────── + zero
            Σ w_j

Σ (v_j - zero) × w_j >= (v_i - zero) × Σ w_j

// kernel/sched/fair.c:813-816
int entity_eligible(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
    return vruntime_eligible(cfs_rq, se->vruntime);
}

// kernel/sched/fair.c:1010-1079
static struct sched_entity *pick_eevdf(struct cfs_rq *cfs_rq, bool protect)
{
    struct rb_node *node = cfs_rq->tasks_timeline.rb_root.rb_node;
    struct sched_entity *se = __pick_first_entity(cfs_rq);
    struct sched_entity *curr = cfs_rq->curr;
    struct sched_entity *best = NULL;

    // kernel/sched/fair.c:1021-1022
    if (cfs_rq->nr_queued == 1)
        return curr && curr->on_rq ? curr : se;

    // kernel/sched/fair.c:1027-1032
    if (sched_feat(PICK_BUDDY) &&
        cfs_rq->next && entity_eligible(cfs_rq, cfs_rq->next)) {
        WARN_ON_ONCE(cfs_rq->next->sched_delayed);
        return cfs_rq->next;
    }

    // kernel/sched/fair.c:1034-1038
    if (curr && (!curr->on_rq || !entity_eligible(cfs_rq, curr)))
        curr = NULL;

    if (curr && protect && protect_slice(curr))
        return curr;

// kernel/sched/fair.c:980-983
static inline bool protect_slice(struct sched_entity *se)
{
    return vruntime_cmp(se->vruntime, "<", se->vprot);
}

// kernel/sched/fair.c:958-971
static inline void set_protect_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
    u64 slice = normalized_sysctl_sched_base_slice;
    u64 vprot = se->deadline;

    if (sched_feat(RUN_TO_PARITY))
        slice = cfs_rq_min_slice(cfs_rq);

    slice = min(slice, se->slice);
    if (slice != se->slice)
        vprot = min_vruntime(vprot, se->vruntime + calc_delta_fair(slice, se));

    se->vprot = vprot;
}

    // kernel/sched/fair.c:1040-1044
    /* Pick the leftmost entity if it's eligible */
    if (se && entity_eligible(cfs_rq, se)) {
        best = se;
        goto found;
    }

    // kernel/sched/fair.c:1046-1073
    /* Heap search for the EEVD entity */
    while (node) {
        struct rb_node *left = node->rb_left;

        /*
         * Eligible entities in left subtree are always better
         * choices, since they have earlier deadlines.
         */
        if (left && vruntime_eligible(cfs_rq,
                    __node_2_se(left)->min_vruntime)) {
            node = left;
            continue;
        }

        se = __node_2_se(node);

        /*
         * The left subtree either is empty or has no eligible
         * entity, so check the current node since it is the one
         * with earliest deadline that might be eligible.
         */
        if (entity_eligible(cfs_rq, se)) {
            best = se;
            break;
        }

        node = node->rb_right;
    }

    // kernel/sched/fair.c:1074-1078
found:
    if (!best || (curr && entity_before(curr, best)))
        best = curr;

    return best;

// kernel/sched/fair.c:1112-1135
static bool update_deadline(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
    if (vruntime_cmp(se->vruntime, "<", se->deadline))
        return false;

    /*
     * For EEVDF the virtual time slope is determined by w_i (iow.
     * nice) while the request time r_i is determined by
     * sysctl_sched_base_slice.
     */
    if (!se->custom_slice)
        se->slice = sysctl_sched_base_slice;

    /*
     * EEVDF: vd_i = ve_i + r_i / w_i
     */
    se->deadline = se->vruntime + calc_delta_fair(se->slice, se);
    avg_vruntime(cfs_rq);

    /*
     * The task has consumed its request, reschedule.
     */
    return true;
}

vd_new = vruntime_current + slice / weight

// kernel/sched/fair.c:767-778
static void update_entity_lag(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
    u64 max_slice = cfs_rq_max_slice(cfs_rq) + TICK_NSEC;
    s64 vlag, limit;

    WARN_ON_ONCE(!se->on_rq);

    vlag = avg_vruntime(cfs_rq) - se->vruntime;
    limit = calc_delta_fair(max_slice, se);

    se->vlag = clamp(vlag, -limit, limit);
}

vlag = V(t) - v_i

se->vlag = clamp(vlag, -limit, limit);

// kernel/sched/fair.c:5160-5265
place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
    u64 vslice, vruntime = avg_vruntime(cfs_rq);
    s64 lag = 0;

    if (!se->custom_slice)
        se->slice = sysctl_sched_base_slice;
    vslice = calc_delta_fair(se->slice, se);

    if (sched_feat(PLACE_LAG) && cfs_rq->nr_queued && se->vlag) {
        struct sched_entity *curr = cfs_rq->curr;
        unsigned long load;

        lag = se->vlag;

        load = cfs_rq->sum_weight;
        if (curr && curr->on_rq)
            load += scale_load_down(curr->load.weight);

        lag *= load + scale_load_down(se->load.weight);
        if (WARN_ON_ONCE(!load))
            load = 1;
        lag = div_s64(lag, load);
    }

    se->vruntime = vruntime - lag;

    if (se->rel_deadline) {
        se->deadline += se->vruntime;
        se->rel_deadline = 0;
        return;
    }

    if (sched_feat(PLACE_DEADLINE_INITIAL) && (flags & ENQUEUE_INITIAL))
        vslice /= 2;

    se->deadline = se->vruntime + vslice;
}

lag_adjusted = vlag × (W + w_i) / W

加入前：V = Σ(w_j × v_j) / W

加入后：V' = (Σ(w_j × v_j) + w_i × v_i) / (W + w_i)
          = (W × V + w_i × (V - vlag_i)) / (W + w_i)
          = V - w_i × vlag_i / (W + w_i)

有效 vlag：vlag'_i = V' - v_i
                = V - w_i × vlag_i / (W + w_i) - (V - vlag_i)
                = vlag_i - w_i × vlag_i / (W + w_i)
                = vlag_i × W / (W + w_i)

要使 vlag'_i = 目标值 vlag_target：
vlag_i = vlag_target × (W + w_i) / W

se->vruntime = vruntime - lag;    // vruntime = V - lag_adjusted

se->deadline = se->vruntime + vslice;

if (sched_feat(PLACE_DEADLINE_INITIAL) && (flags & ENQUEUE_INITIAL))
    vslice /= 2;

// kernel/sched/fair.c:5538-5551
pick_next_entity(struct rq *rq, struct cfs_rq *cfs_rq, bool protect)
{
    struct sched_entity *se;

    se = pick_eevdf(cfs_rq, protect);
    if (se->sched_delayed) {
        dequeue_entities(rq, se, DEQUEUE_SLEEP | DEQUEUE_DELAYED);
        return NULL;
    }
    return se;
}

// kernel/sched/fair.c:8803
static void wakeup_preempt_fair(struct rq *rq, struct task_struct *p, int wake_flags)
{
    // ...
    update_curr(cfs_rq);

    if (sched_feat(PREEMPT_SHORT) && (pse->slice < se->slice)) {
        preempt_action = PREEMPT_WAKEUP_SHORT;
        goto pick;
    }
    // ...
}

# 查看所有特性状态
cat /sys/kernel/debug/sched/features

# 关闭 RUN_TO_PARITY（可能导致更多抢占）
echo NO_RUN_TO_PARITY > /sys/kernel/debug/sched/features

# 重新开启
echo RUN_TO_PARITY > /sys/kernel/debug/sched/features

SCHED_DEADLINE > SCHED_FIFO / SCHED_RR > SCHED_NORMAL / SCHED_FAIR > SCHED_IDLE

// kernel/sched/sched.h, line 831
struct rt_rq {
    struct rt_prio_array  active;          // 优先级位数组 + 链表
    unsigned int          rt_nr_running;   // 队列中实时任务数
    unsigned int          rr_nr_running;   // SCHED_RR 任务数
    struct {
        int  curr;   // 当前最高优先级
        int  next;   // 次高优先级
    } highest_prio;
    bool                  overloaded;      // 是否过载（多个 RT 任务）
    struct plist_head     pushable_tasks;  // 可推送任务列表（用于负载均衡）
    int                   rt_queued;       // 队列是否有内容
    // ... 组调度相关字段省略
};

// kernel/sched/rt.c, line 70
struct rt_prio_array *array;
int i;

array = &rt_rq->active;
for (i = 0; i < MAX_RT_PRIO; i++) {
    INIT_LIST_HEAD(array->queue + i);
    __clear_bit(i, array->bitmap);
}
/* delimiter for bitsearch: */
__set_bit(MAX_RT_PRIO, array->bitmap);

// include/linux/sched.h, line 623
struct sched_rt_entity {
    struct list_head    run_list;       // 同优先级链表中的节点
    unsigned long       timeout;        // 看门狗超时计数
    unsigned long       watchdog_stamp; // 看门狗时间戳
    unsigned int        time_slice;     // 剩余时间片（SCHED_RR 使用）
    unsigned short      on_rq;          // 是否在运行队列上
    unsigned short      on_list;        // 是否在链表上
    struct sched_rt_entity  *back;      // 链表反向指针
    // ... 组调度相关字段省略
};

// kernel/sched/rt.c, line 1689
static struct task_struct *_pick_next_task_rt(struct rq *rq)
{
    struct sched_rt_entity *rt_se;
    struct rt_rq *rt_rq = &rq->rt;

    do {
        rt_se = pick_next_rt_entity(rt_rq);
        if (unlikely(!rt_se))
            return NULL;
        rt_rq = group_rt_rq(rt_se);
    } while (rt_rq);

    return rt_task_of(rt_se);
}

// kernel/sched/rt.c, line 1673
struct rt_prio_array *array = &rt_rq->active;
struct sched_rt_entity *next = NULL;
struct list_head *queue;
int idx;

idx = sched_find_first_bit(array->bitmap);  // O(1) 找最高优先级
BUG_ON(idx >= MAX_RT_PRIO);

queue = array->queue + idx;
next = list_entry(queue->next, struct sched_rt_entity, run_list);
return next;

// kernel/sched/rt.c, line 10
int sched_rr_timeslice = RR_TIMESLICE;

// kernel/sched/rt.c, line 27
static int sysctl_sched_rr_timeslice = (MSEC_PER_SEC * RR_TIMESLICE) / HZ;

// kernel/sched/rt.c, line 2529
static void task_tick_rt(struct rq *rq, struct task_struct *p, int queued)
{
    struct sched_rt_entity *rt_se = &p->rt;

    update_curr_rt(rq);
    update_rt_rq_load_avg(rq_clock_pelt(rq), rq, 1);
    watchdog(rq, p);

    /* RR tasks need a special form of time-slice management.
     * FIFO tasks have no timeslices. */
    if (p->policy != SCHED_RR)
        return;

    if (--p->rt.time_slice)
        return;

    p->rt.time_slice = sched_rr_timeslice;  // 重新填充时间片

    /* 如果同优先级还有其他任务，重新排队到尾部 */
    if (rt_se->run_list.prev != rt_se->run_list.next) {
        requeue_task_rt(rq, p, 0);  // 0 = 放到尾部
        resched_curr(rq);           // 请求重新调度
        return;
    }
}

// include/linux/sched.h, line 869
unsigned int  rt_priority;

prio = MAX_RT_PRIO - 1 - rt_priority

// kernel/sched/rt.c, line 1431
enqueue_task_rt(struct rq *rq, struct task_struct *p, int flags)
{
    struct sched_rt_entity *rt_se = &p->rt;

    if (flags & ENQUEUE_WAKEUP)
        rt_se->timeout = 0;

    check_schedstat_required();
    update_stats_wait_start_rt(rt_rq_of_se(rt_se), rt_se);

    enqueue_rt_entity(rt_se, flags);

    if (task_is_blocked(p))
        return;

    if (!task_current(rq, p) && p->nr_cpus_allowed > 1)
        enqueue_pushable_task(rq, p);  // 多 CPU 可迁移任务加入推送列表
}

// kernel/sched/rt.c, line 18
int sysctl_sched_rt_period = 1000000;    // 周期：1,000,000 微秒 = 1 秒

// kernel/sched/rt.c, line 24
int sysctl_sched_rt_runtime = 950000;    // RT 可用时间：950,000 微秒 = 0.95 秒

// kernel/sched/rt.c, line 863
static int sched_rt_runtime_exceeded(struct rt_rq *rt_rq)
{
    u64 runtime = sched_rt_runtime(rt_rq);

    if (rt_rq->rt_throttled)
        return rt_rq_throttled(rt_rq);

    if (runtime >= sched_rt_period(rt_rq))
        return 0;    // runtime >= period，不节流

    balance_runtime(rt_rq);
    runtime = sched_rt_runtime(rt_rq);
    if (runtime == RUNTIME_INF)
        return 0;    // 无限制模式

    if (rt_rq->rt_time > runtime) {
        struct rt_bandwidth *rt_b = sched_rt_bandwidth(rt_rq);
        if (likely(rt_b->rt_runtime)) {
            rt_rq->rt_throttled = 1;
            printk_deferred_once("sched: RT throttling activated\n");
        }
        // ...
    }
    return 0;
}

// kernel/sched/rt.c, line 974
static void update_curr_rt(struct rq *rq)
{
    struct task_struct *donor = rq->donor;
    s64 delta_exec;

    if (donor->sched_class != &rt_sched_class)
        return;

    delta_exec = update_curr_common(rq);
    if (unlikely(delta_exec <= 0))
        return;

    // 累积 rt_time 并检查是否超限
    for_each_sched_rt_entity(rt_se) {
        struct rt_rq *rt_rq = rt_rq_of_se(rt_se);
        // ... 累积 rt_rq->rt_time
        exceeded = sched_rt_runtime_exceeded(rt_rq);
        if (exceeded)
            resched_curr(rq);  // 触发重新调度
    }
}

// kernel/sched/rt.c, line 344
static inline void rt_set_overload(struct rq *rq)
{
    if (!rq->online)
        return;
    cpumask_set_cpu(rq->cpu, rq->rd->rto_mask);
    // 设置内存屏障确保 mask 先于 count 可见
    smp_wmb();
    atomic_inc(&rq->rd->rto_count);
}

// kernel/sched/rt.c, line 2066
static void push_rt_tasks(struct rq *rq)
{
    /* push_rt_task will return true if it moved an RT */
    while (push_rt_task(rq, false))
        ;
}

// kernel/sched/rt.c, line 1948
static int push_rt_task(struct rq *rq, bool pull)
{
    struct task_struct *next_task;
    struct rq *lowest_rq;
    int ret = 0;

    if (!rq->rt.overloaded)
        return 0;

    next_task = pick_next_pushable_task(rq);
    if (!next_task)
        return 0;

retry:
    /* 如果推送任务的优先级比当前运行任务还高，直接重调度当前 */
    if (unlikely(next_task->prio < rq->donor->prio)) {
        resched_curr(rq);
        return 0;
    }
    // ... 寻找最低优先级 rq 并迁移
}

// kernel/sched/rt.c, line 2249
static void pull_rt_task(struct rq *this_rq)
{
    int this_cpu = this_rq->cpu, cpu;
    bool resched = false;
    struct task_struct *p, *push_task;
    struct rq *src_rq;
    int rt_overload_count = rt_overloaded(this_rq);

    if (likely(!rt_overload_count))
        return;  // 没有过载 CPU，无需拉取

    smp_rmb();  // 匹配 rt_set_overload 中的屏障

    /* 如果只有自己过载，也不需要拉取 */
    if (rt_overload_count == 1 &&
        cpumask_test_cpu(this_rq->cpu, this_rq->rd->rto_mask))
        return;

    for_each_cpu(cpu, this_rq->rd->rto_mask) {
        if (this_cpu == cpu)
            continue;
        src_rq = cpu_rq(cpu);
        /* 跳过优先级不高于本 CPU 的源 */
        if (src_rq->rt.highest_prio.next >=
            this_rq->rt.highest_prio.curr)
            continue;
        // ... 从 src_rq 拉取任务
    }
}

// kernel/sched/rt.c, line 1594
static int balance_rt(struct rq *rq, struct task_struct *p, struct rq_flags *rf)
{
    if (!on_rt_rq(&p->rt) && need_pull_rt_task(rq, p)) {
        rq_unpin_lock(rq, rf);
        pull_rt_task(rq);
        rq_repin_lock(rq, rf);
    }
    return sched_stop_runnable(rq) || sched_dl_runnable(rq) || sched_rt_runnable(rq);
}

// kernel/sched/rt.c, line 1499
select_task_rq_rt(struct task_struct *p, int cpu, int flags)
{
    struct task_struct *curr, *donor;
    struct rq *rq;
    bool test;

    /* For anything but wake ups, just return the task_cpu */
    if (!(flags & (WF_TTWU | WF_FORK)))
        goto out;

    rq = cpu_rq(cpu);
    rcu_read_lock();
    curr = READ_ONCE(rq->curr);
    donor = READ_ONCE(rq->donor);

    /* 如果当前 CPU 运行的是低优先级 RT 或 FAIR 任务，
     * 尝试找一个优先级更低的 CPU */
    // ... 详细选择逻辑
}