现代各种处理器采用了许多不同的技术，但从物理结构上，CPU的层次结构却可以被统一的表示如下：

最底层为超线程层，此技术为Intel公司研发，目前在ARM等其他架构处理器中并未采用。超线程技术充分利用空闲CPU资源，在单一时间内可以让一个物理核心同时处理两个线程的工作。因此，在开启超线程的4物理核心的机器上，往往可以看到存在有8个逻辑CPU。

再往上的层次就是物理核心层。单独的一个物理核心的标志往往是其独占的私有缓存（Cache）。通常在两级缓存的情况下，每个物理核心独享L1 Cache，L2 Cache则为几个物理核心共享；在三级缓存的情况下，L1与L2为私有，L3为共享。当然前面说的是通常情况，不能武断地认为二级缓存与三级缓存的情况都是统一的。

继续往上层走就是处理器层级，多个物理核心可以共享最后一级缓存（LLC），这多个物理核心就被称为是一个Cluster或者Socket。芯片厂商会把多个物理核心（Core）封装到一个片（Chip）上，主板上会留有插槽，一个插槽可以插一个Chip。

最上层就到了NUMA的概念了，为了减少对内存总线的访问竞争，可以将CPU分属于不同的Node节点，通常情况下，CPU只访问Node内的memory。

在不考虑NUMA的情况下，CPU所属层次从高到低可以表示为Cluster ---> Core ---> Threads。

了解CPU的层次结构有什么作用呢？

以服务器为例，负载均衡是调度器常要考虑的问题。负载均衡在进行任务迁移的时候，把任务移动到哪个CPU上是重中之重。如果开启了超线程，那么移动到超线程层次的兄弟CPU上，被迁移后，原Cache上进程的数据仍然可用，可以说是最优解；如果移动到物理核心层的兄弟CPU上，则LLC上的原先该进程的数据仍然可以被访问到。可以说，迁移到离原CPU层次更近的兄弟CPU上带来的影响更小。

以手机等小型设备为例，功耗是核心问题。尤其是ARM多采用big core和little core的组合结构，即一个Cluster的物理核心是功耗和性能都比较高的CPU，另一个Cluster的物理核心是功耗和性能都比较低的CPU。这时候任务迁移，除了要考虑层次的兄弟临近关系，还要考虑移动到哪个CPU上可以保证功耗和性能的平衡问题。

那么，CPU的层次结构在Linux kernel中是如何表示的呢？

我们以ARM64下CPU的初始化开始入手。ARM64平台下CPU的初始化需要读取DTS（Device Tree Source，设备树）文件。

【配套的Linux内核技术教程文档资料】可以私信我【内核】免费获取。

随意挑选arm64目录下一个处理器的dtsi文件的部分为例：

 cpus {
 #address-cells = <1>;
 #size-cells = <0>;
 
 cpu-map {
 cluster0 {
 core0 {
 cpu = <&cpu0>;
 };
                ......
            };
            ......
    };
 
    cpu0: cpu@20000 {
      device_type = "cpu";
 compatible = "arm,cortex-a57";
 reg = <0x20000>;
 enable-method = "psci";
 next-level-cache = <&cluster0_l2>;
 };
    ......
 
     cluster0_l2: l2-cache0 {
 compatible = "cache";
 };
    ......
 };

以上是DTS文件中CPU定义的一个统一的格式。start_kernel --> setup_arch --> smp_init_cpus。

smp_init_cpus在系统启动的时候读取DTS文件中CPU信息，获得CPU数量，并调用smp_cpu_setup函数进行possible位图的设置。

 static int __init smp_cpu_setup(int cpu)
 {
 const struct cpu_operations *ops;
 
 if (init_cpu_ops(cpu))
 return -ENODEV;
 
 ops = get_cpu_ops(cpu);
 if (ops->cpu_init(cpu))
 return -ENODEV;
 
 set_cpu_possible(cpu, true);
 
 return 0;
 }

这里先了解一下内核中存在的四种CPU的状态表示，分别是possible、online、present和active。

 typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
 
 #define DECLARE_BITMAP(name,bits) \
 unsigned long name[BITS_TO_LONGS(bits)]
 
 extern struct cpumask __cpu_possible_mask;
 extern struct cpumask __cpu_online_mask;
 extern struct cpumask __cpu_present_mask;
 extern struct cpumask __cpu_active_mask;
 #define cpu_possible_mask ((const struct cpumask *)&__cpu_possible_mask)
 #define cpu_online_mask   ((const struct cpumask *)&__cpu_online_mask)
 #define cpu_present_mask ((const struct cpumask *)&__cpu_present_mask)
 #define cpu_active_mask   ((const struct cpumask *)&__cpu_active_mask)

