linux之调度管理（1）-调度器的初始化

一、linux 启动内核时的第一个进程 init_task

linux 进程的鼻祖 0,1,2，我在其他文章中，有具体讲解，链接是： linux 之0号进程、1号进程、2号进程_linux下0号进程 swap-优快云博客。

在这里就不具体展开了。请看上面的文章详解。

当linux启动时，最先会通过汇编代码进行硬件和CPU的初始化，最后会跳转到C代码，而最初跳转到的C代码入口为：

/* 代码地址： linux/init/Main.c */
asmlinkage __visible void __init start_kernel(void)

 补充一点：内核在执行C语言部分是有一段汇编语言，代码路径：kernel/arch/arm64/kernel/head.S

head.S  的汇编大致执行以下内容：

• preserve_boot_args用来保留bootloader传递的参数，比如ARM上通常的dtb的地址
• el2_setup： 用来trap到EL1，说明我们在运行此指令前还在EL2
• __create_page_tables： 用来创建页表，linux才有的是页面管理物理内存的，在使用虚拟地址之前需要设置好页面，然后会打开MMU。目前还是运行在物理地址上的
• __primary_switch： 主要任务是完成MMU的打开工作
• 调用__primary_switched来设置0号进程的运行内核栈，然后调用start_kernel函数，至此，0号进程已经运行了，执行的函数就是 start_kernel 。

在start_kerenl函数中，进行了系统启动过程中几乎所有重要的初始化,包括内存、页表、必要数据结构、信号、调度器、硬件设备等。

而这些初始化是由谁来负责的？就是由init_task这个进程。init_task是静态定义的一个进程，也就是说当内核被放入内存时，它就已经存在，它没有自己的用户空间，一直处于内核空间中运行，并且也只处于内核空间运行。当它执行到最后，将start_kernel中所有的初始化执行完成后，会在内核中启动一个kernel_init内核线程和一个kthreadd内核线程，kernel_init内核线程执行到最后会通过execve系统调用执行转变为我们所熟悉的init进程，而kthreadd内核线程是内核用于管理调度其他的内核线程的守护线程。在最后init_task将变成一个idle进程，用于在CPU没有进程运行时运行它，它在此时仅仅用于空转。

init_task进程也就是0号进程，也是idle 进程，也是swapper进程， 执行完 start_kernel 函数后，运行队列rq 的idle 的指针会指向init_task的静态定义的地址，并不会放到运行队列中。

kernel_init进程 ，也是1号进程，也是系统的init进程，也有的会说systemd进程。

kthreadd进程，也是2号进程，负责创建内核线程，而用户空间创建进程，就需要调用fork系统调用。

上面这三个进程的随着内核启动，变化的流程图如下：

 

上面标注的idle进程其实不严谨，此时还没有变成idle进程，还是正常运行的进程。

二、sched_init 调度初始化

在start_kernel中对调度器进行初始化的函数就是sched_init，其主要工作为

• 对相关数据结构分配内存
• 初始化root_task_group
• 初始化每个CPU的rq队列(包括其中的cfs队列和实时进程队列)
• 将init_task进程转变为idle进程 （只是把rq的idle指针指向 init_task）

需要说明的是init_task在这里会被转变为idle进程，但是它还会继续执行初始化工作，相当于这里只是给init_task挂个idle进程的名号，它其实还是init_task进程，只有到最后init_task进程开启了kernel_init和kthreadd进程之后，才转变为真正意义上的idle进程。

内核源码路径：kernel/kernel/sched/core.c

