void __init sched_init(void)
{
    unsigned long ptr = 0;
    int i;
 
    /*
     * 初始化全局默認(rèn)的rt和dl的CPU帶寬控制數(shù)據(jù)結(jié)構(gòu)
     *
     * 這里的rt_bandwidth和dl_bandwidth是用來控制全局的DL和RT的使用帶寬，防止實(shí)時進(jìn)程
     * CPU使用過多，從而導(dǎo)致普通的CFS進(jìn)程出現(xiàn)饑餓的情況
     */
    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
    /*
     * 初始化默認(rèn)的根域
     *
     * 根域是dl/rt等實(shí)時進(jìn)程做全局均衡的重要數(shù)據(jù)結(jié)構(gòu)，以rt為例
     * root_domain->cpupri 是這個根域范圍內(nèi)每個CPU上運(yùn)行的RT任務(wù)的最高優(yōu)先級，以及
     * 各個優(yōu)先級任務(wù)在CPU上的分布情況，通過cpupri的數(shù)據(jù)，那么在rt enqueue/dequeue
     * 的時候，rt調(diào)度器就可以根據(jù)這個rt任務(wù)分布情況來保證高優(yōu)先級的任務(wù)得到優(yōu)先
     * 運(yùn)行
     */
    init_defrootdomain();
#endif
 
#ifdef CONFIG_RT_GROUP_SCHED
    /*
     * 如果內(nèi)核支持rt組調(diào)度(RT_GROUP_SCHED), 那么對RT任務(wù)的帶寬控制將可以用cgroup
     * 的粒度來控制每個group里rt任務(wù)的CPU帶寬使用情況
     *
     * RT_GROUP_SCHED可以讓rt任務(wù)以cpu cgroup的形式來整體控制帶寬
     * 這樣可以為RT帶寬控制帶來更大的靈活性(沒有RT_GROUP_SCHED的時候，只能控制RT的全局
     * 帶寬使用，不能通過指定group的形式控制部分RT進(jìn)程帶寬)
     */
    init_rt_bandwidth(&root_task_group.rt_bandwidth,
            global_rt_period(), global_rt_runtime());
#endif /* CONFIG_RT_GROUP_SCHED */
 
    /* 為每個CPU初始化它的運(yùn)行隊(duì)列 */
    for_each_possible_cpu(i) {
        struct rq *rq;
 
        rq = cpu_rq(i);
        raw_spin_lock_init(&rq->lock);
        /*
         * 初始化rq上cfs/rt/dl的運(yùn)行隊(duì)列
         * 每個調(diào)度類型在rq上都有各自的運(yùn)行隊(duì)列，每個調(diào)度類都是各自管理自己的進(jìn)程
         * 在pick_next_task()的時候，內(nèi)核根據(jù)調(diào)度類優(yōu)先級的順序，從高到底選擇任務(wù)
         * 這樣就保證了高優(yōu)先級調(diào)度類任務(wù)會優(yōu)先得到運(yùn)行
         *
         * stop和idle是特殊的調(diào)度類型，是為專門的目的而設(shè)計(jì)的調(diào)度類，并不允許用戶
         * 創(chuàng)建相應(yīng)類型的進(jìn)程，所以內(nèi)核也沒有在rq里設(shè)計(jì)對應(yīng)的運(yùn)行隊(duì)列
         */
        init_cfs_rq(&rq->cfs);
        init_rt_rq(&rq->rt);
        init_dl_rq(&rq->dl);
#ifdef CONFIG_FAIR_GROUP_SCHED
        /*
         * CFS的組調(diào)度(group_sched)，可以通過cpu cgroup來對CFS進(jìn)行進(jìn)行控制
         * 可以通過cpu.shares來提供group之間的CPU比例控制(讓不同的cgroup按照對應(yīng)
         * 的比例來分享CPU)，也可以通過cpu.cfs_quota_us來進(jìn)行配額設(shè)定(與RT的
         * 帶寬控制類似)。CFS group_sched帶寬控制是容器實(shí)現(xiàn)的基礎(chǔ)底層技術(shù)之一
         *
         * root_task_group 是默認(rèn)的根task_group，其他的cpu cgroup都會以它做為
         * parent或者ancestor。這里的初始化將root_task_group與rq的cfs運(yùn)行隊(duì)列
         * 關(guān)聯(lián)起來，這里做的很有意思，直接將root_task_group->cfs_rq[cpu] = &rq->cfs
         * 這樣在cpu cgroup根下的進(jìn)程或者cgroup tg的sched_entity會直接加入到rq->cfs
         * 隊(duì)列里，可以減少一層查找開銷。
         */
        root_task_group.shares = ROOT_TASK_GROUP_LOAD;
        INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
        rq->tmp_alone_branch = &rq->leaf_cfs_rq_list;
        init_cfs_bandwidth(&root_task_group.cfs_bandwidth);
        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
        /* 初始化rq上的rt運(yùn)行隊(duì)列，與上面的CFS的組調(diào)度初始化類似 */
        init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, NULL);
#endif
 
#ifdef CONFIG_SMP
        /*
         * 這里將rq與默認(rèn)的def_root_domain進(jìn)行關(guān)聯(lián)，如果是SMP系統(tǒng)，那么后面
         * 在sched_init_smp的時候，內(nèi)核會創(chuàng)建新的root_domain，然后替換這里
         * def_root_domain
         */
        rq_attach_root(rq, &def_root_domain);
#endif /* CONFIG_SMP */
    }
 
    /*
     * 注冊CFS的SCHED_SOFTIRQ軟中斷服務(wù)函數(shù)
     * 這個軟中斷住要是周期性負(fù)載均衡以及nohz idle load balance而準(zhǔn)備的
     */
    init_sched_fair_class();
 
    scheduler_running = 1;
}

