CPU拓扑结构和调度域/组

        cpu0: cpu@000 {
            device_type = "cpu";
            compatible = "arm,cortex-a53";
            reg = <0x000>;
            enable-method = "psci";
            clock-frequency = <2301000000>;
            operating-points-v2 = <&cluster0_opp>;
            dynamic-power-coefficient = <275>;
            capacity-dmips-mhz = <1024>;
            cpu-idle-states = <&STANDBY &MCDI_CPU &MCDI_CLUSTER>,
                <&SODI &SODI3 &DPIDLE &SUSPEND>;
        };

        cpu1: cpu@001 {
            device_type = "cpu";
            compatible = "arm,cortex-a53";
            reg = <0x001>;
            enable-method = "psci";
            clock-frequency = <2301000000>;
            operating-points-v2 = <&cluster0_opp>;
            dynamic-power-coefficient = <275>;
            capacity-dmips-mhz = <1024>;
            cpu-idle-states = <&STANDBY &MCDI_CPU &MCDI_CLUSTER>,
                <&SODI &SODI3 &DPIDLE &SUSPEND>;
        };

        cpu2: cpu@002 {
            device_type = "cpu";
            compatible = "arm,cortex-a53";
            reg = <0x002>;
            enable-method = "psci";
            clock-frequency = <2301000000>;
            operating-points-v2 = <&cluster0_opp>;
            dynamic-power-coefficient = <275>;
            capacity-dmips-mhz = <1024>;
            cpu-idle-states = <&STANDBY &MCDI_CPU &MCDI_CLUSTER>,
                <&SODI &SODI3 &DPIDLE &SUSPEND>;
        };

        cpu3: cpu@003 {
            device_type = "cpu";
            compatible = "arm,cortex-a53";
            reg = <0x003>;
            enable-method = "psci";
            clock-frequency = <2301000000>;
            operating-points-v2 = <&cluster0_opp>;
            dynamic-power-coefficient = <275>;
            capacity-dmips-mhz = <1024>;
            cpu-idle-states = <&STANDBY &MCDI_CPU &MCDI_CLUSTER>,
                <&SODI &SODI3 &DPIDLE &SUSPEND>;
        };

        cpu4: cpu@100 {
            device_type = "cpu";
            compatible = "arm,cortex-a53";
            reg = <0x100>;
            enable-method = "psci";
            clock-frequency = <1800000000>;
            operating-points-v2 = <&cluster1_opp>;
            dynamic-power-coefficient = <85>;
            capacity-dmips-mhz = <801>;
            cpu-idle-states = <&STANDBY &MCDI_CPU &MCDI_CLUSTER>,
                <&SODI &SODI3 &DPIDLE &SUSPEND>;
        };

        cpu5: cpu@101 {
            device_type = "cpu";
            compatible = "arm,cortex-a53";
            reg = <0x101>;
            enable-method = "psci";
            clock-frequency = <1800000000>;
            operating-points-v2 = <&cluster1_opp>;
            dynamic-power-coefficient = <85>;
            capacity-dmips-mhz = <801>;
            cpu-idle-states = <&STANDBY &MCDI_CPU &MCDI_CLUSTER>,
                <&SODI &SODI3 &DPIDLE &SUSPEND>;
        };

        cpu6: cpu@102 {
            device_type = "cpu";
            compatible = "arm,cortex-a53";
            reg = <0x102>;
            enable-method = "psci";
            clock-frequency = <1800000000>;
            operating-points-v2 = <&cluster1_opp>;
            dynamic-power-coefficient = <85>;
            capacity-dmips-mhz = <801>;
            cpu-idle-states = <&STANDBY &MCDI_CPU &MCDI_CLUSTER>,
                <&SODI &SODI3 &DPIDLE &SUSPEND>;
        };

        cpu7: cpu@103 {
            device_type = "cpu";
            compatible = "arm,cortex-a53";
            reg = <0x103>;
            enable-method = "psci";
            clock-frequency = <1800000000>;
            operating-points-v2 = <&cluster1_opp>;
            dynamic-power-coefficient = <85>;
            capacity-dmips-mhz = <801>;
            cpu-idle-states = <&STANDBY &MCDI_CPU &MCDI_CLUSTER>,
                <&SODI &SODI3 &DPIDLE &SUSPEND>;
        };

        cpu-map {
            cluster0 {
                core0 {
                    cpu = <&cpu0>;
                };
                core1 {
                    cpu = <&cpu1>;
                };
                core2 {
                    cpu = <&cpu2>;
                };
                core3 {
                    cpu = <&cpu3>;
                };
            };

            cluster1 {
                core0 {
                    cpu = <&cpu4>;
                };
                core1 {
                    cpu = <&cpu5>;
                };
                core2 {
                    cpu = <&cpu6>;
                };
                core3 {
                    cpu = <&cpu7>;
                };
            };
        };

kernel_init()
    -> kernel_init_freeable()
        -> smp_prepare_cpus()
            -> init_cpu_topology()
                -> parse_dt_topology()

static int __init parse_dt_topology(void)
{
    struct device_node *cn, *map;
    int ret = 0;
    int cpu;

    cn = of_find_node_by_path("/cpus");    //查找dts中 /cpus的节点
    if (!cn) {
        pr_err("No CPU information found in DT\n");
        return 0;
    }

    /*
     * When topology is provided cpu-map is essentially a root
     * cluster with restricted subnodes.
     */
    map = of_get_child_by_name(cn, "cpu-map");    //查找/cpus节点下，cpu-map节点
    if (!map)
        goto out;

    ret = parse_cluster(map, 0);    //(1)解析cluster结构
    if (ret != 0)
        goto out_map;

    topology_normalize_cpu_scale();    //(2)将cpu capacity归一化

    /*
     * Check that all cores are in the topology; the SMP code will
     * only mark cores described in the DT as possible.
     */
    for_each_possible_cpu(cpu)
        if (cpu_topology[cpu].package_id == -1)
            ret = -EINVAL;

out_map:
    of_node_put(map);
out:
    of_node_put(cn);
    return ret;
}

static int __init parse_cluster(struct device_node *cluster, int depth)
{
    char name[20];
    bool leaf = true;
    bool has_cores = false;
    struct device_node *c;
    static int package_id __initdata;
    int core_id = 0;
    int i, ret;

    /*
     * First check for child clusters; we currently ignore any
     * information about the nesting of clusters and present the
     * scheduler with a flat list of them.
     */
    i = 0;
    do {
        snprintf(name, sizeof(name), "cluster%d", i);    //依次解析cluster0,1... 当前平台只有cluster0/1
        c = of_get_child_by_name(cluster, name);  //检查cpu-map下，是否有cluster结构
        if (c) {
            leaf = false;
            ret = parse_cluster(c, depth + 1);     //如果有cluster结构，会继续解析更深层次的core结构。（这里通过代码复用，接着解析core结构）
            of_node_put(c);
            if (ret != 0)
                return ret;
        }
        i++;
    } while (c);

    /* Now check for cores */
    i = 0;
    do {
        snprintf(name, sizeof(name), "core%d", i);    //依次解析core0,1... 当前平台有8个core
        c = of_get_child_by_name(cluster, name);    //检查cluster下，是否有core结构
        if (c) {
            has_cores = true;

            if (depth == 0) {                                            //这里要注意，是因为上面depth+1的调用才会走下去
                pr_err("%pOF: cpu-map children should be clusters\n",    //如果cpu-map下没有cluster结构的（depth==0），就会报错
                       c);
                of_node_put(c);
                return -EINVAL;
            }

            if (leaf) {                                            //在depth+1的情况下，leaf == true，说明是core level了
                ret = parse_core(c, package_id, core_id++);     //(1-1)解析core结构
            } else {
                pr_err("%pOF: Non-leaf cluster with core %s\n",
                       cluster, name);
                ret = -EINVAL;
            }

            of_node_put(c);
            if (ret != 0)
                return ret;
        }
        i++;
    } while (c);

    if (leaf && !has_cores)
        pr_warn("%pOF: empty cluster\n", cluster);

    if (leaf)            //在core level遍历完成：说明1个cluster解析完成，要解析下一个cluster了，package id要递增了
        package_id++;    //所以package id就对应了cluster id

    return 0;
}

static int __init parse_core(struct device_node *core, int package_id,
                 int core_id)
{
    char name[20];
    bool leaf = true;
    int i = 0;
    int cpu;
    struct device_node *t;

    do {
        snprintf(name, sizeof(name), "thread%d", i);    //不支持SMT，所以dts没有在core下面配置超线程
        t = of_get_child_by_name(core, name);
        if (t) {
            leaf = false;
            cpu = get_cpu_for_node(t);
            if (cpu >= 0) {
                cpu_topology[cpu].package_id = package_id;
                cpu_topology[cpu].core_id = core_id;
                cpu_topology[cpu].thread_id = i;
            } else {
                pr_err("%pOF: Can't get CPU for thread\n",
                       t);
                of_node_put(t);
                return -EINVAL;
            }
            of_node_put(t);
        }
        i++;
    } while (t);

    cpu = get_cpu_for_node(core);    //（1-1-1）从core中解析cpu节点
    if (cpu >= 0) {
        if (!leaf) {
            pr_err("%pOF: Core has both threads and CPU\n",
                   core);
            return -EINVAL;
        }

        cpu_topology[cpu].package_id = package_id;    //保存package id（cluster id）到cpu_topology结构体的数组
        cpu_topology[cpu].core_id = core_id;        //保存core id到cpu_topology结构体的数组; core id对应cpu号：0,1...7
    } else if (leaf) {
        pr_err("%pOF: Can't get CPU for leaf core\n", core);
        return -EINVAL;
    }

    return 0;
}