void __init sched_init(void)
{
        unsigned long ptr = 0;
        int i;

        /* Make sure the linker didn't screw up */
        BUG_ON(&idle_sched_class + 1 != &fair_sched_class ||
               &fair_sched_class + 1 != &rt_sched_class ||
               &rt_sched_class + 1   != &dl_sched_class);
#ifdef CONFIG_SMP
        BUG_ON(&dl_sched_class + 1 != &stop_sched_class);
#endif

        wait_bit_init();
/* 计算所需要分配的数据结构空间 */
#ifdef CONFIG_FAIR_GROUP_SCHED
        ptr += 2 * nr_cpu_ids * sizeof(void **);
#endif
#ifdef CONFIG_RT_GROUP_SCHED
        ptr += 2 * nr_cpu_ids * sizeof(void **);
#endif
        if (ptr) {/* 分配内存 */
                ptr = (unsigned long)kzalloc(ptr, GFP_NOWAIT);

#ifdef CONFIG_FAIR_GROUP_SCHED
           /* 设置 root_task_group 每个CPU上的CFS调度实体指针se */
                root_task_group.se = (struct sched_entity **)ptr;
                ptr += nr_cpu_ids * sizeof(void **);

            /* 设置 root_task_group 每个CPU上的CFS运行队列指针cfs_rq */
                root_task_group.cfs_rq = (struct cfs_rq **)ptr;
                ptr += nr_cpu_ids * sizeof(void **);

                root_task_group.shares = ROOT_TASK_GROUP_LOAD;
                init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
#endif /* CONFIG_FAIR_GROUP_SCHED */
#ifdef CONFIG_RT_GROUP_SCHED
            /* 设置 root_task_group 每个CPU上的实时调度实体指针se */
                root_task_group.rt_se = (struct sched_rt_entity **)ptr;
                ptr += nr_cpu_ids * sizeof(void **);

                root_task_group.rt_rq = (struct rt_rq **)ptr;
                ptr += nr_cpu_ids * sizeof(void **);

#endif /* CONFIG_RT_GROUP_SCHED */
        }
#ifdef CONFIG_CPUMASK_OFFSTACK
        for_each_possible_cpu(i) {
                per_cpu(load_balance_mask, i) = (cpumask_var_t)kzalloc_node(
                        cpumask_size(), GFP_KERNEL, cpu_to_node(i));
                per_cpu(select_idle_mask, i) = (cpumask_var_t)kzalloc_node(
                        cpumask_size(), GFP_KERNEL, cpu_to_node(i));
        }
#endif /* CONFIG_CPUMASK_OFFSTACK */
        /* 初始化实时进程的带宽限制，用于设置实时进程在CPU中所占用比的 */
        init_rt_bandwidth(&def_rt_bandwidth, global_rt_period(), global_rt_runtime());
        init_dl_bandwidth(&def_dl_bandwidth, global_rt_period(), global_rt_runtime());

#ifdef CONFIG_SMP
        /* 初始化默认的调度域，调度域包含一个或多个CPU，负载均衡是在调度域内执行的，相互之间隔离 */
        init_defrootdomain();
#endif

#ifdef CONFIG_RT_GROUP_SCHED/* 初始化实时进程的带宽限制，用于设置实时进程在CPU中所占用比的 */
        init_rt_bandwidth(&root_task_group.rt_bandwidth,
                        global_rt_period(), global_rt_runtime());
#endif /* CONFIG_RT_GROUP_SCHED */

#ifdef CONFIG_CGROUP_SCHED
        task_group_cache = KMEM_CACHE(task_group, 0);
        /* 将分配好空间的 root_task_group 加入 task_groups 链表 */
        list_add(&root_task_group.list, &task_groups);
        INIT_LIST_HEAD(&root_task_group.children);
        INIT_LIST_HEAD(&root_task_group.siblings);
        /* 自动分组初始化
        autogroup_init(&init_task);

#endif /* CONFIG_CGROUP_SCHED */
       for_each_possible_cpu(i) { /* 遍历设置每一个CPU */
                struct rq *rq;

                rq = cpu_rq(i);/* 获取CPUi的rq队列 */
                raw_spin_lock_init(&rq->lock);/* 初始化rq队列的自旋锁 */
                rq->nr_running = 0;/* CPU运行队列中调度实体(sched_entity)数量为0 */
                rq->calc_load_active = 0;/* CPU负载 */
                rq->calc_load_update = jiffies + LOAD_FREQ;/* 负载下次更新时间 */
                init_cfs_rq(&rq->cfs);/* 初始化CFS运行队列 */
                init_rt_rq(&rq->rt);/* 初始化实时进程运行队列 */
                init_dl_rq(&rq->dl);
#ifdef CONFIG_FAIR_GROUP_SCHED
                INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
                rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
                /*
                 * How much CPU bandwidth does root_task_group get?
                 *
                 * In case of task-groups formed thr' the cgroup filesystem, it
                 * gets 100% of the CPU resources in the system. This overall
                 * system CPU resource is divided among the tasks of
                 * root_task_group and its child task-groups in a fair manner,
                 * based on each entity's (task or task-group's) weight
                 * (se->load.weight).
                 *
                 * In other words, if root_task_group has 10 tasks of weight
                 * 1024) and two child groups A0 and A1 (of weight 1024 each),
                 * then A0's share of the CPU resource is:
                 *
                 *      A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%
                 *
                 * We achieve this by letting root_task_group's tasks sit
                 * directly in rq->cfs (i.e root_task_group->se[] = NULL).
                 */
                init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, NULL);
#endif /* CONFIG_FAIR_GROUP_SCHED */

                rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
#ifdef CONFIG_RT_GROUP_SCHED
                init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL);
