sched_ext: Use the NUMA scheduling domain for NUMA optimizations

Rely on the NUMA scheduling domain topology, instead of accessing NUMA
topology information directly.

There is basically no functional change, but in this way we ensure
consistent use of the same topology information determined by the
scheduling subsystem.

Fixes: f6ce6b949304 ("sched_ext: Do not enable LLC/NUMA optimizations when domains overlap")
Signed-off-by: Andrea Righi <arighi@nvidia.com>
Signed-off-by: Tejun Heo <tj@kernel.org>

diff --git a/kernel/sched/ext.c b/kernel/sched/ext.c
index 7fff1d0454770f5fab3e13708816d56653637ee9..71342f3719c128853a58aa363e33cbef16ad7762 100644 (file)
--- a/kernel/sched/ext.c
+++ b/kernel/sched/ext.c
@@ -3215,6 +3215,74 @@ found:
                goto retry;
 }
 
+/*
+ * Return the amount of CPUs in the same LLC domain of @cpu (or zero if the LLC
+ * domain is not defined).
+ */
+static unsigned int llc_weight(s32 cpu)
+{
+       struct sched_domain *sd;
+
+       sd = rcu_dereference(per_cpu(sd_llc, cpu));
+       if (!sd)
+               return 0;
+
+       return sd->span_weight;
+}
+
+/*
+ * Return the cpumask representing the LLC domain of @cpu (or NULL if the LLC
+ * domain is not defined).
+ */
+static struct cpumask *llc_span(s32 cpu)
+{
+       struct sched_domain *sd;
+
+       sd = rcu_dereference(per_cpu(sd_llc, cpu));
+       if (!sd)
+               return 0;
+
+       return sched_domain_span(sd);
+}
+
+/*
+ * Return the amount of CPUs in the same NUMA domain of @cpu (or zero if the
+ * NUMA domain is not defined).
+ */
+static unsigned int numa_weight(s32 cpu)
+{
+       struct sched_domain *sd;
+       struct sched_group *sg;
+
+       sd = rcu_dereference(per_cpu(sd_numa, cpu));
+       if (!sd)
+               return 0;
+       sg = sd->groups;
+       if (!sg)
+               return 0;
+
+       return sg->group_weight;
+}
+
+/*
+ * Return the cpumask representing the NUMA domain of @cpu (or NULL if the NUMA
+ * domain is not defined).
+ */
+static struct cpumask *numa_span(s32 cpu)
+{
+       struct sched_domain *sd;
+       struct sched_group *sg;
+
+       sd = rcu_dereference(per_cpu(sd_numa, cpu));
+       if (!sd)
+               return NULL;
+       sg = sd->groups;
+       if (!sg)
+               return NULL;
+
+       return sched_group_span(sg);
+}
+
 /*
  * Return true if the LLC domains do not perfectly overlap with the NUMA
  * domains, false otherwise.
@@ -3246,19 +3314,10 @@ static bool llc_numa_mismatch(void)
         * overlapping, which is incorrect (as NUMA 1 has two distinct LLC
         * domains).
         */
-       for_each_online_cpu(cpu) {
-               const struct cpumask *numa_cpus;
-               struct sched_domain *sd;
-
-               sd = rcu_dereference(per_cpu(sd_llc, cpu));
-               if (!sd)
+       for_each_online_cpu(cpu)
+               if (llc_weight(cpu) != numa_weight(cpu))
                        return true;
 
-               numa_cpus = cpumask_of_node(cpu_to_node(cpu));
-               if (sd->span_weight != cpumask_weight(numa_cpus))
-                       return true;
-       }
-
        return false;
 }
 
@@ -3276,8 +3335,7 @@ static bool llc_numa_mismatch(void)
 static void update_selcpu_topology(void)
 {
        bool enable_llc = false, enable_numa = false;
-       struct sched_domain *sd;
-       const struct cpumask *cpus;
+       unsigned int nr_cpus;
        s32 cpu = cpumask_first(cpu_online_mask);
 
        /*
@@ -3291,10 +3349,12 @@ static void update_selcpu_topology(void)
         * CPUs.
         */
        rcu_read_lock();
-       sd = rcu_dereference(per_cpu(sd_llc, cpu));
-       if (sd) {
-               if (sd->span_weight < num_online_cpus())
+       nr_cpus = llc_weight(cpu);
+       if (nr_cpus > 0) {
+               if (nr_cpus < num_online_cpus())
                        enable_llc = true;
+               pr_debug("sched_ext: LLC=%*pb weight=%u\n",
+                        cpumask_pr_args(llc_span(cpu)), llc_weight(cpu));
        }
 
        /*
@@ -3306,9 +3366,13 @@ static void update_selcpu_topology(void)
         * enabling both NUMA and LLC optimizations is unnecessary, as checking
         * for an idle CPU in the same domain twice is redundant.
         */
-       cpus = cpumask_of_node(cpu_to_node(cpu));
-       if ((cpumask_weight(cpus) < num_online_cpus()) && llc_numa_mismatch())
-               enable_numa = true;
+       nr_cpus = numa_weight(cpu);
+       if (nr_cpus > 0) {
+               if (nr_cpus < num_online_cpus() && llc_numa_mismatch())
+                       enable_numa = true;
+               pr_debug("sched_ext: NUMA=%*pb weight=%u\n",
+                        cpumask_pr_args(numa_span(cpu)), numa_weight(cpu));
+       }
        rcu_read_unlock();
 
        pr_debug("sched_ext: LLC idle selection %s\n",
@@ -3360,7 +3424,6 @@ static s32 scx_select_cpu_dfl(struct task_struct *p, s32 prev_cpu,
 
        *found = false;
 
-
        /*
         * This is necessary to protect llc_cpus.
         */
@@ -3379,15 +3442,10 @@ static s32 scx_select_cpu_dfl(struct task_struct *p, s32 prev_cpu,
         */
        if (p->nr_cpus_allowed >= num_possible_cpus()) {
                if (static_branch_maybe(CONFIG_NUMA, &scx_selcpu_topo_numa))
-                       numa_cpus = cpumask_of_node(cpu_to_node(prev_cpu));
-
-               if (static_branch_maybe(CONFIG_SCHED_MC, &scx_selcpu_topo_llc)) {
-                       struct sched_domain *sd;
+                       numa_cpus = numa_span(prev_cpu);
 
-                       sd = rcu_dereference(per_cpu(sd_llc, prev_cpu));
-                       if (sd)
-                               llc_cpus = sched_domain_span(sd);
-               }
+               if (static_branch_maybe(CONFIG_SCHED_MC, &scx_selcpu_topo_llc))
+                       llc_cpus = llc_span(prev_cpu);
        }
 
        /*