static int __init get_cpu_for_node(struct device_node *node)
{
    struct device_node *cpu_node;
    int cpu;

    cpu_node = of_parse_phandle(node, "cpu", 0);    //获取core节点中cpu节点信息
    if (!cpu_node)
        return -1;

    cpu = of_cpu_node_to_id(cpu_node);    //获取cpu节点对应的cpu core id：cpu-0,1...
    if (cpu >= 0)
        topology_parse_cpu_capacity(cpu_node, cpu);    //（1-1-1-1）解析每个cpu core的capacity
    else
        pr_crit("Unable to find CPU node for %pOF\n", cpu_node);

    of_node_put(cpu_node);
    return cpu;
}

bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu)
{
    static bool cap_parsing_failed;
    int ret;
    u32 cpu_capacity;

    if (cap_parsing_failed)
        return false;

    ret = of_property_read_u32(cpu_node, "capacity-dmips-mhz",    //解析cpu core算力，kernel4.19后配置该参数
                   &cpu_capacity);
    if (!ret) {
        if (!raw_capacity) {
            raw_capacity = kcalloc(num_possible_cpus(),        //为所有cpu raw_capacity变量都申请空间
                           sizeof(*raw_capacity),
                           GFP_KERNEL);
            if (!raw_capacity) {
                cap_parsing_failed = true;
                return false;
            }
        }
        capacity_scale = max(cpu_capacity, capacity_scale);    //记录最大cpu capacity值作为scale
        raw_capacity[cpu] = cpu_capacity;                    //raw capacity就是dts中dmips值
        pr_debug("cpu_capacity: %pOF cpu_capacity=%u (raw)\n",
            cpu_node, raw_capacity[cpu]);
    } else {
        if (raw_capacity) {
            pr_err("cpu_capacity: missing %pOF raw capacity\n",
                cpu_node);
            pr_err("cpu_capacity: partial information: fallback to 1024 for all CPUs\n");
        }
        cap_parsing_failed = true;
        free_raw_capacity();
    }

    return !ret;
}

void topology_normalize_cpu_scale(void)
{
    u64 capacity;
    int cpu;

    if (!raw_capacity)
        return;

    pr_debug("cpu_capacity: capacity_scale=%u\n", capacity_scale);
    for_each_possible_cpu(cpu) {
        pr_debug("cpu_capacity: cpu=%d raw_capacity=%u\n",
             cpu, raw_capacity[cpu]);
        capacity = (raw_capacity[cpu] << SCHED_CAPACITY_SHIFT)        //就是按照max cpu capacity的100% = 1024的方式归一化capacity
            / capacity_scale;
        topology_set_cpu_scale(cpu, capacity);                    //更新per_cpu变量cpu_scale(cpu_capacity_orig)为各自的cpu raw capacity
        pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
            cpu, topology_get_cpu_scale(cpu));
    }
}

kernel_init
    -> kernel_init_freeable
        -> smp_prepare_cpus
            -> store_cpu_topology

secondary_start_kernel
    -> store_cpu_topology

void store_cpu_topology(unsigned int cpuid)
{
    struct cpu_topology *cpuid_topo = &cpu_topology[cpuid];
    u64 mpidr;

    if (cpuid_topo->package_id != -1)　　//这里因为已经解析过package_id了，所以直接就不会走读协处理器寄存器等相关步骤了
        goto topology_populated;

    mpidr = read_cpuid_mpidr();

    /* Uniprocessor systems can rely on default topology values */
    if (mpidr & MPIDR_UP_BITMASK)
        return;

    /*
     * This would be the place to create cpu topology based on MPIDR.
     *
     * However, it cannot be trusted to depict the actual topology; some
     * pieces of the architecture enforce an artificial cap on Aff0 values
     * (e.g. GICv3's ICC_SGI1R_EL1 limits it to 15), leading to an
     * artificial cycling of Aff1, Aff2 and Aff3 values. IOW, these end up
     * having absolutely no relationship to the actual underlying system
     * topology, and cannot be reasonably used as core / package ID.
     *
     * If the MT bit is set, Aff0 *could* be used to define a thread ID, but
     * we still wouldn't be able to obtain a sane core ID. This means we
     * need to entirely ignore MPIDR for any topology deduction.
     */
    cpuid_topo->thread_id  = -1;
    cpuid_topo->core_id    = cpuid;
    cpuid_topo->package_id = cpu_to_node(cpuid);

    pr_debug("CPU%u: cluster %d core %d thread %d mpidr %#016llx\n",
         cpuid, cpuid_topo->package_id, cpuid_topo->core_id,
         cpuid_topo->thread_id, mpidr);

topology_populated:
    update_siblings_masks(cpuid);    //（1）更新当前cpu的sibling_mask
}

void update_siblings_masks(unsigned int cpuid)
{
    struct cpu_topology *cpu_topo, *cpuid_topo = &cpu_topology[cpuid];
    int cpu;

    /* update core and thread sibling masks */
    for_each_online_cpu(cpu) {
        cpu_topo = &cpu_topology[cpu];

        if (cpuid_topo->llc_id == cpu_topo->llc_id) {        //当前平台不支持acpi，所以所有cpu的llc_id都是-1。这里都会满足
            cpumask_set_cpu(cpu, &cpuid_topo->llc_sibling);
            cpumask_set_cpu(cpuid, &cpu_topo->llc_sibling);
        }

        if (cpuid_topo->package_id != cpu_topo->package_id)    //只有当在同一个cluster内时，才可能成为core_sibling/thread_sibling（当前平台不支持线程sibling）
            continue;

        cpumask_set_cpu(cpuid, &cpu_topo->core_sibling);    //互相设置各自cpu topo结构体的core_sibling mask中添加对方的cpu bit
        cpumask_set_cpu(cpu, &cpuid_topo->core_sibling);

        if (cpuid_topo->core_id != cpu_topo->core_id)    //只有在同一个core内时，才有可能成为thread_sibling
            continue;

        cpumask_set_cpu(cpuid, &cpu_topo->thread_sibling);    //互相设置thread_sibling mask中的thread bit
        cpumask_set_cpu(cpu, &cpuid_topo->thread_sibling);
    }
}

TECNO-KF6p:/sys/devices/system/cpu/cpu0/topology # ls
core_id  core_siblings  core_siblings_list  physical_package_id  thread_siblings  thread_siblings_list

TECNO-KF6p:/sys/devices/system/cpu/cpu0/topology # cat core_id
0
TECNO-KF6p:/sys/devices/system/cpu/cpu0/topology # cat core_siblings
0f
TECNO-KF6p:/sys/devices/system/cpu/cpu0/topology # cat core_siblings_list
0-3
TECNO-KF6p:/sys/devices/system/cpu/cpu0/topology # cat physical_package_id
0
TECNO-KF6p:/sys/devices/system/cpu/cpu0/topology # cat thread_siblings
01
TECNO-KF6p:/sys/devices/system/cpu/cpu0/topology # cat thread_siblings_list
0

TECNO-KF6p:/sys/devices/system/cpu/cpu1/topology # cat *
1
0f
0-3
0
02　　//thread_siblings
1　　 //thread_siblings_list

TECNO-KF6p:/sys/devices/system/cpu/cpu7/topology # cat *
3　　 //core_id(cpu4-7的core id分别为0,1,2,3。相当于另一个cluster内重新开始计数)
f0　　//core_siblings
4-7　 //core_siblings_list（兄弟姐妹core列表）
1　　 //physical_package_id（就是cluster id）
80　　//thread_siblings
7　　 //thread_siblings_list

 *     cpu_possible_mask- has bit 'cpu' set iff cpu is populatable //系统所有cpu
 *     cpu_present_mask - has bit 'cpu' set iff cpu is populated //存在的所有cpu，根据hotplug变化， <= possible
 *     cpu_online_mask  - has bit 'cpu' set iff cpu available to scheduler //处于online的cpu，即active cpu + idle cpu
 *     cpu_active_mask  - has bit 'cpu' set iff cpu available to migration //处于active的cpu，区别与idle cpu
 *     cpu_isolated_mask- has bit 'cpu' set iff cpu isolated //处于isolate的cpu，隔离的cpu不会被分配task运行，但是没有下电
 *
1、如果没有CONFIG_HOTPLUG_CPU，那么 present == possible， active == online。
2、配置了cpu hotplug的情况下，present会根据hotplug状态，动态变化。

kernel_init()
    -> kernel_init_freeable()
        -> sched_init_smp()
            -> sched_init_domains()

/* Current sched domains: */
static cpumask_var_t            *doms_cur;

/* Number of sched domains in 'doms_cur': */
static int                ndoms_cur;