#endif
#ifdef CONFIG_SMP/* 这些参数都是负载均衡使用的 */
                rq->sd = NULL;
                rq->rd = NULL;
                rq->cpu_capacity = rq->cpu_capacity_orig = SCHED_CAPACITY_SCALE;
                rq->balance_callback = NULL;
                rq->active_balance = 0;
                rq->next_balance = jiffies;
                rq->push_cpu = 0;
                rq->cpu = i;
                rq->online = 0;
                rq->idle_stamp = 0;
                rq->avg_idle = 2*sysctl_sched_migration_cost;
                rq->max_idle_balance_cost = sysctl_sched_migration_cost;

                INIT_LIST_HEAD(&rq->cfs_tasks);
            /* 将CPU运行队列加入到默认调度域中 */
                rq_attach_root(rq, &def_root_domain);
#ifdef CONFIG_NO_HZ_COMMON
                /* 该队列最后一次更新cpu_load的时间值为当前 */
                rq->last_blocked_load_update_tick = jiffies;
                atomic_set(&rq->nohz_flags, 0);/* 动态时钟使用的标志位，初始时动态时钟是不使用的 */

                rq_csd_init(rq, &rq->nohz_csd, nohz_csd_func);
#endif
#ifdef CONFIG_HOTPLUG_CPU
                rcuwait_init(&rq->hotplug_wait);
#endif
#endif /* CONFIG_SMP *
   /* 初始化运行队列定时器，这个是高精度定时器，但是只是初始化，这时并没有使用 */
                hrtick_rq_init(rq);
                atomic_set(&rq->nr_iowait, 0);
        }
       /* 设置 init_task 进程的权重 */
        set_load_weight(&init_task, false);

        /*
         * The boot idle thread does lazy MMU switching as well:
         */
        mmgrab(&init_mm);
        enter_lazy_tlb(&init_mm, current);

        /*
         * Make us the idle thread. Technically, schedule() should not be
         * called from this thread, however somewhere below it might be,
         * but because we are the idle thread, we just pick up running again
         * when this runqueue becomes "idle".
         */
/* 将当前进程初始化为idle进程，idle进程用于当CPU没有进程可运行时运行，空转 */
        init_idle(current, smp_processor_id());
 /* 下次负载更新时间(是一个相对时间) */
        calc_load_update = jiffies + LOAD_FREQ;

#ifdef CONFIG_SMP
        idle_thread_set_boot_cpu();
