Skip to contentSkip to conversation

mm/fake-numa: fix under-allocation detection in uniform split

PATCH In review Sang-Heon Jeon 2 participants 9 messages Apr 17 – Apr 24

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 mm/fake-numa: fix under-allocation detection in uniform split

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the under-allocation will not be detected.

Fix under-allocation detection logic to compare the number of actually created nodes (ret - nid) against the request count (n). Also skip under-allocation detection logic for memoryless physical nodes where no fake nodes are created.

Also, fix the outdated comment to match the actual return value.

Fixes cc9aec03e58f ("x86/numa_emulation: Introduce uniform split capability") # 4.19

---
Changes from RFC v1 [1]
- Merge patchset into once.
- Change base from linux-next to mm-unstable

Changes from RFC v2 [2]
- Fix error message to use the number of created node instead of returned node ID.
- Define nr_created variable to explicitly show the number of created nodes.

Changes from v1 [1]
- Skip under-allocation check for memoryless node where no fake nodes are created.

[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/[email protected]/
[3] https://lore.kernel.org/all/[email protected]/
---
QEMU-based test results

1) Check under-allocation is well detected (based on commit message scenario)
a) AS-IS (before fix)

[    0.001878] NUMA: Node 0 [mem 0x00001000-0x0009ffff] + [mem 0x00100000-0x7fffffff] ]
[    0.001881] Fake node size 255MB too small, increasing to 256MB
[    0.001882] Faking node 0 at [mem 0x0000000000001000-0x0000000010000fff] (256MB)
[    0.001883] Faking node 1 at [mem 0x0000000010001000-0x0000000020000fff] (256MB)
[    0.001883] Faking node 2 at [mem 0x0000000020001000-0x0000000030000fff] (256MB)
[    0.001884] Faking node 3 at [mem 0x0000000030001000-0x0000000040000fff] (256MB)
[    0.001884] Faking node 4 at [mem 0x0000000040001000-0x0000000050000fff] (256MB)
[    0.001884] Faking node 5 at [mem 0x0000000050001000-0x0000000060000fff] (256MB)
[    0.001885] Faking node 6 at [mem 0x0000000060001000-0x0000000070000fff] (256MB)
[    0.001885] Faking node 7 at [mem 0x0000000070001000-0x000000007fffffff] (255MB)
[    0.001885] Fake node size 15MB too small, increasing to 32MB
[    0.001886] Faking node 8 at [mem 0x0000000080000000-0x0000000081ffffff] (32MB)
[    0.001886] Faking node 9 at [mem 0x0000000082000000-0x0000000083ffffff] (32MB)
[    0.001887] Faking node 10 at [mem 0x0000000084000000-0x0000000087fdcfff] (63MB)
[    0.001924] NODE_DATA(0) allocated [mem 0x0fffd6c0-0x10000fff]
[    0.019852] NODE_DATA(1) allocated [mem 0x1fffd6c0-0x20000fff]
[    0.022458] NODE_DATA(2) allocated [mem 0x2dffc6c0-0x2dffffff]
[    0.023293] NODE_DATA(3) allocated [mem 0x3fffd6c0-0x40000fff]
[    0.028522] NODE_DATA(4) allocated [mem 0x4fffd6c0-0x50000fff]
[    0.032397] NODE_DATA(5) allocated [mem 0x5fffd6c0-0x60000fff]
[    0.036552] NODE_DATA(6) allocated [mem 0x6fffd6c0-0x70000fff]
[    0.038746] NODE_DATA(7) allocated [mem 0x7fffc6c0-0x7fffffff]
[    0.040286] NODE_DATA(8) allocated [mem 0x81ffc6c0-0x81ffffff]
[    0.041517] NODE_DATA(9) allocated [mem 0x83ffc6c0-0x83ffffff]
[    0.043678] NODE_DATA(10) allocated [mem 0x87fd86c0-0x87fdbfff]

b) TO-BE (after fix)