/*
 * Called by boot processor to activate the rest.
 *
 * 在SMP架構(gòu)里，BSP需要將其他的非boot cp全部bring up
 */
void __init smp_init(void)
{
    int num_nodes, num_cpus;
    unsigned int cpu;
 
    /* 為每個CPU創(chuàng)建其idle thread */
    idle_threads_init();
    /* 向內(nèi)核注冊cpuhp線程 */
    cpuhp_threads_init();
 
    pr_info("Bringing up secondary CPUs ...\n");
 
    /*
     * FIXME: This should be done in userspace --RR
     *
     * 如果CPU沒有online，則用cpu_up將其bring up
     */
    for_each_present_cpu(cpu) {
        if (num_online_cpus() >= setup_max_cpus)
            break;
        if (!cpu_online(cpu))
            cpu_up(cpu);
    }
     
    .............
}

/*
 * Topology list, bottom-up.
 *
 * Linux默認(rèn)的物理拓?fù)浣Y(jié)構(gòu)
 *
 * 這里只有三級物理拓?fù)浣Y(jié)構(gòu)，NUMA域是在sched_init_numa()自動檢測的
 * 如果存在NUMA域，則會添加對應(yīng)的NUMA調(diào)度域
 *
 * 注：這里默認(rèn)的 default_topology 調(diào)度域可能會存在一些問題，例如
 * 有的平臺不存在DIE域(intel平臺)，那么就可能出現(xiàn)LLC與DIE域重疊的情況
 * 所以內(nèi)核會在調(diào)度域建立好后，在cpu_attach_domain()里掃描所有調(diào)度
 * 如果存在調(diào)度重疊的情況，則會destroy_sched_domain對應(yīng)的重疊調(diào)度域
 */
static struct sched_domain_topology_level default_topology[] = {
#ifdef CONFIG_SCHED_SMT
    { cpu_smt_mask, cpu_smt_flags, SD_INIT_NAME(SMT) },
#endif
#ifdef CONFIG_SCHED_MC
    { cpu_coregroup_mask, cpu_core_flags, SD_INIT_NAME(MC) },
#endif
    { cpu_cpu_mask, SD_INIT_NAME(DIE) },
    { NULL, },
};

/*
 * NUMA調(diào)度域初始化(根據(jù)硬件信息創(chuàng)建新的sched_domain_topology物理拓?fù)浣Y(jié)構(gòu))
 *
 * 內(nèi)核在默認(rèn)情況下并不會主動添加NUMA topology，需要根據(jù)配置(如果開啟了NUMA)
 * 如果開啟了NUMA，這里就要根據(jù)硬件拓?fù)湫畔砼袛嗍欠裥枰砑?
 * sched_domain_topology_level 域(只有添加了這個域之后，內(nèi)核才會在后面初始化
 * sched_domain的時候創(chuàng)建NUMA DOMAIN)
 */
void sched_init_numa(void)
{
    ...................
    /*
     * 這里會根據(jù)distance檢查是否存在NUMA域(甚至存在多級NUMA域)，然后根據(jù)
     * 情況將其更新到物理拓?fù)浣Y(jié)構(gòu)里。后面的建立調(diào)度域的時候，就會這個新的
     * 物理拓?fù)浣Y(jié)構(gòu)來建立新的調(diào)度域
     */
    for (j = 1; j < level; i++, j++) {
        tl[i] = (struct sched_domain_topology_level){
            .mask = sd_numa_mask,
            .sd_flags = cpu_numa_flags,
            .flags = SDTL_OVERLAP,
            .numa_level = j,
            SD_INIT_NAME(NUMA)
        };
    }
 
    sched_domain_topology = tl;
 
    sched_domains_numa_levels = level;
    sched_max_numa_distance = sched_domains_numa_distance[level - 1];
 
    init_numa_topology_type();
}