#endif
        init_sched_fair_class();

        init_schedstats();

        psi_init();

        init_uclamp();
 /* 这里只是标记调度器开始运行了，但是此时系统只有一个init_task(idle)进程，并且定时器都还没启动。并不会调度到其他进程，也没有其他进程可供调度 */
        scheduler_running = 1;
}

 执行到此时内核只有一个进程init_task，current就为init_task。之后的init进程在初始化到最后的rest_init中启动 */

sched_init 初始化之后，各个CPU 上都有各自的rq,如下图所示： 

 

调度器的初始化还是比较简单的，毕竟调度器的核心不在此，重头戏在它的运行时处理，之后的文章会详细分析调度器的运行时处理。

三、进程加入运行队列的时机

只有处于TASK_RUNNING状态下的进程才能够加入到调度器，其他状态都不行，也就说明了，当一个进程处于睡眠、挂起状态的时候是不存在于调度器中的，而进程加入调度器的时机如下：

• 当进程创建完成时，进程刚创建完成时，即使它运行起来立即调用sleep()进程睡眠，它也必定先会加入到调度器，因为实际上它加入调度器后自己还需要进行一定的初始化和操作，才会调用到我们的“立即”sleep()。
• 当进程被唤醒时，也使用sleep的例子说明，我们平常写程序使用的sleep()函数实现原理就是通过系统调用将进程状态改为TASK_INTERRUPTIBLE，然后移出运行队列，并且启动一个定时器，在定时器到期后唤醒进程，再重新放入运行队列。

（1）进程创建的函数：sched_fork

//kernel/kernel/sched/core.c

/*
 * fork()/clone()-time setup:
 */
int sched_fork(unsigned long clone_flags, struct task_struct *p)
{
        /* 初始化跟调度相关的值，比如调度实体，运行时间等 */
        __sched_fork(clone_flags, p);
        /*
         * We mark the process as NEW here. This guarantees that
         * nobody will actually run it, and a signal or other external
         * event cannot wake it up and insert it on the runqueue either.
         */
/*标记为运行状态，表明此进程正在运行或准备好运行，实际上没有真正在CPU上运行，这里只是导致了外部信号和事件不能够唤醒此进程，之后将它插入到运行队列中*/

        p->state = TASK_NEW;

        /*
         * Make sure we do not leak PI boosting priority to the child.
         */
        p->prio = current->normal_prio;//根据父进程的运行优先级设置设置进程的优先级

        uclamp_fork(p);

        /*
         * Revert to default priority/policy on fork if requested.
         */
        //    如果需要重新设置优先级
        if (unlikely(p->sched_reset_on_fork)) {
                     /* 如果是dl调度或者实时调度 */
                if (task_has_dl_policy(p) || task_has_rt_policy(p)) {
                        p->policy = SCHED_NORMAL;//调度策略为SCHED_NORMAL，这个选项将使用CFS调度
                        p->static_prio = NICE_TO_PRIO(0);//根据默认nice值设置静态优先级
                        p->rt_priority = 0;实时优先级为0 
                } else if (PRIO_TO_NICE(p->static_prio) < 0)
                        p->static_prio = NICE_TO_PRIO(0);//根据默认nice值设置静态优先级

                p->prio = p->normal_prio = p->static_prio;
                set_load_weight(p, false);/* 设置进程权重 */

                /*
                 * We don't need the reset flag anymore after the fork. It has
                 * fulfilled its duty:
                 */
         /* sched_reset_on_fork成员在之后已经不需要使用了，直接设为0 */

                p->sched_reset_on_fork = 0;
        }

        if (dl_prio(p->prio))
                return -EAGAIN;
        else if (rt_prio(p->prio))/* 根据优先级判断，如果是实时进程，设置其调度类为rt_sched_class */
                p->sched_class = &rt_sched_class;
        else
                p->sched_class = &fair_sched_class;设置其调度类为fair_sched_class

        init_entity_runnable_average(&p->se);

#ifdef CONFIG_SCHED_INFO
        if (likely(sched_info_on()))
                memset(&p->sched_info, 0, sizeof(p->sched_info));
#endif
#if defined(CONFIG_SMP)
        p->on_cpu = 0;
#endif
        init_task_preempt_count(p); /* 初始化该进程为内核禁止抢占 */
#ifdef CONFIG_HAVE_PREEMPT_LAZY
        task_thread_info(p)->preempt_lazy_count = 0;
#endif
#ifdef CONFIG_SMP
        plist_node_init(&p->pushable_tasks, MAX_PRIO);
        RB_CLEAR_NODE(&p->pushable_dl_tasks);
#endif
        return 0;
}

