fork进程在CFS的处理过程

    在进程fork子进程的过程中，可以想到的内核中的大致过程就是fork出的子进程，根据load选择出一个的rq，然后把task的状态置为running，把子进程插入到这个rq中，同时更新vruntime，最后根据vruntime确定是否要check preempt（标记TIF_NEED_RESCHED），尝试调度这个新fork出的进程。

    在fork进程的copy_process函数中会调用sched_fork函数，会设置task的state设置为TASK_RUNNING，调用cfs的task_fork_fair函数，这个函数的做的事情：

1. 因为这里需要用到父进程的vruntime，子进程的vruntime以父进程为基础，所以这里需要更新curr的vruntime到最新，调用update_curr函数。
2. 初始化子进程的vruntime为父进程vruntime。
3. 根据当前子进程的load和cfs_rq中的从load平分sysctl_sched_latency，计算子进程的vruntime。

    sysctl_sched_latency就是一个sched_entity的调度的最大延时，在时钟中断函数tick中，会判断这轮运行的时间（计算这个依赖于sum_exec_runtime和prev_sum_exec_runtime之差），如果sched_entity运行超过了时间段，那么一定会标记resched，这个细节后面blog会讲到。

代码：

    

static void task_fork_fair(struct task_struct *p){
        struct cfs_rq *cfs_rq = task_cfs_rq(current);
        struct sched_entity *se = &p->se, *curr = cfs_rq->curr;
        int this_cpu = smp_processor_id();
        struct rq *rq = this_rq(); //获得当前cpu 的rq
        unsigned long flags;

        raw_spin_lock_irqsave(&rq->lock, flags);

        if (unlikely(task_cpu(p) != this_cpu)) {
            rcu_read_lock();
            __set_task_cpu(p, this_cpu);
            rcu_read_unlock();
        }

        update_curr(cfs_rq); //根据时间片的deltatime和load更新curr的vruntime和cfs的min_vruntime

        if (curr)
            se->vruntime = curr->vruntime; //初始化子进程的vruntime
        place_entity(cfs_rq, se, 1); //根据sched_entity的load和cfs_rq中的load平分sysctl_sched_latency最大延时
                                                               //如果设置了 sysctl_sched_child_runs_first，那么需要让子进程的vruntime最小
        if (sysctl_sched_child_runs_first && curr && entity_before(curr, se)) {
            swap(curr->vruntime, se->vruntime);
            resched_task(rq->curr);
        }

        se->vruntime -= cfs_rq->min_vruntime; //这里需要说明下
        raw_spin_unlock_irqrestore(&rq->lock, flags);
    }

    这里为何 se->vruntime要减去 cfs_rq->min_vruntime，查了一下，写到

To prevent boost or penalty in the new cfs_rq caused by delta min_vruntime between the two cfs_rqs, we skip vruntime adjustment.

    可以看到内核中的注释说为了避免sched_entity在换cfs_rq的时候，导致了继承了原来cfs_rq的min_vruntime，因为不同的cfs_rq，min_vruntime不相同，可以让在计算vruntime的时候先减去当前cfs_rq的vruntime，在enqueue到其他cfs_rq的时候在加上那个cfs_rq的min_vruntime。

    可以看到这个减去cfs_rq的min_vruntime的时机：

1. task_fork的时候，因为fork的最后会去挑选load的cfs_rq去enqueue子进程task，所以在执行task_fork_fair的时候当前cfs_rq不一定是最后task enqueue的那个queue。
2. 在dequeue_entity的时候，表示当前sched_entity出runqueue，有可能移动到其他的runqueue中，所以这个时候需要减去min_vruntime

    在enqueue_entity的时候需要把当前sched_entity的vruntime加上当前cfs_rq的min_vruntime，在do_fork的最后会把当前fork出的子线程放到load最低的cfs_rq中，然后check preempt。

主要逻辑：    

    cpu = select_task_rq(rq, p, SD_BALANCE_FORK, 0); //按照load，挑选出load最低的cpu
    set_task_cpu(p, cpu);
    p->state = TASK_RUNNING;                        //更新状态
    task_rq_unlock(rq, &flags);
    rq = task_rq_lock(p, &flags);
    activate_task(rq, p, 0);                         //sched_entity进入相应的cfs_rq运行队列
    trace_sched_wakeup_new(p, 1);
    check_preempt_curr(rq, p, WF_FORK);              //检测当前正在执行的进程是否可以被抢占

active_task的逻辑就是把task enqueue进相关的运行队列

static void activate_task(struct rq *rq, struct task_struct *p, int flags){
        if (task_contributes_to_load(p))
            rq->nr_uninterruptible--;
        enqueue_task(rq, p, flags);
        inc_nr_running(rq);
    }

    check_preempt_curr函数主要是看当前执行的进程是否可以被抢占（标记TIF_NEED_RESCHED），来运行新的子进程,check_preempt_curr函数判断是否可以resched,主要逻辑在wakeup_preempt_entity函数中。

static int wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se){
    s64 gran, vdiff = curr->vruntime - se->vruntime;
    if (vdiff <= 0)
        return -1;
    gran = wakeup_gran(curr, se);
    if (vdiff > gran)
        return 1;
    return 0;
}

 代码中的注释很好的说明了wakeup_gran函数的作用
                                             

    这里利用到cfs中的一个调度参数sysctl_sched_wakeup_granularity，这个参数表示wakeup时最小粒度，决定当前sched_entity是否被抢占的时候，如果有sched_entity的vruntime比curr的vruntime大至少sysctl_sched_wakeup_granularity，那么这个时候需要标记重新调度（TIF_NEED_RESCHED），如果差距不足sysctl_sched_wakeup_granularity就不需要抢占，如果没有这个参数，只比较vruntime，会导致抢占的太频繁，这样系统的进程切换也会很频繁，性能也不会很高。如果不抢占会导致，有的sched_entity被调度到需要一定的延时，所以定一个临界值（sysctl_sched_wakeup_granularity）是很有必要的。