[    0.001858] NUMA: Node 0 [mem 0x00001000-0x0009ffff] + [mem 0x00100000-0x7fffffff] ]
[    0.001860] Fake node size 255MB too small, increasing to 256MB
[    0.001861] Faking node 0 at [mem 0x0000000000001000-0x0000000010000fff] (256MB)
[    0.001861] Faking node 1 at [mem 0x0000000010001000-0x0000000020000fff] (256MB)
[    0.001862] Faking node 2 at [mem 0x0000000020001000-0x0000000030000fff] (256MB)
[    0.001862] Faking node 3 at [mem 0x0000000030001000-0x0000000040000fff] (256MB)
[    0.001863] Faking node 4 at [mem 0x0000000040001000-0x0000000050000fff] (256MB)
[    0.001863] Faking node 5 at [mem 0x0000000050001000-0x0000000060000fff] (256MB)
[    0.001863] Faking node 6 at [mem 0x0000000060001000-0x0000000070000fff] (256MB)
[    0.001864] Faking node 7 at [mem 0x0000000070001000-0x000000007fffffff] (255MB)
[    0.001864] Fake node size 15MB too small, increasing to 32MB
[    0.001864] Faking node 8 at [mem 0x0000000080000000-0x0000000081ffffff] (32MB)
[    0.001865] Faking node 9 at [mem 0x0000000082000000-0x0000000083ffffff] (32MB)
[    0.001865] Faking node 10 at [mem 0x0000000084000000-0x0000000087fdcfff] (63MB)
[    0.001866] numa_emulation: phys: 1 only got 3 of 8 nodes, failing
[    0.001867] NODE_DATA(0) allocated [mem 0x7fffc6c0-0x7fffffff]
[    0.001940] NODE_DATA(1) allocated [mem 0x87fd96c0-0x87fdcfff]

2) No false failure with memoryless node
- Node 0: 2GB, Node 1: memoryless
- numa=fake=2U

a) AS-IS (before fix)

[    0.001843] NUMA: Node 0 [mem 0x00001000-0x0009ffff] + [mem 0x00100000-0x7ffdcfff] -> [mem 0x00001000-0x7ffdcfff]
[    0.001845] Fake node size 1023MB too small, increasing to 1024MB
[    0.001846] Faking node 0 at [mem 0x0000000000001000-0x0000000040000fff] (1024MB)
[    0.001846] Faking node 1 at [mem 0x0000000040001000-0x000000007ffdcfff] (1023MB)
[    0.001847] Fake node size 0MB too small, increasing to 32MB
[    0.001869] NODE_DATA(0) allocated [mem 0x3fffd6c0-0x40000fff]
[    0.002023] NODE_DATA(1) allocated [mem 0x7ffd86c0-0x7ffdbfff]

b) TO-BE (after fix)

[    0.001862] NUMA: Node 0 [mem 0x00001000-0x0009ffff] + [mem 0x00100000-0x7ffdcfff] -> [mem 0x00001000-0x7ffdcfff]
[    0.001864] Fake node size 1023MB too small, increasing to 1024MB
[    0.001865] Faking node 0 at [mem 0x0000000000001000-0x0000000040000fff] (1024MB)
[    0.001866] Faking node 1 at [mem 0x0000000040001000-0x000000007ffdcfff] (1023MB)
[    0.001866] Fake node size 0MB too small, increasing to 32MB
[    0.001889] NODE_DATA(0) allocated [mem 0x3fffd6c0-0x40000fff]
[    0.002034] NODE_DATA(1) allocated [mem 0x7ffd86c0-0x7ffdbfff]

And also there is other scenario tested by Donghyeon. [1]

[1] https://lore.kernel.org/all/CAFPTC5e1OLpHa3HqwhtSPjS_PTQz+iG=ovM2cZ=VnOZ_5z7oxg@mail.gmail.com/

---

 mm/numa_emulation.c | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)