/*
 * 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();        //（1）填充cpu_core_map数组
    ndoms_cur = 1;                    //记录调度域数量的变量，当前初始化为1
    doms_cur = alloc_sched_domains(ndoms_cur);    //alloc调度域相关结构体内存空间
    if (!doms_cur)
        doms_cur = &fallback_doms;
    cpumask_and(doms_cur[0], cpu_map, housekeeping_cpumask(HK_FLAG_DOMAIN));    //这里会从cpu_map中挑选没有isolate的cpu，初始化时没有isolate cpu？
    err = build_sched_domains(doms_cur[0], NULL);    //（2）根据提供的一组cpu，建立调度域
    register_sched_domain_sysctl(); //（3）注册proc/sys/kernel/sched_domain目录，并完善其中相关sysctl控制参数

    return err;
}

int arch_update_cpu_topology(void)
{
    unsigned int cpu;

    for_each_possible_cpu(cpu)        //遍历每个cpu
        cpu_core_map[cpu] = cpu_coregroup_map(cpu);    //利用cpu_possiable_mask，也就是物理上所有的cpu core

    return 0;
}

/*
 * 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;
    int i, ret = -ENOMEM;
    struct sched_domain_topology_level *tl_asym;
    bool has_asym = false;

    if (WARN_ON(cpumask_empty(cpu_map)))    //过滤cpu_map为空的情况
        goto error;

    alloc_state = __visit_domain_allocation_hell(&d, cpu_map);    //（2-1）建立MC、DIE的拓扑结构；初始化root domain
    if (alloc_state != sa_rootdomain)
        goto error;

    tl_asym = asym_cpu_capacity_level(cpu_map);        //（2-2）获取包含max cpu capacity的最浅level：DIE level

    /* Set up domains for CPUs specified by the cpu_map: */  //根据cpu map建立调度域
    for_each_cpu(i, cpu_map) {                        //遍历每个cpu map中的cpu：0-7
        struct sched_domain_topology_level *tl;

        sd = NULL;
        for_each_sd_topology(tl) {                //遍历MC、DIE level
            int dflags = 0;

            if (tl == tl_asym) {                //DIE level会带有：SD_ASYM_CPUCAPACITY flag，并设has_asym = true
                dflags |= SD_ASYM_CPUCAPACITY;
                has_asym = true;
            }

            if (WARN_ON(!topology_span_sane(tl, cpu_map, i)))
                goto error;

            sd = build_sched_domain(tl, cpu_map, attr, sd, dflags, i); //（2-3）建立MC、DIE level的调度域

            if (tl == sched_domain_topology)    //将最低层级的sd保存到s_data.sd的per_cpu变量中，当前平台为MC level的sd
                *per_cpu_ptr(d.sd, i) = sd;
            if (tl->flags & SDTL_OVERLAP)        //判断是否sd有重叠，当前平台没有重叠
                sd->flags |= SD_OVERLAP;
            if (cpumask_equal(cpu_map, sched_domain_span(sd)))    //判断cpu map和当前sd->span是否一致，一致则表示当前cpu_map中的所有cpu都在这个sd->span内。就会停止下一层tl的sd建立，可能用当前这一层的sd就已经足够了？
                break;
        }
    }

    /* Build the groups for the domains */
    for_each_cpu(i, cpu_map) {                        //遍历cpu_map中每个cpu
        for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {            //从cpu的最低层级sd开始向上遍历，当前平台遍历顺序是：MC->DIE
            sd->span_weight = cpumask_weight(sched_domain_span(sd));    //获取当前sd范围内的cpu数量
            if (sd->flags & SD_OVERLAP) {                //根据是否有重叠的sd，建立调度组sg（NUMA架构才会有这个flag）
                if (build_overlap_sched_groups(sd, i))    //重叠sd情况下，建立sg（非当前平台，暂不展开）
                    goto error;
            } else {
                if (build_sched_groups(sd, i))            //（2-4）因为当前平台没有重叠sd，所以走这里建立调度组sg
                    goto error;
            }
        }
    }

    /* Calculate CPU capacity for physical packages and nodes */
    for (i = nr_cpumask_bits-1; i >= 0; i--) {                //遍历所有cpu，当前平台遍历顺序是cpu7,6...0
        if (!cpumask_test_cpu(i, cpu_map))            //如果cpu不在cpu map中，应该是hotplug的情况
            continue;

        for (sd = *per_cpu_ptr(d.sd, i); sd; sd = sd->parent) {    //依次遍历MC level和DIE level
            claim_allocations(i, sd);                //(2-5)将用于建立sd、sg的per_cpu指针（sdd），防止随后的__free_domain_allocs()将其free
            init_sched_groups_capacity(i, sd);        //(2-6)初始化sg的cpu_capacity
        }
    }

    /* Attach the domains */
    rcu_read_lock();
    for_each_cpu(i, cpu_map) {                    //遍历cpu map中所有cpu
#ifdef CONFIG_SCHED_WALT
        int max_cpu = READ_ONCE(d.rd->wrd.max_cap_orig_cpu);    //获取walt_root_domain中保存最大orig_capacity cpu的变量
        int min_cpu = READ_ONCE(d.rd->wrd.min_cap_orig_cpu);    //获取walt_root_domain中保存最小orig_capacity cpu的变量
#endif

        sd = *per_cpu_ptr(d.sd, i);                //最低层级的sd在上面的流程中被保存到per_cpu变量中，当前平台为MC level

#ifdef CONFIG_SCHED_WALT                                    //通过遍历循环，找除最大和最小orig_capacity的cpu
        if ((max_cpu < 0) || (arch_scale_cpu_capacity(i) >
                arch_scale_cpu_capacity(max_cpu)))
            WRITE_ONCE(d.rd->wrd.max_cap_orig_cpu, i);

        if ((min_cpu < 0) || (arch_scale_cpu_capacity(i) <
                arch_scale_cpu_capacity(min_cpu)))
            WRITE_ONCE(d.rd->wrd.min_cap_orig_cpu, i);
#endif

        cpu_attach_domain(sd, d.rd, i);        //(2-7)将sd、rd与cpu rq绑定起来
    }

#ifdef CONFIG_SCHED_WALT
    /* set the mid capacity cpu (assumes only 3 capacities) */
    for_each_cpu(i, cpu_map) {
        int max_cpu = READ_ONCE(d.rd->wrd.max_cap_orig_cpu);        //获取拥有最大orig cpu capacity的第一个cpu
        int min_cpu = READ_ONCE(d.rd->wrd.min_cap_orig_cpu);        //获取拥有最小orig cpu capacity的第一个cpu

        if ((arch_scale_cpu_capacity(i)                                //找到orig cpu capacity在最大和最小之间的cpu
                != arch_scale_cpu_capacity(min_cpu)) &&
                (arch_scale_cpu_capacity(i)
                != arch_scale_cpu_capacity(max_cpu))) {
            WRITE_ONCE(d.rd->wrd.mid_cap_orig_cpu, i);                //当前平台只有2个值orig cpu capacity，所以这里找不到mid值的cpu
            break;
        }
    }

    /*
     * The max_cpu_capacity reflect the original capacity which does not
     * change dynamically. So update the max cap CPU and its capacity
     * here.
     */
    if (d.rd->wrd.max_cap_orig_cpu != -1) {
        d.rd->max_cpu_capacity.cpu = d.rd->wrd.max_cap_orig_cpu;    //更新rd中的拥有最大orig cpu capacity的cpu（注意变量与max_cap_orig_cpu不同）
        d.rd->max_cpu_capacity.val = arch_scale_cpu_capacity(        //并更新该cpu的orig cpu capacity值
                        d.rd->wrd.max_cap_orig_cpu);
    }
#endif

    rcu_read_unlock();

    if (has_asym)                                                    //当前平台为大小核架构，所以为true
        static_branch_inc_cpuslocked(&sched_asym_cpucapacity);        //针对sched_asym_cpucapacity的变量判断分支做更改（static key机制用来优化指令预取，类似likely/unlikely）

    ret = 0;
error:
    __free_domain_allocs(&d, alloc_state, cpu_map);        //(2-8)根据函数最上面建立拓扑、以及申请root domain结果，释放相应的空间

    return ret;
}

static enum s_alloc
__visit_domain_allocation_hell(struct s_data *d, const struct cpumask *cpu_map)
{
    memset(d, 0, sizeof(*d));

    if (__sdt_alloc(cpu_map))    //（2-1-1）初始化MC、DIE的拓扑结构
        return sa_sd_storage;
    d->sd = alloc_percpu(struct sched_domain *);    //申请d->sd空间
    if (!d->sd)
        return sa_sd_storage;
    d->rd = alloc_rootdomain();    //（2-1-2）申请root domain并初始化
    if (!d->rd)
        return sa_sd;

    return sa_rootdomain;
}

/*
 * Topology list, bottom-up.
 */
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, },
};