可以从smp_cpu_setup函数看出，如果一个CPU编号对应的struct cpu_operations被建立成功，并且其对应的init函数没有执行失败，则将该CPU标记为possible。

 struct cpu_operations {
 const char*name;
 int(*cpu_init)(unsigned int);
 int(*cpu_prepare)(unsigned int);
 int(*cpu_boot)(unsigned int);
 void(*cpu_postboot)(void);
 #ifdef CONFIG_HOTPLUG_CPU
 bool(*cpu_can_disable)(unsigned int cpu);
 int(*cpu_disable)(unsigned int cpu);
 void(*cpu_die)(unsigned int cpu);
 int(*cpu_kill)(unsigned int cpu);
 #endif
 #ifdef CONFIG_CPU_IDLE
 int(*cpu_init_idle)(unsigned int);
 int(*cpu_suspend)(unsigned long);
 #endif
 };

• cpu_init：读取提出一个逻辑CPU的激活方法的必要数据；
• cpu_prepare：测试是否可以启动给定CPU；
• cpu_boot：启动CPU；
• cpu_postboot：启动CPU后必要的清理工作。

除了上述的几个成员函数，可以看到其他成员函数是分别和CPU热插拔和CPUIDLE相关的电源操作，kernel抽象出了struct cpu_operations这个结构体，将启动、热插拔、空闲态接口统一起来，交给各个体系结构自己完成。

start_kernel --> arch_call_rest_init --> rest_init --> kernel_init --> kernel_init_freezable --> smp_prepare_cpus

接下来一直到smp_prepare_cpus函数，才到设置present位图的时候。

以下是smp_prepare_cpus的部分代码：

 void __init smp_prepare_cpus(unsigned int max_cpus)
 {
 const struct cpu_operations *ops;
 int err;
 unsigned int cpu;
 unsigned int this_cpu;
 
    ......
 
 for_each_possible_cpu(cpu) {
 
 per_cpu(cpu_number, cpu) = cpu;
 
 if (cpu == smp_processor_id())
 continue;
 
 ops = get_cpu_ops(cpu);
 if (!ops)
 continue;
 
 err = ops->cpu_prepare(cpu);
 if (err)
 continue;
 
 set_cpu_present(cpu, true);
 numa_store_cpu_info(cpu);
 }
 }

前面看到，possible位图的设置依赖于cpu_operations结构体的初始化以及是否读取到正确的CPU信息；那这里present位图的设置则依赖于cpu_prepare的执行结果，也就是检测对应CPU是否可以启动。

kernel_init_freezable --> smp_init --> bringup_nonboot_cpus。

 void bringup_nonboot_cpus(unsigned int setup_max_cpus)
 {
 unsigned int cpu;
 
 for_each_present_cpu(cpu) {
 if (num_online_cpus() >= setup_max_cpus)
 break;
 if (!cpu_online(cpu))
 cpu_up(cpu, CPUHP_ONLINE);
 }
 }

cpu_up --> _cpu_up --> cpuhp_up_callbacks --> cpuhp_invoke_callback --> bringup_cpu --> __cpu_up --> boot_secondary

cpu_up，这里可以这么简单的理解，最开始系统中只有一个CPU，当代码执行到这里的时候，开始启动其他的CPU，其他CPU的启动过程，首先是需要复制主CPU的0号线程（即空闲线程），然后去执行热插拔相关的回调函数，一直执行到boot_secondary，在这里最终会执行到struct cpu_operations中的回调函数cpu_boot。

 static int boot_secondary(unsigned int cpu, struct task_struct *idle)
 {
 const struct cpu_operations *ops = get_cpu_ops(cpu);
 
 if (ops->cpu_boot)
 return ops->cpu_boot(cpu);
 
 return -EOPNOTSUPP;
 }

而通常在struct cpu_operations中的成员cpu_boot的执行中，会执行到secondary_entry --> secondary_startup --> __secondary_switched --> secondary_start_kernel。

而在secondary_start_kernel中会调用set_cpu_online函数设置online位图。