mm/numa_emulation.c +13 -4
index 703c8fa05048..5d72559fcdf2 100644
@@ -214,7 +214,7 @@ static u64 uniform_size(u64 max_addr, u64 base, u64 hole, int nr_nodes)
  * Sets up fake nodes of `size' interleaved over physical nodes ranging from
  * `addr' to `max_addr'.
  *
- * Returns zero on success or negative on error.
+ * Returns absolute node ID on success or negative on error.
  */
 static int __init split_nodes_size_interleave_uniform(struct numa_meminfo *ei,
 					      struct numa_meminfo *pi,
@@ -398,7 +398,7 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
 	 */
 	if (strchr(emu_cmdline, 'U')) {
 		unsigned long n;
-		int nid = 0;
+		int nid = 0, nr_created;
 
 		n = simple_strtoul(emu_cmdline, &emu_cmdline, 0);
 		ret = -1;
@@ -416,9 +416,18 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
 					n, &pi.blk[0], nid);
 			if (ret < 0)
 				break;
-			if (ret < n) {
+
+			/*
+			 * If no memory was found for this physical node,
+			 * skip the under-allocation check. 
+			 */
+			if (ret == nid)
+				continue;
+
+			nr_created = ret - nid;
+			if (nr_created < n) {
 				pr_info("%s: phys: %d only got %d of %ld nodes, failing\n",
-						__func__, i, ret, n);
+						__func__, i, nr_created, n);
 				ret = -1;
 				break;
 			}
Signature · 1 line
2.43.0
maintainer
#1 lore raw

Hi,

Quoted 6 lines · Sang-Heon Jeon

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

Quoted 7 lines

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the

In this example it would be 11, won't it?
I'll update when applying.

Quoted 13 lines

under-allocation will not be detected.

Fix under-allocation detection logic to compare the number of actually created nodes (ret - nid) against the request count (n). Also skip under-allocation detection logic for memoryless physical nodes where no fake nodes are created.

Also, fix the outdated comment to match the actual return value.

Fixes cc9aec03e58f ("x86/numa_emulation: Introduce uniform split capability") # 4.19

...

mm/numa_emulation.c void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt) · line 422

Quoted 9 lines
mm/numa_emulation.c +4 -1
@@ -416,9 +416,18 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
 					n, &pi.blk[0], nid);
 			if (ret < 0)
 				break;
-			if (ret < n) {
+
+			/*
+			 * If no memory was found for this physical node,
+			 * skip the under-allocation check. 

checkpatch complains about trailing white space here. I'll fix it up when applying.

Quoted 15 lines
mm/numa_emulation.c +7 -1
+			 */
+			if (ret == nid)
+				continue;
+
+			nr_created = ret - nid;
+			if (nr_created < n) {
 				pr_info("%s: phys: %d only got %d of %ld nodes, failing\n",
-						__func__, i, ret, n);
+						__func__, i, nr_created, n);
 				ret = -1;
 				break;
 			}
Signature · 1 line
2.43.0
Signature · 2 lines
Sincerely yours,
Mike.
#2 lore raw

Hi

Quoted 18 lines · Mike Rapoport

Hi,

Quoted 6 lines · Sang-Heon Jeon

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

Quoted 7 lines

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the

Quoted 2 lines

In this example it would be 11, won't it?
I'll update when applying.

I think 12 is correct because there is a difference between the attached QEMU test log and the scenario which is described in the commit message. This is because I missed the reserved memory (~140KB) for ACPI table.

1) Previous attached QEMU test scenario

QEMU command line :

    qemu-system-x86_64 \
    ...
    -m 2176M \
    -object memory-backend-ram,id=mem0,size=2G \
    -object memory-backend-ram,id=mem1,size=128M \
    -numa node,nodeid=0,cpus=0-1,memdev=mem0 \
    -numa node,nodeid=1,cpus=2-3,memdev=mem1 \

log :