static int __sdt_alloc(const struct cpumask *cpu_map)
{
    struct sched_domain_topology_level *tl;
    int j;

    for_each_sd_topology(tl) {            //依次遍历MC、DIE结构
        struct sd_data *sdd = &tl->data;        //如下是为MC、DIE level的percpu变量sd_data，申请空间

        sdd->sd = alloc_percpu(struct sched_domain *);        //sched_domain
        if (!sdd->sd)
            return -ENOMEM;

        sdd->sds = alloc_percpu(struct sched_domain_shared *);    //sched_domain_shared
        if (!sdd->sds)
            return -ENOMEM;

        sdd->sg = alloc_percpu(struct sched_group *);        //sched_group
        if (!sdd->sg)
            return -ENOMEM;

        sdd->sgc = alloc_percpu(struct sched_group_capacity *);    //sched_group_capacity
        if (!sdd->sgc)
            return -ENOMEM;

        for_each_cpu(j, cpu_map) {            //遍历了cpu_map中所有cpu，当前平台为8核：cpu0-7
            struct sched_domain *sd;
            struct sched_domain_shared *sds;
            struct sched_group *sg;
            struct sched_group_capacity *sgc;

            sd = kzalloc_node(sizeof(struct sched_domain) + cpumask_size(),    //申请sd + cpumask的空间
                    GFP_KERNEL, cpu_to_node(j));    //cpu_to_node应该是选择cpu所在本地的内存node，UMA架构仅有一个node
            if (!sd)
                return -ENOMEM;

            *per_cpu_ptr(sdd->sd, j) = sd;    //将cpu[j]的调度域sd绑定到sdd->sd上

            sds = kzalloc_node(sizeof(struct sched_domain_shared),    //类似申请sds空间，并绑定到sdd->sds
                    GFP_KERNEL, cpu_to_node(j));
            if (!sds)
                return -ENOMEM;

            *per_cpu_ptr(sdd->sds, j) = sds;

            sg = kzalloc_node(sizeof(struct sched_group) + cpumask_size(), //类似申请sg + cpumask空间，并绑定到sdd->sg
                    GFP_KERNEL, cpu_to_node(j));
            if (!sg)
                return -ENOMEM;

            sg->next = sg;    //初始化时，sg的链表并未真正建立

            *per_cpu_ptr(sdd->sg, j) = sg;

            sgc = kzalloc_node(sizeof(struct sched_group_capacity) + cpumask_size(),//类似申请sgc + cpumask空间，并绑定到sdd->sgc
                    GFP_KERNEL, cpu_to_node(j));
            if (!sgc)
                return -ENOMEM;

#ifdef CONFIG_SCHED_DEBUG
            sgc->id = j;    //将cpu编号绑定到sgc->id
#endif

            *per_cpu_ptr(sdd->sgc, j) = sgc;
        }
    }

    return 0;
}

static struct root_domain *alloc_rootdomain(void)
{
    struct root_domain *rd;

    rd = kzalloc(sizeof(*rd), GFP_KERNEL);
    if (!rd)
        return NULL;

    if (init_rootdomain(rd) != 0) {    //（2-1-2-1）初始化root domain
        kfree(rd);
        return NULL;
    }

    return rd;
}

static int init_rootdomain(struct root_domain *rd)
{
    if (!zalloc_cpumask_var(&rd->span, GFP_KERNEL))        //申请4个cpu mask的空间
        goto out;
    if (!zalloc_cpumask_var(&rd->online, GFP_KERNEL))
        goto free_span;
    if (!zalloc_cpumask_var(&rd->dlo_mask, GFP_KERNEL))
        goto free_online;
    if (!zalloc_cpumask_var(&rd->rto_mask, GFP_KERNEL))
        goto free_dlo_mask;

#ifdef HAVE_RT_PUSH_IPI
    rd->rto_cpu = -1;                            //初始化rto相关参数和队列，针对IPI pull的请求，在rto_mask中loop，暂时没理解？
    raw_spin_lock_init(&rd->rto_lock);
    init_irq_work(&rd->rto_push_work, rto_push_irq_work_func);
#endif

    init_dl_bw(&rd->dl_bw);                //初始化deadline bandwidth
    if (cpudl_init(&rd->cpudl) != 0)    //初始化cpudl结构体
        goto free_rto_mask;

    if (cpupri_init(&rd->cpupri) != 0)    //初始化cpupri结构体
        goto free_cpudl;

#ifdef CONFIG_SCHED_WALT
    rd->wrd.max_cap_orig_cpu = rd->wrd.min_cap_orig_cpu = -1;    //初始化walt_root_domain
    rd->wrd.mid_cap_orig_cpu = -1;
#endif

    init_max_cpu_capacity(&rd->max_cpu_capacity);    //初始化max_cpu_capacity ->val=0、->cpu=-1

    return 0;

free_cpudl:
    cpudl_cleanup(&rd->cpudl);
free_rto_mask:
    free_cpumask_var(rd->rto_mask);
free_dlo_mask:
    free_cpumask_var(rd->dlo_mask);
free_online:
    free_cpumask_var(rd->online);
free_span:
    free_cpumask_var(rd->span);
out:
    return -ENOMEM;
}

/*
 * Find the sched_domain_topology_level where all CPU capacities are visible
 * for all CPUs.
 */
static struct sched_domain_topology_level
*asym_cpu_capacity_level(const struct cpumask *cpu_map)
{
    int i, j, asym_level = 0;
    bool asym = false;
    struct sched_domain_topology_level *tl, *asym_tl = NULL;
    unsigned long cap;

    /* Is there any asymmetry? */
    cap = arch_scale_cpu_capacity(cpumask_first(cpu_map));    //获取cpu_map中第一个cpu，cpu0的capacity

    for_each_cpu(i, cpu_map) {                        //判断是否有不同capacity的cpu，决定是否是大小核架构
        if (arch_scale_cpu_capacity(i) != cap) {    //当前平台是大小核有不同capacity
            asym = true;
            break;
        }
    }

    if (!asym)
        return NULL;

    /*
     * Examine topology from all CPU's point of views to detect the lowest
     * sched_domain_topology_level where a highest capacity CPU is visible
     * to everyone.
     */
    for_each_cpu(i, cpu_map) {                //遍历cpu map中的每个cpu，cpu 0-7
        unsigned long max_capacity = arch_scale_cpu_capacity(i);
        int tl_id = 0;

        for_each_sd_topology(tl) {            //依次遍历MC、DIE level
            if (tl_id < asym_level)
                goto next_level;

            for_each_cpu_and(j, tl->mask(i), cpu_map) {        //(2-2-1)在MC level时分别遍历cpu0-3、cpu4-7；DIE level时遍历cpu0-7
                unsigned long capacity;

                capacity = arch_scale_cpu_capacity(j);        //获取cpu_capacity_orig

                if (capacity <= max_capacity)
                    continue;

                max_capacity = capacity;    //在所有cpu中找到最大的cpu capacity
                asym_level = tl_id;            //记录level id：1
                asym_tl = tl;                //记录有不同cpu capacity的cpu topology level: DIE
            }
next_level:
            tl_id++;
        }
    }

    return asym_tl;
}

const struct cpumask *cpu_coregroup_mask(int cpu)
{
    const cpumask_t *core_mask = cpumask_of_node(cpu_to_node(cpu));

    /* Find the smaller of NUMA, core or LLC siblings */
    if (cpumask_subset(&cpu_topology[cpu].core_sibling, core_mask)) {
        /* not numa in package, lets use the package siblings */
        core_mask = &cpu_topology[cpu].core_sibling;
    }
    if (cpu_topology[cpu].llc_id != -1) {
        if (cpumask_subset(&cpu_topology[cpu].llc_sibling, core_mask))
            core_mask = &cpu_topology[cpu].llc_sibling;
    }

    return core_mask;
}

static inline const struct cpumask *cpu_cpu_mask(int cpu)
{
    return cpumask_of_node(cpu_to_node(cpu));
}

/* Returns a pointer to the cpumask of CPUs on Node 'node'. */
static inline const struct cpumask *cpumask_of_node(int node)
{
    if (node == NUMA_NO_NODE)　　//当前平台是UMA架构，非NUMA结构，所以只有一个node
        return cpu_all_mask;

    return node_to_cpumask_map[node];
}

static struct sched_domain *build_sched_domain(struct sched_domain_topology_level *tl,
        const struct cpumask *cpu_map, struct sched_domain_attr *attr,
        struct sched_domain *child, int dflags, int cpu)
{
    struct sched_domain *sd = sd_init(tl, cpu_map, child, dflags, cpu); //(2-3-1)初始化sched_domain，填充sd结构体，根据tl level构建sd父子关系等

    if (child) {                                                        //MC level的child为NULL；所以下面只针对DIE level
        sd->level = child->level + 1;                                    //DIE level值为child level+1
        sched_domain_level_max = max(sched_domain_level_max, sd->level);//记录sd最大level
        child->parent = sd;                                                //将MC level sd的parent设置为DIE level的sd

        if (!cpumask_subset(sched_domain_span(child),
                    sched_domain_span(sd))) {
            pr_err("BUG: arch topology borken\n");
#ifdef CONFIG_SCHED_DEBUG
            pr_err("     the %s domain not a subset of the %s domain\n",
                    child->name, sd->name);
#endif
            /* Fixup, ensure @sd has at least @child CPUs. */
            cpumask_or(sched_domain_span(sd),
                   sched_domain_span(sd),
                   sched_domain_span(child));
        }

    }
    set_domain_attribute(sd, attr);　　//（2-3-2）这里attr为NULL，打开idle balance

    return sd;
}