/*
 * Set up scheduler domains and groups.  For now this just excludes isolated
 * CPUs, but could be used to exclude other special cases in the future.
 */
int sched_init_domains(const struct cpumask *cpu_map)
{
    int err;
 
    zalloc_cpumask_var(&sched_domains_tmpmask, GFP_KERNEL);
    zalloc_cpumask_var(&sched_domains_tmpmask2, GFP_KERNEL);
    zalloc_cpumask_var(&fallback_doms, GFP_KERNEL);
 
    arch_update_cpu_topology();
    ndoms_cur = 1;
    doms_cur = alloc_sched_domains(ndoms_cur);
    if (!doms_cur)
        doms_cur = &fallback_doms;
    /*
     * doms_cur[0] 表示調(diào)度域需要覆蓋的cpumask
     *
     * 如果系統(tǒng)里用isolcpus=對某些CPU進(jìn)行了隔離，那么這些CPU是不會加入到調(diào)度
     * 域里面，即這些CPU不會參于到負(fù)載均衡(這里的負(fù)載均衡包括DL/RT以及CFS)。
     * 這里用 cpu_map & housekeeping_cpumask(HK_FLAG_DOMAIN) 的方式將isolate
     * cpu去除掉，從而在保證建立的調(diào)度域里不包含isolate cpu
     */
    cpumask_and(doms_cur[0], cpu_map, housekeeping_cpumask(HK_FLAG_DOMAIN));
    /* 調(diào)度域建立的實(shí)現(xiàn)函數(shù) */
    err = build_sched_domains(doms_cur[0], NULL);
    register_sched_domain_sysctl();
 
    return err;
}

/*
 * Build sched domains for a given set of CPUs and attach the sched domains
 * to the individual CPUs
 */