active这个位图的修改函数定义在CPU热插拔的回调函数数组中，也就是struct cpuhp_step cpuhp_hp_states[]中，该位图服务于调度器，在开启热插拔的情况下，调度器需要实时监控CPU热插拔的每个信息，因此需要该位图实时将某个CPU移除或添加。

说完了四种位图，突然发现还没有说到CPU的层次结构在代码上的表示，CPU的层次结构使用一个结构体struct cpu_topology来表示。

 struct cpu_topology {
 int thread_id;
 int core_id;
 int package_id;
 int llc_id;
 cpumask_t thread_sibling;
 cpumask_t core_sibling;
 cpumask_t llc_sibling;
 };
 
 #ifdef CONFIG_GENERIC_ARCH_TOPOLOGY
 extern struct cpu_topology cpu_topology[NR_CPUS];

其实，代码上CPU的层次结构的赋值代码与CPU启动的时间基本一致，主CPU的赋值是在smp_prepare_cpus函数中；其余CPU是在secondary_start_kernel函数中。

直接来看cpu_topology结构体的赋值函数store_cpu_topology。在调用该函数之前，已经在init_cpu_topology函数中进行过cpu_topology数组的初始化了，其中thread_id、core_id、package_id和llc_id皆初始化为-1。

 void store_cpu_topology(unsigned int cpuid)
 {
 struct cpu_topology *cpuid_topo = &cpu_topology[cpuid];
 u64 mpidr;
 
 if (cpuid_topo->package_id != -1)
 goto topology_populated;
 
 mpidr = read_cpuid_mpidr();
 
 /* Uniprocessor systems can rely on default topology values */
 if (mpidr & MPIDR_UP_BITMASK)
 return;
 
 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);
 }

以arm64为例，thread_id应该是超线程情况下才有意义，这里不考虑。core_id等同于物理核心id，也就是逻辑核心id，二者一致，package_id指向了其所属的NUMA的Node号。update_sibling_masks则用于更新用于表示各个层级的兄弟关系。

说了这么多，一直在说CPU的物理层次结构在代码上的表示，却还没有说到调度中CPU物理结构的参与。

这里关注kernel_init_freezable函数有这样一段代码：

     smp_init();
 sched_init_smp();

前面已经了解到smp_init函数执行完成时，各个次CPU已经启动完成，此时进入sched_init_smp函数。

sched_init_smp --> sched_init_domains --> build_sched_domains

 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;
 
     // 核心函数1，此时的cpu_map是active的位图
 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: */
 for_each_cpu(i, cpu_map) {
 struct sched_domain_topology_level *tl;
 int dflags = 0;
 
 sd = NULL;
 for_each_sd_topology(tl) {
 if (tl == tl_asym) {
 dflags |= SD_ASYM_CPUCAPACITY;
 has_asym = true;
 }
 
 if (WARN_ON(!topology_span_sane(tl, cpu_map, i)))
 goto error;
 
 // 核心函数2
 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 */
 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 {
 // 核心函数3
 if (build_sched_groups(sd, i))
 goto error;
 }
 }
 }
 
 /* Calculate CPU capacity for physical packages and nodes */
 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();
 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;
 }

首先，分析第1个核心函数__visit_domain_allocation_hell。

 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))
 return sa_sd_storage;
 d->sd = alloc_percpu(struct sched_domain *);
 if (!d->sd)
 return sa_sd_storage;
 d->rd = alloc_rootdomain();
 if (!d->rd)
 return sa_sd;
 
 return sa_rootdomain;
 }

