Currently the CPU capacity asymmetry detection, performed through
asym_cpu_capacity_level, tries to identify the lowest topology level
at which the highest CPU capacity is being observed, not necessarily
finding the level at which all possible capacity values are visible
to all CPUs, which might be bit problematic for some possible/valid
asymmetric topologies i.e.:
DIE [ ]
MC [ ][ ]
CPU [0] [1] [2] [3] [4] [5] [6] [7]
Capacity |.....| |.....| |.....| |.....|
L M B B
Where:
arch_scale_cpu_capacity(L) = 512
arch_scale_cpu_capacity(M) = 871
arch_scale_cpu_capacity(B) = 1024
In this particular case, the asymmetric topology level will point
at MC, as all possible CPU masks for that level do cover the CPU
with the highest capacity. It will work just fine for the first
cluster, not so much for the second one though (consider the
find_energy_efficient_cpu which might end up attempting the energy
aware wake-up for a domain that does not see any asymmetry at all)
Rework the way the capacity asymmetry levels are being detected,
allowing to point to the lowest topology level (for a given CPU), where
full range of available CPU capacities is visible to all CPUs within given
domain. As a result, the per-cpu sd_asym_cpucapacity might differ across
the domains. This will have an impact on EAS wake-up placement in a way
that it might see different rage of CPUs to be considered, depending on
the given current and target CPUs.
Additionally, those levels, where any range of asymmetry (not
necessarily full) is being detected will get identified as well.
The selected asymmetric topology level will be denoted by
SD_ASYM_CPUCAPACITY_FULL sched domain flag whereas the 'sub-levels'
would receive the already used SD_ASYM_CPUCAPACITY flag. This allows
maintaining the current behaviour for asymmetric topologies, with
misfit migration operating correctly on lower levels, if applicable,
as any asymmetry is enough to trigger the misfit migration.
The logic there relies on the SD_ASYM_CPUCAPACITY flag and does not
relate to the full asymmetry level denoted by the sd_asym_cpucapacity
pointer.
Suggested-by: Peter Zijlstra <[email protected]>
Signed-off-by: Beata Michalska <[email protected]>
---
kernel/sched/topology.c | 129 +++++++++++++++++++++++++++++-------------------
1 file changed, 79 insertions(+), 50 deletions(-)
diff --git a/kernel/sched/topology.c b/kernel/sched/topology.c
index 55a0a24..81957f7 100644
--- a/kernel/sched/topology.c
+++ b/kernel/sched/topology.c
@@ -675,7 +675,7 @@ static void update_top_cache_domain(int cpu)
sd = highest_flag_domain(cpu, SD_ASYM_PACKING);
rcu_assign_pointer(per_cpu(sd_asym_packing, cpu), sd);
- sd = lowest_flag_domain(cpu, SD_ASYM_CPUCAPACITY);
+ sd = lowest_flag_domain(cpu, SD_ASYM_CPUCAPACITY_FULL);
rcu_assign_pointer(per_cpu(sd_asym_cpucapacity, cpu), sd);
}
@@ -1989,66 +1989,96 @@ static bool topology_span_sane(struct sched_domain_topology_level *tl,
return true;
}
-
+/**
+ * Asym capacity bits
+ */
+struct asym_cap_data {
+ struct list_head link;
+ unsigned long capacity;
+ struct cpumask *cpu_mask;
+};
/*
- * Find the sched_domain_topology_level where all CPU capacities are visible
- * for all CPUs.
+ * Set of available CPUs grouped by their corresponding capacities
+ * Each list entry contains a CPU mask reflecting CPUs that share the same
+ * capacity.
+ * The lifespan of data is unlimited.
*/
-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;
+static LIST_HEAD(asym_cap_list);
- /* Is there any asymmetry? */
- cap = arch_scale_cpu_capacity(cpumask_first(cpu_map));
-
- for_each_cpu(i, cpu_map) {
- if (arch_scale_cpu_capacity(i) != cap) {
- asym = true;
- break;
- }
+/*
+ * Verify whether given CPU at a given topology level belongs to a sched domain
+ * that does span CPUs with different capacities.
+ * Provides sd_flags reflecting the asymmetry scope.
+ */
+static inline int
+asym_cpu_capacity_classify(struct sched_domain_topology_level *tl, int cpu)
+{
+ int sd_asym_flags = SD_ASYM_CPUCAPACITY | SD_ASYM_CPUCAPACITY_FULL;
+ const struct cpumask *tl_mask = tl->mask(cpu);
+ struct asym_cap_data *entry;
+ int asym_cap_count = 0;
+
+ if (list_is_singular(&asym_cap_list))
+ goto leave;
+
+ list_for_each_entry(entry, &asym_cap_list, link) {
+ if (cpumask_intersects(tl_mask, entry->cpu_mask))
+ ++asym_cap_count;
+ else
+ sd_asym_flags &= ~SD_ASYM_CPUCAPACITY_FULL;
}
+ WARN_ON_ONCE(!asym_cap_count);
+leave:
+ return asym_cap_count > 1 ? sd_asym_flags : 0;
+}
- 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) {
- unsigned long max_capacity = arch_scale_cpu_capacity(i);
- int tl_id = 0;
+/*
+ * Build-up/update list of CPUs grouped by their capacities
+ */
+static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
+{
+ struct asym_cap_data *entry, *next;
+ int cpu;
- for_each_sd_topology(tl) {
- if (tl_id < asym_level)
- goto next_level;
+ if (!list_empty(&asym_cap_list))
+ list_for_each_entry(entry, &asym_cap_list, link)
+ cpumask_clear(entry->cpu_mask);
- for_each_cpu_and(j, tl->mask(i), cpu_map) {
- unsigned long capacity;
+ entry = list_first_entry_or_null(&asym_cap_list,
+ struct asym_cap_data, link);
- capacity = arch_scale_cpu_capacity(j);
+ for_each_cpu(cpu, cpu_map) {
+ unsigned long capacity = arch_scale_cpu_capacity(cpu);
- if (capacity <= max_capacity)
- continue;
+ if (entry && capacity == entry->capacity)
+ goto next;
- max_capacity = capacity;
- asym_level = tl_id;
- asym_tl = tl;
- }
-next_level:
- tl_id++;
+ list_for_each_entry(entry, &asym_cap_list, link)
+ if (capacity == entry->capacity)
+ goto next;
+
+ entry = kzalloc(sizeof(*entry) + cpumask_size(), GFP_KERNEL);
+ if (entry) {
+ entry->capacity = capacity;
+ entry->cpu_mask = (struct cpumask *)((char *)entry +
+ sizeof(*entry));
+ list_add(&entry->link, &asym_cap_list);
}
+ WARN_ONCE(!entry,
+ "Failed to allocate memory for capacity asymmetry detection\n");
+next:
+ __cpumask_set_cpu(cpu, entry->cpu_mask);
}
- return asym_tl;
+ list_for_each_entry_safe(entry, next, &asym_cap_list, link) {
+ if (cpumask_empty(entry->cpu_mask)) {
+ list_del(&entry->link);
+ kfree(entry);
+ }
+ }
}
-
/*
* Build sched domains for a given set of CPUs and attach the sched domains
* to the individual CPUs
@@ -2061,7 +2091,6 @@ build_sched_domains(const struct cpumask *cpu_map, struct sched_domain_attr *att
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)))
@@ -2071,7 +2100,7 @@ build_sched_domains(const struct cpumask *cpu_map, struct sched_domain_attr *att
if (alloc_state != sa_rootdomain)
goto error;
- tl_asym = asym_cpu_capacity_level(cpu_map);
+ asym_cpu_capacity_scan(cpu_map);
/* Set up domains for CPUs specified by the cpu_map: */
for_each_cpu(i, cpu_map) {
@@ -2080,9 +2109,9 @@ build_sched_domains(const struct cpumask *cpu_map, struct sched_domain_attr *att
sd = NULL;
for_each_sd_topology(tl) {
- if (tl == tl_asym) {
- dflags |= SD_ASYM_CPUCAPACITY;
- has_asym = true;
+ if (!(dflags & SD_ASYM_CPUCAPACITY_FULL)) {
+ dflags |= asym_cpu_capacity_classify(tl, i);
+ has_asym = dflags & SD_ASYM_CPUCAPACITY;
}
if (WARN_ON(!topology_span_sane(tl, cpu_map, i)))
--
2.7.4
On 17/05/21 09:23, Beata Michalska wrote:
> Currently the CPU capacity asymmetry detection, performed through
> asym_cpu_capacity_level, tries to identify the lowest topology level
> at which the highest CPU capacity is being observed, not necessarily
> finding the level at which all possible capacity values are visible
> to all CPUs, which might be bit problematic for some possible/valid
> asymmetric topologies i.e.:
>
> DIE [ ]
> MC [ ][ ]
>
> CPU [0] [1] [2] [3] [4] [5] [6] [7]
> Capacity |.....| |.....| |.....| |.....|
> L M B B
>
> Where:
> arch_scale_cpu_capacity(L) = 512
> arch_scale_cpu_capacity(M) = 871
> arch_scale_cpu_capacity(B) = 1024
>
> In this particular case, the asymmetric topology level will point
> at MC, as all possible CPU masks for that level do cover the CPU
> with the highest capacity. It will work just fine for the first
> cluster, not so much for the second one though (consider the
> find_energy_efficient_cpu which might end up attempting the energy
> aware wake-up for a domain that does not see any asymmetry at all)
>
> Rework the way the capacity asymmetry levels are being detected,
> allowing to point to the lowest topology level (for a given CPU), where
> full range of available CPU capacities is visible to all CPUs within given
> domain. As a result, the per-cpu sd_asym_cpucapacity might differ across
> the domains. This will have an impact on EAS wake-up placement in a way
> that it might see different rage of CPUs to be considered, depending on
> the given current and target CPUs.
>
> Additionally, those levels, where any range of asymmetry (not
> necessarily full) is being detected will get identified as well.
> The selected asymmetric topology level will be denoted by
> SD_ASYM_CPUCAPACITY_FULL sched domain flag whereas the 'sub-levels'
> would receive the already used SD_ASYM_CPUCAPACITY flag. This allows
> maintaining the current behaviour for asymmetric topologies, with
> misfit migration operating correctly on lower levels, if applicable,
> as any asymmetry is enough to trigger the misfit migration.
> The logic there relies on the SD_ASYM_CPUCAPACITY flag and does not
> relate to the full asymmetry level denoted by the sd_asym_cpucapacity
> pointer.
>
> Suggested-by: Peter Zijlstra <[email protected]>
> Signed-off-by: Beata Michalska <[email protected]>
That does look quite simpler :-)
A lesson for me as a reviewer here is to resist biting into the nitty
gritty code details and spend more time on a first conceptual / high level
review pass. It's not the first time I'm guilty of it, so I do need to work
on that.
> ---
> kernel/sched/topology.c | 129 +++++++++++++++++++++++++++++-------------------
> 1 file changed, 79 insertions(+), 50 deletions(-)
>
> diff --git a/kernel/sched/topology.c b/kernel/sched/topology.c
> index 55a0a24..81957f7 100644
> --- a/kernel/sched/topology.c
> +++ b/kernel/sched/topology.c
> @@ -675,7 +675,7 @@ static void update_top_cache_domain(int cpu)
> sd = highest_flag_domain(cpu, SD_ASYM_PACKING);
> rcu_assign_pointer(per_cpu(sd_asym_packing, cpu), sd);
>
> - sd = lowest_flag_domain(cpu, SD_ASYM_CPUCAPACITY);
> + sd = lowest_flag_domain(cpu, SD_ASYM_CPUCAPACITY_FULL);
> rcu_assign_pointer(per_cpu(sd_asym_cpucapacity, cpu), sd);
> }
>
> @@ -1989,66 +1989,96 @@ static bool topology_span_sane(struct sched_domain_topology_level *tl,
>
> return true;
> }
> -
> +/**
> + * Asym capacity bits
Nit: Dietmar would have us phrase this "Asymmetric CPU capacity bits".
> + */
> +struct asym_cap_data {
> + struct list_head link;
> + unsigned long capacity;
> + struct cpumask *cpu_mask;
> +};
> +/*
> + * Verify whether given CPU at a given topology level belongs to a sched domain
> + * that does span CPUs with different capacities.
> + * Provides sd_flags reflecting the asymmetry scope.
> + */
> +static inline int
> +asym_cpu_capacity_classify(struct sched_domain_topology_level *tl, int cpu)
> +{
> + int sd_asym_flags = SD_ASYM_CPUCAPACITY | SD_ASYM_CPUCAPACITY_FULL;
> + const struct cpumask *tl_mask = tl->mask(cpu);
> + struct asym_cap_data *entry;
> + int asym_cap_count = 0;
> +
> + if (list_is_singular(&asym_cap_list))
> + goto leave;
> +
> + list_for_each_entry(entry, &asym_cap_list, link) {
> + if (cpumask_intersects(tl_mask, entry->cpu_mask))
> + ++asym_cap_count;
Ah, this is using tl->mask() which *isn't* masked by the root_domain's
cpu_map...
See comment below on the scan; long story short we could issue this *after*
build_sched_domain() so we can directly use sched_domain_span(sd) which
*is* masked by the cpu_map. This kind of removes the need for that dflags
param, but then we're already sidestepping it for SD_OVERLAP.
EDIT: nope, we have a check against SD_ASYM_CPUCAPACITY in sd_init()... I
guess we could issue asym_cpu_capacity_classify() in sd_init() itself?
> +/*
> + * Build-up/update list of CPUs grouped by their capacities
> + */
> +static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
> +{
> + struct asym_cap_data *entry, *next;
> + int cpu;
>
> - for_each_sd_topology(tl) {
> - if (tl_id < asym_level)
> - goto next_level;
> + if (!list_empty(&asym_cap_list))
> + list_for_each_entry(entry, &asym_cap_list, link)
> + cpumask_clear(entry->cpu_mask);
>
The topology isn't going to change between domain rebuilds, so why
recompute the masks? The sched_domain spans are already masked by cpu_map,
so no need to do this masking twice. I'm thinking this scan should be done
once against the cpu_possible_mask - kinda like sched_init_numa() done once
against the possible nodes.
Ideally I'd see this as an __init function, unfortunately we need that to
happen after cpufreq drivers have been loaded (in case all CPUs have same
µarch but some can reach higher frequencies, which would yield asymmetry),
and some of those can be built as modules :/
> + entry = kzalloc(sizeof(*entry) + cpumask_size(), GFP_KERNEL);
> + if (entry) {
> + entry->capacity = capacity;
> + entry->cpu_mask = (struct cpumask *)((char *)entry +
> + sizeof(*entry));
> + list_add(&entry->link, &asym_cap_list);
> }
> + WARN_ONCE(!entry,
> + "Failed to allocate memory for capacity asymmetry detection\n");
> +next:
> + __cpumask_set_cpu(cpu, entry->cpu_mask);
That looks like a NULL deref if the above WARN is hit.
On Mon, May 17, 2021 at 01:04:25PM +0100, Valentin Schneider wrote:
> On 17/05/21 09:23, Beata Michalska wrote:
> > Currently the CPU capacity asymmetry detection, performed through
> > asym_cpu_capacity_level, tries to identify the lowest topology level
> > at which the highest CPU capacity is being observed, not necessarily
> > finding the level at which all possible capacity values are visible
> > to all CPUs, which might be bit problematic for some possible/valid
> > asymmetric topologies i.e.:
> >
> > DIE [ ]
> > MC [ ][ ]
> >
> > CPU [0] [1] [2] [3] [4] [5] [6] [7]
> > Capacity |.....| |.....| |.....| |.....|
> > L M B B
> >
> > Where:
> > arch_scale_cpu_capacity(L) = 512
> > arch_scale_cpu_capacity(M) = 871
> > arch_scale_cpu_capacity(B) = 1024
> >
> > In this particular case, the asymmetric topology level will point
> > at MC, as all possible CPU masks for that level do cover the CPU
> > with the highest capacity. It will work just fine for the first
> > cluster, not so much for the second one though (consider the
> > find_energy_efficient_cpu which might end up attempting the energy
> > aware wake-up for a domain that does not see any asymmetry at all)
> >
> > Rework the way the capacity asymmetry levels are being detected,
> > allowing to point to the lowest topology level (for a given CPU), where
> > full range of available CPU capacities is visible to all CPUs within given
> > domain. As a result, the per-cpu sd_asym_cpucapacity might differ across
> > the domains. This will have an impact on EAS wake-up placement in a way
> > that it might see different rage of CPUs to be considered, depending on
> > the given current and target CPUs.
> >
> > Additionally, those levels, where any range of asymmetry (not
> > necessarily full) is being detected will get identified as well.
> > The selected asymmetric topology level will be denoted by
> > SD_ASYM_CPUCAPACITY_FULL sched domain flag whereas the 'sub-levels'
> > would receive the already used SD_ASYM_CPUCAPACITY flag. This allows
> > maintaining the current behaviour for asymmetric topologies, with
> > misfit migration operating correctly on lower levels, if applicable,
> > as any asymmetry is enough to trigger the misfit migration.
> > The logic there relies on the SD_ASYM_CPUCAPACITY flag and does not
> > relate to the full asymmetry level denoted by the sd_asym_cpucapacity
> > pointer.
> >
> > Suggested-by: Peter Zijlstra <[email protected]>
> > Signed-off-by: Beata Michalska <[email protected]>
>
> That does look quite simpler :-)
>
> A lesson for me as a reviewer here is to resist biting into the nitty
> gritty code details and spend more time on a first conceptual / high level
> review pass. It's not the first time I'm guilty of it, so I do need to work
> on that.
>
> > ---
> > kernel/sched/topology.c | 129 +++++++++++++++++++++++++++++-------------------
> > 1 file changed, 79 insertions(+), 50 deletions(-)
> >
> > diff --git a/kernel/sched/topology.c b/kernel/sched/topology.c
> > index 55a0a24..81957f7 100644
> > --- a/kernel/sched/topology.c
> > +++ b/kernel/sched/topology.c
> > @@ -675,7 +675,7 @@ static void update_top_cache_domain(int cpu)
> > sd = highest_flag_domain(cpu, SD_ASYM_PACKING);
> > rcu_assign_pointer(per_cpu(sd_asym_packing, cpu), sd);
> >
> > - sd = lowest_flag_domain(cpu, SD_ASYM_CPUCAPACITY);
> > + sd = lowest_flag_domain(cpu, SD_ASYM_CPUCAPACITY_FULL);
> > rcu_assign_pointer(per_cpu(sd_asym_cpucapacity, cpu), sd);
> > }
> >
> > @@ -1989,66 +1989,96 @@ static bool topology_span_sane(struct sched_domain_topology_level *tl,
> >
> > return true;
> > }
> > -
> > +/**
> > + * Asym capacity bits
>
> Nit: Dietmar would have us phrase this "Asymmetric CPU capacity bits".
>
> > + */
> > +struct asym_cap_data {
> > + struct list_head link;
> > + unsigned long capacity;
> > + struct cpumask *cpu_mask;
> > +};
>
> > +/*
> > + * Verify whether given CPU at a given topology level belongs to a sched domain
> > + * that does span CPUs with different capacities.
> > + * Provides sd_flags reflecting the asymmetry scope.
> > + */
> > +static inline int
> > +asym_cpu_capacity_classify(struct sched_domain_topology_level *tl, int cpu)
> > +{
> > + int sd_asym_flags = SD_ASYM_CPUCAPACITY | SD_ASYM_CPUCAPACITY_FULL;
> > + const struct cpumask *tl_mask = tl->mask(cpu);
> > + struct asym_cap_data *entry;
> > + int asym_cap_count = 0;
> > +
> > + if (list_is_singular(&asym_cap_list))
> > + goto leave;
> > +
> > + list_for_each_entry(entry, &asym_cap_list, link) {
> > + if (cpumask_intersects(tl_mask, entry->cpu_mask))
> > + ++asym_cap_count;
>
> Ah, this is using tl->mask() which *isn't* masked by the root_domain's
> cpu_map...
>
> See comment below on the scan; long story short we could issue this *after*
> build_sched_domain() so we can directly use sched_domain_span(sd) which
> *is* masked by the cpu_map. This kind of removes the need for that dflags
> param, but then we're already sidestepping it for SD_OVERLAP.
>
> EDIT: nope, we have a check against SD_ASYM_CPUCAPACITY in sd_init()... I
> guess we could issue asym_cpu_capacity_classify() in sd_init() itself?
>
Yeah, sd_init does rely on the SD_ASYM_CPUCAPACITY flag being available,
if needed. The tl->mask isn't masked out but the per-capacity masks are.
Should be enough for the intersection check.
> > +/*
> > + * Build-up/update list of CPUs grouped by their capacities
> > + */
> > +static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
> > +{
> > + struct asym_cap_data *entry, *next;
> > + int cpu;
> >
> > - for_each_sd_topology(tl) {
> > - if (tl_id < asym_level)
> > - goto next_level;
> > + if (!list_empty(&asym_cap_list))
> > + list_for_each_entry(entry, &asym_cap_list, link)
> > + cpumask_clear(entry->cpu_mask);
> >
>
> The topology isn't going to change between domain rebuilds, so why
> recompute the masks? The sched_domain spans are already masked by cpu_map,
> so no need to do this masking twice. I'm thinking this scan should be done
> once against the cpu_possible_mask - kinda like sched_init_numa() done once
> against the possible nodes.
>
This is currently done, as what you have mentioned earlier, the tl->mask
may contain CPUs that are not 'available'. So it makes sure that the masks
kept on the list are representing only those CPUs that are online.
And it is also needed case all CPUs of given capacity go offline - not to to
lose the full asymmetry that might change because of that ( empty masks are
being removed from the list).
I could change that and use the CPU mask that represents the online CPUs as
a checkpoint but then it also means additional tracking which items on the
list are actually available at a given point of time.
So if the CPUs masks on the list are to be set once (as you are suggesting)
than it needs additional logic to count the number of available capacities
to decide whether there is a full asymmetry or not.
> Ideally I'd see this as an __init function, unfortunately we need that to
> happen after cpufreq drivers have been loaded (in case all CPUs have same
> ?arch but some can reach higher frequencies, which would yield asymmetry),
> and some of those can be built as modules :/
>
Yeah, this is the tricky bit: and one of the reasons the capacity masks are
being cleared.
> > + entry = kzalloc(sizeof(*entry) + cpumask_size(), GFP_KERNEL);
> > + if (entry) {
> > + entry->capacity = capacity;
> > + entry->cpu_mask = (struct cpumask *)((char *)entry +
> > + sizeof(*entry));
> > + list_add(&entry->link, &asym_cap_list);
> > }
> > + WARN_ONCE(!entry,
> > + "Failed to allocate memory for capacity asymmetry detection\n");
> > +next:
> > + __cpumask_set_cpu(cpu, entry->cpu_mask);
>
> That looks like a NULL deref if the above WARN is hit.
Nah, indeed!
---
BR
B.
On 17/05/21 14:18, Beata Michalska wrote:
> On Mon, May 17, 2021 at 01:04:25PM +0100, Valentin Schneider wrote:
>> On 17/05/21 09:23, Beata Michalska wrote:
>> > +static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
>> > +{
>> > + struct asym_cap_data *entry, *next;
>> > + int cpu;
>> >
>> > - for_each_sd_topology(tl) {
>> > - if (tl_id < asym_level)
>> > - goto next_level;
>> > + if (!list_empty(&asym_cap_list))
>> > + list_for_each_entry(entry, &asym_cap_list, link)
>> > + cpumask_clear(entry->cpu_mask);
>> >
>>
>> The topology isn't going to change between domain rebuilds, so why
>> recompute the masks? The sched_domain spans are already masked by cpu_map,
>> so no need to do this masking twice. I'm thinking this scan should be done
>> once against the cpu_possible_mask - kinda like sched_init_numa() done once
>> against the possible nodes.
>>
> This is currently done, as what you have mentioned earlier, the tl->mask
> may contain CPUs that are not 'available'. So it makes sure that the masks
> kept on the list are representing only those CPUs that are online.
> And it is also needed case all CPUs of given capacity go offline - not to to
> lose the full asymmetry that might change because of that ( empty masks are
> being removed from the list).
>
> I could change that and use the CPU mask that represents the online CPUs as
> a checkpoint but then it also means additional tracking which items on the
> list are actually available at a given point of time.
> So if the CPUs masks on the list are to be set once (as you are suggesting)
> than it needs additional logic to count the number of available capacities
> to decide whether there is a full asymmetry or not.
>
That should be doable by counting non-empty intersections between each
entry->cpumask and the cpu_online_mask in _classify().
That said I'm afraid cpufreq module loading forces us to dynamically update
those masks, as you've done. The first domain build could see asymmetry
without cpufreq loaded, and a later one with cpufreq loaded would need an
update. Conversely, as much of a fringe case as it is, we'd have to cope
with the cpufreq module being unloaded later on...
:(
On Mon, May 17, 2021 at 04:06:05PM +0100, Valentin Schneider wrote:
> On 17/05/21 14:18, Beata Michalska wrote:
> > On Mon, May 17, 2021 at 01:04:25PM +0100, Valentin Schneider wrote:
> >> On 17/05/21 09:23, Beata Michalska wrote:
> >> > +static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
> >> > +{
> >> > + struct asym_cap_data *entry, *next;
> >> > + int cpu;
> >> >
> >> > - for_each_sd_topology(tl) {
> >> > - if (tl_id < asym_level)
> >> > - goto next_level;
> >> > + if (!list_empty(&asym_cap_list))
> >> > + list_for_each_entry(entry, &asym_cap_list, link)
> >> > + cpumask_clear(entry->cpu_mask);
> >> >
> >>
> >> The topology isn't going to change between domain rebuilds, so why
> >> recompute the masks? The sched_domain spans are already masked by cpu_map,
> >> so no need to do this masking twice. I'm thinking this scan should be done
> >> once against the cpu_possible_mask - kinda like sched_init_numa() done once
> >> against the possible nodes.
> >>
> > This is currently done, as what you have mentioned earlier, the tl->mask
> > may contain CPUs that are not 'available'. So it makes sure that the masks
> > kept on the list are representing only those CPUs that are online.
> > And it is also needed case all CPUs of given capacity go offline - not to to
> > lose the full asymmetry that might change because of that ( empty masks are
> > being removed from the list).
> >
> > I could change that and use the CPU mask that represents the online CPUs as
> > a checkpoint but then it also means additional tracking which items on the
> > list are actually available at a given point of time.
> > So if the CPUs masks on the list are to be set once (as you are suggesting)
> > than it needs additional logic to count the number of available capacities
> > to decide whether there is a full asymmetry or not.
> >
>
> That should be doable by counting non-empty intersections between each
> entry->cpumask and the cpu_online_mask in _classify().
>
> That said I'm afraid cpufreq module loading forces us to dynamically update
> those masks, as you've done. The first domain build could see asymmetry
> without cpufreq loaded, and a later one with cpufreq loaded would need an
> update. Conversely, as much of a fringe case as it is, we'd have to cope
> with the cpufreq module being unloaded later on...
>
> :(
So it got me thinking that maybe we could actually make it more
'update-on-demand' and use the cpufreq policy notifier to trigger the update.
I could try to draft smth generic enough to make it ... relatively easy to adapt
to different archs case needed.
Any thoughts ?
---
BR
B.
On 18/05/21 15:40, Beata Michalska wrote:
> On Mon, May 17, 2021 at 04:06:05PM +0100, Valentin Schneider wrote:
>> On 17/05/21 14:18, Beata Michalska wrote:
>> > On Mon, May 17, 2021 at 01:04:25PM +0100, Valentin Schneider wrote:
>> >> On 17/05/21 09:23, Beata Michalska wrote:
>> >> > +static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
>> >> > +{
>> >> > + struct asym_cap_data *entry, *next;
>> >> > + int cpu;
>> >> >
>> >> > - for_each_sd_topology(tl) {
>> >> > - if (tl_id < asym_level)
>> >> > - goto next_level;
>> >> > + if (!list_empty(&asym_cap_list))
>> >> > + list_for_each_entry(entry, &asym_cap_list, link)
>> >> > + cpumask_clear(entry->cpu_mask);
>> >> >
>> >>
>> >> The topology isn't going to change between domain rebuilds, so why
>> >> recompute the masks? The sched_domain spans are already masked by cpu_map,
>> >> so no need to do this masking twice. I'm thinking this scan should be done
>> >> once against the cpu_possible_mask - kinda like sched_init_numa() done once
>> >> against the possible nodes.
>> >>
>> > This is currently done, as what you have mentioned earlier, the tl->mask
>> > may contain CPUs that are not 'available'. So it makes sure that the masks
>> > kept on the list are representing only those CPUs that are online.
>> > And it is also needed case all CPUs of given capacity go offline - not to to
>> > lose the full asymmetry that might change because of that ( empty masks are
>> > being removed from the list).
>> >
>> > I could change that and use the CPU mask that represents the online CPUs as
>> > a checkpoint but then it also means additional tracking which items on the
>> > list are actually available at a given point of time.
>> > So if the CPUs masks on the list are to be set once (as you are suggesting)
>> > than it needs additional logic to count the number of available capacities
>> > to decide whether there is a full asymmetry or not.
>> >
>>
>> That should be doable by counting non-empty intersections between each
>> entry->cpumask and the cpu_online_mask in _classify().
>>
>> That said I'm afraid cpufreq module loading forces us to dynamically update
>> those masks, as you've done. The first domain build could see asymmetry
>> without cpufreq loaded, and a later one with cpufreq loaded would need an
>> update. Conversely, as much of a fringe case as it is, we'd have to cope
>> with the cpufreq module being unloaded later on...
>>
>> :(
> So it got me thinking that maybe we could actually make it more
> 'update-on-demand' and use the cpufreq policy notifier to trigger the update.
> I could try to draft smth generic enough to make it ... relatively easy to adapt
> to different archs case needed.
> Any thoughts ?
>
The cpufreq policy notifier rebuild is currently an arch_topology.c
specificity, and perhaps we can consider this as our standing policy: if an
arch needs a topology rebuild upon X event (which isn't hotplug), it is
responsible for triggering it itself.
There's those sched_energy_update / arch_update_cpu_topology() bools that
are used to tweak the rebuild behaviour, perhaps you could gate the
capacity maps rebuild behind arch_update_cpu_topology()?
That way you could build those maps based on a cpu_possible_mask iterator,
and only rebuild them when the arch requests it (arch_topology already does
that with the cpufreq notifier). How does it sound?
> ---
> BR
> B.
On Tue, May 18, 2021 at 04:53:54PM +0100, Valentin Schneider wrote:
> On 18/05/21 15:40, Beata Michalska wrote:
> > On Mon, May 17, 2021 at 04:06:05PM +0100, Valentin Schneider wrote:
> >> On 17/05/21 14:18, Beata Michalska wrote:
> >> > On Mon, May 17, 2021 at 01:04:25PM +0100, Valentin Schneider wrote:
> >> >> On 17/05/21 09:23, Beata Michalska wrote:
> >> >> > +static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
> >> >> > +{
> >> >> > + struct asym_cap_data *entry, *next;
> >> >> > + int cpu;
> >> >> >
> >> >> > - for_each_sd_topology(tl) {
> >> >> > - if (tl_id < asym_level)
> >> >> > - goto next_level;
> >> >> > + if (!list_empty(&asym_cap_list))
> >> >> > + list_for_each_entry(entry, &asym_cap_list, link)
> >> >> > + cpumask_clear(entry->cpu_mask);
> >> >> >
> >> >>
> >> >> The topology isn't going to change between domain rebuilds, so why
> >> >> recompute the masks? The sched_domain spans are already masked by cpu_map,
> >> >> so no need to do this masking twice. I'm thinking this scan should be done
> >> >> once against the cpu_possible_mask - kinda like sched_init_numa() done once
> >> >> against the possible nodes.
> >> >>
> >> > This is currently done, as what you have mentioned earlier, the tl->mask
> >> > may contain CPUs that are not 'available'. So it makes sure that the masks
> >> > kept on the list are representing only those CPUs that are online.
> >> > And it is also needed case all CPUs of given capacity go offline - not to to
> >> > lose the full asymmetry that might change because of that ( empty masks are
> >> > being removed from the list).
> >> >
> >> > I could change that and use the CPU mask that represents the online CPUs as
> >> > a checkpoint but then it also means additional tracking which items on the
> >> > list are actually available at a given point of time.
> >> > So if the CPUs masks on the list are to be set once (as you are suggesting)
> >> > than it needs additional logic to count the number of available capacities
> >> > to decide whether there is a full asymmetry or not.
> >> >
> >>
> >> That should be doable by counting non-empty intersections between each
> >> entry->cpumask and the cpu_online_mask in _classify().
> >>
> >> That said I'm afraid cpufreq module loading forces us to dynamically update
> >> those masks, as you've done. The first domain build could see asymmetry
> >> without cpufreq loaded, and a later one with cpufreq loaded would need an
> >> update. Conversely, as much of a fringe case as it is, we'd have to cope
> >> with the cpufreq module being unloaded later on...
> >>
> >> :(
> > So it got me thinking that maybe we could actually make it more
> > 'update-on-demand' and use the cpufreq policy notifier to trigger the update.
> > I could try to draft smth generic enough to make it ... relatively easy to adapt
> > to different archs case needed.
> > Any thoughts ?
> >
>
> The cpufreq policy notifier rebuild is currently an arch_topology.c
> specificity, and perhaps we can consider this as our standing policy: if an
> arch needs a topology rebuild upon X event (which isn't hotplug), it is
> responsible for triggering it itself.
>
> There's those sched_energy_update / arch_update_cpu_topology() bools that
> are used to tweak the rebuild behaviour, perhaps you could gate the
> capacity maps rebuild behind arch_update_cpu_topology()?
>
> That way you could build those maps based on a cpu_possible_mask iterator,
> and only rebuild them when the arch requests it (arch_topology already does
> that with the cpufreq notifier). How does it sound?
>
That sounds reasonable/doable. Will see how that plays out.
Thanks.
---
BR
B.
> > ---
> > BR
> > B.
Mostly style nits, since I read you're already looking at reworking this
due to other feedback, do with it what you like.
On Mon, May 17, 2021 at 09:23:50AM +0100, Beata Michalska wrote:
> @@ -1989,66 +1989,96 @@ static bool topology_span_sane(struct sched_domain_topology_level *tl,
>
> return true;
> }
+ whitespace
> +/**
> + * Asym capacity bits
> + */
> +struct asym_cap_data {
> + struct list_head link;
> + unsigned long capacity;
> + struct cpumask *cpu_mask;
> +};
+ whitespace
> /*
> + * Set of available CPUs grouped by their corresponding capacities
> + * Each list entry contains a CPU mask reflecting CPUs that share the same
> + * capacity.
> + * The lifespan of data is unlimited.
> */
> +static LIST_HEAD(asym_cap_list);
>
> +/*
> + * Verify whether given CPU at a given topology level belongs to a sched domain
> + * that does span CPUs with different capacities.
> + * Provides sd_flags reflecting the asymmetry scope.
> + */
> +static inline int
> +asym_cpu_capacity_classify(struct sched_domain_topology_level *tl, int cpu)
> +{
> + int sd_asym_flags = SD_ASYM_CPUCAPACITY | SD_ASYM_CPUCAPACITY_FULL;
> + const struct cpumask *tl_mask = tl->mask(cpu);
> + struct asym_cap_data *entry;
> + int asym_cap_count = 0;
> +
> + if (list_is_singular(&asym_cap_list))
> + goto leave;
> +
> + list_for_each_entry(entry, &asym_cap_list, link) {
> + if (cpumask_intersects(tl_mask, entry->cpu_mask))
> + ++asym_cap_count;
> + else
> + sd_asym_flags &= ~SD_ASYM_CPUCAPACITY_FULL;
> }
> + WARN_ON_ONCE(!asym_cap_count);
> +leave:
> + return asym_cap_count > 1 ? sd_asym_flags : 0;
> +}
>
>
- whitespace
> +/*
> + * Build-up/update list of CPUs grouped by their capacities
> + */
> +static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
> +{
> + struct asym_cap_data *entry, *next;
> + int cpu;
>
> + if (!list_empty(&asym_cap_list))
> + list_for_each_entry(entry, &asym_cap_list, link)
> + cpumask_clear(entry->cpu_mask);
two nits:
- the if() needs { } because while what follows is strictly a single
statement, it is multi-line, so coding style requires { }.
- the if() is strictly superfluous, if the list is empty the
list_for_each_entry() iteration already doesn't do anything.
>
> + entry = list_first_entry_or_null(&asym_cap_list,
> + struct asym_cap_data, link);
Please align line-breaks at the most nested (, vim can help you do this
with: set cino=(0:0, if you're using that other editor, I'm sure you can
convince it to align properly too :-)
>
> + for_each_cpu(cpu, cpu_map) {
> + unsigned long capacity = arch_scale_cpu_capacity(cpu);
>
> + if (entry && capacity == entry->capacity)
> + goto next;
>
> + list_for_each_entry(entry, &asym_cap_list, link)
> + if (capacity == entry->capacity)
> + goto next;
{ } again
> +
> + entry = kzalloc(sizeof(*entry) + cpumask_size(), GFP_KERNEL);
> + if (entry) {
> + entry->capacity = capacity;
> + entry->cpu_mask = (struct cpumask *)((char *)entry +
> + sizeof(*entry));
alignment again
> + list_add(&entry->link, &asym_cap_list);
> }
> + WARN_ONCE(!entry,
> + "Failed to allocate memory for capacity asymmetry detection\n");
alignment again
(also, eeew, if this lives, perhaps a find_asym_data(capacity) helper
might make it better:
if (!entry || entry->capacity != capacity)
entry = find_asym_data(capacity);
)
> +next:
> + __cpumask_set_cpu(cpu, entry->cpu_mask);
> }
>
> + list_for_each_entry_safe(entry, next, &asym_cap_list, link) {
> + if (cpumask_empty(entry->cpu_mask)) {
> + list_del(&entry->link);
> + kfree(entry);
> + }
> + }
See, this has { }
> }
On Wed, May 19, 2021 at 01:30:05PM +0200, Peter Zijlstra wrote:
>
> Mostly style nits, since I read you're already looking at reworking this
> due to other feedback, do with it what you like.
>
Will apply your remarks on whatever ends up in the new version, which should be
most of it. To be out soon.
Thank You
---
BR
B.
> On Mon, May 17, 2021 at 09:23:50AM +0100, Beata Michalska wrote:
> > @@ -1989,66 +1989,96 @@ static bool topology_span_sane(struct sched_domain_topology_level *tl,
> >
> > return true;
> > }
>
> + whitespace
>
> > +/**
> > + * Asym capacity bits
> > + */
> > +struct asym_cap_data {
> > + struct list_head link;
> > + unsigned long capacity;
> > + struct cpumask *cpu_mask;
> > +};
>
> + whitespace
>
> > /*
> > + * Set of available CPUs grouped by their corresponding capacities
> > + * Each list entry contains a CPU mask reflecting CPUs that share the same
> > + * capacity.
> > + * The lifespan of data is unlimited.
> > */
> > +static LIST_HEAD(asym_cap_list);
> >
> > +/*
> > + * Verify whether given CPU at a given topology level belongs to a sched domain
> > + * that does span CPUs with different capacities.
> > + * Provides sd_flags reflecting the asymmetry scope.
> > + */
> > +static inline int
> > +asym_cpu_capacity_classify(struct sched_domain_topology_level *tl, int cpu)
> > +{
> > + int sd_asym_flags = SD_ASYM_CPUCAPACITY | SD_ASYM_CPUCAPACITY_FULL;
> > + const struct cpumask *tl_mask = tl->mask(cpu);
> > + struct asym_cap_data *entry;
> > + int asym_cap_count = 0;
> > +
> > + if (list_is_singular(&asym_cap_list))
> > + goto leave;
> > +
> > + list_for_each_entry(entry, &asym_cap_list, link) {
> > + if (cpumask_intersects(tl_mask, entry->cpu_mask))
> > + ++asym_cap_count;
> > + else
> > + sd_asym_flags &= ~SD_ASYM_CPUCAPACITY_FULL;
> > }
> > + WARN_ON_ONCE(!asym_cap_count);
> > +leave:
> > + return asym_cap_count > 1 ? sd_asym_flags : 0;
> > +}
> >
> >
>
> - whitespace
>
> > +/*
> > + * Build-up/update list of CPUs grouped by their capacities
> > + */
> > +static void asym_cpu_capacity_scan(const struct cpumask *cpu_map)
> > +{
> > + struct asym_cap_data *entry, *next;
> > + int cpu;
> >
> > + if (!list_empty(&asym_cap_list))
> > + list_for_each_entry(entry, &asym_cap_list, link)
> > + cpumask_clear(entry->cpu_mask);
>
> two nits:
>
> - the if() needs { } because while what follows is strictly a single
> statement, it is multi-line, so coding style requires { }.
>
> - the if() is strictly superfluous, if the list is empty the
> list_for_each_entry() iteration already doesn't do anything.
>
> >
> > + entry = list_first_entry_or_null(&asym_cap_list,
> > + struct asym_cap_data, link);
>
> Please align line-breaks at the most nested (, vim can help you do this
> with: set cino=(0:0, if you're using that other editor, I'm sure you can
> convince it to align properly too :-)
>
> >
> > + for_each_cpu(cpu, cpu_map) {
> > + unsigned long capacity = arch_scale_cpu_capacity(cpu);
> >
> > + if (entry && capacity == entry->capacity)
> > + goto next;
> >
> > + list_for_each_entry(entry, &asym_cap_list, link)
> > + if (capacity == entry->capacity)
> > + goto next;
>
> { } again
>
> > +
> > + entry = kzalloc(sizeof(*entry) + cpumask_size(), GFP_KERNEL);
> > + if (entry) {
> > + entry->capacity = capacity;
> > + entry->cpu_mask = (struct cpumask *)((char *)entry +
> > + sizeof(*entry));
>
> alignment again
>
> > + list_add(&entry->link, &asym_cap_list);
> > }
> > + WARN_ONCE(!entry,
> > + "Failed to allocate memory for capacity asymmetry detection\n");
>
> alignment again
>
> (also, eeew, if this lives, perhaps a find_asym_data(capacity) helper
> might make it better:
>
> if (!entry || entry->capacity != capacity)
> entry = find_asym_data(capacity);
> )
>
> > +next:
> > + __cpumask_set_cpu(cpu, entry->cpu_mask);
> > }
> >
> > + list_for_each_entry_safe(entry, next, &asym_cap_list, link) {
> > + if (cpumask_empty(entry->cpu_mask)) {
> > + list_del(&entry->link);
> > + kfree(entry);
> > + }
> > + }
>
> See, this has { }
>
> > }