static struct sched_domain *
sd_init(struct sched_domain_topology_level *tl,
    const struct cpumask *cpu_map,
    struct sched_domain *child, int dflags, int cpu)
{
    struct sd_data *sdd = &tl->data;
    struct sched_domain *sd = *per_cpu_ptr(sdd->sd, cpu);    //获取当前cpu的sd结构体
    int sd_id, sd_weight, sd_flags = 0;

#ifdef CONFIG_NUMA
    /*
     * Ugly hack to pass state to sd_numa_mask()...
     */
    sched_domains_curr_level = tl->numa_level;
#endif

    sd_weight = cpumask_weight(tl->mask(cpu));        //获取MC/DIE level下的sd_weight（就是topology level下的cpu个数，当前平台：MC为4，DIE为8）

    if (tl->sd_flags)                                //只有MC level有配置
        sd_flags = (*tl->sd_flags)();                // MC level的sd_flags：SD_SHARE_PKG_RESOURCES；DIE level则没有
    if (WARN_ONCE(sd_flags & ~TOPOLOGY_SD_FLAGS,            //仅仅是判断下是否有相关bit位是否越界
            "wrong sd_flags in topology description\n"))
        sd_flags &= TOPOLOGY_SD_FLAGS;                        //然后越界的话，清零下

    /* Apply detected topology flags */
    sd_flags |= dflags;                        //DIE level会传入 SD_ASYM_CPUCAPACITY flag

    *sd = (struct sched_domain){            //初始化sd结构体
        .min_interval        = sd_weight,    //MC：4，DIE：8
        .max_interval        = 2*sd_weight,    //MC：8，DIE：16
        .busy_factor        = 32,            
        .imbalance_pct        = 125,            //用于load balance

        .cache_nice_tries    = 0,

        .flags            = 1*SD_LOAD_BALANCE
                    | 1*SD_BALANCE_NEWIDLE
                    | 1*SD_BALANCE_EXEC
                    | 1*SD_BALANCE_FORK
                    | 0*SD_BALANCE_WAKE
                    | 1*SD_WAKE_AFFINE
                    | 0*SD_SHARE_CPUCAPACITY
                    | 0*SD_SHARE_PKG_RESOURCES
                    | 0*SD_SERIALIZE
                    | 1*SD_PREFER_SIBLING
                    | 0*SD_NUMA
                    | sd_flags                //MC:SD_SHARE_PKG_RESOURCES，DIE：SD_ASYM_CPUCAPACITY
                    ,

        .last_balance        = jiffies,        //初始化load balance的时间戳
        .balance_interval    = sd_weight,    //load balance的间隔，MC：4，DIE：8
        .max_newidle_lb_cost    = 0,        //newidle load balance的cost
        .next_decay_max_lb_cost    = jiffies,    //idle balance中用到，暂时还不清楚什么cost
        .child            = child,            //MC level：sd的child为NULL；而DIE level：sd的child是MC level的sd
#ifdef CONFIG_SCHED_DEBUG
        .name            = tl->name,
#endif
    };

    cpumask_and(sched_domain_span(sd), cpu_map, tl->mask(cpu));        //将对应tl mask（MC:core_siblings, DIE:所有物理cpu），与cpu map进行“位与”，作为sd的范围
    sd_id = cpumask_first(sched_domain_span(sd));            //拿取sd范围内的第一个cpu，作为sd_id

    /*
     * Convert topological properties into behaviour.
     */

    /* Don't attempt to spread across CPUs of different capacities. */
    if ((sd->flags & SD_ASYM_CPUCAPACITY) && sd->child)        //当前平台只有DIE level满足条件
        sd->child->flags &= ~SD_PREFER_SIBLING;                //所以DIE level的child，就是MC level的sd，其flags会去掉清掉SD_PREFER_SIBLING
                                                            //所以，DIE sd的flag有SD_PREFER_SIBLING;而MC sd没有此flag
    if (sd->flags & SD_SHARE_CPUCAPACITY) {                //这个flag应该是超线程sd支持的flag
        sd->imbalance_pct = 110;

    } else if (sd->flags & SD_SHARE_PKG_RESOURCES) {    //从上面*tl->sd_flags()调用了MC level函数：cpu_core_flags()，所有这个flag在MC level是为1的
        sd->imbalance_pct = 117;                        //修改MC level的sd不平衡百分比
        sd->cache_nice_tries = 1;                        //修改MC level的cache_nice_tries = 2，暂时不清楚变量用途？

#ifdef CONFIG_NUMA                                    //当前平台不支持NUMA（平台为UMA架构）
    } else if (sd->flags & SD_NUMA) {
        sd->cache_nice_tries = 2;

        sd->flags &= ~SD_PREFER_SIBLING;
        sd->flags |= SD_SERIALIZE;
        if (sched_domains_numa_distance[tl->numa_level] > node_reclaim_distance) {
            sd->flags &= ~(SD_BALANCE_EXEC |
                       SD_BALANCE_FORK |
                       SD_WAKE_AFFINE);
        }

#endif
    } else {                                //DIE level的cache_nice_tries = 1
        sd->cache_nice_tries = 1;
    }

    sd->shared = *per_cpu_ptr(sdd->sds, sd_id);         //MC level是每个cpu各自的sds；而DIE level：是cpu0、cpu4的sds
    atomic_inc(&sd->shared->ref);            //对sd->shared的引用计数+1

    if (sd->flags & SD_SHARE_PKG_RESOURCES)                    //MC leve满足
        atomic_set(&sd->shared->nr_busy_cpus, sd_weight);    //设置sd->shared->nr_busy_cpus = 4

    sd->private = sdd;            //sd->private指向&tl->data，MC/DIE level的cpu sd都指向对应level的tl->data的结构

    return sd;
}

static void set_domain_attribute(struct sched_domain *sd,
                 struct sched_domain_attr *attr)
{
    int request;

    if (!attr || attr->relax_domain_level < 0) {
        if (default_relax_domain_level < 0)
            return;
        else
            request = default_relax_domain_level;
    } else
        request = attr->relax_domain_level;
    if (request < sd->level) {
        /* Turn off idle balance on this domain: */
        sd->flags &= ~(SD_BALANCE_WAKE|SD_BALANCE_NEWIDLE);
    } else {
        /* Turn on idle balance on this domain: */
        sd->flags |= (SD_BALANCE_WAKE|SD_BALANCE_NEWIDLE);
    }
}

/*
 * build_sched_groups will build a circular linked list of the groups
 * covered by the given span, will set each group's ->cpumask correctly,
 * and will initialize their ->sgc.
 *
 * Assumes the sched_domain tree is fully constructed
 */
static int
build_sched_groups(struct sched_domain *sd, int cpu)
{
    struct sched_group *first = NULL, *last = NULL;
    struct sd_data *sdd = sd->private;
    const struct cpumask *span = sched_domain_span(sd);        //获取当前sd的范围，MC是core_siblings，DIE是所有物理cpu
    struct cpumask *covered;
    int i;

    lockdep_assert_held(&sched_domains_mutex);
    covered = sched_domains_tmpmask;

    cpumask_clear(covered);                //每次外面大循环新的sd或者cpu，就会清空covered mask

    for_each_cpu_wrap(i, span, cpu) {    //从当前cpu开始遍历整个sd span
        struct sched_group *sg;

        if (cpumask_test_cpu(i, covered))    //已经在covered mask中的cpu，不需要再进行下面工作
            continue;

        sg = get_group(i, sdd);            //（2-4-1）初始化cpu i的调度组sg

        cpumask_or(covered, covered, sched_group_span(sg));     //将covered = covered | sg的span

        if (!first)                //每个cpu、每个level进来记录第一个sg
            first = sg;
        if (last)
            last->next = sg;    //每个sg的next都指向下一个sg
        last = sg;
    }
    last->next = first;        //将所有sg->next形成环形链表
    sd->groups = first;        //sd->groups只指向第一个sg

    return 0;
}

/*
 * Package topology (also see the load-balance blurb in fair.c)
 *
 * The scheduler builds a tree structure to represent a number of important
 * topology features. By default (default_topology[]) these include:
 *
 *  - Simultaneous multithreading (SMT)
 *  - Multi-Core Cache (MC)
 *  - Package (DIE)
 *
 * Where the last one more or less denotes everything up to a NUMA node.
 *
 * The tree consists of 3 primary data structures:
 *
 *    sched_domain -> sched_group -> sched_group_capacity
 *        ^ ^             ^ ^
 *          `-'             `-'
 *
 * The sched_domains are per-CPU and have a two way link (parent & child) and
 * denote the ever growing mask of CPUs belonging to that level of topology.
 *
 * Each sched_domain has a circular (double) linked list of sched_group's, each
 * denoting the domains of the level below (or individual CPUs in case of the
 * first domain level). The sched_group linked by a sched_domain includes the
 * CPU of that sched_domain [*].
 *
 * Take for instance a 2 threaded, 2 core, 2 cache cluster part:
 *
 * CPU   0   1   2   3   4   5   6   7
 *
 * DIE  [                             ]
 * MC   [             ] [             ]
 * SMT  [     ] [     ] [     ] [     ]
 *
 *  - or -
 *
 * DIE  0-7 0-7 0-7 0-7 0-7 0-7 0-7 0-7
 * MC    0-3 0-3 0-3 0-3 4-7 4-7 4-7 4-7
 * SMT  0-1 0-1 2-3 2-3 4-5 4-5 6-7 6-7
 *
 * CPU   0   1   2   3   4   5   6   7
 *
 * One way to think about it is: sched_domain moves you up and down among these
 * topology levels, while sched_group moves you sideways through it, at child
 * domain granularity.
 *
 * sched_group_capacity ensures each unique sched_group has shared storage.
 *
 * There are two related construction problems, both require a CPU that
 * uniquely identify each group (for a given domain):
 *
 *  - The first is the balance_cpu (see should_we_balance() and the
 *    load-balance blub in fair.c); for each group we only want 1 CPU to
 *    continue balancing at a higher domain.
 *
 *  - The second is the sched_group_capacity; we want all identical groups
 *    to share a single sched_group_capacity.
 *
 * Since these topologies are exclusive by construction. That is, its
 * impossible for an SMT thread to belong to multiple cores, and cores to
 * be part of multiple caches. There is a very clear and unique location
 * for each CPU in the hierarchy.
 *
 * Therefore computing a unique CPU for each group is trivial (the iteration
 * mask is redundant and set all 1s; all CPUs in a group will end up at _that_
 * group), we can simply pick the first CPU in each group.
 *
 *
 * [*] in other words, the first group of each domain is its child domain.
 */

