sched: Instrument sched domain flags
Subsystems (2)
v3 cover sched: Instrument sched domain flags
Hi,
I've repeatedly stared at an SD flag and asked myself "how should that be set up in the domain hierarchy anyway?". I figured that if we formalize our flags zoology a bit, we could also do some runtime assertions on them - this is what this series is all about.
Patches
=======
The idea is to associate the flags with metaflags that describes how they should be set in a sched domain hierarchy ("if this SD has it, all its {parents, children} have it") or how they behave wrt degeneration - details are in the comments and commit logs.
The good thing is that the debugging bits go away when CONFIG_SCHED_DEBUG isn't set. The bad thing is that this replaces SD_* flags definitions with some unsavoury macros. This is mainly because I wanted to avoid having to duplicate work between declaring the flags and declaring their metaflags.
o Patches 1-2 set up the SD flag definition groundwork
o Patch 3 enables the hierarchy debugging
o Patch 4 is a derelict SD flag removal
o Patches 5-7 tweak the SD degeneration to leverage metaflags as well (suggested by Peter).
Note that this builds a compile-time mask using the single most horrendous macro I have ever presented to the public eye. It might end up being much better to explicitely build the mask in topology.h, but to be honest I felt like I had to show that monster around out of morbid fascination.
Revisions
=========
v2 -> v3
--------
o Reworded comment for SD_OVERLAP (it's about the groups, not the domains)
o Added more flags to the SD degeneration mask
o Added generation of an SD flag mask for the degeneration functions (Peter)
RFC -> v2
---------
o Rebased on top of tip/sched/core
o Aligned wording of comments between flags
o Rectified some flag descriptions (Morten)
o Added removal of SD_SHARE_POWERDOMAIN (Morten)
Valentin Schneider (7):
sched/topology: Split out SD_* flags declaration to its own file sched/topology: Define and assign sched_domain flag metadata sched/topology: Verify SD_* flags setup when sched_debug is on arm, sched/topology: Remove SD_SHARE_POWERDOMAIN sched/topology: Add more flags to the SD degeneration mask sched/topology: Introduce SD metaflag for flags needing > 1 groups sched/topology: Use prebuilt SD flag degeneration mask
arch/arm/kernel/topology.c | 2 +- include/linux/sched/sd_flags.h | 153 +++++++++++++++++++++++++++++++++ include/linux/sched/topology.h | 36 +++++--- kernel/sched/topology.c | 40 +++++---- 4 files changed, 197 insertions(+), 34 deletions(-) create mode 100644 include/linux/sched/sd_flags.h
--
2.27.0
PATCH v3 1/7 sched/topology: Split out SD_* flags declaration to its own file
To associate the SD flags with some metadata, we need some more structure in the way they are declared.
Rather than shove that in a free-standing macro list, move the declaration in a separate file that can be re-imported with different SD_FLAG definitions, inspired by what we do with syscalls and unistd.h.
No change in functionality.
--- include/linux/sched/sd_flags.h | 33 +++++++++++++++++++++++++++++++++ include/linux/sched/topology.h | 18 ++++-------------- 2 files changed, 37 insertions(+), 14 deletions(-) create mode 100644 include/linux/sched/sd_flags.h
include/linux/sched/sd_flags.h new file +33 -0
@@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* sched-domains (multiprocessor balancing) flag declarations. +*/ + +/* Balance when about to become idle */ +SD_FLAG (SD_BALANCE_NEWIDLE ,0 ) +/* Balance on exec */ +SD_FLAG (SD_BALANCE_EXEC ,1 ) +/* Balance on fork, clone */ +SD_FLAG (SD_BALANCE_FORK ,2 ) +/* Balance on wakeup */ +SD_FLAG (SD_BALANCE_WAKE ,3 ) +/* Wake task to waking CPU */ +SD_FLAG (SD_WAKE_AFFINE ,4 ) +/* Domain members have different CPU capacities */ +SD_FLAG (SD_ASYM_CPUCAPACITY ,5 ) +/* Domain members share CPU capacity */ +SD_FLAG (SD_SHARE_CPUCAPACITY ,6 ) +/* Domain members share power domain */ +SD_FLAG (SD_SHARE_POWERDOMAIN ,7 ) +/* Domain members share CPU pkg resources */ +SD_FLAG (SD_SHARE_PKG_RESOURCES ,8 ) +/* Only a single load balancing instance */ +SD_FLAG (SD_SERIALIZE ,9 ) +/* Place busy groups earlier in the domain */ +SD_FLAG (SD_ASYM_PACKING ,10 ) +/* Prefer to place tasks in a sibling domain */ +SD_FLAG (SD_PREFER_SIBLING ,11 ) +/* sched_domains of this level overlap */ +SD_FLAG (SD_OVERLAP ,12 ) +/* cross-node balancing */ +SD_FLAG (SD_NUMA ,13 )
include/linux/sched/topology.h +4 -14
@@ -11,20 +11,10 @@*/ #ifdef CONFIG_SMP -#define SD_BALANCE_NEWIDLE 0x0001/* Balance when about to become idle */ -#define SD_BALANCE_EXEC 0x0002/* Balance on exec */ -#define SD_BALANCE_FORK 0x0004/* Balance on fork, clone */ -#define SD_BALANCE_WAKE 0x0008/* Balance on wakeup */ -#define SD_WAKE_AFFINE 0x0010/* Wake task to waking CPU */ -#define SD_ASYM_CPUCAPACITY 0x0020/* Domain members have different CPU capacities */ -#define SD_SHARE_CPUCAPACITY 0x0040/* Domain members share CPU capacity */ -#define SD_SHARE_POWERDOMAIN 0x0080/* Domain members share power domain */ -#define SD_SHARE_PKG_RESOURCES 0x0100/* Domain members share CPU pkg resources */ -#define SD_SERIALIZE 0x0200/* Only a single load balancing instance */ -#define SD_ASYM_PACKING 0x0400/* Place busy groups earlier in the domain */ -#define SD_PREFER_SIBLING 0x0800/* Prefer to place tasks in a sibling domain */ -#define SD_OVERLAP 0x1000/* sched_domains of this level overlap */ -#define SD_NUMA 0x2000/* cross-node balancing */ +/* Generate SD_FOO = VALUE */ +#define SD_FLAG (name, idx) static const unsigned int name = BIT(idx); +#include <linux/sched/sd_flags.h> +#undef SD_FLAG#ifdef CONFIG_SCHED_SMT static inline int cpu_smt_flags (void )
Signature · 1 line
2.27.0
PATCH v3 2/7 sched/topology: Define and assign sched_domain flag metadata
In reply to Valentin SchneiderThere are some expectations regarding how sched domain flags should be laid out, but none of them are checked or asserted in sched_domain_debug_one(). After staring at said flags for a while, I've come to realize they all (except *one*) fall in either of two categories:
- Shared with children: those flags are set from the base CPU domain upwards. Any domain that has it set will have it set in its children. It hints at "some property holds true / some behaviour is enabled until this level".
- Shared with parents: those flags are set from the topmost domain downwards. Any domain that has it set will have it set in its parents. It hints at "some property isn't visible / some behaviour is disabled until this level".
The odd one out is SD_PREFER_SIBLING, which is cleared below levels with SD_ASYM_CPUCAPACITY. The change was introduced by commit
9c63e84db29b ("sched/core: Disable SD_PREFER_SIBLING on asymmetric CPU capacity domains")
as it could break misfit migration on some systems. In light of this, we might want to change it back to make it fit one of the two categories and fix the issue another way.
Tweak the sched_domain flag declaration to assign each flag an expected layout, and include the rationale for each flag "meta type" assignment as a comment. Consolidate the flag metadata into an array; the index of a flag's metadata can easily be found with log2(flag), IOW __ffs(flag).
--- include/linux/sched/sd_flags.h | 164 +++++++++++++++++++++++++++------ include/linux/sched/topology.h | 13 ++- 2 files changed, 148 insertions(+), 29 deletions(-)
include/linux/sched/sd_flags.h +136 -28
@@ -3,31 +3,139 @@* sched-domains (multiprocessor balancing) flag declarations. */ -/* Balance when about to become idle */ -SD_FLAG (SD_BALANCE_NEWIDLE ,0 ) -/* Balance on exec */ -SD_FLAG (SD_BALANCE_EXEC ,1 ) -/* Balance on fork, clone */ -SD_FLAG (SD_BALANCE_FORK ,2 ) -/* Balance on wakeup */ -SD_FLAG (SD_BALANCE_WAKE ,3 ) -/* Wake task to waking CPU */ -SD_FLAG (SD_WAKE_AFFINE ,4 ) -/* Domain members have different CPU capacities */ -SD_FLAG (SD_ASYM_CPUCAPACITY ,5 ) -/* Domain members share CPU capacity */ -SD_FLAG (SD_SHARE_CPUCAPACITY ,6 ) -/* Domain members share power domain */ -SD_FLAG (SD_SHARE_POWERDOMAIN ,7 ) -/* Domain members share CPU pkg resources */ -SD_FLAG (SD_SHARE_PKG_RESOURCES ,8 ) -/* Only a single load balancing instance */ -SD_FLAG (SD_SERIALIZE ,9 ) -/* Place busy groups earlier in the domain */ -SD_FLAG (SD_ASYM_PACKING ,10 ) -/* Prefer to place tasks in a sibling domain */ -SD_FLAG (SD_PREFER_SIBLING ,11 ) -/* sched_domains of this level overlap */ -SD_FLAG (SD_OVERLAP ,12 ) -/* cross-node balancing */ -SD_FLAG (SD_NUMA ,13 ) +#ifndef SD_FLAG +#define SD_FLAG (x, y, z) +#endif + +/* +* Expected flag uses +* +* SHARED_CHILD: These flags are meant to be set from the base domain upwards. +* If a domain has this flag set, all of its children should have it set. This +* is usually because the flag describes some shared resource (all CPUs in that +* domain share the same foobar), or because they are tied to a scheduling +* behaviour that we want to disable at some point in the hierarchy for +* scalability reasons. +* +* In those cases it doesn't make sense to have the flag set for a domain but +* not have it in (some of) its children: sched domains ALWAYS span their child +* domains, so operations done with parent domains will cover CPUs in the lower +* child domains. +* +* +* SHARED_PARENT: These flags are meant to be set from the highest domain +* downwards. If a domain has this flag set, all of its parents should have it +* set. This is usually for topology properties that start to appear above a +* certain level (e.g. domain starts spanning CPUs outside of the base CPU's +* socket). +*/ +#define SDF_SHARED_CHILD 0x1 +#define SDF_SHARED_PARENT 0x2 + +/* +* Balance when about to become idle +* +* SHARED_CHILD: Set from the base domain up to cpuset.sched_relax_domain_level. +*/ +SD_FLAG (SD_BALANCE_NEWIDLE ,0 ,SDF_SHARED_CHILD ) + +/* +* Balance on exec +* +* SHARED_CHILD: Set from the base domain up to the NUMA reclaim level. + */ +SD_FLAG (SD_BALANCE_EXEC ,1 ,SDF_SHARED_CHILD ) + +/* +* Balance on fork, clone +* +* SHARED_CHILD: Set from the base domain up to the NUMA reclaim level. + */ +SD_FLAG (SD_BALANCE_FORK ,2 ,SDF_SHARED_CHILD ) + +/* +* Balance on wakeup +* +* SHARED_CHILD: Set from the base domain up to cpuset.sched_relax_domain_level. + */ +SD_FLAG (SD_BALANCE_WAKE ,3 ,SDF_SHARED_CHILD ) + +/* +* Consider waking task on waking CPU. +* +* SHARED_CHILD: Set from the base domain up to the NUMA reclaim level. + */ +SD_FLAG (SD_WAKE_AFFINE ,4 ,SDF_SHARED_CHILD ) + +/* +* Domain members have different CPU capacities +* +* SHARED_PARENT: Set from the topmost domain down to the first domain where +* asymmetry is detected. + */ +SD_FLAG (SD_ASYM_CPUCAPACITY ,5 ,SDF_SHARED_PARENT ) + +/* +* Domain members share CPU capacity (i.e. SMT) +* +* SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share +* CPU capacity. + */ +SD_FLAG (SD_SHARE_CPUCAPACITY ,6 ,SDF_SHARED_CHILD ) + +/* +* Domain members share power domain +* +* SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share +* the same power domain. + */ +SD_FLAG (SD_SHARE_POWERDOMAIN ,7 ,SDF_SHARED_CHILD ) + +/* +* Domain members share CPU package resources (i.e. caches) +* +* SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share +* the same cache(s). + */ +SD_FLAG (SD_SHARE_PKG_RESOURCES ,8 ,SDF_SHARED_CHILD ) + +/* +* Only a single load balancing instance +* +* SHARED_PARENT: Set for all NUMA levels above NODE. Could be set from a +* different level upwards, but it doesn't change that if a domain has this flag +* set, then all of its parents need to have it too (otherwise the serialization +* doesn't make sense). + */ +SD_FLAG (SD_SERIALIZE ,9 ,SDF_SHARED_PARENT ) + +/* +* Place busy tasks earlier in the domain +* +* SHARED_CHILD: Usually set on the SMT level. Technically could be set further +* up, but currently assumed to be set from the base domain upwards (see +* update_top_cache_domain()). + */ +SD_FLAG (SD_ASYM_PACKING ,10 ,SDF_SHARED_CHILD ) + +/* +* Prefer to place tasks in a sibling domain +* +* Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD +* flag, but cleared below domains with SD_ASYM_CPUCAPACITY. + */ +SD_FLAG (SD_PREFER_SIBLING ,11 ,0 ) + +/* +* sched_groups of this level overlap +* +* SHARED_PARENT: Set for all NUMA levels above NODE. + */ +SD_FLAG (SD_OVERLAP ,12 ,SDF_SHARED_PARENT ) + +/* +* cross-node balancing +* +* SHARED_PARENT: Set for all NUMA levels above NODE. + */ +SD_FLAG (SD_NUMA ,13 ,SDF_SHARED_PARENT )
include/linux/sched/topology.h +12 -1
@@ -12,10 +12,21 @@ #ifdef CONFIG_SMP /* Generate SD_FOO = VALUE */ -#define SD_FLAG(name, idx) static const unsigned int name = BIT(idx); +#define SD_FLAG(name, idx, mflags) static const unsigned int name = BIT(idx); #include <linux/sched/sd_flags.h> #undef SD_FLAG +#ifdef CONFIG_SCHED_DEBUG +#define SD_FLAG(_name, idx, mflags) [idx] = {.meta_flags = mflags, .name = #_name}, +static const struct { + unsigned int meta_flags; + char *name; +} sd_flag_debug[] = { +#include <linux/sched/sd_flags.h> +}; +#undef SD_FLAG +#endif + #ifdef CONFIG_SCHED_SMT static inline int cpu_smt_flags(void) {
Signature · 1 line
2.27.0
Re: [PATCH v3 2/7] sched/topology: Define and assign sched_domain flag metadata
Hey Valentin,
include/linux/sched/sd_flags.h line 76
Quoted 7 lines · Valentin Schneider
include/linux/sched/sd_flags.h +7
-0+/* +* Domain members have different CPU capacities +* +* SHARED_PARENT: Set from the topmost domain down to the first domain where +* asymmetry is detected. +*/ +SD_FLAG (SD_ASYM_CPUCAPACITY ,5 ,SDF_SHARED_PARENT )
Probably not a huge deal, but I don't think this is _exactly_ how SD_ASYM_CPUCAPACITY was defined originally, nor how the topology detection code deals with it (IIRC).
That is, IIRC Morten defined SD_ASYM_CPUCAPACITY as the _lowest_ domain at which all CPU capacities are visible. On all real systems I can think of, this domain also happens to be the topmost domain, so that might not be a huge deal and we can probably change that definition to the one you suggest. But we should perhaps make the matching changes to asym_cpu_capacity_level()/build_sched_domains() if we're going down that path?
Thanks,
Quentin
Re: [PATCH v3 2/7] sched/topology: Define and assign sched_domain flag metadata
Hi Quentin,
Thanks for having a look!
Quoted 15 lines · Quentin Perret
Hey Valentin,
Review
Quoted 7 lines · Valentin Schneider
(quoted diff) +7
-0+/* + * Domain members have different CPU capacities + * + * SHARED_PARENT: Set from the topmost domain down to the first domain where + * asymmetry is detected. + */ +SD_FLAG(SD_ASYM_CPUCAPACITY, 5, SDF_SHARED_PARENT)Probably not a huge deal, but I don't think this is _exactly_ how
SD_ASYM_CPUCAPACITYwas defined originally, nor how the topology detection code deals with it (IIRC).
Quoted 8 lines
That is, IIRC Morten defined
SD_ASYM_CPUCAPACITYas the _lowest_ domain at which all CPU capacities are visible. On all real systems I can think of, this domain also happens to be the topmost domain, so that might not be a huge deal and we can probably change that definition to the one you suggest. But we should perhaps make the matching changes to asym_cpu_capacity_level()/build_sched_domains() if we're going down that path?
You're spot on, I was trying to sweep some of it under the carpet...
There an "interesting" quirk of asym_cpu_capacity_level() in that it does something slightly different than what it says on the tin: it detects the lowest topology level where *the biggest* CPU capacity is visible by all CPUs. That works just fine on big.LITTLE, but there are questionable DynamIQ topologies that could hit some issues.
Consider:
DIE [ ]
MC [ ][ ] <- sd_asym_cpucapacity
0 1 2 3 4 5
L L B B B Basym_cpu_capacity_level() would pick MC as the asymmetric topology level, and you can argue either way: it should be DIE, because that's where CPUs 4 and 5 can see a LITTLE, or it should be MC, at least for CPUs 0-3 because there they see all CPU capacities.
I have a plan on how to fix that, but I haven't been made aware of any "real" topology that would seriously break there. The moment one does, this will surface up to the top of my todo-list.
In the meantime, we can make it match the SDF_SHARED_PARENT semantics, and this actually fixes an issue with solo big CPU clusters (which I anecdotally found out while first writing this series, and forgot to include):
--->8
From: Valentin Schneider <[email protected]>
Date: Wed, 16 Oct 2019 18:12:12 +0100
Subject: [PATCH 1/1] sched/topology: Propagate SD_ASYM_CPUCAPACITY upwards
We currently set this flag *only* on domains whose topology level exactly match the level where we detect asymmetry (as returned by asym_cpu_capacity_level()). This is rather problematic.
Say there are two clusters in the system, one with a lone big CPU and the other with a mix of big and LITTLE CPUs:
DIE [ ]
MC [ ][ ]
0 1 2 3 4
L L B B Basym_cpu_capacity_level() will figure out that the MC level is the one where all CPUs can see a CPU of max capacity, and we will thus set SD_ASYM_CPUCAPACITY at MC level for all CPUs.
That lone big CPU will degenerate its MC domain, since it would be alone in there, and will end up with just a DIE domain. Since the flag was only set at MC, this CPU ends up not seeing any SD with the flag set, which is broken.
Rather than clearing dflags at every topology level, clear it before entering the topology level loop. This will properly propagate upwards flags that are set starting from a certain level.
--- kernel/sched/topology.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
kernel/sched/topology.c +1 -2
@@ -1965,11 +1965,10 @@ build_sched_domains(const struct cpumask *cpu_map, struct sched_domain_attr *att/* 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) { -int dflags =0 ; -if (tl == tl_asym) { dflags |=SD_ASYM_CPUCAPACITY ; has_asym = true;
--
2.27.0
Quentin Perret
Reviewed-byRe: [PATCH v3 2/7] sched/topology: Define and assign sched_domain flag metadata
Quoted 10 lines · Valentin Schneider
There an "interesting" quirk of
asym_cpu_capacity_level()in that it does something slightly different than what it says on the tin: it detects the lowest topology level where *the biggest* CPU capacity is visible by all CPUs. That works just fine on big.LITTLE, but there are questionable DynamIQ topologies that could hit some issues.Consider:
DIE [ ]
MC [ ][ ] <-sd_asym_cpucapacity
Quoted 7 lines
0 1 2 3 4 5 L L B B B B
asym_cpu_capacity_level()would pick MC as the asymmetric topology level, and you can argue either way: it should be DIE, because that's where CPUs 4 and 5 can see a LITTLE, or it should be MC, at least for CPUs 0-3 because there they see all CPU capacities.
Right, I am not looking forward to these topologies...
Quoted 26 lines
I have a plan on how to fix that, but I haven't been made aware of any "real" topology that would seriously break there. The moment one does, this will surface up to the top of my todo-list.
In the meantime, we can make it match the
SDF_SHARED_PARENTsemantics, and this actually fixes an issue with solo big CPU clusters (which I anecdotally found out while first writing this series, and forgot to include):--->8
From: Valentin Schneider <[email protected]>
Date: Wed, 16 Oct 2019 18:12:12 +0100
Subject: [PATCH 1/1] sched/topology: PropagateSD_ASYM_CPUCAPACITYupwardsWe currently set this flag *only* on domains whose topology level exactly match the level where we detect asymmetry (as returned by
asym_cpu_capacity_level()). This is rather problematic.Say there are two clusters in the system, one with a lone big CPU and the other with a mix of big and LITTLE CPUs:
DIE [ ]
MC [ ][ ]0 1 2 3 4 L L B B B
Quoted 8 lines
asym_cpu_capacity_level()will figure out that the MC level is the one where all CPUs can see a CPU of max capacity, and we will thus setSD_ASYM_CPUCAPACITYat MC level for all CPUs.That lone big CPU will degenerate its MC domain, since it would be alone in there, and will end up with just a DIE domain. Since the flag was only set at MC, this CPU ends up not seeing any SD with the flag set, which is broken.
+1
Quoted 3 lines
Rather than clearing dflags at every topology level, clear it before entering the topology level loop. This will properly propagate upwards flags that are set starting from a certain level.
I'm feeling a bit nervous about that asymmetry -- in your example select_idle_capacity() on, say, CPU3 will see less CPUs than on CPU4. So, you might get fun side-effects where all task migrated to CPUs 0-3 will be 'stuck' there while CPU 4 stays mostly idle.
I have a few ideas to avoid that (e.g. looking at the rd span in select_idle_capacity() instead of sd_asym_cpucapacity) but all this is theoretical, so I'm happy to wait for a real platform to be released before we worry too much about it.
In the meantime:
Quoted 23 lines
Signed-off-by Valentin Schneider <[email protected]>--- kernel/sched/topology.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)kernel/sched/topology.c +1
-3@@ -1965,11 +1965,10 @@ build_sched_domains(const struct cpumask *cpu_map, struct sched_domain_attr *att/* 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) { -int dflags =0 ; -if (tl == tl_asym) { dflags |=SD_ASYM_CPUCAPACITY ; has_asym = true; --
Quoted 1 line
2.27.0
Thanks,
Quentin
Re: [PATCH v3 2/7] sched/topology: Define and assign sched_domain flag metadata
Quoted 14 lines · Quentin Perret
Quoted 13 lines · Valentin Schneider
There an "interesting" quirk of
asym_cpu_capacity_level()in that it does something slightly different than what it says on the tin: it detects the lowest topology level where *the biggest* CPU capacity is visible by all CPUs. That works just fine on big.LITTLE, but there are questionable DynamIQ topologies that could hit some issues.Consider:
DIE [ ]
MC [ ][ ] <-sd_asym_cpucapacity0 1 2 3 4 5 L L B B B B
Quoted 6 lines
Quoted 4 lines
asym_cpu_capacity_level()would pick MC as the asymmetric topology level, and you can argue either way: it should be DIE, because that's where CPUs 4 and 5 can see a LITTLE, or it should be MC, at least for CPUs 0-3 because there they see all CPU capacities.Right, I am not looking forward to these topologies...
I'll try my best to prevent those from seeing the light of day, but you know how this works...
Quoted 19 lines
Quoted 8 lines
Say there are two clusters in the system, one with a lone big CPU and the other with a mix of big and LITTLE CPUs:
DIE [ ]
MC [ ][ ]0 1 2 3 4 L L B B BQuoted 8 lines
asym_cpu_capacity_level()will figure out that the MC level is the one where all CPUs can see a CPU of max capacity, and we will thus setSD_ASYM_CPUCAPACITYat MC level for all CPUs.That lone big CPU will degenerate its MC domain, since it would be alone in there, and will end up with just a DIE domain. Since the flag was only set at MC, this CPU ends up not seeing any SD with the flag set, which is broken.
+1
Quoted 9 lines
Quoted 3 lines
Rather than clearing dflags at every topology level, clear it before entering the topology level loop. This will properly propagate upwards flags that are set starting from a certain level.
I'm feeling a bit nervous about that asymmetry -- in your example
select_idle_capacity()on, say, CPU3 will see less CPUs than on CPU4. So, you might get fun side-effects where all task migrated to CPUs 0-3 will be 'stuck' there while CPU 4 stays mostly idle.
It's actually pretty close to what happens with the LLC domain on SMP - select_idle_sibling() doesn't look outside of it. The wake_affine() stuff might steer the task towards a different LLC, but that's about it for wakeups. We rely on load balancing (fork/exec, newidle, nohz and periodic) to spread this further - and we would here too.
It gets "funny" for EAS when we aren't overutilized and thus can't rely on load balancing; at least misfit ought to still work. It *is* a weird topology, for sure.
Quoted 8 lines
I have a few ideas to avoid that (e.g. looking at the rd span in
select_idle_capacity()instead ofsd_asym_cpucapacity) but all this is theoretical, so I'm happy to wait for a real platform to be released before we worry too much about it.In the meantime:
Reviewed-by Quentin Perret <[email protected]>
Thanks!
Re: [PATCH v3 2/7] sched/topology: Define and assign sched_domain flag metadata
Quoted 5 lines · Valentin Schneider
It's actually pretty close to what happens with the LLC domain on SMP -
select_idle_sibling()doesn't look outside of it. Thewake_affine()stuff might steer the task towards a different LLC, but that's about it for wakeups. We rely on load balancing (fork/exec, newidle, nohz and periodic) to spread this further - and we would here too.
Sure, but on SMP the search space in select_idle_sibling is always consistent -- you search within the LLC. With the fix you suggested, CPUs 0-3 will search within their LLCs, while CPU4 searches the entire system, which creates an imbalanced mess IMO.
For affine wake-ups, you could migrate from CPU4 -> CPU0-3, but CPU0-3 to CPU4 is not possible, so this asymmetry is almost guaranteed to actively create imbalance. And sure, the periodic load balancer ought to fix it, but really wake-up balance and periodic load balance should be pushing in the same direction and not fighting against each other.
Anyways, enough bikeshedding for today, I'll try and have look at the rest of the series :)
Cheers,
Quentin
Re: [PATCH v3 2/7] sched/topology: Define and assign sched_domain flag metadata
Quoted 7 lines · Quentin Perret
Quoted 5 lines · Valentin Schneider
It's actually pretty close to what happens with the LLC domain on SMP -
select_idle_sibling()doesn't look outside of it. Thewake_affine()stuff might steer the task towards a different LLC, but that's about it for wakeups. We rely on load balancing (fork/exec, newidle, nohz and periodic) to spread this further - and we would here too.
Quoted 5 lines
Sure, but on SMP the search space in
select_idle_siblingis always consistent -- you search within the LLC. With the fix you suggested, CPUs 0-3 will search within their LLCs, while CPU4 searches the entire system, which creates an imbalanced mess IMO.
Yeah, it is a mess.
Quoted 2 lines
For affine wake-ups, you could migrate from CPU4 -> CPU0-3, but CPU0-3 to CPU4 is not possible
AIU the wake_affine bits, you get to steer the wakeup towards the waking CPU. So if the task previously ran on CPU0-3, wake_affine can make the target CPU4 (waking CPU), so it would become a possible candidate.
But as you say, this thing is still an ugly asymmetric mess.
Quoted 8 lines
so this asymmetry is almost guaranteed to
actively create imbalance. And sure, the periodic load balancer ought to fix it, but really wake-up balance and periodic load balance should be pushing in the same direction and not fighting against each other.Anyways, enough bikeshedding for today, I'll try and have look at the rest of the series :)
Thanks!
Quoted 2 lines
Cheers,
Quentin
PATCH v3 3/7 sched/topology: Verify SD_* flags setup when sched_debug is on
In reply to Valentin SchneiderNow that we have some description of what we expect the flags layout to be, we can use that to assert at runtime that the actual layout is sane.
--- kernel/sched/topology.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
kernel/sched/topology.c +17 -0
@@ -29,6 +29,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, struct cpumask *groupmask) {struct sched_group *group = sd->groups; +int flags = sd->flags;cpumask_clear (groupmask);
@@ -43,6 +44,22 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,printk (KERN_ERR "ERROR: domain->groups does not contain CPU%d\n" , cpu); } +for (; flags; flags &= flags -1 ) { +unsigned int idx =__ffs (flags); +unsigned int flag =BIT (idx); +unsigned int meta_flags = sd_flag_debug[idx].meta_flags; + +if ((meta_flags &SDF_SHARED_CHILD ) && sd->child && + !(sd->child->flags & flag)) +printk (KERN_ERR "ERROR: flag %s set here but not in child\n" , + sd_flag_debug[idx].name); + +if ((meta_flags &SDF_SHARED_PARENT ) && sd->parent && + !(sd->parent->flags & flag)) +printk (KERN_ERR "ERROR: flag %s set here but not in parent\n" , + sd_flag_debug[idx].name); + } +printk (KERN_DEBUG "%*s groups:" , level +1 ,"" ); do { if (!group) {
Signature · 1 line
2.27.0
Peter Zijlstra
maintainerRe: [PATCH v3 3/7] sched/topology: Verify SD_* flags setup when sched_debug is on
kernel/sched/topology.c static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, · line 32
Quoted 5 lines · Valentin Schneider
kernel/sched/topology.c +1
-0@@ -29,6 +29,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, struct cpumask *groupmask) {struct sched_group *group = sd->groups; +int flags = sd->flags;
unsigned long flags = sd->flags;
kernel/sched/topology.c static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, · line 48
Quoted 9 lines
kernel/sched/topology.c +2
-0cpumask_clear (groupmask);@@ -43,6 +44,22 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,printk (KERN_ERR "ERROR: domain->groups does not contain CPU%d\n" , cpu); } +for (; flags; flags &= flags -1 ) { +unsigned int idx =__ffs (flags);
for_each_set_bit(idx, &flags, SD_MAX_BIT) {Yes, it's a bit yuck, but far more readable imo.
Quoted 20 lines
kernel/sched/topology.c +14
-0+unsigned int flag =BIT (idx); +unsigned int meta_flags = sd_flag_debug[idx].meta_flags; + +if ((meta_flags &SDF_SHARED_CHILD ) && sd->child && + !(sd->child->flags & flag)) +printk (KERN_ERR "ERROR: flag %s set here but not in child\n" , + sd_flag_debug[idx].name); + +if ((meta_flags &SDF_SHARED_PARENT ) && sd->parent && + !(sd->parent->flags & flag)) +printk (KERN_ERR "ERROR: flag %s set here but not in parent\n" , + sd_flag_debug[idx].name); + } +printk (KERN_DEBUG "%*s groups:" , level +1 ,"" ); do { if (!group) {Signature · 1 line
2.27.0
Re: [PATCH v3 3/7] sched/topology: Verify SD_* flags setup when sched_debug is on
Quoted 17 lines · Peter Zijlstra
kernel/sched/topology.c static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, · line 32
Quoted 5 lines · Valentin Schneider
kernel/sched/topology.c +1
-0@@ -29,6 +29,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, struct cpumask *groupmask) {struct sched_group *group = sd->groups; +int flags = sd->flags;unsigned long flags = sd->flags;Quoted 7 lines
kernel/sched/topology.c +0
-0cpumask_clear (groupmask);@@ -43,6 +44,22 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,printk (KERN_ERR "ERROR: domain->groups does not contain CPU%d\n" , cpu); }
Quoted 7 lines
kernel/sched/topology.c static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, · line 48
Quoted 2 lines
kernel/sched/topology.c +2
-0+for (; flags; flags &= flags -1 ) { +unsigned int idx =__ffs (flags);for_each_set_bit(idx, &flags, SD_MAX_BIT) {Yes, it's a bit yuck, but far more readable imo.
Much better than homegrown stuff, thanks!
Quoted 20 lines
Quoted 20 lines
kernel/sched/topology.c +14
-1+unsigned int flag =BIT (idx); +unsigned int meta_flags = sd_flag_debug[idx].meta_flags; + +if ((meta_flags &SDF_SHARED_CHILD ) && sd->child && + !(sd->child->flags & flag)) +printk (KERN_ERR "ERROR: flag %s set here but not in child\n" , + sd_flag_debug[idx].name); + +if ((meta_flags &SDF_SHARED_PARENT ) && sd->parent && + !(sd->parent->flags & flag)) +printk (KERN_ERR "ERROR: flag %s set here but not in parent\n" , + sd_flag_debug[idx].name); + } +printk (KERN_DEBUG "%*s groups:" , level +1 ,"" ); do { if (!group) { --2.27.0
PATCH v3 4/7 arm, sched/topology: Remove SD_SHARE_POWERDOMAIN
In reply to Valentin SchneiderThis flag was introduced in 2014 by commit
d77b3ed5c9f8 ("sched: Add a new SD_SHARE_POWERDOMAIN for sched_domain")
but AFAIA it was never leveraged by the scheduler. The closest thing I can think of is EAS caring about frequency domains, and it does that by leveraging performance domains.
Remove the flag.
--- arch/arm/kernel/topology.c | 2 +- include/linux/sched/sd_flags.h | 20 ++++++-------------- kernel/sched/topology.c | 10 +++------- 3 files changed, 10 insertions(+), 22 deletions(-)
arch/arm/kernel/topology.c +1 -1
@@ -243,7 +243,7 @@ void store_cpu_topology(unsigned int cpuid)static inline int cpu_corepower_flags (void ) { -return SD_SHARE_PKG_RESOURCES |SD_SHARE_POWERDOMAIN ; +return SD_SHARE_PKG_RESOURCES ; }static struct sched_domain_topology_level arm_topology[] = {
include/linux/sched/sd_flags.h +6 -14
@@ -83,21 +83,13 @@ SD_FLAG(SD_ASYM_CPUCAPACITY, 5, SDF_SHARED_PARENT)*/ SD_FLAG (SD_SHARE_CPUCAPACITY ,6 ,SDF_SHARED_CHILD ) -/* -* Domain members share power domain -* -* SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share -* the same power domain. - */ -SD_FLAG (SD_SHARE_POWERDOMAIN ,7 ,SDF_SHARED_CHILD ) -/* * Domain members share CPU package resources (i.e. caches) * * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share * the same cache(s). */ -SD_FLAG (SD_SHARE_PKG_RESOURCES ,8 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_SHARE_PKG_RESOURCES ,7 ,SDF_SHARED_CHILD )/* * Only a single load balancing instance
@@ -107,7 +99,7 @@ SD_FLAG(SD_SHARE_PKG_RESOURCES, 8, SDF_SHARED_CHILD)* set, then all of its parents need to have it too (otherwise the serialization * doesn't make sense). */ -SD_FLAG (SD_SERIALIZE ,9 ,SDF_SHARED_PARENT ) +SD_FLAG (SD_SERIALIZE ,8 ,SDF_SHARED_PARENT )/* * Place busy tasks earlier in the domain
@@ -116,7 +108,7 @@ SD_FLAG(SD_SERIALIZE, 9, SDF_SHARED_PARENT)* up, but currently assumed to be set from the base domain upwards (see * update_top_cache_domain()). */ -SD_FLAG (SD_ASYM_PACKING ,10 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_ASYM_PACKING ,9 ,SDF_SHARED_CHILD )/* * Prefer to place tasks in a sibling domain
@@ -124,18 +116,18 @@ SD_FLAG(SD_ASYM_PACKING, 10, SDF_SHARED_CHILD)* Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD * flag, but cleared below domains with SD_ASYM_CPUCAPACITY. */ -SD_FLAG (SD_PREFER_SIBLING ,11 ,0 ) +SD_FLAG (SD_PREFER_SIBLING ,10 ,0 )/* * sched_groups of this level overlap * * SHARED_PARENT: Set for all NUMA levels above NODE. */ -SD_FLAG (SD_OVERLAP ,12 ,SDF_SHARED_PARENT ) +SD_FLAG (SD_OVERLAP ,11 ,SDF_SHARED_PARENT )/* * cross-node balancing * * SHARED_PARENT: Set for all NUMA levels above NODE. */ -SD_FLAG (SD_NUMA ,13 ,SDF_SHARED_PARENT ) +SD_FLAG (SD_NUMA ,12 ,SDF_SHARED_PARENT )
kernel/sched/topology.c +3 -7
@@ -165,8 +165,7 @@ static int sd_degenerate(struct sched_domain *sd) SD_BALANCE_EXEC | SD_SHARE_CPUCAPACITY | SD_ASYM_CPUCAPACITY | -SD_SHARE_PKG_RESOURCES | - SD_SHARE_POWERDOMAIN)) { + SD_SHARE_PKG_RESOURCES)) {if (sd->groups != sd->groups->next)return 0 ; }
@@ -197,8 +196,7 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)SD_ASYM_CPUCAPACITY |SD_SHARE_CPUCAPACITY |SD_SHARE_PKG_RESOURCES | -SD_PREFER_SIBLING | - SD_SHARE_POWERDOMAIN); + SD_PREFER_SIBLING);if (nr_node_ids ==1 ) pflags &= ~SD_SERIALIZE ; }
@@ -1309,7 +1307,6 @@ int __read_mostly node_reclaim_distance = RECLAIM_DISTANCE;* SD_SHARE_CPUCAPACITY - describes SMT topologies * SD_SHARE_PKG_RESOURCES - describes shared caches * SD_NUMA - describes NUMA topologies -* SD_SHARE_POWERDOMAIN - describes shared power domain * * Odd one out, which beside describing the topology has a quirk also * prescribes the desired behaviour that goes along with it:
@@ -1320,8 +1317,7 @@ int __read_mostly node_reclaim_distance = RECLAIM_DISTANCE; (SD_SHARE_CPUCAPACITY | \SD_SHARE_PKG_RESOURCES | \SD_NUMA | \ -SD_ASYM_PACKING | \ - SD_SHARE_POWERDOMAIN) + SD_ASYM_PACKING)static struct sched_domain * sd_init(struct sched_domain_topology_level *tl,
Signature · 1 line
2.27.0
Dietmar Eggemann
reviewerRe: [PATCH v3 4/7] arm, sched/topology: Remove SD_SHARE_POWERDOMAIN
Quoted 7 lines · Valentin Schneider
This flag was introduced in 2014 by commit
d77b3ed5c9f8("sched: Add a newSD_SHARE_POWERDOMAINforsched_domain")but AFAIA it was never leveraged by the scheduler. The closest thing I can think of is EAS caring about frequency domains, and it does that by leveraging performance domains.
... and even this was purely out of tree (SD_SHARE_CAP_STATES).
Quoted 15 lines
Remove the flag.
Suggested-by Morten Rasmussen <[email protected]>Signed-off-by Valentin Schneider <[email protected]>--- arch/arm/kernel/topology.c | 2 +- include/linux/sched/sd_flags.h | 20 ++++++-------------- kernel/sched/topology.c | 10 +++------- 3 files changed, 10 insertions(+), 22 deletions(-)arch/arm/kernel/topology.c +0
-0
arch/arm/kernel/topology.c void store_cpu_topology(unsigned int cpuid) · line 249
Quoted 8 lines
arch/arm/kernel/topology.c +1
-1@@ -243,7 +243,7 @@ void store_cpu_topology(unsigned int cpuid)static inline int cpu_corepower_flags (void ) { -return SD_SHARE_PKG_RESOURCES |SD_SHARE_POWERDOMAIN ; +return SD_SHARE_PKG_RESOURCES ; }static struct sched_domain_topology_level arm_topology[] = {
I guess with SD_SHARE_POWERDOMAIN gone, arch arm can even use the default_topology[]:
arch/arm/kernel/topology.c +0 -17
@@ -241,20 +241,6 @@ void store_cpu_topology(unsigned int cpuid)update_siblings_masks (cpuid); } -static inline int cpu_corepower_flags (void ) -{ -return SD_SHARE_PKG_RESOURCES |SD_SHARE_POWERDOMAIN ; -} - -static struct sched_domain_topology_level arm_topology[] = { -#ifdef CONFIG_SCHED_MC - { cpu_corepower_mask, cpu_corepower_flags,SD_INIT_NAME (GMC ) }, - { cpu_coregroup_mask, cpu_core_flags,SD_INIT_NAME (MC ) }, -#endif - { cpu_cpu_mask,SD_INIT_NAME (DIE ) }, - {NULL , }, -}; -/* * init_cpu_topology is called at boot when only one cpu is running * which prevent simultaneous write access to cpu_topology array
@@ -265,7 +251,4 @@ void __init init_cpu_topology(void)smp_wmb ();parse_dt_topology (); - -/* Set scheduler topology descriptor */ -set_sched_topology (arm_topology); }
Re: [PATCH v3 4/7] arm, sched/topology: Remove SD_SHARE_POWERDOMAIN
Quoted 33 lines · Dietmar Eggemann
Quoted 7 lines · Valentin Schneider
This flag was introduced in 2014 by commit
d77b3ed5c9f8("sched: Add a newSD_SHARE_POWERDOMAINforsched_domain")but AFAIA it was never leveraged by the scheduler. The closest thing I can think of is EAS caring about frequency domains, and it does that by leveraging performance domains.
... and even this was purely out of tree (
SD_SHARE_CAP_STATES).Quoted 22 lines
Remove the flag.
Suggested-by Morten Rasmussen <[email protected]>Signed-off-by Valentin Schneider <[email protected]>--- arch/arm/kernel/topology.c | 2 +- include/linux/sched/sd_flags.h | 20 ++++++-------------- kernel/sched/topology.c | 10 +++------- 3 files changed, 10 insertions(+), 22 deletions(-)arch/arm/kernel/topology.c +1
-1@@ -243,7 +243,7 @@ void store_cpu_topology(unsigned int cpuid)static inline int cpu_corepower_flags (void ) { -return SD_SHARE_PKG_RESOURCES |SD_SHARE_POWERDOMAIN ; +return SD_SHARE_PKG_RESOURCES ; }
Quoted 3 lines
arch/arm/kernel/topology.c void store_cpu_topology(unsigned int cpuid) · line 249
Quoted 1 line
arch/arm/kernel/topology.c +0
-0static struct sched_domain_topology_level arm_topology[] = {I guess with
SD_SHARE_POWERDOMAINgone, arch arm can even use the default_topology[]:
That does look like it! I never noticed we declared this GMC topology level. Given it uses the thread_sibling mask, and that no (upstream) arm DT uses the thread topology binding, I guess that makes sense.
Quoted 34 lines
arch/arm/kernel/topology.c +0
-17@@ -241,20 +241,6 @@ void store_cpu_topology(unsigned int cpuid)update_siblings_masks (cpuid); } -static inline int cpu_corepower_flags (void ) -{ -return SD_SHARE_PKG_RESOURCES |SD_SHARE_POWERDOMAIN ; -} - -static struct sched_domain_topology_level arm_topology[] = { -#ifdef CONFIG_SCHED_MC - { cpu_corepower_mask, cpu_corepower_flags,SD_INIT_NAME (GMC ) }, - { cpu_coregroup_mask, cpu_core_flags,SD_INIT_NAME (MC ) }, -#endif - { cpu_cpu_mask,SD_INIT_NAME (DIE ) }, - {NULL , }, -}; -/* * init_cpu_topology is called at boot when only one cpu is running * which prevent simultaneous write access to cpu_topology array @@ -265,7 +251,4 @@ void __init init_cpu_topology(void)smp_wmb ();parse_dt_topology (); - -/* Set scheduler topology descriptor */ -set_sched_topology (arm_topology); }
PATCH v3 5/7 sched/topology: Add more flags to the SD degeneration mask
In reply to Valentin SchneiderI don't think it is going to change much in practice, but we were missing those:
o SD_BALANCE_WAKE: Used just like the other SD_BALANCE_* flags, so also needs > 1 group.
o SD_ASYM_PACKING: Hinges on load balancing (periodic / wakeup), thus needs
Quoted 1 line
1 group to happen
o SD_OVERLAP: Describes domains with overlapping groups; can't have overlaps with a single group.
SD_PREFER_SIBLING is as always the odd one out: we currently consider it in sd_parent_degenerate() but not in sd_degenerate(). It too hinges on load balancing, and thus won't have any effect when set on a domain with a single group. Add it to the sd_degenerate() groups mask.
--- kernel/sched/topology.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
kernel/sched/topology.c +8 -1
@@ -161,11 +161,15 @@ static int sd_degenerate(struct sched_domain *sd)/* Following flags need at least 2 groups */ if (sd->flags & (SD_BALANCE_NEWIDLE | +SD_BALANCE_WAKE |SD_BALANCE_FORK |SD_BALANCE_EXEC | +SD_ASYM_PACKING |SD_SHARE_CPUCAPACITY |SD_ASYM_CPUCAPACITY | -SD_SHARE_PKG_RESOURCES )) { +SD_SHARE_PKG_RESOURCES | +SD_OVERLAP | +SD_PREFER_SIBLING )) {if (sd->groups != sd->groups->next)return 0 ; }
@@ -191,11 +195,14 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)/* Flags needing groups don't count if only 1 group in parent */ if (parent->groups == parent->groups->next) { pflags &= ~(SD_BALANCE_NEWIDLE | +SD_BALANCE_WAKE |SD_BALANCE_FORK |SD_BALANCE_EXEC | +SD_ASYM_PACKING |SD_ASYM_CPUCAPACITY |SD_SHARE_CPUCAPACITY |SD_SHARE_PKG_RESOURCES | +SD_OVERLAP |SD_PREFER_SIBLING );if (nr_node_ids ==1 ) pflags &= ~SD_SERIALIZE ;
Signature · 1 line
2.27.0
Dietmar Eggemann
reviewerRe: [PATCH v3 5/7] sched/topology: Add more flags to the SD degeneration mask
Quoted 28 lines · Valentin Schneider
I don't think it is going to change much in practice, but we were missing those:
o
SD_BALANCE_WAKE: Used just like the other SD_BALANCE_* flags, so also needs > 1 group.
oSD_ASYM_PACKING: Hinges on load balancing (periodic / wakeup), thus needsQuoted 1 line
1 group to happen
o
SD_OVERLAP: Describes domains with overlapping groups; can't have overlaps with a single group.
SD_PREFER_SIBLINGis as always the odd one out: we currently consider it insd_parent_degenerate()but not insd_degenerate(). It too hinges on load balancing, and thus won't have any effect when set on a domain with a single group. Add it to thesd_degenerate()groups mask.Signed-off-by Valentin Schneider <[email protected]>--- kernel/sched/topology.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)kernel/sched/topology.c +0
-0@@ -161,11 +161,15 @@ static int sd_degenerate(struct sched_domain *sd)/* Following flags need at least 2 groups */ if (sd->flags & (SD_BALANCE_NEWIDLE |
kernel/sched/topology.c static int sd_degenerate(struct sched_domain *sd) · line 172
Quoted 10 lines
kernel/sched/topology.c +5
-1+SD_BALANCE_WAKE |SD_BALANCE_FORK |SD_BALANCE_EXEC | +SD_ASYM_PACKING |SD_SHARE_CPUCAPACITY |SD_ASYM_CPUCAPACITY | - SD_SHARE_PKG_RESOURCES)) { +SD_SHARE_PKG_RESOURCES | +SD_OVERLAP | + SD_PREFER_SIBLING)) {
Why do you add SD_PREFER_SIBLING here? It doesn't have SDF_NEEDS_GROUPS set in [PATCH v3 6/7].
$ cat ./include/linux/sched/sd_flags.h | grep ^SD_FLAG SD_FLAG(SD_BALANCE_NEWIDLE, 0, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) SD_FLAG(SD_BALANCE_EXEC, 1, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) SD_FLAG(SD_BALANCE_FORK, 2, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) SD_FLAG(SD_BALANCE_WAKE, 3, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) SD_FLAG(SD_WAKE_AFFINE, 4, SDF_SHARED_CHILD) SD_FLAG(SD_ASYM_CPUCAPACITY, 5, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS) SD_FLAG(SD_SHARE_CPUCAPACITY, 6, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) SD_FLAG(SD_SHARE_PKG_RESOURCES, 7, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) SD_FLAG(SD_SERIALIZE, 8, SDF_SHARED_PARENT) SD_FLAG(SD_ASYM_PACKING, 9, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) SD_FLAG(SD_PREFER_SIBLING, 10, 0) <-- !!! SD_FLAG(SD_OVERLAP, 11, SDF_SHARED_PARENT |SDF_NEEDS_GROUPS) SD_FLAG(SD_NUMA, 12, SDF_SHARED_PARENT)
PATCH v3 6/7 sched/topology: Introduce SD metaflag for flags needing > 1 groups
In reply to Valentin SchneiderIn preparation of cleaning up the sd_degenerate*() functions, mark flags that are only relevant when their associated domain has more than a single group. With this, build a compile-time mask of those SD flags.
--- include/linux/sched/sd_flags.h | 60 ++++++++++++++++++++++------------ include/linux/sched/topology.h | 7 ++++ 2 files changed, 47 insertions(+), 20 deletions(-)
include/linux/sched/sd_flags.h +40 -20
@@ -8,7 +8,7 @@#endif /* -* Expected flag uses +* Hierarchical metaflags * * SHARED_CHILD: These flags are meant to be set from the base domain upwards. * If a domain has this flag set, all of its children should have it set. This
@@ -29,36 +29,50 @@* certain level (e.g. domain starts spanning CPUs outside of the base CPU's * socket). */ -#define SDF_SHARED_CHILD 0x1 -#define SDF_SHARED_PARENT 0x2 +#define SDF_SHARED_CHILD 0x1 +#define SDF_SHARED_PARENT 0x2 + +/* +* Behavioural metaflags +* +* NEEDS_GROUPS: These flags are only relevant if the domain they are set on has +* more than one group. This is usually for balancing flags (load balancing +* involves equalizing a metric between groups), or for flags describing some +* shared resource (which would be shared between groups). +*/ +#define SDF_NEEDS_GROUPS 0x4/* * Balance when about to become idle * * SHARED_CHILD: Set from the base domain up to cpuset.sched_relax_domain_level. +* NEEDS_GROUPS: Load balancing flag. */ -SD_FLAG (SD_BALANCE_NEWIDLE ,0 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_BALANCE_NEWIDLE ,0 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )/* * Balance on exec * * SHARED_CHILD: Set from the base domain up to the NUMA reclaim level. +* NEEDS_GROUPS: Load balancing flag. */ -SD_FLAG (SD_BALANCE_EXEC ,1 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_BALANCE_EXEC ,1 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )/* * Balance on fork, clone * * SHARED_CHILD: Set from the base domain up to the NUMA reclaim level. +* NEEDS_GROUPS: Load balancing flag. */ -SD_FLAG (SD_BALANCE_FORK ,2 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_BALANCE_FORK ,2 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )/* * Balance on wakeup * * SHARED_CHILD: Set from the base domain up to cpuset.sched_relax_domain_level. +* NEEDS_GROUPS: Load balancing flag. */ -SD_FLAG (SD_BALANCE_WAKE ,3 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_BALANCE_WAKE ,3 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )/* * Consider waking task on waking CPU.
@@ -71,33 +85,36 @@ SD_FLAG(SD_WAKE_AFFINE, 4, SDF_SHARED_CHILD)* Domain members have different CPU capacities * * SHARED_PARENT: Set from the topmost domain down to the first domain where -* asymmetry is detected. +* asymmetry is detected. +* NEEDS_GROUPS: Per-CPU capacity is asymmetric between groups. */ -SD_FLAG (SD_ASYM_CPUCAPACITY ,5 ,SDF_SHARED_PARENT ) +SD_FLAG (SD_ASYM_CPUCAPACITY ,5 ,SDF_SHARED_PARENT |SDF_NEEDS_GROUPS )/* * Domain members share CPU capacity (i.e. SMT) * * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share -* CPU capacity. +* CPU capacity. +* NEEDS_GROUPS: Capacity is shared between groups. */ -SD_FLAG (SD_SHARE_CPUCAPACITY ,6 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_SHARE_CPUCAPACITY ,6 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )/* * Domain members share CPU package resources (i.e. caches) * * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share -* the same cache(s). +* the same cache(s). +* NEEDS_GROUPS: Caches are shared between groups. */ -SD_FLAG (SD_SHARE_PKG_RESOURCES ,7 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_SHARE_PKG_RESOURCES ,7 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )/* * Only a single load balancing instance * * SHARED_PARENT: Set for all NUMA levels above NODE. Could be set from a -* different level upwards, but it doesn't change that if a domain has this flag -* set, then all of its parents need to have it too (otherwise the serialization -* doesn't make sense). +* different level upwards, but it doesn't change that if a +* domain has this flag set, then all of its parents need to have +* it too (otherwise the serialization doesn't make sense). */SD_FLAG (SD_SERIALIZE ,8 ,SDF_SHARED_PARENT )
@@ -105,16 +122,18 @@ SD_FLAG(SD_SERIALIZE, 8, SDF_SHARED_PARENT)* Place busy tasks earlier in the domain * * SHARED_CHILD: Usually set on the SMT level. Technically could be set further -* up, but currently assumed to be set from the base domain upwards (see -* update_top_cache_domain()). +* up, but currently assumed to be set from the base domain +* upwards (see update_top_cache_domain()). */ -SD_FLAG (SD_ASYM_PACKING ,9 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_ASYM_PACKING ,9 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )/* * Prefer to place tasks in a sibling domain * * Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD * flag, but cleared below domains with SD_ASYM_CPUCAPACITY. +* +* NEEDS_GROUPS: Load balancing flag. */SD_FLAG (SD_PREFER_SIBLING ,10 ,0 )
@@ -122,8 +141,9 @@ SD_FLAG(SD_PREFER_SIBLING, 10, 0)* sched_groups of this level overlap * * SHARED_PARENT: Set for all NUMA levels above NODE. +* NEEDS_GROUPS: Overlaps can only exist with more than one group. */ -SD_FLAG (SD_OVERLAP ,11 ,SDF_SHARED_PARENT ) +SD_FLAG (SD_OVERLAP ,11 ,SDF_SHARED_PARENT |SDF_NEEDS_GROUPS )/* * cross-node balancing
include/linux/sched/topology.h +7 -0
@@ -16,6 +16,13 @@#include <linux/sched/sd_flags.h> #undef SD_FLAG +/* Generate a mask of SD flags with the SDF_NEEDS_GROUPS metaflag */ +#define SD_FLAG (name, idx, mflags) (BIT(idx) * (((mflags) & SDF_NEEDS_GROUPS) / SDF_NEEDS_GROUPS)) | +static const int SD_DEGENERATE_GROUPS_MASK = +#include<linux/sched/sd_flags.h> +0 ; +#undef SD_FLAG + #ifdef CONFIG_SCHED_DEBUG #define SD_FLAG(_name, idx, mflags) [idx] = {.meta_flags = mflags, .name = #_name}, static const struct {
Signature · 1 line
2.27.0
Dietmar Eggemann
reviewerRe: [PATCH v3 6/7] sched/topology: Introduce SD metaflag for flags needing > 1 groups
On 01/07/2020 21:06, Valentin Schneider wrote:
[...]
Quoted 11 lines
include/linux/sched/sd_flags.h +3
-3@@ -105,16 +122,18 @@ SD_FLAG(SD_SERIALIZE, 8, SDF_SHARED_PARENT)* Place busy tasks earlier in the domain * * SHARED_CHILD: Usually set on the SMT level. Technically could be set further -* up, but currently assumed to be set from the base domain upwards (see -* update_top_cache_domain()). +* up, but currently assumed to be set from the base domain +* upwards (see update_top_cache_domain()). */ -SD_FLAG (SD_ASYM_PACKING ,9 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_ASYM_PACKING ,9 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )
include/linux/sched/sd_flags.h SD_FLAG(SD_SERIALIZE, 8, SDF_SHARED_PARENT) · line 138
Quoted 10 lines
include/linux/sched/sd_flags.h +2
-0/* * Prefer to place tasks in a sibling domain * * Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD * flag, but cleared below domains with SD_ASYM_CPUCAPACITY. +* +* NEEDS_GROUPS: Load balancing flag. */ SD_FLAG (SD_PREFER_SIBLING ,10 ,0 )
Related to my comment in [PATCH v3 5/7], maybe you wanted to add SDF_NEEDS_GROUPS for SD_PREFER_SIBLING as well ? This comment 'NEEDS_GROUPS: Load balancing flag.' makes me wondering.
Currently, SD_PREFER_SIBLING isn't in SD_DEGENERATE_GROUPS_MASK=0xaef.
[...]
Re: [PATCH v3 6/7] sched/topology: Introduce SD metaflag for flags needing > 1 groups
Quoted 30 lines · Dietmar Eggemann
On 01/07/2020 21:06, Valentin Schneider wrote:
[...]
Quoted 11 lines
include/linux/sched/sd_flags.h +3
-3@@ -105,16 +122,18 @@ SD_FLAG(SD_SERIALIZE, 8, SDF_SHARED_PARENT)* Place busy tasks earlier in the domain * * SHARED_CHILD: Usually set on the SMT level. Technically could be set further -* up, but currently assumed to be set from the base domain upwards (see -* update_top_cache_domain()). +* up, but currently assumed to be set from the base domain +* upwards (see update_top_cache_domain()). */ -SD_FLAG (SD_ASYM_PACKING ,9 ,SDF_SHARED_CHILD ) +SD_FLAG (SD_ASYM_PACKING ,9 ,SDF_SHARED_CHILD |SDF_NEEDS_GROUPS )include/linux/sched/sd_flags.h SD_FLAG(SD_SERIALIZE, 8, SDF_SHARED_PARENT) · line 138
Quoted 10 lines
include/linux/sched/sd_flags.h +2
-0/* * Prefer to place tasks in a sibling domain * * Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD * flag, but cleared below domains with SD_ASYM_CPUCAPACITY. +* +* NEEDS_GROUPS: Load balancing flag. */ SD_FLAG (SD_PREFER_SIBLING ,10 ,0 )Related to my comment in [PATCH v3 5/7], maybe you wanted to add
SDF_NEEDS_GROUPSforSD_PREFER_SIBLINGas well ? This comment 'NEEDS_GROUPS: Load balancing flag.' makes me wondering.
Quoted 2 lines
Currently,
SD_PREFER_SIBLINGisn't in SD_DEGENERATE_GROUPS_MASK=0xaef.
You're right, that's a fail from my end. Thanks (and sorry)!
Quoted 1 line
[...]
Peter Zijlstra
maintainerRe: [PATCH v3 6/7] sched/topology: Introduce SD metaflag for flags needing > 1 groups
In reply to Valentin Schneiderinclude/linux/sched/topology.h line 20
Quoted 2 lines · Valentin Schneider
include/linux/sched/topology.h +2
-0+/* Generate a mask of SD flags with the SDF_NEEDS_GROUPS metaflag */ +#define SD_FLAG (name, idx, mflags) (BIT(idx) * (((mflags) & SDF_NEEDS_GROUPS) / SDF_NEEDS_GROUPS)) |
#define SD_FLAGS(name, idx, mflags) (!!((mflags) & SDF_NEEDS_GROUPS) * BIT(idx))
Quoted 11 lines
include/linux/sched/topology.h +5
-0+static const int SD_DEGENERATE_GROUPS_MASK = +#include<linux/sched/sd_flags.h> +0 ; +#undef SD_FLAG + #ifdef CONFIG_SCHED_DEBUG #define SD_FLAG(_name, idx, mflags) [idx] = {.meta_flags = mflags, .name = #_name}, static const struct {Signature · 1 line
2.27.0
Re: [PATCH v3 6/7] sched/topology: Introduce SD metaflag for flags needing > 1 groups
Quoted 6 lines · Peter Zijlstra
include/linux/sched/topology.h line 20
Quoted 2 lines · Valentin Schneider
include/linux/sched/topology.h +2
-0+/* Generate a mask of SD flags with the SDF_NEEDS_GROUPS metaflag */ +#define SD_FLAG (name, idx, mflags) (BIT(idx) * (((mflags) & SDF_NEEDS_GROUPS) / SDF_NEEDS_GROUPS)) |#define
SD_FLAGS(name, idx, mflags)(!!((mflags) &SDF_NEEDS_GROUPS) * BIT(idx))
Was paranoid about really getting a 1 or a 0, but AFAICT the standard does agree with you!
Quoted 11 lines
Quoted 11 lines
include/linux/sched/topology.h +5
-1+static const int SD_DEGENERATE_GROUPS_MASK = +#include<linux/sched/sd_flags.h> +0 ; +#undef SD_FLAG + #ifdef CONFIG_SCHED_DEBUG #define SD_FLAG(_name, idx, mflags) [idx] = {.meta_flags = mflags, .name = #_name}, static const struct { --2.27.0
PATCH v3 7/7 sched/topology: Use prebuilt SD flag degeneration mask
In reply to Valentin SchneiderLeverage SD_DEGENERATE_GROUPS_MASK in sd_degenerate() and sd_degenerate_parent().
Note that this changes sd_degenerate() somewhat: I'm using the negation of SD_DEGENERATE_GROUPS_MASK as the mask of flags not requiring groups, which is equivalent to:
SD_WAKE_AFFINE | SD_SERIALIZE | SD_NUMA
whereas the current mask for that is simply
SD_WAKE_AFFINE
I played with a few toy NUMA topologies on QEMU and couldn't cause a different degeneration than what mainline does currently. If that is deemed too risky, we can go back to using SD_WAKE_AFFINE explicitly.
--- kernel/sched/topology.c | 24 +++--------------------- 1 file changed, 3 insertions(+), 21 deletions(-)
kernel/sched/topology.c +3 -21
@@ -160,22 +160,13 @@ static int sd_degenerate(struct sched_domain *sd)return 1 ;/* Following flags need at least 2 groups */ -if (sd->flags & (SD_BALANCE_NEWIDLE | -SD_BALANCE_WAKE | -SD_BALANCE_FORK | -SD_BALANCE_EXEC | -SD_ASYM_PACKING | -SD_SHARE_CPUCAPACITY | -SD_ASYM_CPUCAPACITY | -SD_SHARE_PKG_RESOURCES | -SD_OVERLAP | -SD_PREFER_SIBLING )) { +if (sd->flags &SD_DEGENERATE_GROUPS_MASK ) {if (sd->groups != sd->groups->next)return 0 ; }/* Following flags don't use groups */ -if (sd->flags & (SD_WAKE_AFFINE )) +if (sd->flags & ~SD_DEGENERATE_GROUPS_MASK )return 0 ;return 1 ;
@@ -194,16 +185,7 @@ sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)/* Flags needing groups don't count if only 1 group in parent */ if (parent->groups == parent->groups->next) { - pflags &= ~(SD_BALANCE_NEWIDLE | -SD_BALANCE_WAKE | -SD_BALANCE_FORK | -SD_BALANCE_EXEC | -SD_ASYM_PACKING | -SD_ASYM_CPUCAPACITY | -SD_SHARE_CPUCAPACITY | -SD_SHARE_PKG_RESOURCES | -SD_OVERLAP | -SD_PREFER_SIBLING ); + pflags &= ~SD_DEGENERATE_GROUPS_MASK ;if (nr_node_ids ==1 ) pflags &= ~SD_SERIALIZE ; }
Signature · 1 line
2.27.0
Peter Zijlstra
maintainerRe: [PATCH v3 7/7] sched/topology: Use prebuilt SD flag degeneration mask
Quoted 9 lines · Valentin Schneider
Leverage
SD_DEGENERATE_GROUPS_MASKinsd_degenerate()andsd_degenerate_parent().Note that this changes
sd_degenerate()somewhat: I'm using the negation ofSD_DEGENERATE_GROUPS_MASKas the mask of flags not requiring groups, which is equivalent to:
SD_WAKE_AFFINE|SD_SERIALIZE|SD_NUMA
Quoted 7 lines
whereas the current mask for that is simply
SD_WAKE_AFFINEI played with a few toy NUMA topologies on QEMU and couldn't cause a different degeneration than what mainline does currently. If that is deemed too risky, we can go back to using
SD_WAKE_AFFINEexplicitly.
Arguably SD_SERIALIZE needs groups, note how we're only having that effective for machines with at least 2 nodes. It's a bit shit how we end up there, but IIRC that's what it ends up as.
SD_NUMA is descriptive, and not marking a group as degenerates because it has SD_NUMA seems a bit silly. But then, it would be the top domain and would survive anyway?
Re: [PATCH v3 7/7] sched/topology: Use prebuilt SD flag degeneration mask
Quoted 14 lines · Peter Zijlstra
Quoted 13 lines · Valentin Schneider
Leverage
SD_DEGENERATE_GROUPS_MASKinsd_degenerate()andsd_degenerate_parent().Note that this changes
sd_degenerate()somewhat: I'm using the negation ofSD_DEGENERATE_GROUPS_MASKas the mask of flags not requiring groups, which is equivalent to:
SD_WAKE_AFFINE|SD_SERIALIZE|SD_NUMAwhereas the current mask for that is simply
SD_WAKE_AFFINE
Quoted 8 lines
Quoted 3 lines
I played with a few toy NUMA topologies on QEMU and couldn't cause a different degeneration than what mainline does currently. If that is deemed too risky, we can go back to using
SD_WAKE_AFFINEexplicitly.Arguably
SD_SERIALIZEneeds groups, note how we're only having that effective for machines with at least 2 nodes. It's a bit shit how we end up there, but IIRC that's what it ends up as.
Right, AFAICT we get SD_SERIALIZE wherever we have SD_NUMA, which is any level above NODE.
Quoted 2 lines
SD_NUMAis descriptive, and not marking a group as degenerates because it hasSD_NUMAseems a bit silly.
It does, although we can still degenerate it, see below.
Quoted 2 lines
But then, it would be the top domain
and would survive anyway?
So from what I've tested we still get rid of those via sd_parent_degenerate(): child and parent have the same flags and same span, so parent goes out.
That happens in the middle of the NUMA topology levels on that borked topology with weird distances, aka
node distances:
node 0 1 2 3
0: 10 12 20 22
1: 12 10 22 24
2: 20 22 10 12
3: 22 24 12 10which ought to look something like (+local distance to end result)
2 10 2
1 <---> 0 <---> 2 <---> 3
We end up with the following NUMA levels (i.e. deduplicated distances)
NUMA (<= 12)
NUMA (<= 20)
NUMA (<= 22)
NUMA (<= 24)
For e.g. any CPU of node1, NUMA(<=20) is gonna have the same span as NUMA(<=12), so we'll degenerate it.
Peter Zijlstra
maintainerRe: [PATCH v3 7/7] sched/topology: Use prebuilt SD flag degeneration mask
Quoted 20 lines · Valentin Schneider
Quoted 18 lines · Peter Zijlstra
Quoted 16 lines · Valentin Schneider
Leverage
SD_DEGENERATE_GROUPS_MASKinsd_degenerate()andsd_degenerate_parent().Note that this changes
sd_degenerate()somewhat: I'm using the negation ofSD_DEGENERATE_GROUPS_MASKas the mask of flags not requiring groups, which is equivalent to:
SD_WAKE_AFFINE|SD_SERIALIZE|SD_NUMAwhereas the current mask for that is simply
SD_WAKE_AFFINEI played with a few toy NUMA topologies on QEMU and couldn't cause a different degeneration than what mainline does currently. If that is deemed too risky, we can go back to using
SD_WAKE_AFFINEexplicitly.
Quoted 7 lines
Quoted 4 lines
Arguably
SD_SERIALIZEneeds groups, note how we're only having that effective for machines with at least 2 nodes. It's a bit shit how we end up there, but IIRC that's what it ends up as.Right, AFAICT we get
SD_SERIALIZEwherever we haveSD_NUMA, which is any level above NODE.
Oh, right, I forgot we have NODE, d'0h. But in that case these lines:
if (nr_node_ids == 1) pflags &= ~SD_SERIALIZE;
are dead code, right?
Quoted 27 lines
Quoted 2 lines
SD_NUMAis descriptive, and not marking a group as degenerates because it hasSD_NUMAseems a bit silly.It does, although we can still degenerate it, see below.
Quoted 2 lines
But then, it would be the top domain
and would survive anyway?So from what I've tested we still get rid of those via
sd_parent_degenerate(): child and parent have the same flags and same span, so parent goes out.That happens in the middle of the NUMA topology levels on that borked topology with weird distances, aka
node distances:
node 0 1 2 30: 10 12 20 22 1: 12 10 22 24 2: 20 22 10 12 3: 22 24 12 10which ought to look something like (+local distance to end result)
2 10 2
1 <---> 0 <---> 2 <---> 3
Quoted 8 lines
We end up with the following NUMA levels (i.e. deduplicated distances)
NUMA (<= 12)
NUMA (<= 20)
NUMA (<= 22)
NUMA (<= 24)For e.g. any CPU of node1, NUMA(<=20) is gonna have the same span as NUMA(<=12), so we'll degenerate it.
Man, that's horrible :-) OK, fair enough, keep it as is, we'll see what if anything breaks.
Re: [PATCH v3 7/7] sched/topology: Use prebuilt SD flag degeneration mask
Quoted 29 lines · Peter Zijlstra
Quoted 20 lines · Valentin Schneider
Quoted 18 lines · Peter Zijlstra
Quoted 16 lines · Valentin Schneider
Leverage
SD_DEGENERATE_GROUPS_MASKinsd_degenerate()andsd_degenerate_parent().Note that this changes
sd_degenerate()somewhat: I'm using the negation ofSD_DEGENERATE_GROUPS_MASKas the mask of flags not requiring groups, which is equivalent to:
SD_WAKE_AFFINE|SD_SERIALIZE|SD_NUMAwhereas the current mask for that is simply
SD_WAKE_AFFINEI played with a few toy NUMA topologies on QEMU and couldn't cause a different degeneration than what mainline does currently. If that is deemed too risky, we can go back to using
SD_WAKE_AFFINEexplicitly.Quoted 7 lines
Quoted 4 lines
Arguably
SD_SERIALIZEneeds groups, note how we're only having that effective for machines with at least 2 nodes. It's a bit shit how we end up there, but IIRC that's what it ends up as.Right, AFAICT we get
SD_SERIALIZEwherever we haveSD_NUMA, which is any level above NODE.
Quoted 7 lines
Oh, right, I forgot we have NODE, d'0h. But in that case these lines:
if (nr_node_ids == 1) pflags &= ~SD_SERIALIZE;are dead code, right?
Uuuuh right, that does sound like something made obsolete by having NODE; we didn't have it back then:
5436499e6098 ("sched: fix sd_parent_degenerate on non-numa smp machine")
I'll fold that in (and test it, just to be sure :-)).
Quoted 33 lines
Quoted 33 lines
Quoted 2 lines
SD_NUMAis descriptive, and not marking a group as degenerates because it hasSD_NUMAseems a bit silly.It does, although we can still degenerate it, see below.
Quoted 2 lines
But then, it would be the top domain
and would survive anyway?So from what I've tested we still get rid of those via
sd_parent_degenerate(): child and parent have the same flags and same span, so parent goes out.That happens in the middle of the NUMA topology levels on that borked topology with weird distances, aka
node distances:
node 0 1 2 30: 10 12 20 22 1: 12 10 22 24 2: 20 22 10 12 3: 22 24 12 10which ought to look something like (+local distance to end result)
2 10 2
1 <---> 0 <---> 2 <---> 3We end up with the following NUMA levels (i.e. deduplicated distances)
NUMA (<= 12)
NUMA (<= 20)
NUMA (<= 22)
NUMA (<= 24)
Quoted 4 lines
Quoted 2 lines
For e.g. any CPU of node1, NUMA(<=20) is gonna have the same span as NUMA(<=12), so we'll degenerate it.
Man, that's horrible :-)
It is :(
Quoted 2 lines
OK, fair enough, keep it as is, we'll see what
if anything breaks.