static int
build_sched_domains(const struct cpumask *cpu_map, struct sched_domain_attr *attr)
{
    enum s_alloc alloc_state = sa_none;
    struct sched_domain *sd;
    struct s_data d;
    struct rq *rq = NULL;
    int i, ret = -ENOMEM;
    struct sched_domain_topology_level *tl_asym;
    bool has_asym = false;
 
    if (WARN_ON(cpumask_empty(cpu_map)))
        goto error;
 
    /*
     * Linux里的絕大部分進(jìn)程都為CFS調(diào)度類，所以CFS里的sched_domain將會被頻繁
     * 的訪問與修改(例如nohz_idle以及sched_domain里的各種統(tǒng)計(jì))，所以sched_domain
     * 的設(shè)計(jì)需要優(yōu)先考慮到效率問題，于是內(nèi)核采用了percpu的方式來實(shí)現(xiàn)sched_domain
     * CPU間的每級sd都是獨(dú)立申請的percpu變量，這樣可以利用percpu的特性解決它們
     * 間的并發(fā)競爭問題(1、不需要鎖保護(hù) 2、沒有cachline偽共享)
     */
    alloc_state = __visit_domain_allocation_hell(&d, cpu_map);
    if (alloc_state != sa_rootdomain)
        goto error;
 
    tl_asym = asym_cpu_capacity_level(cpu_map);
 
    /*
     * Set up domains for CPUs specified by the cpu_map:
     *
     * 這里會遍歷cpu_map里所有CPU，為這些CPU創(chuàng)建與物理拓?fù)浣Y(jié)構(gòu)對應(yīng)(
     * for_each_sd_topology)的多級調(diào)度域。
     *
     * 在調(diào)度域建立的時候，會通過tl->mask(cpu)獲得cpu在該級調(diào)度域?qū)?yīng)
     * 的span(即cpu與其他對應(yīng)的cpu組成了這個調(diào)度域)，在同一個調(diào)度域里
     * 的CPU對應(yīng)的sd在剛開始的時候會被初始化成一樣的(包括sd->pan、
     * sd->imbalance_pct以及sd->flags等參數(shù))。
     */
    for_each_cpu(i, cpu_map) {
        struct sched_domain_topology_level *tl;
 
        sd = NULL;
        for_each_sd_topology(tl) {
            int dflags = 0;
 
            if (tl == tl_asym) {
                dflags |= SD_ASYM_CPUCAPACITY;
                has_asym = true;
            }
 
            sd = build_sched_domain(tl, cpu_map, attr, sd, dflags, i);
 
            if (tl == sched_domain_topology)
                *per_cpu_ptr(d.sd, i) = sd;
            if (tl->flags & SDTL_OVERLAP)
                sd->flags |= SD_OVERLAP;
            if (cpumask_equal(cpu_map, sched_domain_span(sd)))
                break;
        }
    }
 
    /*
     * Build the groups for the domains
     *
     * 創(chuàng)建調(diào)度組
     *
     * 我們可以從2個調(diào)度域的實(shí)現(xiàn)看到sched_group的作用
     * 1、NUMA域 2、LLC域
     *
     * numa sched_domain->span會包含NUMA域上所有的CPU，當(dāng)需要進(jìn)行均衡的時候
     * NUMA域不應(yīng)該以cpu為單位，而是應(yīng)該以socket為單位，即只有socket1與socket2
     * 極度不平衡的時候才在這兩個SOCKET間遷移CPU。如果用sched_domain來實(shí)現(xiàn)這個
     * 抽象則會導(dǎo)致靈活性不夠(后面的MC域可以看到)，所以內(nèi)核會以sched_group來
     * 表示一個cpu集合，每個socket屬于一個sched_group。當(dāng)這兩個sched_group不平衡
     * 的時候才會允許遷移
     *
     * MC域也是類似的，CPU可能是超線程，而超線程的性能與物理核不是對等的。一對
     * 超線程大概等于1.2倍于物理核的性能。所以在調(diào)度的時候，我們需要考慮超線程
     * 對之間的均衡性，即先要滿足CPU間均衡，然后才是CPU內(nèi)的超線程均衡。這個時候
     * 用sched_group來做抽象，一個sched_group表示一個物理CPU(2個超線程)，這個時候
     * LLC保證CPU間的均衡，從而避免一種極端情況：超線程間均衡，但是物理核上不均衡
     * 的情況，同時可以保證調(diào)度選核的時候，內(nèi)核會優(yōu)先實(shí)現(xiàn)物理線程，只有物理線程
     * 用完之后再考慮使用另外的超線程，讓系統(tǒng)可以更充分的利用CPU算力
     */
    for_each_cpu(i, cpu_map) {
        for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
            sd->span_weight = cpumask_weight(sched_domain_span(sd));
            if (sd->flags & SD_OVERLAP) {
                if (build_overlap_sched_groups(sd, i))
                    goto error;
            } else {
                if (build_sched_groups(sd, i))
                    goto error;
            }
        }
    }
 
    /*
     * Calculate CPU capacity for physical packages and nodes
     *
     * sched_group_capacity 是用來表示sg可使用的CPU算力
     *
     * sched_group_capacity 是考慮了每個CPU本身的算力不同(最高主頻設(shè)置不同、
     * ARM的大小核等等)、去除掉RT進(jìn)程所使用的CPU(sg是為CFS準(zhǔn)備的，所以需要
     * 去掉CPU上DL/RT進(jìn)程等所使用的CPU算力)等因素之后，留給CFS sg的可用算力(因?yàn)?
     * 在負(fù)載均衡的時候，不僅應(yīng)該考慮到CPU上的負(fù)載，還應(yīng)該考慮這個sg上的CFS
     * 可用算力。如果這個sg上進(jìn)程較少，但是sched_group_capacity也較小，也是
     * 不應(yīng)該遷移進(jìn)程到這個sg上的)
     */
    for (i = nr_cpumask_bits-1; i >= 0; i--) {
        if (!cpumask_test_cpu(i, cpu_map))
            continue;
 
        for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {
            claim_allocations(i, sd);
            init_sched_groups_capacity(i, sd);
        }
    }
 
    /* Attach the domains */
    rcu_read_lock();
    /*
     * 將每個CPU的rq與rd(root_domain)進(jìn)行綁定，并且會檢查sd是否有重疊
     * 如果是的則需要用destroy_sched_domain()將其去掉(所以我們可以看到
     * intel的服務(wù)器是只有3層調(diào)度域，DIE域其實(shí)與LLC域重疊了，所以在這里
     * 會被去掉)
     */
    for_each_cpu(i, cpu_map) {
        rq = cpu_rq(i);
        sd = *per_cpu_ptr(d.sd, i);
 
        /* Use READ_ONCE()/WRITE_ONCE() to avoid load/store tearing: */
        if (rq->cpu_capacity_orig > READ_ONCE(d.rd->max_cpu_capacity))
            WRITE_ONCE(d.rd->max_cpu_capacity, rq->cpu_capacity_orig);
 
        cpu_attach_domain(sd, d.rd, i);
    }
    rcu_read_unlock();
 
    if (has_asym)
        static_branch_inc_cpuslocked(&sched_asym_cpucapacity);
 
    if (rq && sched_debug_enabled) {
        pr_info("root domain span: %*pbl (max cpu_capacity = %lu)\n",
            cpumask_pr_args(cpu_map), rq->rd->max_cpu_capacity);
    }
 
    ret = 0;
error:
    __free_domain_allocs(&d, alloc_state, cpu_map);
 
    return ret;
}