static struct sched_group *get_group(int cpu, struct sd_data *sdd)
{
    struct sched_domain *sd = *per_cpu_ptr(sdd->sd, cpu);
    struct sched_domain *child = sd->child;
    struct sched_group *sg;
    bool already_visited;

    if (child)                    //child sd存在，说明当前是DIE level的sd
        cpu = cpumask_first(sched_domain_span(child));    //那么取出MC level中child sd的第一个cpu；DIE level时，下面用的sg都是每个cluster的第一个cpu的sg

    sg = *per_cpu_ptr(sdd->sg, cpu);　　　　　　//绑定sd和sg
    sg->sgc = *per_cpu_ptr(sdd->sgc, cpu);    //绑定sg和sgc

    /* Increase refcounts for claim_allocations: */                //计算sg的引用计数
    already_visited = atomic_inc_return(&sg->ref) > 1;
    /* sgc visits should follow a similar trend as sg */
    WARN_ON(already_visited != (atomic_inc_return(&sg->sgc->ref) > 1));

    /* If we have already visited that group, it's already initialized. */    //过滤已经初始化过的sg：在DIE level时，build_sched_groups函数遍历所有物理cpu，但是当前函数仅初始化child sd中的第一个cpu。所以当遍历cpu0/4，会实际执行下去，而cpu1-3/cpu5-7时，就会在这里过滤
    if (already_visited)
        return sg;

    if (child) {                                                        //如果是DIE level
        cpumask_copy(sched_group_span(sg), sched_domain_span(child));    //sg的范围（sg->cpumask）是child sd的范围
        cpumask_copy(group_balance_mask(sg), sched_group_span(sg));        //sg->sgc->cpumask也是child sd的范围
    } else {                                                        //如果是MC level
        cpumask_set_cpu(cpu, sched_group_span(sg));                    //那么sg的范围（sg->cpumask）就是自己对应的单个cpu
        cpumask_set_cpu(cpu, group_balance_mask(sg));                //sg->sgc->cpumask也是自己对应的单个cpu
    }

    sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sched_group_span(sg));    //根据sg范围内有几个cpu，来简单计算总capacity
    sg->sgc->min_capacity = SCHED_CAPACITY_SCALE;    //初始化最小capacity
    sg->sgc->max_capacity = SCHED_CAPACITY_SCALE;    //初始化最大capacity

    return sg;
}

/*
 * NULL the sd_data elements we've used to build the sched_domain and
 * sched_group structure so that the subsequent __free_domain_allocs()
 * will not free the data we're using.
 */
static void claim_allocations(int cpu, struct sched_domain *sd)
{
    struct sd_data *sdd = sd->private;

    WARN_ON_ONCE(*per_cpu_ptr(sdd->sd, cpu) != sd);                //依次判断sd、sds、sg、sgc的per_cpu指针，并置为NULL
    *per_cpu_ptr(sdd->sd, cpu) = NULL;

    if (atomic_read(&(*per_cpu_ptr(sdd->sds, cpu))->ref))
        *per_cpu_ptr(sdd->sds, cpu) = NULL;

    if (atomic_read(&(*per_cpu_ptr(sdd->sg, cpu))->ref))
        *per_cpu_ptr(sdd->sg, cpu) = NULL;

    if (atomic_read(&(*per_cpu_ptr(sdd->sgc, cpu))->ref))
        *per_cpu_ptr(sdd->sgc, cpu) = NULL;
}

/*
 * Initialize sched groups cpu_capacity.
 *
 * cpu_capacity indicates the capacity of sched group, which is used while
 * distributing the load between different sched groups in a sched domain.
 * Typically cpu_capacity for all the groups in a sched domain will be same
 * unless there are asymmetries in the topology. If there are asymmetries,
 * group having more cpu_capacity will pickup more load compared to the
 * group having less cpu_capacity.
 */
void init_sched_groups_capacity(int cpu, struct sched_domain *sd)
{
    struct sched_group *sg = sd->groups;        //获取sd对应的sg
#ifdef CONFIG_SCHED_WALT
    cpumask_t avail_mask;
#endif

    WARN_ON(!sg);

    do {                                //do-while循环中，对sg环形链表中的所有sg的->group_weight进行初始化
        int cpu, max_cpu = -1;

#ifdef CONFIG_SCHED_WALT
        cpumask_andnot(&avail_mask, sched_group_span(sg),    //如果支持WALT，那么group_weight = sg的范围中去掉isolate cpu；MC level，sg范围是对应cpu；DIE level，sg范围是cluster的范围
                            cpu_isolated_mask);
        sg->group_weight = cpumask_weight(&avail_mask);
#else
        sg->group_weight = cpumask_weight(sched_group_span(sg));    //如果不支持WALT，那么group_weight = sg的范围；MC level，sg范围是对应cpu；DIE level，sg范围是cluster的范围
#endif

        if (!(sd->flags & SD_ASYM_PACKING))        //当前平台没有这个flag。这个flag应该表示支持非对称SMT调度
            goto next;

        for_each_cpu(cpu, sched_group_span(sg)) {
            if (max_cpu < 0)
                max_cpu = cpu;
            else if (sched_asym_prefer(cpu, max_cpu))
                max_cpu = cpu;
        }
        sg->asym_prefer_cpu = max_cpu;

next:
        sg = sg->next;
    } while (sg != sd->groups);

    if (cpu != group_balance_cpu(sg))        //仅对sg->sgc->cpumask中第一个cpu，进行下一步更新group capacity。MC level，cpumask为sg对应cpu；DIE level，cpumask为cluster中第一个cpu
        return;

    update_group_capacity(sd, cpu);            //(2-6-1)更新对应group的capacity
}

void update_group_capacity(struct sched_domain *sd, int cpu)
{
    struct sched_domain *child = sd->child;
    struct sched_group *group, *sdg = sd->groups;
    unsigned long capacity, min_capacity, max_capacity;
    unsigned long interval;

    interval = msecs_to_jiffies(sd->balance_interval);                //sgc的更新有间隔限制：1 ~ HZ/10
    interval = clamp(interval, 1UL, max_load_balance_interval);
    sdg->sgc->next_update = jiffies + interval;

    if (!child) {                        //如果是MC level的sd更新sgc，那么就只要更新cpu capacity，因为MC level的sg只有单个cpu在内
        update_cpu_capacity(sd, cpu);    //(2-6-1-1)更新cpu capacity
        return;
    }

    capacity = 0;
    min_capacity = ULONG_MAX;
    max_capacity = 0;

    if (child->flags & SD_OVERLAP) {            //这个是sd有重叠的情况，当前平台没有sd重叠
        /*
         * SD_OVERLAP domains cannot assume that child groups
         * span the current group.
         */

        for_each_cpu(cpu, sched_group_span(sdg)) {
            struct sched_group_capacity *sgc;
            struct rq *rq = cpu_rq(cpu);

            if (cpu_isolated(cpu))
                continue;

            /*
             * build_sched_domains() -> init_sched_groups_capacity()
             * gets here before we've attached the domains to the
             * runqueues.
             *
             * Use capacity_of(), which is set irrespective of domains
             * in update_cpu_capacity().
             *
             * This avoids capacity from being 0 and
             * causing divide-by-zero issues on boot.
             */
            if (unlikely(!rq->sd)) {
                capacity += capacity_of(cpu);
            } else {
                sgc = rq->sd->groups->sgc;
                capacity += sgc->capacity;
            }

            min_capacity = min(capacity, min_capacity);
            max_capacity = max(capacity, max_capacity);
        }
    } else  {
        /*
         * !SD_OVERLAP domains can assume that child groups        因为没有sd重叠，那么所有child sd的groups合在一起，就是当前的group
         * span the current group.
         */

        group = child->groups;
        do {                                                    //do-while遍历child sd的sg环形链表；当前平台为例，走到这里是DIE level，那么child sd就是MC level的groups
            struct sched_group_capacity *sgc = group->sgc;        //获取对应sgc
            __maybe_unused cpumask_t *cpus =
                    sched_group_span(group);                    //因为group是处于MC level，所以范围就是sg对应的cpu

            if (!cpu_isolated(cpumask_first(cpus))) {        //排除isolate状态的cpu
                capacity += sgc->capacity;                    //将每个sgc（cpu）的capacity累加起来
                min_capacity = min(sgc->min_capacity,        //保存最小的sgc->capacity
                            min_capacity);
                max_capacity = max(sgc->max_capacity,        //保存最大的sgc->capacity
                            max_capacity);
            }
            group = group->next;
        } while (group != child->groups);
    }

    sdg->sgc->capacity = capacity;                //将MC level中每个sgc->capacity累加起来，其总和作为DIE level中group capacity
    sdg->sgc->min_capacity = min_capacity;        //并保存最大、最小capacity
    sdg->sgc->max_capacity = max_capacity;
}