[    0.000000] BIOS-provided physical RAM map:
[    0.000000] BIOS-e820: [mem 0x0000000000000000-0x000000000009fbff]
System RAM
[    0.000000] BIOS-e820: [mem 0x000000000009fc00-0x000000000009ffff]
device reserved
[    0.000000] BIOS-e820: [gap 0x00000000000a0000-0x00000000000effff]
[    0.000000] BIOS-e820: [mem 0x00000000000f0000-0x00000000000fffff]
device reserved
[    0.000000] BIOS-e820: [mem 0x0000000000100000-0x0000000087fdcfff]
System RAM
[    0.000000] BIOS-e820: [mem 0x0000000087fdd000-0x0000000087ffffff]
device reserved
[    0.000000] BIOS-e820: [gap 0x0000000088000000-0x00000000feffbfff]
[    0.000000] BIOS-e820: [mem 0x00000000feffc000-0x00000000feffffff]
device reserved
[    0.000000] BIOS-e820: [gap 0x00000000ff000000-0x00000000fffbffff]
[    0.000000] BIOS-e820: [mem 0x00000000fffc0000-0x00000000ffffffff]
device reserved
[    0.000000] BIOS-e820: [gap 0x0000000100000000-0x000000fcffffffff]
[    0.000000] BIOS-e820: [mem 0x000000fd00000000-0x000000ffffffffff]

device reserved

...

[    0.001919] ACPI: SRAT: Node 0 PXM 0 [mem 0x00000000-0x0009ffff]
[    0.001921] ACPI: SRAT: Node 0 PXM 0 [mem 0x00100000-0x7fffffff]
[    0.001922] ACPI: SRAT: Node 1 PXM 1 [mem 0x80000000-0x87ffffff]

...

[    0.001930] Fake node size 15MB too small, increasing to 32MB
[    0.001930] Faking node 8 at [mem
0x0000000080000000-0x0000000081ffffff] (32MB)
[    0.001931] Faking node 9 at [mem
0x0000000082000000-0x0000000083ffffff] (32MB)
[    0.001931] Faking node 10 at [mem

0x0000000084000000-0x0000000087fdcfff] (63MB)

So actual node 1 usable memory is [0x80000000-0x87fdcfff] (~127.86MB) That's why uniformly splitted memory count is 3 for node 1

2) Commit message scenario (Log is newly attached)

QEMU command line :

     ...
     -m 2228480K \
    -object memory-backend-ram,id=mem0,size=2G \
    -object memory-backend-ram,id=mem1,size=131328K \ # 128MB + 256KB for margin
    -numa node,nodeid=0,cpus=0-1,memdev=mem0 \
    -numa node,nodeid=1,cpus=2-3,memdev=mem1 \

log:

[    0.000000] BIOS-provided physical RAM map:
[    0.000000] BIOS-e820: [mem 0x0000000000000000-0x000000000009fbff]
System RAM
[    0.000000] BIOS-e820: [mem 0x000000000009fc00-0x000000000009ffff]
device reserved
[    0.000000] BIOS-e820: [gap 0x00000000000a0000-0x00000000000effff]
[    0.000000] BIOS-e820: [mem 0x00000000000f0000-0x00000000000fffff]
device reserved
[    0.000000] BIOS-e820: [mem 0x0000000000100000-0x000000008801cfff]
System RAM
[    0.000000] BIOS-e820: [mem 0x000000008801d000-0x000000008803ffff]
device reserved
[    0.000000] BIOS-e820: [gap 0x0000000088040000-0x00000000feffbfff]
[    0.000000] BIOS-e820: [mem 0x00000000feffc000-0x00000000feffffff]
device reserved
[    0.000000] BIOS-e820: [gap 0x00000000ff000000-0x00000000fffbffff]
[    0.000000] BIOS-e820: [mem 0x00000000fffc0000-0x00000000ffffffff]
device reserved
[    0.000000] BIOS-e820: [gap 0x0000000100000000-0x000000fcffffffff]
[    0.000000] BIOS-e820: [mem 0x000000fd00000000-0x000000ffffffffff]

device reserved

...