在sched_fork()函数中，主要工作如下：

• 初始化进程p的一些变量(实时进程和普通进程通用的那些变量)
• 根据进程p的优先级设置其调度类(实时进程优先级:0~99　　普通进程优先级:100~139)
• 初始化进程p禁止内核抢占(因为当CPU执行到进程p时，进程p还需要进行一些初始化)

可以看出sched_fork()进行的初始化也比较简单，需要注意的是不同类型的进程会使用不同的调度类，并且也会调用调度类中的初始化函数。在实时进程的调度类中是没有特定的task_fork()函数的，而普通进程使用cfs策略时会调用到task_fork_fair()函数，我们具体看看实现：

源码路径：kernel/kernel/sched/fair.c

static void task_fork_fair(struct task_struct *p)
{
        struct cfs_rq *cfs_rq;
        struct sched_entity *se = &p->se, *curr;  /* 进程p的调度实体se */
        struct rq *rq = this_rq();/* 获取当前CPU rq */
        struct rq_flags rf;

        rq_lock(rq, &rf);上锁并保存中断记录
        update_rq_clock(rq);/* 更新rq运行时间 */

        cfs_rq = task_cfs_rq(current);
        curr = cfs_rq->curr;/* 设置当前进程所在队列为父进程所在队列 */
        if (curr) {
                /* 更新当前进程运行时间 */
                update_curr(cfs_rq);
                /* 将父进程的虚拟运行时间赋给了新进程的虚拟运行时间 */
                se->vruntime = curr->vruntime;
        }
        place_entity(cfs_rq, se, 1); /* 调整了se的虚拟运行时间 */

        if (sysctl_sched_child_runs_first && curr && entity_before(curr, se)) {
                /*
                 * Upon rescheduling, sched_class::put_prev_task() will place
                 * 'current' within the tree based on its new key value.
                 */
                swap(curr->vruntime, se->vruntime);
                resched_curr_lazy(rq);
        }
/* 保证了进程p的vruntime是运行队列中最小的(这里暂时不确定是不是这个用法，不过确实是最小的了) */
        se->vruntime -= cfs_rq->min_vruntime;
        rq_unlock(rq, &rf);/* 解锁，还原中断记录 */
}

在task_fork_fair()函数中主要就是设置进程p的虚拟运行时间和所处的cfs队列，值得我们注意的是 cfs_rq = task_cfs_rq(current); 这一行，在注释中已经表明task_cfs_rq(current)返回的是current的se.cfs_rq，注意se.cfs_rq保存的并不是根cfs队列，而是所处的cfs_rq，也就是如果父进程处于一个进程组的cfs_rq中，新创建的进程也会处于这个进程组的cfs_rq中。

（2）到这里新进程关于调度的初始化已经完成，但是还没有被调度器加入到队列中，其是在do_fork()中的wake_up_new_task(p)；中加入到队列中的，我们具体看看wake_up_new_task()的实现：

