Currently, a debug message gets printed every time an attempt to
add(remove) a CPU. However this is redundant if the CPU is already added
(removed) from the node.
Cc: linuxppc-dev@lists.ozlabs.org
Cc: Nathan Lynch <redacted>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Valentin Schneider <redacted>
Cc: Gautham R Shenoy <redacted>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: Geetika Moolchandani <redacted>
Cc: Laurent Dufour <redacted>
Signed-off-by: Srikar Dronamraju <redacted>
---
arch/powerpc/mm/numa.c | 11 +++++------
1 file changed, 5 insertions(+), 6 deletions(-)
@@ -141,10 +141,11 @@ static void map_cpu_to_node(int cpu, int node){update_numa_cpu_lookup_table(cpu,node);-dbg("adding cpu %d to node %d\n",cpu,node);-if(!(cpumask_test_cpu(cpu,node_to_cpumask_map[node])))+if(!(cpumask_test_cpu(cpu,node_to_cpumask_map[node]))){+dbg("adding cpu %d to node %d\n",cpu,node);cpumask_set_cpu(cpu,node_to_cpumask_map[node]);+}}#if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_PPC_SPLPAR)
@@ -152,13 +153,11 @@ static void unmap_cpu_from_node(unsigned long cpu){intnode=numa_cpu_lookup_table[cpu];-dbg("removing cpu %lu from node %d\n",cpu,node);-if(cpumask_test_cpu(cpu,node_to_cpumask_map[node])){cpumask_clear_cpu(cpu,node_to_cpumask_map[node]);+dbg("removing cpu %lu from node %d\n",cpu,node);}else{-printk(KERN_ERR"WARNING: cpu %lu not found in node %d\n",-cpu,node);+pr_err("WARNING: cpu %lu not found in node %d\n",cpu,node);}}#endif /* CONFIG_HOTPLUG_CPU || CONFIG_PPC_SPLPAR */
@@ -597,9 +597,6 @@ static int ppc_numa_cpu_prepare(unsigned int cpu)staticintppc_numa_cpu_dead(unsignedintcpu){-#ifdef CONFIG_HOTPLUG_CPU-unmap_cpu_from_node(cpu);-#endifreturn0;}
Scheduler expects unique number of node distances to be available at
boot. It uses node distance to calculate this unique node distances.
On POWER, node distances for offline nodes is not available. However,
POWER already knows unique possible node distances. Fake the offline
node's distance_lookup_table entries so that all possible node
distances are updated.
However this only needs to be done if the number of unique node
distances that can be computed for online nodes is less than the
number of possible unique node distances as represented by
distance_ref_points_depth. When the node is actually onlined,
distance_lookup_table will be updated with actual entries.
Cc: linuxppc-dev@lists.ozlabs.org
Cc: Nathan Lynch <redacted>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Valentin Schneider <redacted>
Cc: Gautham R Shenoy <redacted>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: Geetika Moolchandani <redacted>
Cc: Laurent Dufour <redacted>
Cc: kernel test robot <redacted>
Signed-off-by: Srikar Dronamraju <redacted>
---
arch/powerpc/mm/numa.c | 70 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 70 insertions(+)
Changelog:
v1: https://lore.kernel.org/linuxppc-dev/20210701041552.112072-3-srikar@linux.vnet.ibm.com/t/#u
[ Fixed a missing prototype warning Reported-by: kernel test robot [off-list ref]]
@@ -856,6 +856,75 @@ void __init dump_numa_cpu_topology(void)}}+/*+*Schedulerexpectsuniquenumberofnodedistancestobeavailableat+*boot.Itusesnodedistancetocalculatethisuniquenodedistances.On+*POWER,nodedistancesforofflinenodesisnotavailable.However,POWER+*alreadyknowsuniquepossiblenodedistances.Faketheofflinenode's+*distance_lookup_tableentriessothatallpossiblenodedistancesare+*updated.+*/+staticvoid__initfake_update_distance_lookup_table(void)+{+unsignedlongdistance_map;+inti,nr_levels,nr_depth,node;++if(!numa_enabled)+return;++if(!form1_affinity)+return;++/*+*distance_ref_points_depthliststheuniquenumadomains+*available.HoweveritignoreLOCAL_DISTANCE.Soadd+1+*togettheactualnumberofuniquedistances.+*/+nr_depth=distance_ref_points_depth+1;++WARN_ON(nr_depth>sizeof(distance_map));++bitmap_zero(&distance_map,nr_depth);+bitmap_set(&distance_map,0,1);++for_each_online_node(node){+intnd,distance=LOCAL_DISTANCE;++if(node==first_online_node)+continue;++nd=__node_distance(node,first_online_node);+for(i=0;i<nr_depth;i++,distance*=2){+if(distance==nd){+bitmap_set(&distance_map,i,1);+break;+}+}+nr_levels=bitmap_weight(&distance_map,nr_depth);+if(nr_levels==nr_depth)+return;+}++for_each_node(node){+if(node_online(node))+continue;++i=find_first_zero_bit(&distance_map,nr_depth);+if(i>=nr_depth||i==0){+pr_warn("Levels(%d) not matching levels(%d)",nr_levels,nr_depth);+return;+}++bitmap_set(&distance_map,i,1);+while(i--)+distance_lookup_table[node][i]=node;++nr_levels=bitmap_weight(&distance_map,nr_depth);+if(nr_levels==nr_depth)+return;+}+}+/* Initialize NODE_DATA for a node on the local memory */staticvoid__initsetup_node_data(intnid,u64start_pfn,u64end_pfn){
From: Peter Zijlstra <peterz@infradead.org> Date: 2021-08-23 08:34:43
On Sat, Aug 21, 2021 at 03:55:32PM +0530, Srikar Dronamraju wrote:
Scheduler expects unique number of node distances to be available
at boot. It uses node distance to calculate this unique node
distances. On Power Servers, node distances for offline nodes is not
available. However, Power Servers already knows unique possible node
distances. Fake the offline node's distance_lookup_table entries so
that all possible node distances are updated.
For example distance info from numactl from a fully populated 8 node
system at boot may look like this.
node distances:
node 0 1 2 3 4 5 6 7
0: 10 20 40 40 40 40 40 40
1: 20 10 40 40 40 40 40 40
2: 40 40 10 20 40 40 40 40
3: 40 40 20 10 40 40 40 40
4: 40 40 40 40 10 20 40 40
5: 40 40 40 40 20 10 40 40
6: 40 40 40 40 40 40 10 20
7: 40 40 40 40 40 40 20 10
However the same system when only two nodes are online at boot, then
distance info from numactl will look like
node distances:
node 0 1
0: 10 20
1: 20 10
With the faked numa distance at boot, the node distance table will look
like
node 0 1 2
0: 10 20 40
1: 20 10 40
2: 40 40 10
The actual distance will be populated once the nodes are onlined.
How did you want all this merged? I picked up Valentin's patch, do you
want me to pick up these PowerPC patches in the same tree, or do you
want to route them seperately?
Le 21/08/2021 à 12:25, Srikar Dronamraju a écrit :
quoted hunk
Currently, a debug message gets printed every time an attempt to
add(remove) a CPU. However this is redundant if the CPU is already added
(removed) from the node.
Cc: linuxppc-dev@lists.ozlabs.org
Cc: Nathan Lynch <redacted>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Valentin Schneider <redacted>
Cc: Gautham R Shenoy <redacted>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: Geetika Moolchandani <redacted>
Cc: Laurent Dufour <redacted>
Signed-off-by: Srikar Dronamraju <redacted>
---
arch/powerpc/mm/numa.c | 11 +++++------
1 file changed, 5 insertions(+), 6 deletions(-)
@@ -141,10 +141,11 @@ static void map_cpu_to_node(int cpu, int node){update_numa_cpu_lookup_table(cpu,node);-dbg("adding cpu %d to node %d\n",cpu,node);-if(!(cpumask_test_cpu(cpu,node_to_cpumask_map[node])))+if(!(cpumask_test_cpu(cpu,node_to_cpumask_map[node]))){+dbg("adding cpu %d to node %d\n",cpu,node);cpumask_set_cpu(cpu,node_to_cpumask_map[node]);+}}#if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_PPC_SPLPAR)
@@ -152,13 +153,11 @@ static void unmap_cpu_from_node(unsigned long cpu){intnode=numa_cpu_lookup_table[cpu];-dbg("removing cpu %lu from node %d\n",cpu,node);-if(cpumask_test_cpu(cpu,node_to_cpumask_map[node])){cpumask_clear_cpu(cpu,node_to_cpumask_map[node]);+dbg("removing cpu %lu from node %d\n",cpu,node);}else{-printk(KERN_ERR"WARNING: cpu %lu not found in node %d\n",-cpu,node);+pr_err("WARNING: cpu %lu not found in node %d\n",cpu,node);
Would pr_warn() be more appropriate here (or removing the "WARNING" statement)?
* Peter Zijlstra [off-list ref] [2021-08-23 10:33:30]:
On Sat, Aug 21, 2021 at 03:55:32PM +0530, Srikar Dronamraju wrote:
quoted
Scheduler expects unique number of node distances to be available
at boot. It uses node distance to calculate this unique node
distances. On Power Servers, node distances for offline nodes is not
available. However, Power Servers already knows unique possible node
distances. Fake the offline node's distance_lookup_table entries so
that all possible node distances are updated.
For example distance info from numactl from a fully populated 8 node
system at boot may look like this.
node distances:
node 0 1 2 3 4 5 6 7
0: 10 20 40 40 40 40 40 40
1: 20 10 40 40 40 40 40 40
2: 40 40 10 20 40 40 40 40
3: 40 40 20 10 40 40 40 40
4: 40 40 40 40 10 20 40 40
5: 40 40 40 40 20 10 40 40
6: 40 40 40 40 40 40 10 20
7: 40 40 40 40 40 40 20 10
However the same system when only two nodes are online at boot, then
distance info from numactl will look like
node distances:
node 0 1
0: 10 20
1: 20 10
With the faked numa distance at boot, the node distance table will look
like
node 0 1 2
0: 10 20 40
1: 20 10 40
2: 40 40 10
The actual distance will be populated once the nodes are onlined.
How did you want all this merged? I picked up Valentin's patch, do you
want me to pick up these PowerPC patches in the same tree, or do you
want to route them seperately?
While both (the patch you accepted and this series) together help solve the
problem, I think there is no hard dependency between the two. Hence I would
think it should be okay to go through the powerpc tree.
--
Thanks and Regards
Srikar Dronamraju
Le 21/08/2021 à 12:25, Srikar Dronamraju a écrit :
quoted
Currently, a debug message gets printed every time an attempt to
add(remove) a CPU. However this is redundant if the CPU is already added
(removed) from the node.
Cc: linuxppc-dev@lists.ozlabs.org
Cc: Nathan Lynch <redacted>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Valentin Schneider <redacted>
Cc: Gautham R Shenoy <redacted>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: Geetika Moolchandani <redacted>
Cc: Laurent Dufour <redacted>
Signed-off-by: Srikar Dronamraju <redacted>
---
arch/powerpc/mm/numa.c | 11 +++++------
1 file changed, 5 insertions(+), 6 deletions(-)
@@ -141,10 +141,11 @@ static void map_cpu_to_node(int cpu, int node){update_numa_cpu_lookup_table(cpu,node);-dbg("adding cpu %d to node %d\n",cpu,node);-if(!(cpumask_test_cpu(cpu,node_to_cpumask_map[node])))+if(!(cpumask_test_cpu(cpu,node_to_cpumask_map[node]))){+dbg("adding cpu %d to node %d\n",cpu,node);cpumask_set_cpu(cpu,node_to_cpumask_map[node]);+}}#if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_PPC_SPLPAR)
@@ -152,13 +153,11 @@ static void unmap_cpu_from_node(unsigned long cpu){intnode=numa_cpu_lookup_table[cpu];-dbg("removing cpu %lu from node %d\n",cpu,node);-if(cpumask_test_cpu(cpu,node_to_cpumask_map[node])){cpumask_clear_cpu(cpu,node_to_cpumask_map[node]);+dbg("removing cpu %lu from node %d\n",cpu,node);}else{-printk(KERN_ERR"WARNING: cpu %lu not found in node %d\n",-cpu,node);+pr_err("WARNING: cpu %lu not found in node %d\n",cpu,node);
Would pr_warn() be more appropriate here (or removing the "WARNING" statement)?
Its a fair point.
Michael,
Do you want me to resend this patch with s/pr_err/pr_warn for the above
line?
From: Peter Zijlstra <peterz@infradead.org> Date: 2021-08-23 09:39:50
On Mon, Aug 23, 2021 at 03:04:37PM +0530, Srikar Dronamraju wrote:
* Peter Zijlstra [off-list ref] [2021-08-23 10:33:30]:
quoted
On Sat, Aug 21, 2021 at 03:55:32PM +0530, Srikar Dronamraju wrote:
quoted
Scheduler expects unique number of node distances to be available
at boot. It uses node distance to calculate this unique node
distances. On Power Servers, node distances for offline nodes is not
available. However, Power Servers already knows unique possible node
distances. Fake the offline node's distance_lookup_table entries so
that all possible node distances are updated.
For example distance info from numactl from a fully populated 8 node
system at boot may look like this.
node distances:
node 0 1 2 3 4 5 6 7
0: 10 20 40 40 40 40 40 40
1: 20 10 40 40 40 40 40 40
2: 40 40 10 20 40 40 40 40
3: 40 40 20 10 40 40 40 40
4: 40 40 40 40 10 20 40 40
5: 40 40 40 40 20 10 40 40
6: 40 40 40 40 40 40 10 20
7: 40 40 40 40 40 40 20 10
However the same system when only two nodes are online at boot, then
distance info from numactl will look like
node distances:
node 0 1
0: 10 20
1: 20 10
With the faked numa distance at boot, the node distance table will look
like
node 0 1 2
0: 10 20 40
1: 20 10 40
2: 40 40 10
The actual distance will be populated once the nodes are onlined.
How did you want all this merged? I picked up Valentin's patch, do you
want me to pick up these PowerPC patches in the same tree, or do you
want to route them seperately?
While both (the patch you accepted and this series) together help solve the
problem, I think there is no hard dependency between the two. Hence I would
think it should be okay to go through the powerpc tree.
Le 21/08/2021 à 12:25, Srikar Dronamraju a écrit :
quoted
Currently, a debug message gets printed every time an attempt to
add(remove) a CPU. However this is redundant if the CPU is already added
(removed) from the node.
Cc: linuxppc-dev@lists.ozlabs.org
Cc: Nathan Lynch <redacted>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Valentin Schneider <redacted>
Cc: Gautham R Shenoy <redacted>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: Geetika Moolchandani <redacted>
Cc: Laurent Dufour <redacted>
Signed-off-by: Srikar Dronamraju <redacted>
---
arch/powerpc/mm/numa.c | 11 +++++------
1 file changed, 5 insertions(+), 6 deletions(-)
@@ -141,10 +141,11 @@ static void map_cpu_to_node(int cpu, int node){update_numa_cpu_lookup_table(cpu,node);-dbg("adding cpu %d to node %d\n",cpu,node);-if(!(cpumask_test_cpu(cpu,node_to_cpumask_map[node])))+if(!(cpumask_test_cpu(cpu,node_to_cpumask_map[node]))){+dbg("adding cpu %d to node %d\n",cpu,node);cpumask_set_cpu(cpu,node_to_cpumask_map[node]);+}}#if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_PPC_SPLPAR)
@@ -152,13 +153,11 @@ static void unmap_cpu_from_node(unsigned long cpu){intnode=numa_cpu_lookup_table[cpu];-dbg("removing cpu %lu from node %d\n",cpu,node);-if(cpumask_test_cpu(cpu,node_to_cpumask_map[node])){cpumask_clear_cpu(cpu,node_to_cpumask_map[node]);+dbg("removing cpu %lu from node %d\n",cpu,node);}else{-printk(KERN_ERR"WARNING: cpu %lu not found in node %d\n",-cpu,node);+pr_err("WARNING: cpu %lu not found in node %d\n",cpu,node);
Would pr_warn() be more appropriate here (or removing the "WARNING" statement)?
Its a fair point.
Michael,
Do you want me to resend this patch with s/pr_err/pr_warn for the above
line?
I think what I'd prefer is if we stopped using this custom dbg() stuff
in numa.c, and cleaned up all the messages to use pr_xxx().
Those debug statements only appear if you boot with numa=debug, which is
not documented anywhere and I had completely forgotten existed TBH.
These days there's CONFIG_DYNAMIC_DEBUG for turning on/off messages,
which is much more flexible.
So can we drop the numa=debug bits, and convert all the dbg()s to
pr_debug().
And then do a pass converting all the printk("NUMA: ") to pr_xxx() which
will get "numa:" from pr_fmt().
cheers
Le 21/08/2021 à 12:25, Srikar Dronamraju a écrit :
quoted
Currently, a debug message gets printed every time an attempt to
add(remove) a CPU. However this is redundant if the CPU is already added
(removed) from the node.
Its a fair point.
Michael,
Do you want me to resend this patch with s/pr_err/pr_warn for the above
line?
I think what I'd prefer is if we stopped using this custom dbg() stuff
in numa.c, and cleaned up all the messages to use pr_xxx().
Those debug statements only appear if you boot with numa=debug, which is
not documented anywhere and I had completely forgotten existed TBH.
These days there's CONFIG_DYNAMIC_DEBUG for turning on/off messages,
which is much more flexible.
So can we drop the numa=debug bits, and convert all the dbg()s to
pr_debug().
And then do a pass converting all the printk("NUMA: ") to pr_xxx() which
will get "numa:" from pr_fmt().
cheers
Okay, will do the needful.
--
Thanks and Regards
Srikar Dronamraju
From: Michael Ellerman <mpe@ellerman.id.au> Date: 2021-08-26 13:37:45
Srikar Dronamraju [off-list ref] writes:
Scheduler expects unique number of node distances to be available at
boot.
I think it needs "the number of unique node distances" ?
It uses node distance to calculate this unique node distances.
It iterates over all pairs of nodes and records node_distance() for that
pair, and then calculates the set of unique distances.
On POWER, node distances for offline nodes is not available. However,
POWER already knows unique possible node distances.
I think it would be more accurate to say PAPR rather than POWER there.
It's PAPR that defines the way we determine distances and imposes that
limitation.
Fake the offline node's distance_lookup_table entries so that all
possible node distances are updated.
Does this work if we have a single node offline at boot?
Say we start with:
node distances:
node 0 1
0: 10 20
1: 20 10
And node 2 is offline at boot. We can only initialise that nodes entries
in the distance_lookup_table:
while (i--)
distance_lookup_table[node][i] = node;
By filling them all with 2 that causes node_distance(2, X) to return the
maximum distance for all other nodes X, because we won't break out of
the loop in __node_distance():
for (i = 0; i < distance_ref_points_depth; i++) {
if (distance_lookup_table[a][i] == distance_lookup_table[b][i])
break;
/* Double the distance for each NUMA level */
distance *= 2;
}
If distance_ref_points_depth was 4 we'd return 160.
That'd leave us with 3 unique distances at boot, 10, 20, 160.
But when node 2 comes online it might introduce more than 1 new distance
value, eg. it could be that the actual distances are:
node distances:
node 0 1 2
0: 10 20 40
1: 20 10 80
2: 40 80 10
ie. we now have 4 distances, 10, 20, 40, 80.
What am I missing?
However this only needs to be done if the number of unique node
distances that can be computed for online nodes is less than the
number of possible unique node distances as represented by
distance_ref_points_depth.
Looking at a few machines they all have distance_ref_points_depth = 2.
So maybe that explains it, in practice we only see 10, 20, 40.
When the node is actually onlined, distance_lookup_table will be
updated with actual entries.
+static void __init fake_update_distance_lookup_table(void)
+{
+ unsigned long distance_map;
+ int i, nr_levels, nr_depth, node;
Are they distances, depths, or levels? :)
Bit more consistency in the variable names might make the code easier to
follow.
+
+ if (!numa_enabled)
+ return;
+
+ if (!form1_affinity)
+ return;
That doesn't exist since Aneesh's FORM2 series, so that will need a
rebase, and possibly some more rework to interact with that series.
+ /*
+ * distance_ref_points_depth lists the unique numa domains
+ * available. However it ignore LOCAL_DISTANCE. So add +1
+ * to get the actual number of unique distances.
+ */
+ nr_depth = distance_ref_points_depth + 1;
num_depths would be a better name IMHO.
+
+ WARN_ON(nr_depth > sizeof(distance_map));
Warn but then continue, and corrupt something on the stack? Seems like a
bad idea :)
I guess it's too early to use bitmap_alloc(). But can we at least return
if nr_depth is too big.
+
+ bitmap_zero(&distance_map, nr_depth);
+ bitmap_set(&distance_map, 0, 1);
+
+ for_each_online_node(node) {
+ int nd, distance = LOCAL_DISTANCE;
+
+ if (node == first_online_node)
+ continue;
+
+ nd = __node_distance(node, first_online_node);
+ for (i = 0; i < nr_depth; i++, distance *= 2) {
for (i = 0, distance = LOCAL_DISTANCE; i < nr_depth; i++, distance *= 2) {
Could make it clearer what the for loop is doing I think.
+ if (distance == nd) {
+ bitmap_set(&distance_map, i, 1);
+ break;
+ }
+ }
+ nr_levels = bitmap_weight(&distance_map, nr_depth);
+ if (nr_levels == nr_depth)
+ return;
+ }
+
+ for_each_node(node) {
+ if (node_online(node))
+ continue;
+
+ i = find_first_zero_bit(&distance_map, nr_depth);
+ if (i >= nr_depth || i == 0) {
Neither of those can happen can they?
We checked the bitmap weight in the previous for loop, or at the bottom
of this one, and returned if we'd filled the map already.
And we set bit zero explicitly with bitmap_set().
+ pr_warn("Levels(%d) not matching levels(%d)", nr_levels, nr_depth);
+ return;
+ }
+
+ bitmap_set(&distance_map, i, 1);
+ while (i--)
+ distance_lookup_table[node][i] = node;
That leaves distance_lookup_table[node][i+1] and so on uninitialised, or
initialised to zero because it's static, is that OK?
quoted hunk
+ nr_levels = bitmap_weight(&distance_map, nr_depth);
+ if (nr_levels == nr_depth)
+ return;
+ }
+}
+
/* Initialize NODE_DATA for a node on the local memory */
static void __init setup_node_data(int nid, u64 start_pfn, u64 end_pfn)
{
* Michael Ellerman [off-list ref] [2021-08-26 23:36:53]:
Srikar Dronamraju [off-list ref] writes:
quoted
Scheduler expects unique number of node distances to be available at
boot.
I think it needs "the number of unique node distances" ?
quoted
It uses node distance to calculate this unique node distances.
It iterates over all pairs of nodes and records node_distance() for that
pair, and then calculates the set of unique distances.
quoted
On POWER, node distances for offline nodes is not available. However,
POWER already knows unique possible node distances.
I think it would be more accurate to say PAPR rather than POWER there.
It's PAPR that defines the way we determine distances and imposes that
limitation.
Okay, will do all the necessary modifications as suggested above.
quoted
Fake the offline node's distance_lookup_table entries so that all
possible node distances are updated.
Does this work if we have a single node offline at boot?
It should.
Say we start with:
node distances:
node 0 1
0: 10 20
1: 20 10
And node 2 is offline at boot. We can only initialise that nodes entries
in the distance_lookup_table:
while (i--)
distance_lookup_table[node][i] = node;
By filling them all with 2 that causes node_distance(2, X) to return the
maximum distance for all other nodes X, because we won't break out of
the loop in __node_distance():
for (i = 0; i < distance_ref_points_depth; i++) {
if (distance_lookup_table[a][i] == distance_lookup_table[b][i])
break;
/* Double the distance for each NUMA level */
distance *= 2;
}
If distance_ref_points_depth was 4 we'd return 160.
As you already know, distance 10, 20, .. are defined by Powerpc, form1
affinity. PAPR doesn't define actual distances, it only provides us the
associativity. If there are distance_ref_points_depth is 4,
(distance_ref_points_depth doesn't take local distance into consideration)
10, 20, 40, 80, 160.
That'd leave us with 3 unique distances at boot, 10, 20, 160.
So if there are unique distances, then the distances as per the current
code has to be 10, 20, 40, 80.. I dont see a way in which we have a break in
the series. like having 160 without 80.
But when node 2 comes online it might introduce more than 1 new distance
value, eg. it could be that the actual distances are:
node distances:
node 0 1 2
0: 10 20 40
1: 20 10 80
2: 40 80 10
ie. we now have 4 distances, 10, 20, 40, 80.
What am I missing?
As I said above, I am not sure how we can have a break in the series.
If distance_ref_points_depth is 3, the distances has to be 10,20,40,80 as
atleast for form1 affinity.
quoted
However this only needs to be done if the number of unique node
distances that can be computed for online nodes is less than the
number of possible unique node distances as represented by
distance_ref_points_depth.
Looking at a few machines they all have distance_ref_points_depth = 2.
So maybe that explains it, in practice we only see 10, 20, 40.
quoted
When the node is actually onlined, distance_lookup_table will be
updated with actual entries.
+static void __init fake_update_distance_lookup_table(void)
+{
+ unsigned long distance_map;
+ int i, nr_levels, nr_depth, node;
Are they distances, depths, or levels? :)
Bit more consistency in the variable names might make the code easier to
follow.
quoted
+
+ if (!numa_enabled)
+ return;
+
+ if (!form1_affinity)
+ return;
That doesn't exist since Aneesh's FORM2 series, so that will need a
rebase, and possibly some more rework to interact with that series.
We only have to handle for form1, so it should be easier to handle.
quoted
+ /*
+ * distance_ref_points_depth lists the unique numa domains
+ * available. However it ignore LOCAL_DISTANCE. So add +1
+ * to get the actual number of unique distances.
+ */
+ nr_depth = distance_ref_points_depth + 1;
num_depths would be a better name IMHO.
Okay,
s/nr_depth/num_depths/g
s/nr_level/depth/g
quoted
+
+ WARN_ON(nr_depth > sizeof(distance_map));
Warn but then continue, and corrupt something on the stack? Seems like a
bad idea :)
I guess it's too early to use bitmap_alloc(). But can we at least return
if nr_depth is too big.
Yes, we can't use bitmap_alloc here.
Now should we continue if nr_depth is greater than sizeof(distance_map)
If we don't and return immediately, then we can end up not creating enough
scheduler domains and may later on lead to build_sched_domain OOPs, when we
online nodes.
However if don't return, chance of surviving when the domains are actually
onlined is more.
We could probably reset nr_depth to be same as sizeof(distance_map).
That said, I think we are too far away from nr_depths being anywhere closer
to sizeof(long). So I am okay either way.
quoted
+
+ bitmap_zero(&distance_map, nr_depth);
+ bitmap_set(&distance_map, 0, 1);
+
+ for_each_online_node(node) {
+ int nd, distance = LOCAL_DISTANCE;
+
+ if (node == first_online_node)
+ continue;
+
+ nd = __node_distance(node, first_online_node);
+ for (i = 0; i < nr_depth; i++, distance *= 2) {
for (i = 0, distance = LOCAL_DISTANCE; i < nr_depth; i++, distance *= 2) {
Could make it clearer what the for loop is doing I think.
quoted
+ if (distance == nd) {
+ bitmap_set(&distance_map, i, 1);
+ break;
+ }
+ }
+ nr_levels = bitmap_weight(&distance_map, nr_depth);
+ if (nr_levels == nr_depth)
+ return;
+ }
+
+ for_each_node(node) {
+ if (node_online(node))
+ continue;
+
+ i = find_first_zero_bit(&distance_map, nr_depth);
+ if (i >= nr_depth || i == 0) {
Neither of those can happen can they?
We checked the bitmap weight in the previous for loop, or at the bottom
of this one, and returned if we'd filled the map already.
And we set bit zero explicitly with bitmap_set().
+
+ bitmap_set(&distance_map, i, 1);
+ while (i--)
+ distance_lookup_table[node][i] = node;
That leaves distance_lookup_table[node][i+1] and so on uninitialised, or
initialised to zero because it's static, is that OK?
Yes, this should be fine, because we are only interested in finding number
of unique numa distances, By the time actual distances come and overwrite,
we would no more use these fake distances.
But if you are comfortable with updating for all the depths, I can update
too.
quoted
+ nr_levels = bitmap_weight(&distance_map, nr_depth);
+ if (nr_levels == nr_depth)
+ return;
+ }
+}
+
/* Initialize NODE_DATA for a node on the local memory */
static void __init setup_node_data(int nid, u64 start_pfn, u64 end_pfn)
{
From: Michael Ellerman <mpe@ellerman.id.au> Date: 2021-09-23 11:18:14
Srikar Dronamraju [off-list ref] writes:
* Michael Ellerman [off-list ref] [2021-08-26 23:36:53]:
quoted
Srikar Dronamraju [off-list ref] writes:
quoted
Scheduler expects unique number of node distances to be available at
boot.
...
quoted
quoted
Fake the offline node's distance_lookup_table entries so that all
possible node distances are updated.
Does this work if we have a single node offline at boot?
It should.
quoted
Say we start with:
node distances:
node 0 1
0: 10 20
1: 20 10
And node 2 is offline at boot. We can only initialise that nodes entries
in the distance_lookup_table:
while (i--)
distance_lookup_table[node][i] = node;
By filling them all with 2 that causes node_distance(2, X) to return the
maximum distance for all other nodes X, because we won't break out of
the loop in __node_distance():
for (i = 0; i < distance_ref_points_depth; i++) {
if (distance_lookup_table[a][i] == distance_lookup_table[b][i])
break;
/* Double the distance for each NUMA level */
distance *= 2;
}
If distance_ref_points_depth was 4 we'd return 160.
As you already know, distance 10, 20, .. are defined by Powerpc, form1
affinity. PAPR doesn't define actual distances, it only provides us the
associativity. If there are distance_ref_points_depth is 4,
(distance_ref_points_depth doesn't take local distance into consideration)
10, 20, 40, 80, 160.
quoted
That'd leave us with 3 unique distances at boot, 10, 20, 160.
So if there are unique distances, then the distances as per the current
code has to be 10, 20, 40, 80.. I dont see a way in which we have a break in
the series. like having 160 without 80.
I'm confused what you mean there.
If we have a node that's offline at boot then we get 160 for that node,
that's just the result of having no info for it, so we never break out
of the for loop.
So if we have two nodes, one hop apart, and then an offline node we get
10, 20, 160.
Or if you're using depth = 3 then it's 10, 20, 80.
quoted
But when node 2 comes online it might introduce more than 1 new distance
value, eg. it could be that the actual distances are:
node distances:
node 0 1 2
0: 10 20 40
1: 20 10 80
2: 40 80 10
ie. we now have 4 distances, 10, 20, 40, 80.
What am I missing?
As I said above, I am not sure how we can have a break in the series.
If distance_ref_points_depth is 3, the distances has to be 10,20,40,80 as
atleast for form1 affinity.
I agree for depth 3 we have to see 10, 20, 40, 80. But nothing
guarantees we see each value (other than 10).
We can have two nodes one hop apart, so we have 10 and 20, then a third
node is added 3 hops away, so we get 10, 20, 80.
The real problem is that the third node could be 3 hops from node 0
and 2 hops from node 1, and so the addition of the third node causes
two new distance values (40 & 80) to be required.
I think maybe what you're saying is that in practice we don't see setups
like that. But I don't know if I'm happy with a solution that doesn't
work in the general case, and relies on the particular properties of our
current set of systems.
Possibly we just need to detect that case and WARN about it. The only
problem is we won't know until the system is already up and running, ie.
we can't know at boot that the onlining of the third node will cause 2
new distance values to be added.
cheers
* Michael Ellerman [off-list ref] [2021-09-23 21:17:25]:
Srikar Dronamraju [off-list ref] writes:
quoted
* Michael Ellerman [off-list ref] [2021-08-26 23:36:53]:
quoted
Srikar Dronamraju [off-list ref] writes:
quoted
Scheduler expects unique number of node distances to be available at
boot.
...
quoted
quoted
quoted
Fake the offline node's distance_lookup_table entries so that all
possible node distances are updated.
Does this work if we have a single node offline at boot?
It should.
quoted
Say we start with:
node distances:
node 0 1
0: 10 20
1: 20 10
And node 2 is offline at boot. We can only initialise that nodes entries
in the distance_lookup_table:
while (i--)
distance_lookup_table[node][i] = node;
By filling them all with 2 that causes node_distance(2, X) to return the
maximum distance for all other nodes X, because we won't break out of
the loop in __node_distance():
for (i = 0; i < distance_ref_points_depth; i++) {
if (distance_lookup_table[a][i] == distance_lookup_table[b][i])
break;
/* Double the distance for each NUMA level */
distance *= 2;
}
If distance_ref_points_depth was 4 we'd return 160.
As you already know, distance 10, 20, .. are defined by Powerpc, form1
affinity. PAPR doesn't define actual distances, it only provides us the
associativity. If there are distance_ref_points_depth is 4,
(distance_ref_points_depth doesn't take local distance into consideration)
10, 20, 40, 80, 160.
quoted
That'd leave us with 3 unique distances at boot, 10, 20, 160.
So if there are unique distances, then the distances as per the current
code has to be 10, 20, 40, 80.. I dont see a way in which we have a break in
the series. like having 160 without 80.
I'm confused what you mean there.
At the outset, if we have a better probable solution, do let me know, I am
willing to try that too.
If we have a node that's offline at boot then we get 160 for that node,
that's just the result of having no info for it, so we never break out
of the for loop.
So if we have two nodes, one hop apart, and then an offline node we get
10, 20, 160.
Or if you're using depth = 3 then it's 10, 20, 80.
My understanding is as below:
device-tree provides the max hops by way of
ibm,associativity-reference-points. This is mapped to
distance_ref_points_depth in Linux-powerpc.
Now Linux-powerpc encodes hops as (dis-regarding local distance) 20, 40, 80,
160, 320 ...
So if the distance_ref_points_depth is 3, then the hops are 20, 40, 80.
Do you disagree?
quoted
quoted
But when node 2 comes online it might introduce more than 1 new distance
value, eg. it could be that the actual distances are:
node distances:
node 0 1 2
0: 10 20 40
1: 20 10 80
2: 40 80 10
ie. we now have 4 distances, 10, 20, 40, 80.
What am I missing?
As I said above, I am not sure how we can have a break in the series.
If distance_ref_points_depth is 3, the distances has to be 10,20,40,80 as
atleast for form1 affinity.
I agree for depth 3 we have to see 10, 20, 40, 80. But nothing
guarantees we see each value (other than 10).
The hop distances are not from the device-tree, the device-tree only gives
us the max hops possible. Linux-powerpc is actually hard-coding the
distances which each hop distance being 2x the previous.
So we may not see any nodes at a particular hop, but we know maximum hops.
And if distance_ref_points_depth is 3, then hops are 20, 40, 80 only.
We can have two nodes one hop apart, so we have 10 and 20, then a third
node is added 3 hops away, so we get 10, 20, 80.
The real problem is that the third node could be 3 hops from node 0
and 2 hops from node 1, and so the addition of the third node causes
two new distance values (40 & 80) to be required.
So here the max hops as given by device-tree is 3. So we know that we are
looking for max-distance of 80 by way of distance_ref_points_depth.
Even if the 3rd node was at 4 hops, we would already know the max distance
of 160, by way of distance_ref_points_depth. However in the most unlikely
scenarios where the number of possible nodes are less than the
distance_ref_points_depth(aka max hops) + there are CPUless/memoryless nodes
we may not have initialized to the right distances.
I think maybe what you're saying is that in practice we don't see setups
like that. But I don't know if I'm happy with a solution that doesn't
work in the general case, and relies on the particular properties of our
current set of systems.
But our current set of systems are having a problem (Systems can likely
crash on adding a CPU to a node.) The only other way I can think of is the
previous approach were we ask scheduler hook which tells how many unique
node distances are possible. But then it was stuck down because, we didnt
want to add a hook just for one arch.
However isn't this is much much better than the current situation we are in?
i.e This is not going to cause any regression for the other setups.
Possibly we just need to detect that case and WARN about it. The only
problem is we won't know until the system is already up and running, ie.
we can't know at boot that the onlining of the third node will cause 2
new distance values to be added.
Yes, We should be able to detect this very easily.
At the end of the function (v2 or v3) if cur_depth != max_depth then we
havent initialized all possible node distances.
From: Michael Ellerman <mpe@ellerman.id.au> Date: 2021-10-11 11:45:48
Srikar Dronamraju [off-list ref] writes:
* Michael Ellerman [off-list ref] [2021-09-23 21:17:25]:
quoted
Srikar Dronamraju [off-list ref] writes:
quoted
* Michael Ellerman [off-list ref] [2021-08-26 23:36:53]:
quoted
Srikar Dronamraju [off-list ref] writes:
quoted
Scheduler expects unique number of node distances to be available at
boot.
...
quoted
quoted
quoted
Fake the offline node's distance_lookup_table entries so that all
possible node distances are updated.
Does this work if we have a single node offline at boot?
It should.
quoted
Say we start with:
node distances:
node 0 1
0: 10 20
1: 20 10
And node 2 is offline at boot. We can only initialise that nodes entries
in the distance_lookup_table:
while (i--)
distance_lookup_table[node][i] = node;
By filling them all with 2 that causes node_distance(2, X) to return the
maximum distance for all other nodes X, because we won't break out of
the loop in __node_distance():
for (i = 0; i < distance_ref_points_depth; i++) {
if (distance_lookup_table[a][i] == distance_lookup_table[b][i])
break;
/* Double the distance for each NUMA level */
distance *= 2;
}
If distance_ref_points_depth was 4 we'd return 160.
As you already know, distance 10, 20, .. are defined by Powerpc, form1
affinity. PAPR doesn't define actual distances, it only provides us the
associativity. If there are distance_ref_points_depth is 4,
(distance_ref_points_depth doesn't take local distance into consideration)
10, 20, 40, 80, 160.
quoted
That'd leave us with 3 unique distances at boot, 10, 20, 160.
So if there are unique distances, then the distances as per the current
code has to be 10, 20, 40, 80.. I dont see a way in which we have a break in
the series. like having 160 without 80.
I'm confused what you mean there.
At the outset, if we have a better probable solution, do let me know, I am
willing to try that too.
I don't have one in mind no, I'm just trying to satisfy myself that this
solution will work in all cases we're likely to encounter.
quoted
If we have a node that's offline at boot then we get 160 for that node,
that's just the result of having no info for it, so we never break out
of the for loop.
So if we have two nodes, one hop apart, and then an offline node we get
10, 20, 160.
Or if you're using depth = 3 then it's 10, 20, 80.
My understanding is as below:
device-tree provides the max hops by way of
ibm,associativity-reference-points. This is mapped to
distance_ref_points_depth in Linux-powerpc.
Now Linux-powerpc encodes hops as (dis-regarding local distance) 20, 40, 80,
160, 320 ...
So if the distance_ref_points_depth is 3, then the hops are 20, 40, 80.
Do you disagree?
I'm not sure. You didn't really address my point.
You said that we can't have 160 without 80 (for depth = 4).
I gave an example where we could see a gap in the used distance values,
ie. 10, 20, 80 for a depth of 3.
Which is not to say that distance 40 doesn't exist in that scenario,
rather that it's not used by any node.
quoted
quoted
quoted
But when node 2 comes online it might introduce more than 1 new distance
value, eg. it could be that the actual distances are:
node distances:
node 0 1 2
0: 10 20 40
1: 20 10 80
2: 40 80 10
ie. we now have 4 distances, 10, 20, 40, 80.
What am I missing?
As I said above, I am not sure how we can have a break in the series.
If distance_ref_points_depth is 3, the distances has to be 10,20,40,80 as
atleast for form1 affinity.
I agree for depth 3 we have to see 10, 20, 40, 80. But nothing
guarantees we see each value (other than 10).
The hop distances are not from the device-tree, the device-tree only gives
us the max hops possible. Linux-powerpc is actually hard-coding the
distances which each hop distance being 2x the previous.
Yes. I guess I was sloppy to say "see each value", I didn't mean we see
those values directly in the device-tree.
So we may not see any nodes at a particular hop, but we know maximum hops.
And if distance_ref_points_depth is 3, then hops are 20, 40, 80 only.
OK, so we agree that "we may not see any nodes at a particular hop".
Which is what I was trying to say above.
quoted
We can have two nodes one hop apart, so we have 10 and 20, then a third
node is added 3 hops away, so we get 10, 20, 80.
quoted
The real problem is that the third node could be 3 hops from node 0
and 2 hops from node 1, and so the addition of the third node causes
two new distance values (40 & 80) to be required.
So here the max hops as given by device-tree is 3. So we know that we are
looking for max-distance of 80 by way of distance_ref_points_depth.
Even if the 3rd node was at 4 hops, we would already know the max distance
of 160, by way of distance_ref_points_depth.
I agree we know that the max value is, and therefore the total number of
possible distance values.
But I think there are topologies where we can not represent all the
possible distances in the distance table.
However in the most unlikely scenarios where the number of possible
nodes are less than the distance_ref_points_depth(aka max hops) +
there are CPUless/memoryless nodes we may not have initialized to the
right distances.
OK, so I think you're saying you agree that there are situations where
we might not be able to represent all the distances.
But you say that's an "unlikely scenario", why is it unlikely?
If you can convince me it's 100% unlikely then maybe we can forget about
it :)
quoted
I think maybe what you're saying is that in practice we don't see setups
like that. But I don't know if I'm happy with a solution that doesn't
work in the general case, and relies on the particular properties of our
current set of systems.
But our current set of systems are having a problem (Systems can likely
crash on adding a CPU to a node.)
Yes I agree that's bad, but also we don't want to merge a solution (and
presumably backport it everywhere) if it doesn't work for some cases.
The only other way I can think of is the previous approach were we ask
scheduler hook which tells how many unique node distances are
possible. But then it was stuck down because, we didnt want to add a
hook just for one arch.
OK.
However isn't this is much much better than the current situation we are in?
i.e This is not going to cause any regression for the other setups.
Yes that's true. But equally if we can find a 100% solution that would
save us having to fix the same issue again in future.
quoted
Possibly we just need to detect that case and WARN about it. The only
problem is we won't know until the system is already up and running, ie.
we can't know at boot that the onlining of the third node will cause 2
new distance values to be added.
Yes, We should be able to detect this very easily.
At the end of the function (v2 or v3) if cur_depth != max_depth then we
havent initialized all possible node distances.
The only issue is what do we do when we detect that case?
We can't BUG/panic, because we don't know for sure that the offline
nodes will cause new distance values to be needed. So the system might
be completely fine, all we know is it might not be. If we print a scary
warning we'll end up with bugs filed for that.
cheers