static void update_cpu_capacity(struct sched_domain *sd, int cpu)
{
    unsigned long capacity = arch_scale_cpu_capacity(cpu);    //获取per_cpu变量cpu_scale
    struct sched_group *sdg = sd->groups;

    capacity *= arch_scale_max_freq_capacity(sd, cpu);        //获取per_cpu变量max_freq_scale，参与计算
    capacity >>= SCHED_CAPACITY_SHIFT;                        //这2步计算为：cpu_scale * max_freq_scale / 1024

    capacity = min(capacity, thermal_cap(cpu));                //计算得出的capacity不能超过thermal限制中的cpu的capacity
    cpu_rq(cpu)->cpu_capacity_orig = capacity;                //将计算得出的capacity作为当前cpu rq的cpu_capacity_orig

    capacity = scale_rt_capacity(cpu, capacity);        //(2-6-1-1-1)计算cfs rq剩余的cpu capacity

    if (!capacity)            //如果没有剩余cpu capacity给cfs了，那么就强制写为1
        capacity = 1;

    cpu_rq(cpu)->cpu_capacity = capacity;        //更新相关sgc capacity：cpu rq的cpu_capacity、sgc的最大/最小的capacity
    sdg->sgc->capacity = capacity;
    sdg->sgc->min_capacity = capacity;
    sdg->sgc->max_capacity = capacity;
}

static unsigned long scale_rt_capacity(int cpu, unsigned long max)
{
    struct rq *rq = cpu_rq(cpu);
    unsigned long used, free;
    unsigned long irq;

    irq = cpu_util_irq(rq);            //获取cpu rq的avg_irq.util_avg

    if (unlikely(irq >= max))        //如果util_avg超过max，则说明util满了？
        return 1;

    used = READ_ONCE(rq->avg_rt.util_avg);        //获取rt task rq的util_avg
    used += READ_ONCE(rq->avg_dl.util_avg);        //获取并累加dl task rq的util_avg

    if (unlikely(used >= max))        //如果util_avg超过max，则说明util满了？
        return 1;

    free = max - used;        //计算free util = 最大capacity - rt的util_avg - dl的util_avg

    return scale_irq_capacity(free, irq, max);    //(max - rt的util_avg - dl的util_avg) * (max - irq) /max
}

/*
 * Attach the domain 'sd' to 'cpu' as its base domain. Callers must
 * hold the hotplug lock.
 */
static void
cpu_attach_domain(struct sched_domain *sd, struct root_domain *rd, int cpu)
{
    struct rq *rq = cpu_rq(cpu);
    struct sched_domain *tmp;

    /* Remove the sched domains which do not contribute to scheduling. */
    for (tmp = sd; tmp; ) {
        struct sched_domain *parent = tmp->parent;        //过滤没有parent sd的sd，即过滤DIE level sd
        if (!parent)
            break;

        if (sd_parent_degenerate(tmp, parent)) {    //(2-7-1)判断是否要对parent sd进行degenerate操作
            tmp->parent = parent->parent;            //首先断开parent' sd的链表关系
            if (parent->parent)                        //根据parent->parent是否存在，将parnet->parent的child链接到tmp sd
                parent->parent->child = tmp;
            /*
             * Transfer SD_PREFER_SIBLING down in case of a
             * degenerate parent; the spans match for this
             * so the property transfers.
             */
            if (parent->flags & SD_PREFER_SIBLING)    //因为当前平台只有DIE level有这个flag，又因为DIE level没有parent sd，所以在上面已经过滤了，这里的条件不会满足
                tmp->flags |= SD_PREFER_SIBLING;
            destroy_sched_domain(parent);            //(2-7-2)销毁'parent' sd
        } else                            //如果不需要degenerate操作
            tmp = tmp->parent;            //则直接更新tmp，准备遍历下一层level
    }

    if (sd && sd_degenerate(sd)) {        //判断sd是否需要进行degenerate
        tmp = sd;
        sd = sd->parent;
        destroy_sched_domain(tmp);        //销毁sd，同上
        if (sd)                            //如果被销毁的sd有parent sd，那么就将parent sd的->child置为NULL
            sd->child = NULL;
    }

    sched_domain_debug(sd, cpu);        //打印sd attach的debug信息

    rq_attach_root(rq, rd);            //(2-7-3) 将新的root doamin与cpu rq绑定在一起
    tmp = rq->sd;
    rcu_assign_pointer(rq->sd, sd);        //将新sd与rq->sd绑定起来
    dirty_sched_domain_sysctl(cpu);    //(2-7-4)更新sd_sysctl_cpus的cpu mask
    destroy_sched_domains(tmp);        //(2-7-5)将tmp sd销毁

    update_top_cache_domain(cpu);    //(2-7-6)更新cpu的sd相关的per_cpu变量
}

static int
sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
{
    unsigned long cflags = sd->flags, pflags = parent->flags;

    if (sd_degenerate(parent))        //(2-7-1-1) 判断parent sd是否有必要做下面的步骤来degenerate判断
        return 1;

    if (!cpumask_equal(sched_domain_span(sd), sched_domain_span(parent)))        //判断MC和DIE level是否sd范围一样？当前平台不一样
        return 0;                                                                //所以，一般这里就会return 0

    /* Flags needing groups don't count if only 1 group in parent */
    if (parent->groups == parent->groups->next) {                        //如果parent sg只有一个了，那么下面这些flag，就不需要了
        pflags &= ~(SD_LOAD_BALANCE |
                SD_BALANCE_NEWIDLE |
                SD_BALANCE_FORK |
                SD_BALANCE_EXEC |
                SD_ASYM_CPUCAPACITY |
                SD_SHARE_CPUCAPACITY |
                SD_SHARE_PKG_RESOURCES |
                SD_PREFER_SIBLING |
                SD_SHARE_POWERDOMAIN);
        if (nr_node_ids == 1)
            pflags &= ~SD_SERIALIZE;
    }
    if (~cflags & pflags)        //判断MC level的flag与DIE level修改后的flag是否一致？
        return 0;                //如果一致，则return 1；不一致，则return 0

    return 1;
}

static int sd_degenerate(struct sched_domain *sd)
{
    if (cpumask_weight(sched_domain_span(sd)) == 1)        //如果DIE level sd中，只有一个cpu（当前平台有8个cpu），就return 1
        return 1;                           

    /* Following flags need at least 2 groups */
    if (sd->flags & (SD_LOAD_BALANCE |                    //当前DIE level中会由部分flag，但同时sg有2个，所以会return 0
             SD_BALANCE_NEWIDLE |
             SD_BALANCE_FORK |
             SD_BALANCE_EXEC |
             SD_SHARE_CPUCAPACITY |
             SD_ASYM_CPUCAPACITY |
             SD_SHARE_PKG_RESOURCES |
             SD_SHARE_POWERDOMAIN)) {
        if (sd->groups != sd->groups->next)
            return 0;
    }

    /* Following flags don't use groups */
    if (sd->flags & (SD_WAKE_AFFINE))             //所有sd都这个flag，所以这里都会return 0
        return 0;

    return 1;
}

static void destroy_sched_domain(struct sched_domain *sd)
{
    /*
     * A normal sched domain may have multiple group references, an
     * overlapping domain, having private groups, only one.  Iterate,
     * dropping group/capacity references, freeing where none remain.
     */
    free_sched_groups(sd->groups, 1);        //（2-7-2-1）free sd对应的sg结构体

    if (sd->shared && atomic_dec_and_test(&sd->shared->ref))    //判断是否有sds结构，并且sds的引用==1时。就free掉sds
        kfree(sd->shared);
    kfree(sd);                //free sd结构体
}

static void free_sched_groups(struct sched_group *sg, int free_sgc)
{
    struct sched_group *tmp, *first;

    if (!sg)
        return;

    first = sg;
    do {                            //do-while循环，完整遍历sg循环链表元素一次
        tmp = sg->next;

        if (free_sgc && atomic_dec_and_test(&sg->sgc->ref))        //检查引用数是否为1，判断是否要free sgc结构
            kfree(sg->sgc);                                        //free sgc结构体

        if (atomic_dec_and_test(&sg->ref))            //检查sg结构应用数是否为1
            kfree(sg);                                //free sg结构体
        sg = tmp;
    } while (sg != first);
}