首先进入__sdt_alloc函数。

 static int __sdt_alloc(const struct cpumask *cpu_map)
 {
 struct sched_domain_topology_level *tl;
 int j;
 
 for_each_sd_topology(tl) {
 struct sd_data *sdd = &tl->data;
 
 sdd->sd = alloc_percpu(struct sched_domain *);
 if (!sdd->sd)
 return -ENOMEM;
 
 sdd->sds = alloc_percpu(struct sched_domain_shared *);
 if (!sdd->sds)
 return -ENOMEM;
 
 sdd->sg = alloc_percpu(struct sched_group *);
 if (!sdd->sg)
 return -ENOMEM;
 
 sdd->sgc = alloc_percpu(struct sched_group_capacity *);
 if (!sdd->sgc)
 return -ENOMEM;
 
 for_each_cpu(j, cpu_map) {
 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(),
 GFP_KERNEL, cpu_to_node(j));
 if (!sd)
 return -ENOMEM;
 
 *per_cpu_ptr(sdd->sd, j) = sd;
 
 sds = kzalloc_node(sizeof(struct sched_domain_shared),
 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(),
 GFP_KERNEL, cpu_to_node(j));
 if (!sg)
 return -ENOMEM;
 
 sg->next = sg;
 
 *per_cpu_ptr(sdd->sg, j) = sg;
 
 sgc = kzalloc_node(sizeof(struct sched_group_capacity) + cpumask_size(),
 GFP_KERNEL, cpu_to_node(j));
 if (!sgc)
 return -ENOMEM;
 
 #ifdef CONFIG_SCHED_DEBUG
 sgc->id = j;
 #endif
 
 *per_cpu_ptr(sdd->sgc, j) = sgc;
 }
 }
 
 return 0;
 }

在这个函数中我们接触到第一个比较关键的数据结构struct sched_domain_topology_level。

 struct sched_domain_topology_level {
 sched_domain_mask_f mask;
 sched_domain_flags_f sd_flags;
 int    flags;
 int    numa_level;
 struct sd_data      data;
 #ifdef CONFIG_SCHED_DEBUG
 char                *name;
 #endif
 };
 
 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 struct sched_domain_topology_level *sched_domain_topology =
 default_topology;
 
 #define for_each_sd_topology(tl)\
 for (tl = sched_domain_topology; tl->mask; tl++)
 
 void set_sched_topology(struct sched_domain_topology_level *tl)
 {
 if (WARN_ON_ONCE(sched_smp_initialized))
 return;
 
 sched_domain_topology = tl;
 }

可以看到，struct sched_domain_topology_level使用一个数组default_topology给出，当然各个体系结构下也可以修改该数组。该数组一般按照CPU层次从低到高排列。

struct sched_domain_toplogy_level的前两个成员mask和flag分别是两个函数，用于指定该CPU层次下的兄弟cpumask和flag标志位。而struct sd_data是该数据结构的核心，其成员将在后续完成赋值。

这里简单看下物理核心层的mask成员cpu_coregroup_mask。

 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;
 }

可以看到，本质上是利用cpu_topology数组来获得core_sibling的值，到这里就和物理层级联系起来了。

 struct sd_data {
 struct sched_domain *__percpu *sd;
 struct sched_domain_shared *__percpu *sds;
 struct sched_group *__percpu *sg;
 struct sched_group_capacity *__percpu *sgc;
 };

分析__sdt_alloc，可以看到为每个层次的struct sched_domain_topology_level的sd_data分配percpu的sched_domain、sched_domain_shared、sched_group和sched_group_capacity。这样每个CPU可以通过default_topology数组轻易找到自己的sched_domain等数据。

接下来，继续分析build_sched_domains的第2个核心函数build_sched_domain，该函数在每个CPU的每个层次上都要去调用一次。

 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);
 
 if (child) {
 sd->level = child->level + 1;
 sched_domain_level_max = max(sched_domain_level_max, sd->level);
 child->parent = 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);
 
 return sd;
 }

其中sd_init函数完成对应sched_domain_topology_level对应层次的sched_domain的一些数据的填充以及sd_data中mask和flag的修改。

 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);
 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));
 
 if (tl->sd_flags)
 sd_flags = (*tl->sd_flags)();
 if (WARN_ONCE(sd_flags & ~TOPOLOGY_SD_FLAGS,
 "wrong sd_flags in topology description\n"))
 sd_flags &= TOPOLOGY_SD_FLAGS;
 
 /* Apply detected topology flags */
 sd_flags |= dflags;
 
 *sd = (struct sched_domain){
 .min_interval= sd_weight,
 .max_interval= 2*sd_weight,
 .busy_factor= 16,
 .imbalance_pct= 117,
 
 .cache_nice_tries= 0,
 
 .flags= 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
 ,
 
 .last_balance= jiffies,
 .balance_interval= sd_weight,
 .max_newidle_lb_cost= 0,
 .next_decay_max_lb_cost= jiffies,
 .child= child,
 #ifdef CONFIG_SCHED_DEBUG
 .name= tl->name,
 #endif
 };
 
 cpumask_and(sched_domain_span(sd), cpu_map, tl->mask(cpu));
 sd_id = cpumask_first(sched_domain_span(sd));
 
 /*
  * Convert topological properties into behaviour.
  */
 
 /* Don't attempt to spread across CPUs of different capacities. */
 if ((sd->flags & SD_ASYM_CPUCAPACITY) && sd->child)
 sd->child->flags &= ~SD_PREFER_SIBLING;
 
 if (sd->flags & SD_SHARE_CPUCAPACITY) {
 sd->imbalance_pct = 110;
 
 } else if (sd->flags & SD_SHARE_PKG_RESOURCES) {
 sd->imbalance_pct = 117;
 sd->cache_nice_tries = 1;
 
 #ifdef CONFIG_NUMA
 } 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 {
 sd->cache_nice_tries = 1;
 }
 
 /*
  * For all levels sharing cache; connect a sched_domain_shared
  * instance.
  */
 if (sd->flags & SD_SHARE_PKG_RESOURCES) {
 sd->shared = *per_cpu_ptr(sdd->sds, sd_id);
 atomic_inc(&sd->shared->ref);
 atomic_set(&sd->shared->nr_busy_cpus, sd_weight);
 }
 
 sd->private = sdd;
 
 return sd;
 }