[    0.001870] ACPI: SRAT: Node 0 PXM 0 [mem 0x00000000-0x0009ffff]
[    0.001871] ACPI: SRAT: Node 0 PXM 0 [mem 0x00100000-0x7fffffff]
[    0.001872] ACPI: SRAT: Node 1 PXM 1 [mem 0x80000000-0x8803ffff]

...

[    0.001888] Fake node size 16MB too small, increasing to 32MB
[    0.001888] Faking node 8 at [mem
0x0000000080000000-0x0000000081ffffff] (32MB)
[    0.001888] Faking node 9 at [mem
0x0000000082000000-0x0000000083ffffff] (32MB)
[    0.001889] Faking node 10 at [mem
0x0000000084000000-0x0000000085ffffff] (32MB)
[    0.001889] Faking node 11 at [mem

0x0000000086000000-0x000000008801cfff] (32MB) # (~32.11MB)

So actual node 1 usable memory is [0x80000000-0x8801cfff] (~128.11MB) And Node 1 is successfully uniformly splitted into 4 fake nodes.

Sorry for causing confusion due to the wrong example.

Quoted 16 lines
Quoted 13 lines

under-allocation will not be detected.

Fix under-allocation detection logic to compare the number of actually created nodes (ret - nid) against the request count (n). Also skip under-allocation detection logic for memoryless physical nodes where no fake nodes are created.

Also, fix the outdated comment to match the actual return value.

Fixes cc9aec03e58f ("x86/numa_emulation: Introduce uniform split capability") # 4.19

...

Quoted 12 lines

mm/numa_emulation.c void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt) · line 422

Quoted 9 lines
mm/numa_emulation.c +4 -1
@@ -416,9 +416,18 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
                                      n, &pi.blk[0], nid);
                      if (ret < 0)
                              break;
-                     if (ret < n) {
+
+                     /*
+                      * If no memory was found for this physical node,
+                      * skip the under-allocation check.

checkpatch complains about trailing white space here. I'll fix it up when applying.

Oops, I missed it. Thank you for pointing it out!

Quoted 16 lines
Quoted 13 lines
mm/numa_emulation.c +7 -2
+                      */
+                     if (ret == nid)
+                             continue;
+
+                     nr_created = ret - nid;
+                     if (nr_created < n) {
                              pr_info("%s: phys: %d only got %d of %ld nodes, failing\n",
-                                             __func__, i, ret, n);
+                                             __func__, i, nr_created, n);
                              ret = -1;
                              break;
                      }
--
Quoted 2 lines

2.43.0

Quoted 3 lines

--
Sincerely yours,
Mike.

I really appreciate your detailed review :)

Best Regards,
Sang-Heon Jeon

#3 lore raw
In reply to Mike Rapoport

Hi

Quoted 18 lines · Mike Rapoport

Hi,

Quoted 6 lines · Sang-Heon Jeon

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

Quoted 7 lines

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the

Quoted 2 lines

In this example it would be 11, won't it?
I'll update when applying.

Oops, my previous reply is not the main point of this review. (Please ignore it) But 12 is still correct, because split_nodes_size_interleave_uniform() returns next available node ID.

IMHO, it would be clearer if both the commit message and the function comment change into "next available node ID".
If you're okay with it, I'll create v3 patch soon, including minor fix below

Sorry for the inconvenience.

Quoted 45 lines
Quoted 13 lines

under-allocation will not be detected.

Fix under-allocation detection logic to compare the number of actually created nodes (ret - nid) against the request count (n). Also skip under-allocation detection logic for memoryless physical nodes where no fake nodes are created.

Also, fix the outdated comment to match the actual return value.

Fixes cc9aec03e58f ("x86/numa_emulation: Introduce uniform split capability") # 4.19

...

mm/numa_emulation.c void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt) · line 422

Quoted 9 lines
mm/numa_emulation.c +4 -1
@@ -416,9 +416,18 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
                                      n, &pi.blk[0], nid);
                      if (ret < 0)
                              break;
