80% of CFS's design can be summed up in a single sentence: CFS basically models
an "ideal, precise multi-tasking CPU" on real hardware.

static void place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
{
    u64 vruntime = cfs_rq->min_vruntime;

    /*
     * The 'current' period is already promised to the current tasks,
     * however the extra weight of the new task will slow them down a
     * little, place the new task so that it fits in the slot that
     * stays open at the end.
     */
    if (initial && sched_feat(START_DEBIT))  /* initial表示新进程 */
        vruntime += sched_vslice(cfs_rq, se);

    /* sleeps up to a single latency don't count. */
    if (!initial) { /* 休眠进程 */
        unsigned long thresh = sysctl_sched_latency;

        /*
         * Halve their sleep time's effect, to allow
         * for a gentler effect of sleepers:
         */
        if (sched_feat(GENTLE_FAIR_SLEEPERS))
            thresh >>= 1;

        vruntime -= thresh;
    }

    /* ensure we never gain time by being placed backwards. */
    se->vruntime = max_vruntime(se->vruntime, vruntime);
}

# grep min_vruntime /proc/sched_debug
  .min_vruntime                  : 526279705.695991
  .min_vruntime                  : 532370994.256253
  .min_vruntime                  : 720871453.830955
  .min_vruntime                  : 692323575.852029

static void
dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
...
        /*
         * Normalize the entity after updating the min_vruntime because the
         * update can refer to the ->curr item and we need to reflect this
         * movement in our normalized position.
         */
        if (!(flags & DEQUEUE_SLEEP))
                se->vruntime -= cfs_rq->min_vruntime;
...
}

static void
enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
        /*
         * Update the normalized vruntime before updating min_vruntime
         * through callig update_curr().
         */
        if (!(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_WAKING))
                se->vruntime += cfs_rq->min_vruntime;
...
}

struct task_struct {
    ... ...
    int prio, static_prio, normal_prio;      // 进程优先级
    unsigned int rt_priority;                // RT优先级
    const struct sched_class *sched_class;   // 响应的调度类
    struct sched_entity se;
    struct sched_rt_entity rt;
    struct sched_dl_entity dl;
    unsigned int policy;                     // 调度策略，默认为SCHED_NORMAL
    cpumask_t cpus_allowed;                  // 限制此进程在哪个处理器上运行
    ... ...
};

struct rq {                      // @ kernel/sched/sched.h
    spinlock_t lock;                     // 锁
    unsigned long nr_running;            // 当前就绪对列进程的数目
    struct load_weight load;             // 当前就绪队列负荷
    struct task_struct *curr, *idle;     // 分别指向当前以及空闲进程描述符
    struct cfs_rq cfs;                   // 分别表示三个不同的就绪队列
    struct rt_rq rt;
    struct dl_rq dl;
    u64 clock;                           // 就绪队列的时钟，这个是周期更新的，真实的系统晶振时钟
};

struct cfs_rq {                  // @ kernel/sched/sched.h
    struct load_weight load;             // 队列上所有进程的权重值weight总和
    unsigned int nr_running;             // 当前就绪队列的进程数=队列进程的总数+正在运行的那个进程
    struct sched_entity *curr;           // 指向当前进程的运行实体
    struct rb_root tasks_timeline;       // 就绪队列的树跟
    struct rb_node *rb_leftmost;         // 保存红黑树最左边的节点，直接作为下一个运行进程
};

struct sched_class {            // @ kernel/sched/sched.h
    const struct sched_class *next;                                           // 调度类组成单向链表
    void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);  // 向就绪队列插入进程
    void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);   // 从就绪队列中删除
    void (*yield_task) (struct rq *rq);                                       // 进程主动放弃处理器
    void (*check_preempt_curr) (struct rq *rq, struct task_struct *p);        // 用一个新唤醒的进程抢占当前进程
    struct task_struct * (*pick_next_task) (struct rq *rq);                   // 选择下一个将要运行的进程
    void (*put_prev_task) (struct rq *rq, struct task_struct *p);
    void (*task_tick) (struct rq *rq, struct task_struct *p);                 // 由周期调度器调用
    void (*task_new) (struct rq *rq, struct task_struct *p);                  // 每次建立新进程调用此函数通知调度器
};

struct sched_entity {
    unsigned int        on_rq;                    // 是否在运行队列或正在执行，当前任务不会保存在红黑树中
    struct load_weight  load;                     // 该调度实体的权重，决定了运行时间以及被调用次数
    u64                 vruntime;                 // 存放进程的虚拟运行时间，用于调度器的选择
    u64                 exec_start                // 记录上次执行update_curr()的时间
    u64                 sum_exec_runtime;         // 进程总共执行的cpu clock，占用cpu的物理时间
    u64                 pre_sum_exec_runtime;     // 进程在切换经CPU时的sum_exec_runtime值
};

do_fork()
 |-copy_process()
 | |-security_task_create()
 | |-dup_task_struct()
 | |-sched_fork()
 |-trace_sched_process_fork()
 |-get_task_pid()
 |-wake_up_new_task()
 |-put_pid()

scheduler_tick()
  |-update_rq_clock()                 更新运行队列的时钟rq->clock
  |-curr->sched_class->task_tick()    执行调度器的周期性函数，以CFS为例
  | |-task_tick_fair()                CFS对应的task_tick()
  |   |-entity_tick()
  |     |-update_curr()
  |     |-update_cfs_shares()         对SMP有效
  |     |-check_preempt_tick()        检查当前进程是否运行了足够长的时间，是否需要抢占
  |-update_cpu_load_active()          更新运行队列load，将数组中先前存储的load向后移动一个位置，并插入新值