这里可以看到，sched_domain中的成员往往是与调度中负载均衡操作相关的一些字段，例如min_interval是最小的load balance间隔，max_interval是最大的load balance间隔等等。

这里应该注意，sched_domain的父子关系，高层级的sched_domain是低层级的sched_domain的parent，低层级的sched_domain是高层级的child。sched_domain的span为自己该层级的兄弟CPU以及下面几个层级的兄弟CPU的并集。

创建完sched_domain之后，开始从CPU开始由低到高依次建立sched_group，这就是第3个核心函数，build_sched_groups。

 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);
 struct cpumask *covered;
 int i;
 
 lockdep_assert_held(&sched_domains_mutex);
 covered = sched_domains_tmpmask;
 
 cpumask_clear(covered);
 
 for_each_cpu_wrap(i, span, cpu) {
 struct sched_group *sg;
 
 if (cpumask_test_cpu(i, covered))
 continue;
 
 sg = get_group(i, sdd);
 
 cpumask_or(covered, covered, sched_group_span(sg));
 
 if (!first)
 first = sg;
 if (last)
 last->next = sg;
 last = sg;
 }
 last->next = first;
 sd->groups = first;
 
 return 0;
 }

build_sched_groups函数的核心是get_group函数。

 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)
 cpu = cpumask_first(sched_domain_span(child));
 
 sg = *per_cpu_ptr(sdd->sg, cpu);
 sg->sgc = *per_cpu_ptr(sdd->sgc, cpu);
 
 /* Increase refcounts for claim_allocations: */
 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. */
 if (already_visited)
 return sg;
 
 if (child) {
 cpumask_copy(sched_group_span(sg), sched_domain_span(child));
 cpumask_copy(group_balance_mask(sg), sched_group_span(sg));
 } else {
 cpumask_set_cpu(cpu, sched_group_span(sg));
 cpumask_set_cpu(cpu, group_balance_mask(sg));
 }
 
 sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sched_group_span(sg));
 sg->sgc->min_capacity = SCHED_CAPACITY_SCALE;
 sg->sgc->max_capacity = SCHED_CAPACITY_SCALE;
 
 return sg;
 }

可以从get_group函数看出来，如果是最底层的sched_domain，即不存在child，那么get_group中建立的sched_group是该CPU独有的。而如果是非最底层的sched_domain，那么get_group中建立的sched_group是其child的span成员共享的。这里注意，sched_group_capacity和sched_group两位一体，表示该调度组的计算能力。

到这里，调度域和调度组的关系基本可以理清楚。在CPU层次结构上，CPU在每个层次都有一个调度域，该CPU在高层次的调度域与该CPU在低层次的调度域互成父子关系。

而调度域下皆有一个调度组，调度组是呈链表组织的。一个调度域将其调度域中所有CPU按照兄弟关系分成不同的调度组，然后以链表形式组织起来，一个调度域中的所有CPU在该CPU层次上是共享这个调度组的。

更新完成sched_group_capacity之后，最后一部分cpu_attach_domain --> rq_attach_root。

rq_attach_root中有这样的一行代码：rq->rd = rd;。至此，从rq --> root_domain --> sched_domain的关系已经建立完成。