-                     if (ret < n) {
+
+                     /*
+                      * If no memory was found for this physical node,
+                      * skip the under-allocation check.

checkpatch complains about trailing white space here. I'll fix it up when applying.

Quoted 13 lines
mm/numa_emulation.c +7 -2
+                      */
+                     if (ret == nid)
+                             continue;
+
+                     nr_created = ret - nid;
+                     if (nr_created < n) {
                              pr_info("%s: phys: %d only got %d of %ld nodes, failing\n",
-                                             __func__, i, ret, n);
+                                             __func__, i, nr_created, n);
                              ret = -1;
                              break;
                      }
--
Quoted 2 lines

2.43.0

Quoted 3 lines

--
Sincerely yours,
Mike.

Best Regards,
Sang-Heon Jeon

maintainer
#4 lore raw
Quoted 19 lines · Sang-Heon Jeon
Quoted 15 lines · Mike Rapoport
Quoted 6 lines · Sang-Heon Jeon

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

Quoted 7 lines

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the

Quoted 2 lines

In this example it would be 11, won't it?
I'll update when applying.

Quoted 7 lines

Oops, my previous reply is not the main point of this review. (Please ignore it) But 12 is still correct, because split_nodes_size_interleave_uniform() returns next available node ID.

IMHO, it would be clearer if both the commit message and the function comment change into "next available node ID".
If you're okay with it, I'll create v3 patch soon, including minor fix below

No need for v3, I updated the comment and the whitespace:
https://git.kernel.org/rppt/memblock/c/a34436ac05e76bd6634a89fc0a399ab3a48f509a

Quoted 2 lines

Best Regards,
Sang-Heon Jeon

Signature · 2 lines
Sincerely yours,
Mike.
#5 lore raw

Hi

Quoted 25 lines · Mike Rapoport
Quoted 23 lines · Sang-Heon Jeon
Quoted 15 lines · Mike Rapoport
Quoted 6 lines · Sang-Heon Jeon

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

Quoted 7 lines

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the

Quoted 2 lines

In this example it would be 11, won't it?
I'll update when applying.

Oops, my previous reply is not the main point of this review. (Please ignore it) But 12 is still correct, because split_nodes_size_interleave_uniform() returns next available node ID.

Quoted 6 lines
Quoted 3 lines

IMHO, it would be clearer if both the commit message and the function comment change into "next available node ID".
If you're okay with it, I'll create v3 patch soon, including minor fix below

No need for v3, I updated the comment and the whitespace:
https://git.kernel.org/rppt/memblock/c/a34436ac05e76bd6634a89fc0a399ab3a48f509a

Thanks for your help, Mike. However, it seems like '12' was changed to '11' in the commit message. I think this change should be rolled back. Could you check?

Quoted 6 lines
Quoted 2 lines

Best Regards,
Sang-Heon Jeon

--
Sincerely yours,
Mike.

Best Regards,
Sang-Heon Jeon

maintainer
#6 lore raw
Quoted 32 lines · Sang-Heon Jeon

Hi

Quoted 29 lines · Mike Rapoport
Quoted 26 lines · Sang-Heon Jeon
Quoted 15 lines · Mike Rapoport
Quoted 6 lines · Sang-Heon Jeon

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

Quoted 7 lines

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the

Quoted 2 lines

In this example it would be 11, won't it?
I'll update when applying.

Oops, my previous reply is not the main point of this review. (Please ignore it) But 12 is still correct, because split_nodes_size_interleave_uniform() returns next available node ID.

IMHO, it would be clearer if both the commit message and the function comment change into "next available node ID".
If you're okay with it, I'll create v3 patch soon, including minor fix below

Quoted 6 lines
Quoted 2 lines

No need for v3, I updated the comment and the whitespace:
https://git.kernel.org/rppt/memblock/c/a34436ac05e76bd6634a89fc0a399ab3a48f509a