void rq_attach_root(struct rq *rq, struct root_domain *rd)
{
    struct root_domain *old_rd = NULL;
    unsigned long flags;

    raw_spin_lock_irqsave(&rq->lock, flags);

    if (rq->rd) {
        old_rd = rq->rd;                                //暂存原先的rd

        if (cpumask_test_cpu(rq->cpu, old_rd->online))    //如果原先的rd还处于online
            set_rq_offline(rq);                            //(2-7-3-1)则先让rq offline

        cpumask_clear_cpu(rq->cpu, old_rd->span);        //在old rd中去掉offline rq对应的cpu

        /*
         * If we dont want to free the old_rd yet then
         * set old_rd to NULL to skip the freeing later
         * in this function:
         */
        if (!atomic_dec_and_test(&old_rd->refcount))    //判断old rd的引用是否为0（代表是否需要free old rd）
            old_rd = NULL;                                //设置为NULL后，后面流程就不会free old rd
    }

    atomic_inc(&rd->refcount);        //将rd引用+1
    rq->rd = rd;                    //更新rq->rd为新的rd

    cpumask_set_cpu(rq->cpu, rd->span);                //将rq->cpu为新rd的范围
    if (cpumask_test_cpu(rq->cpu, cpu_active_mask))    //如果rq->cpu都是active的
        set_rq_online(rq);                            //（2-7-3-2）那么就将rq set为online

    raw_spin_unlock_irqrestore(&rq->lock, flags);

    if (old_rd)                                        //根据上面是否设置old rd为NULL，确定是否free old rd
        call_rcu(&old_rd->rcu, free_rootdomain);    //（2-7-3-3）free old rd
}

void set_rq_offline(struct rq *rq)
{
    if (rq->online) {                        //确认rq online
        const struct sched_class *class;

        for_each_class(class) {            //遍历所有调度class
            if (class->rq_offline)        //判断对应class rq_offline是否存在
                class->rq_offline(rq);    //(2-3-7-1-1)调用class对应的rq_offline，这里以cfs rq为例
        }

        cpumask_clear_cpu(rq->cpu, rq->rd->online);        //将rq的rq online mask中去掉当前rq对应的cpu
        rq->online = 0;            //将rq online置为0
    }
}

static void rq_offline_fair(struct rq *rq)
{
    update_sysctl();            //更新sysctl参数

    /* Ensure any throttled groups are reachable by pick_next_task */
    unthrottle_offline_cfs_rqs(rq);    //(2-3-7-1-1-1)把rq中的所有cfs_rq都解除带宽限制
}

/* cpu offline callback */
static void __maybe_unused unthrottle_offline_cfs_rqs(struct rq *rq)
{
    struct task_group *tg;

    lockdep_assert_held(&rq->lock);

    rcu_read_lock();
    list_for_each_entry_rcu(tg, &task_groups, list) {        //遍历所有task group
        struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];        //取出tg中对应cpu的cfs_rq

        if (!cfs_rq->runtime_enabled)            //过滤已关闭带宽限制功能的cfs_rq
            continue;

        /*
         * clock_task is not advancing so we just need to make sure
         * there's some valid quota amount
         */
        cfs_rq->runtime_remaining = 1;            //确保有有效的配额值
        /*
         * Offline rq is schedulable till CPU is completely disabled    //offline rq在take_cpu_down（）中完全disable CPU前，仍然可以被调度
         * in take_cpu_down(), so we prevent new cfs throttling here.    //所以，我们把新的cfs限制在这里。
         */
        cfs_rq->runtime_enabled = 0;        //关闭cfs rq的带宽限制功能

        if (cfs_rq_throttled(cfs_rq))        //判断cfs_rq的是否处于带宽被限制状态
            unthrottle_cfs_rq(cfs_rq);        //解除带宽限制
    }
    rcu_read_unlock();
}

void set_rq_online(struct rq *rq)
{
    if (!rq->online) {
        const struct sched_class *class;

        cpumask_set_cpu(rq->cpu, rq->rd->online);    //将rq->cpu设置到rq->rd->online的cpu mask中，表示对应rd中的online cpu增加了
        rq->online = 1;            //将rq设为online

        for_each_class(class) {                //遍历所有调度class
            if (class->rq_online)            //判断对应class rq_offline是否存在
                class->rq_online(rq);        //(2-3-7-2-1)调用class对应的rq_offline，这里以cfs rq为例
        }
    }
}

static void rq_online_fair(struct rq *rq)
{
    update_sysctl();            //更新sysctl参数

    update_runtime_enabled(rq);    //(2-3-7-2-1-1)更新cfs带宽限制的开关和配置
}

/*
 * Both these CPU hotplug callbacks race against unregister_fair_sched_group()
 *
 * The race is harmless, since modifying bandwidth settings of unhooked group
 * bits doesn't do much.
 */

/* cpu online calback */
static void __maybe_unused update_runtime_enabled(struct rq *rq)
{
    struct task_group *tg;

    lockdep_assert_held(&rq->lock);

    rcu_read_lock();
    list_for_each_entry_rcu(tg, &task_groups, list) {        //遍历所有task group
        struct cfs_bandwidth *cfs_b = &tg->cfs_bandwidth;    //获取tg对应的cfs带宽限制结构体
        struct cfs_rq *cfs_rq = tg->cfs_rq[cpu_of(rq)];        //取出tg中对应cpu的cfs_rq

        raw_spin_lock(&cfs_b->lock);
        cfs_rq->runtime_enabled = cfs_b->quota != RUNTIME_INF;    //根据cfs带宽限制的配额有没有限制，设置cfs_rq带宽限制是否打开
        raw_spin_unlock(&cfs_b->lock);
    }
    rcu_read_unlock();
}

static void free_rootdomain(struct rcu_head *rcu)
{
    struct root_domain *rd = container_of(rcu, struct root_domain, rcu);    //通过rcu获取要free的rd

    cpupri_cleanup(&rd->cpupri);            //free rd结构体中的相关成员
    cpudl_cleanup(&rd->cpudl);
    free_cpumask_var(rd->dlo_mask);
    free_cpumask_var(rd->rto_mask);
    free_cpumask_var(rd->online);
    free_cpumask_var(rd->span);
    free_pd(rd->pd);
    kfree(rd);                                //最后free rd本身
}

void dirty_sched_domain_sysctl(int cpu)
{
    if (cpumask_available(sd_sysctl_cpus))
        __cpumask_set_cpu(cpu, sd_sysctl_cpus);
}

static void destroy_sched_domains(struct sched_domain *sd)
{
    if (sd)
        call_rcu(&sd->rcu, destroy_sched_domains_rcu);        //如果sd是否存在，则进行销毁
}

static void destroy_sched_domains_rcu(struct rcu_head *rcu)
{
    struct sched_domain *sd = container_of(rcu, struct sched_domain, rcu);

    while (sd) {
        struct sched_domain *parent = sd->parent;        //从MC->DIE遍历sd
        destroy_sched_domain(sd);                        //并销毁sd，参照(2-7-2)
        sd = parent;
    }
}

static void update_top_cache_domain(int cpu)
{
    struct sched_domain_shared *sds = NULL;
    struct sched_domain *sd;
    int id = cpu;
    int size = 1;

    sd = highest_flag_domain(cpu, SD_SHARE_PKG_RESOURCES);    //找到该cpu所在的最高的、包含这个flag的domain。即 MC level
    if (sd) {
        id = cpumask_first(sched_domain_span(sd));            //取出该sd中第一个cpu
        size = cpumask_weight(sched_domain_span(sd));        //获取该sd中cpu的数量
        sds = sd->shared;                                    //获取sd的sds
    }

    rcu_assign_pointer(per_cpu(sd_llc, cpu), sd);            //更新sd_lcc = sd
    per_cpu(sd_llc_size, cpu) = size;                        //更新sd_lcc_size = sd中cpu数量
    per_cpu(sd_llc_id, cpu) = id;                            //更新sd_lcc_id = sd中第一个cpu
    rcu_assign_pointer(per_cpu(sd_llc_shared, cpu), sds);    //更新sd_llc_shared = sd->sds

    sd = lowest_flag_domain(cpu, SD_NUMA);                //当前平台不支持NUMA
    rcu_assign_pointer(per_cpu(sd_numa, cpu), sd);        //所以最后这个sd是DIE level，但是其本身也没有什么意义

    sd = highest_flag_domain(cpu, SD_ASYM_PACKING);                //当前平台不支持SMT
    rcu_assign_pointer(per_cpu(sd_asym_packing, cpu), sd);        //所以最后这个sd是DIE level，但是其本身也没有什么意义

    sd = lowest_flag_domain(cpu, SD_ASYM_CPUCAPACITY);            //获取cpu最低的、包含这个flag的domain。即 DIE level
    rcu_assign_pointer(per_cpu(sd_asym_cpucapacity, cpu), sd);    
}

static void __free_domain_allocs(struct s_data *d, enum s_alloc what,
                 const struct cpumask *cpu_map)
{
    switch (what) {
    case sa_rootdomain:                            //一切正常情况下是这个分支
        if (!atomic_read(&d->rd->refcount))        //根据rd的引用，决定是否还需要保留root domain
            free_rootdomain(&d->rd->rcu);        //如不需要，则进行free
        /* Fall through */
    case sa_sd:                            //申请root domain失败的情况
        free_percpu(d->sd);                //free d->sd
        /* Fall through */
    case sa_sd_storage:                    //建立拓扑结构失败、或者申请d->sd 失败的情况
        __sdt_free(cpu_map);            //free整个cpu_map中所有cpu的拓扑结构，并遍历free所有per_cpu的sdd->*
        /* Fall through */
    case sa_none:
        break;
    }
}