void wake_up_new_task(struct task_struct *p)
{
        struct rq_flags rf;
        struct rq *rq;

        raw_spin_lock_irqsave(&p->pi_lock, rf.flags);
        p->state = TASK_RUNNING;
#ifdef CONFIG_SMP
        /*
         * Fork balancing, do it here and not earlier because:
         *  - cpus_ptr can change in the fork path
         *  - any previously selected CPU might disappear through hotplug
         *
         * Use __set_task_cpu() to avoid calling sched_class::migrate_task_rq,
         * as we're not fully set-up yet.
         */
        p->recent_used_cpu = task_cpu(p);
        rseq_migrate(p);
        /* 为进程选择一个合适的CPU */
        __set_task_cpu(p, select_task_rq(p, task_cpu(p), SD_BALANCE_FORK, 0));
#endif
        rq = __task_rq_lock(p, &rf);
        update_rq_clock(rq);
        post_init_entity_util_avg(p);/* 这里是跟多核负载均衡有关 */

        activate_task(rq, p, ENQUEUE_NOCLOCK);/* 将进程加入到CPU的运行队列 */
        trace_sched_wakeup_new(p);/* 跟调试有关 */
        check_preempt_curr(rq, p, WF_FORK);
#ifdef CONFIG_SMP
        if (p->sched_class->task_woken) {
                /*
                 * Nothing relies on rq->lock after this, so its fine to
                 * drop it.
                 */
                rq_unpin_lock(rq, &rf);
                p->sched_class->task_woken(rq, p);
                rq_repin_lock(rq, &rf);
        }
#endif
        task_rq_unlock(rq, p, &rf);
}

在wake_up_new_task()函数中，将进程加入到运行队列的函数为activate_task(),而activate_task()函数最后会调用到新进程调度类中的enqueue_task指针所指函数，这里我们具体看一下cfs调度类的enqueue_task指针所指函数enqueue_task_fair()：

//kernel/kernel/sched/fair.c
static void
enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
{
        struct cfs_rq *cfs_rq;
        struct sched_entity *se = &p->se;
        int idle_h_nr_running = task_has_idle_policy(p);
        int task_new = !(flags & ENQUEUE_WAKEUP);

        /*
         * The code below (indirectly) updates schedutil which looks at
         * the cfs_rq utilization to select a frequency.
         * Let's add the task's estimated utilization to the cfs_rq's
         * estimated utilization, before we update schedutil.
         */
        util_est_enqueue(&rq->cfs, p);

        /*
         * If in_iowait is set, the code below may not trigger any cpufreq
         * utilization updates, so do it here explicitly with the IOWAIT flag
         * passed.
         */
        if (p->in_iowait)
                cpufreq_update_util(rq, SCHED_CPUFREQ_IOWAIT);
/*这里是一个迭代，我们知道，进程有可能是处于一个进程组中的，所以当这个处于进程组中的进程加入到该进程组的队列中时，要对此队列向上迭代 */

        for_each_sched_entity(se) {
                if (se->on_rq)
                        break;
/* 如果不是CONFIG_FAIR_GROUP_SCHED，获取其所在CPU的rq运行队列的cfs_rq运行队列
         * 如果是CONFIG_FAIR_GROUP_SCHED，获取其所在的cfs_rq运行队列
         */
                cfs_rq = cfs_rq_of(se);
                enqueue_entity(cfs_rq, se, flags);/* 加入到队列中 */

                cfs_rq->h_nr_running++;
                cfs_rq->idle_h_nr_running += idle_h_nr_running;

                /* end evaluation on encountering a throttled cfs_rq */
                if (cfs_rq_throttled(cfs_rq))
                        goto enqueue_throttle;

                flags = ENQUEUE_WAKEUP;
        }

/* 只有se不处于队列中或者cfs_rq_throttled(cfs_rq)返回真才会运行这个循环 */
        for_each_sched_entity(se) {
                cfs_rq = cfs_rq_of(se);

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

                cfs_rq->h_nr_running++;
                cfs_rq->idle_h_nr_running += idle_h_nr_running;

                /* end evaluation on encountering a throttled cfs_rq */
                if (cfs_rq_throttled(cfs_rq))
                        goto enqueue_throttle;

               /*
                * One parent has been throttled and cfs_rq removed from the
                * list. Add it back to not break the leaf list.
                */
               if (throttled_hierarchy(cfs_rq))
                       list_add_leaf_cfs_rq(cfs_rq);
        }

        /* At this point se is NULL and we are at root level*/
        add_nr_running(rq, 1); /* 当前CPU运行队列活动进程数 + 1 */

        /*
         * Since new tasks are assigned an initial util_avg equal to
         * half of the spare capacity of their CPU, tiny tasks have the
         * ability to cross the overutilized threshold, which will
         * result in the load balancer ruining all the task placement
         * done by EAS. As a way to mitigate that effect, do not account
         * for the first enqueue operation of new tasks during the
         * overutilized flag detection.
         *
         * A better way of solving this problem would be to wait for
         * the PELT signals of tasks to converge before taking them
         * into account, but that is not straightforward to implement,
         * and the following generally works well enough in practice.
         */
        if (!task_new)
                update_overutilized_status(rq);

enqueue_throttle:
        if (cfs_bandwidth_used()) {
                /*
                 * When bandwidth control is enabled; the cfs_rq_throttled()
                 * breaks in the above iteration can result in incomplete
                 * leaf list maintenance, resulting in triggering the assertion
                 * below.
                 */
                for_each_sched_entity(se) {
                        cfs_rq = cfs_rq_of(se);

                        if (list_add_leaf_cfs_rq(cfs_rq))
                                break;
                }
        }

        assert_list_leaf_cfs_rq(rq);

        hrtick_update(rq);/* 设置下次调度中断发生时间 */
}