Thanks for your help, Mike. However, it seems like '12' was changed to '11' in the commit message. I think this change should be rolled back. Could you check?

Node IDs are counted from 0, hence for 12 nodes the last nid would be 11.

Signature · 2 lines
Sincerely yours,
Mike.
#7 lore raw

Hello,

Quoted 34 lines · Mike Rapoport
Quoted 32 lines · Sang-Heon Jeon

Hi

Quoted 29 lines · Mike Rapoport
Quoted 26 lines · Sang-Heon Jeon
Quoted 15 lines · Mike Rapoport
Quoted 6 lines · Sang-Heon Jeon

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

Quoted 7 lines

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the

Quoted 2 lines

In this example it would be 11, won't it?
I'll update when applying.

Oops, my previous reply is not the main point of this review. (Please ignore it) But 12 is still correct, because split_nodes_size_interleave_uniform() returns next available node ID.

IMHO, it would be clearer if both the commit message and the function comment change into "next available node ID".
If you're okay with it, I'll create v3 patch soon, including minor fix below

Quoted 8 lines
Quoted 6 lines
Quoted 2 lines

No need for v3, I updated the comment and the whitespace:
https://git.kernel.org/rppt/memblock/c/a34436ac05e76bd6634a89fc0a399ab3a48f509a

Thanks for your help, Mike. However, it seems like '12' was changed to '11' in the commit message. I think this change should be rolled back. Could you check?

Node IDs are counted from 0, hence for 12 nodes the last nid would be 11.

Right, the last nid is indeed 11. However, the return value ret here refers to the next nid, so it should be 12 in this example.

Quoted 3 lines

--
Sincerely yours,
Mike.

Best Regards,
Sang-Heon Jeon

maintainer
#8 lore raw
Quoted 40 lines · Sang-Heon Jeon

Hello,

Quoted 37 lines · Mike Rapoport
Quoted 35 lines · Sang-Heon Jeon

Hi

Quoted 31 lines · Mike Rapoport
Quoted 19 lines · Sang-Heon Jeon
Quoted 15 lines · Mike Rapoport
Quoted 6 lines · Sang-Heon Jeon

When split NUMA node uniformly, split_nodes_size_interleave_uniform() returns the next absolute node ID, not the number of nodes created.

The existing under-allocation detection logic compares next absolute node ID (ret) and request count (n), which only works when nid starts at 0.

Quoted 7 lines

For example, on a system with 2 physical NUMA nodes (node 0: 2GB, node 1: 128MB) and numa=fake=8U, 8 fake nodes are successfully created from node 0 and split_nodes_size_interleave_uniform() returns 8. For node 1, fake node nid starts at 8, but only 4 fake nodes are created due to current FAKE_NODE_MIN_SIZE being 32MB, and split_nodes_size_interleave_uniform() returns 12. By existing under-allocation detection logic, "ret < n" (12 < 8) is false, so the

Quoted 2 lines

In this example it would be 11, won't it?
I'll update when applying.

Quoted 7 lines

Oops, my previous reply is not the main point of this review. (Please ignore it) But 12 is still correct, because split_nodes_size_interleave_uniform() returns next available node ID.

IMHO, it would be clearer if both the commit message and the function comment change into "next available node ID".
If you're okay with it, I'll create v3 patch soon, including minor fix below

No need for v3, I updated the comment and the whitespace:
https://git.kernel.org/rppt/memblock/c/a34436ac05e76bd6634a89fc0a399ab3a48f509a

Quoted 8 lines
Quoted 5 lines
Quoted 3 lines

Thanks for your help, Mike. However, it seems like '12' was changed to '11' in the commit message. I think this change should be rolled back. Could you check?

Node IDs are counted from 0, hence for 12 nodes the last nid would be 11.

Right, the last nid is indeed 11. However, the return value ret here refers to the next nid, so it should be 12 in this example.

Fixed now, thanks!

Quoted 2 lines

Best Regards,
Sang-Heon Jeon

Signature · 2 lines
Sincerely yours,
Mike.