在enqueue_task_fair()函数中又使用了enqueue_entity()函数进行操作，如下：

// kernel/kernel/sched/fair.c
static void
enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
        bool renorm = !(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_MIGRATED);
        bool curr = cfs_rq->curr == se;

        /*
         * If we're the current task, we must renormalise before calling
         * update_curr().
         */
        if (renorm && curr)
                se->vruntime += cfs_rq->min_vruntime;
/* 更新当前进程运行时间和虚拟运行时间 */
        update_curr(cfs_rq);

        /*
         * Otherwise, renormalise after, such that we're placed at the current
         * moment in time, instead of some random moment in the past. Being
         * placed in the past could significantly boost this task to the
         * fairness detriment of existing tasks.
         */
        if (renorm && !curr)
                se->vruntime += cfs_rq->min_vruntime;

        /*
         * When enqueuing a sched_entity, we must:
         *   - Update loads to have both entity and cfs_rq synced with now.
         *   - Add its load to cfs_rq->runnable_avg
         *   - For group_entity, update its weight to reflect the new share of
         *     its group cfs_rq
         *   - Add its new weight to cfs_rq->load.weight
         */
/* 更新cfs_rq队列总权重(就是在原有基础上加上se的权重) */
        update_load_avg(cfs_rq, se, UPDATE_TG | DO_ATTACH);
        se_update_runnable(se);
        update_cfs_group(se);
        account_entity_enqueue(cfs_rq, se);

/* 新建的进程flags为0，不会执行这里 */
        if (flags & ENQUEUE_WAKEUP)
                place_entity(cfs_rq, se, 0);

        check_schedstat_required();
        update_stats_enqueue(cfs_rq, se, flags);
        check_spread(cfs_rq, se);
/* 将se插入到运行队列cfs_rq的红黑树中 */
        if (!curr)
                __enqueue_entity(cfs_rq, se);
        se->on_rq = 1;/* 将se的on_rq标记为1 */

        /*
         * When bandwidth control is enabled, cfs might have been removed
         * because of a parent been throttled but cfs->nr_running > 1. Try to
         * add it unconditionnally.
         */
/* 如果cfs_rq的队列中只有一个进程，这里做处理 */
        if (cfs_rq->nr_running == 1 || cfs_bandwidth_used())
                list_add_leaf_cfs_rq(cfs_rq);

        if (cfs_rq->nr_running == 1)
                check_enqueue_throttle(cfs_rq);
}

重点是：加入运行队列时系统会根据CPU的负载情况放入不同的CPU队列中。