Arrange hotpluggable memory as ZONE_MOVABLE

Hey,

Quoted 9 lines · Zhang Yanfei

a little difference here, consider a 16-GB node. If we parse SRAT earlier, and still use the top-down allocation, and kernel image is loaded at 16MB, we reserve other nodes but this 16GB node that kernel resides in is used for boot-up allocation. So the page table is allocated from 16GB to 0. The page table is allocated on top of the the memory as possible.

But if we use this approach, no matter how large the page table is, we allocate the page table in low memory which is the case that hpa concerns about the DMA.

Yeah, sure there will be cases where parsing SRAT would be better.

4k mapping is in use, which is mostly for debugging && memory map is composed such that the highest non-hotpluggable address is high enough.

It's going in circles again but my point has always been that the above in itself don't seem to be substantial enough to justify putting, say, initrd loading before page table init.

Later some argued that bringing SRAT parsing earlier could help implementing finer grained hotplug, which would be an acceptable path to follow; however, that doesn't turn out to be true either.

* Again, it matter if and only if 4k mapping is in use. Do we even care?

* SRAT isn't enough. The whole device tree needs to be parsed to put page tables into local device. It's a lot of churn, including major updates to page table allocation, just to support debug 4k mapping cases. Doesn't make much sense to me.

So, SRAT's usefulness seems extremely limited - it helps if the user wants to use debug features along with memory hotplug on an extreme large machine with devices which have low DMA limit, and that's it. To me, it seems to be a poor argument. Just declaring memory hotplug works iff large kernel mapping is in use feels like a pretty good trade-off to me, and I have no idea why I have to repeat all this, which I've written multiple times already, in a private thread again.

If the thread is to make progress, one has to provide counter arguments to the points raised. It feels like I'm going in circle again. The exact same content I wrote above has been repeated multiple times in the past discussions and I'm getting tired of doing it without getting any actual response.

When replying, please restore cc's and keep the whole body.

Hello tejun,

Quoted 48 lines · Tejun Heo

Hey,

Quoted 9 lines · Zhang Yanfei

a little difference here, consider a 16-GB node. If we parse SRAT earlier, and still use the top-down allocation, and kernel image is loaded at 16MB, we reserve other nodes but this 16GB node that kernel resides in is used for boot-up allocation. So the page table is allocated from 16GB to 0. The page table is allocated on top of the the memory as possible.

But if we use this approach, no matter how large the page table is, we allocate the page table in low memory which is the case that hpa concerns about the DMA.

Yeah, sure there will be cases where parsing SRAT would be better.

4k mapping is in use, which is mostly for debugging && memory map is composed such that the highest non-hotpluggable address is high enough.

It's going in circles again but my point has always been that the above in itself don't seem to be substantial enough to justify putting, say, initrd loading before page table init.

Later some argued that bringing SRAT parsing earlier could help implementing finer grained hotplug, which would be an acceptable path to follow; however, that doesn't turn out to be true either.

* Again, it matter if and only if 4k mapping is in use. Do we even care?

* SRAT isn't enough. The whole device tree needs to be parsed to put page tables into local device. It's a lot of churn, including major updates to page table allocation, just to support debug 4k mapping cases. Doesn't make much sense to me.

So, SRAT's usefulness seems extremely limited - it helps if the user wants to use debug features along with memory hotplug on an extreme large machine with devices which have low DMA limit, and that's it. To me, it seems to be a poor argument. Just declaring memory hotplug works iff large kernel mapping is in use feels like a pretty good trade-off to me, and I have no idea why I have to repeat all this, which I've written multiple times already, in a private thread again.

If the thread is to make progress, one has to provide counter arguments to the points raised. It feels like I'm going in circle again. The exact same content I wrote above has been repeated multiple times in the past discussions and I'm getting tired of doing it without getting any actual response.

The points for parsing SRAT early instead of Yanfei/Tang v7:

1. We just reached one unified path to setup page tables for 32bit, 64bit and xen or non xen after several years. We should not have add another path for system
that support hotplug.

2. also we should avoid adding "movable_nodes" command line.

3. debug mapping 4k, and it is working all the way, why breaking it even for memory hotplug path?

4. numa_meminfo now is static structure.
we have no reason that we can not parse SRAT etc to fill that struct.

5. for device tree, i assume that we could do same like srat parsing to find out numa to fill the numa_meminfo early. or with help of BRK.

6. in the long run, We should rework our NUMA booting:
a. boot system with boot numa nodes early only.
b. in later init stage or user space, init other nodes RAM/CPU/PCI...in parallel.
that will reduce boot time for 8 sockets/32 sockets dramatically.

We will need to parse srat table early so could avoid init memory for non-boot nodes.

Quoted 8 lines

6. in the long run, We should rework our NUMA booting:
a. boot system with boot numa nodes early only.
b. in later init stage or user space, init other nodes RAM/CPU/PCI...in parallel.
that will reduce boot time for 8 sockets/32 sockets dramatically.

We will need to parse srat table early so could avoid init memory for non-boot nodes.

Among the six you listed, this one sounds somewhat valid but still assuming huge page, what difference does it make? We're just talking about page table alloc / init and ACPI init. If you wanna speed up huge NUMA machine booting and chop down memory init per-NUMA, sure, move those pieces to later stages. You can init the amount necessary during early boot and then bring up the rest later on. I don't see why that'd require parsing SRAT.

In fact, I think there'll be more
cases where you want to actively ignore NUMA mapping during early boot. What if the system maps low memory to a non-boot numa node?

Optimizing NUMA boot just requires moving the heavy lifting to appropriate NUMA nodes. It doesn't require that early boot phase should strictly follow NUMA node boundaries.

Quoted 4 lines

Optimizing NUMA boot just requires moving the heavy lifting to appropriate NUMA nodes. It doesn't require that early boot phase should strictly follow NUMA node boundaries.

At end of day, I like to see all numa system (ram/cpu/pci) could have non boot nodes to be hot-removed logically. with any boot command line.

Quoted 9 lines · Yinghai Lu

Quoted 4 lines

Optimizing NUMA boot just requires moving the heavy lifting to appropriate NUMA nodes. It doesn't require that early boot phase should strictly follow NUMA node boundaries.

At end of day, I like to see all numa system (ram/cpu/pci) could have non boot nodes to be hot-removed logically. with any boot command line.

I don't think that is realistic without hardware support, simply because all it takes is a single page of kernel locked memory to prevent a page from being removed. The only realistic way around that, I believe, is to remove the identity-mapping in the kernel, but it still has all kinds of funnies involving devices and DMA.

So if anyone can implement it using huge pages, with a really fast __va() and __pa() implementation, then it might be possible. But that's a pretty major surgery on x86.

Quoted 4 lines · Ingo Molnar

So if anyone can implement it using huge pages, with a really fast __va() and __pa() implementation, then it might be possible. But that's a pretty major surgery on x86.

Well, we already *have* a way to deal with that for Xen (by inserting an otherwise nonexistent logical level.) I'm wondering if those interfaces could be (ab)used for this as well, or if that is functionally equivalent to saying that this should be done in a hypervisor.

The problem is how to define "amount necessary". If we can parse srat early, then we could just map RAM for all boot nodes one time, instead of try some small and then after SRAT table, expand it cover non-boot nodes.

To keep non-boot numa node hot-removable. we need to page table (and other that we allocate during boot stage) on ram of non boot nodes, or their local node ram. (share page table always should be on boot nodes).

Quoted 3 lines

Optimizing NUMA boot just requires moving the heavy lifting to appropriate NUMA nodes. It doesn't require that early boot phase should strictly follow NUMA node boundaries.

At end of day, I like to see all numa system (ram/cpu/pci) could have non boot nodes to be hot-removed logically. with any boot command line.

Hello,

Quoted 3 lines · Yinghai Lu

The problem is how to define "amount necessary". If we can parse srat early, then we could just map RAM for all boot nodes one time, instead of try some small and then after SRAT table, expand it cover non-boot nodes.

Wouldn't that amount be fairly static and restricted? If you wanna chunk memory init anyway, there's no reason to init more than necessary until smp stage is reached. The more you do early, the more serialized you're, so wouldn't the goal naturally be initing the minimum possible?

Quoted 3 lines

To keep non-boot numa node hot-removable. we need to page table (and other that we allocate during boot stage) on ram of non boot nodes, or their local node ram. (share page table always should be on boot nodes).

The above assumes the followings,

* 4k page mappings. It'd be nice to keep everything working for 4k but just following SRAT isn't enough. What if the non-hotpluggable boot node doesn't stretch high enough and page table reaches down too far? This won't be an optional behavior, so it is actually *likely* to happen on certain setups.

* Memory hotplug is at NUMA node granularity instead of device.

Quoted 4 lines

Quoted 3 lines

Optimizing NUMA boot just requires moving the heavy lifting to appropriate NUMA nodes. It doesn't require that early boot phase should strictly follow NUMA node boundaries.

Quoted 3 lines

At end of day, I like to see all numa system (ram/cpu/pci) could have non boot nodes to be hot-removed logically. with any boot command line.

I suppose you mean "without any boot command line"? Sure, but, first of all, there is a clear performance trade-off, and, secondly, don't we want something finer grained? Why would we want to that per-NUMA node, which is extremely coarse?

Hello,

Quoted 3 lines · Yinghai Lu

The problem is how to define "amount necessary". If we can parse srat early, then we could just map RAM for all boot nodes one time, instead of try some small and then after SRAT table, expand it cover non-boot nodes.

Wouldn't that amount be fairly static and restricted? If you wanna chunk memory init anyway, there's no reason to init more than necessary until smp stage is reached. The more you do early, the more serialized you're, so wouldn't the goal naturally be initing the minimum possible?

Quoted 4 lines

To keep non-boot numa node hot-removable. we need to page table (and other that we allocate during boot stage) on ram of non boot nodes, or their local node ram. (share page table always should be on boot nodes).

The above assumes the followings,

* 4k page mappings. It'd be nice to keep everything working for 4k but just following SRAT isn't enough. What if the non-hotpluggable boot node doesn't stretch high enough and page table reaches down too far? This won't be an optional behavior, so it is actually *likely* to happen on certain setups.

* Memory hotplug is at NUMA node granularity instead of device.

Quoted 5 lines

Quoted 4 lines

Optimizing NUMA boot just requires moving the heavy lifting to appropriate NUMA nodes. It doesn't require that early boot phase should strictly follow NUMA node boundaries.

Quoted 3 lines

At end of day, I like to see all numa system (ram/cpu/pci) could have non boot nodes to be hot-removed logically. with any boot command line.

I suppose you mean "without any boot command line"? Sure, but, first of all, there is a clear performance trade-off, and, secondly, don't we want something finer grained? Why would we want to that per-NUMA node, which is extremely coarse?

Quoted 5 lines

Wouldn't that amount be fairly static and restricted? If you wanna chunk memory init anyway, there's no reason to init more than necessary until smp stage is reached. The more you do early, the more serialized you're, so wouldn't the goal naturally be initing the minimum possible?

Even we try to go minimum range instead of range that whole range on boot node, without parsing srat at first, the minimum range could be crossed the boundary of nodes.

Quoted 5 lines

* 4k page mappings. It'd be nice to keep everything working for 4k but just following SRAT isn't enough. What if the non-hotpluggable boot node doesn't stretch high enough and page table reaches down too far? This won't be an optional behavior, so it is actually *likely* to happen on certain setups.

no, do not assume 4k page. even we are using 1GB mapping, we will still have chance to have one node to take 512G RAM, that means we can have one 4k page on local node ram.

On x86 system with intel new cpus there is memory controller built-in., could have hotplug modules (with socket and memory) and those hotplug modules will be serviced as one single point. Just nowadays like we have pcie card hotplugable.

I don't see where is the " a clear performance trade-off".

The points for parsing SRAT early instead of Yanfei/Tang v7:
1. We just reached one unified path to setup page tables for 32bit, 64bit and xen or non xen after several years. We should not have add another path for system
that support hotplug.

2. also we should avoid adding "movable_nodes" command line.

3. debug mapping 4k, and it is working all the way, why breaking it even for memory hotplug path?

4. numa_meminfo now is static structure.
we have no reason that we can not parse SRAT etc to fill that struct.

5. for device tree, i assume that we could do same like srat parsing to find out numa to fill the numa_meminfo early. or with help of BRK.

6. in the long run, We should rework our NUMA booting:
a. boot system with boot numa nodes early only.
b. in later init stage or user space, init other nodes RAM/CPU/PCI...in parallel.
that will reduce boot time for 8 sockets/32 sockets dramatically.

We will need to parse srat table early so could avoid init memory for non-boot nodes.

Quoted 1 line

2. also we should avoid adding "movable_nodes" command line.

Quoted 9 lines

6. in the long run, We should rework our NUMA booting:
a. boot system with boot numa nodes early only.
b. in later init stage or user space, init other nodes RAM/CPU/PCI...in parallel.
that will reduce boot time for 8 sockets/32 sockets dramatically.

We will need to parse srat table early so could avoid init memory for non-boot nodes.

I really like the long-term plan (and, I might want to add, the above writeup.)

However, I don't understand how we can avoid #2, given that it is fundamentally a sysadmin-driven tradeoff between performance and reliability.

Quoted 4 lines

However, I don't understand how we can avoid #2, given that it is fundamentally a sysadmin-driven tradeoff between performance and reliability.

If we make all numa systems support nodes hot-remove logically. like we boot system with node0, and hot add other nodes one by one, we should hot remove them later.

Hello guys, this is the part2 of our memory hotplug work. This part is based on the part1:
"x86, memblock: Allocate memory near kernel image before SRAT parsed"
which is base on 3.12-rc4.

You could refer part1 from: https://lkml.org/lkml/2013/10/10/644

Any comments are welcome! Thanks!

[Problem]

The current Linux cannot migrate pages used by the kerenl because of the kernel direct mapping. In Linux kernel space, va = pa + PAGE_OFFSET. When the pa is changed, we cannot simply update the pagetable and keep the va unmodified. So the kernel pages are not migratable.

There are also some other issues will cause the kernel pages not migratable. For example, the physical address may be cached somewhere and will be used. It is not to update all the caches.

When doing memory hotplug in Linux, we first migrate all the pages in one memory device somewhere else, and then remove the device. But if pages are used by the kernel, they are not migratable. As a result, memory used by the kernel cannot be hot-removed.

Modifying the kernel direct mapping mechanism is too difficult to do. And it may cause the kernel performance down and unstable. So we use the following way to do memory hotplug.

[What we are doing]

In Linux, memory in one numa node is divided into several zones. One of the zones is ZONE_MOVABLE, which the kernel won't use.

In order to implement memory hotplug in Linux, we are going to arrange all hotpluggable memory in ZONE_MOVABLE so that the kernel won't use these memory.

To do this, we need ACPI's help.

[How we do this]

In ACPI, SRAT(System Resource Affinity Table) contains NUMA info. The memory affinities in SRAT record every memory range in the system, and also, flags specifying if the memory range is hotpluggable.
(Please refer to ACPI spec 5.0 5.2.16)

With the help of SRAT, we have to do the following two things to achieve our goal:

1. When doing memory hot-add, allow the users arranging hotpluggable as ZONE_MOVABLE.
(This has been done by the MOVABLE_NODE functionality in Linux.)

2. when the system is booting, prevent bootmem allocator from allocating hotpluggable memory for the kernel before the memory initialization finishes.
(This is what we are going to do. See below.)

[About this patch-set]

In previous part's patches, we have made the kernel allocate memory near kernel image before SRAT parsed to avoid allocating hotpluggable memory for kernel. So this patch-set does the following things:

1. Improve memblock to support flags, which are used to indicate different memory type.

2. Mark all hotpluggable memory in memblock.memory[].

3. Make the default memblock allocator skip hotpluggable memory.

4. Improve "movable_node" boot option to have higher priority of movablecore and kernelcore boot option.

Change log v1 -> v2:
1. Rebase this part on the v7 version of part1
2. Fix bug: If movable_node boot option not specified, memblock still checks hotpluggable memory when allocating memory.

Tang Chen (7):
memblock, numa: Introduce flag into memblock
memblock, mem_hotplug: Introduce MEMBLOCK_HOTPLUG flag to mark
hotpluggable regions
memblock: Make memblock_set_node() support different memblock_type acpi, numa, mem_hotplug: Mark hotpluggable memory in memblock acpi, numa, mem_hotplug: Mark all nodes the kernel resides
un-hotpluggable
memblock, mem_hotplug: Make memblock skip hotpluggable regions if
needed
x86, numa, acpi, memory-hotplug: Make movable_node have higher
priority

Yasuaki Ishimatsu (1):
x86: get pg_data_t's memory from other node

 arch/metag/mm/init.c      |    3 +-
 arch/metag/mm/numa.c      |    3 +-
 arch/microblaze/mm/init.c |    3 +-
 arch/powerpc/mm/mem.c     |    2 +-
 arch/powerpc/mm/numa.c    |    8 ++-
 arch/sh/kernel/setup.c    |    4 +-
 arch/sparc/mm/init_64.c   |    5 +-
 arch/x86/mm/init_32.c     |    2 +-
 arch/x86/mm/init_64.c     |    2 +-
 arch/x86/mm/numa.c        |   63 +++++++++++++++++++++--
 arch/x86/mm/srat.c        |    5 ++
 include/linux/memblock.h  |   39 ++++++++++++++-
 mm/memblock.c             |  123 ++++++++++++++++++++++++++++++++++++++-------
 mm/memory_hotplug.c       |    1 +
 mm/page_alloc.c           |   28 ++++++++++-
 15 files changed, 252 insertions(+), 39 deletions(-)

Hello guys,

Could anyone help reviewing this part?

The first part has been merged into linus's tree. And I've tried to apply this part to today's linus tree:

commit 42a2d923cc349583ebf6fdd52a7d35e1c2f7e6bd
Merge: 5cbb3d2 75ecab1
Author: Linus Torvalds <[email protected]>
Date: Wed Nov 13 17:40:34 2013 +0900

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

No conflict, no compiling error and it works well.

Tejun, any comments?

Quoted 115 lines · Zhang Yanfei

Hello guys, this is the part2 of our memory hotplug work. This part is based on the part1:
"x86, memblock: Allocate memory near kernel image before SRAT parsed"
which is base on 3.12-rc4.

You could refer part1 from: https://lkml.org/lkml/2013/10/10/644

Any comments are welcome! Thanks!

[Problem]

The current Linux cannot migrate pages used by the kerenl because of the kernel direct mapping. In Linux kernel space, va = pa + PAGE_OFFSET. When the pa is changed, we cannot simply update the pagetable and keep the va unmodified. So the kernel pages are not migratable.

There are also some other issues will cause the kernel pages not migratable. For example, the physical address may be cached somewhere and will be used. It is not to update all the caches.

When doing memory hotplug in Linux, we first migrate all the pages in one memory device somewhere else, and then remove the device. But if pages are used by the kernel, they are not migratable. As a result, memory used by the kernel cannot be hot-removed.

Modifying the kernel direct mapping mechanism is too difficult to do. And it may cause the kernel performance down and unstable. So we use the following way to do memory hotplug.

[What we are doing]

In Linux, memory in one numa node is divided into several zones. One of the zones is ZONE_MOVABLE, which the kernel won't use.

In order to implement memory hotplug in Linux, we are going to arrange all hotpluggable memory in ZONE_MOVABLE so that the kernel won't use these memory.

To do this, we need ACPI's help.

[How we do this]

In ACPI, SRAT(System Resource Affinity Table) contains NUMA info. The memory affinities in SRAT record every memory range in the system, and also, flags specifying if the memory range is hotpluggable.
(Please refer to ACPI spec 5.0 5.2.16)

With the help of SRAT, we have to do the following two things to achieve our goal:

1. When doing memory hot-add, allow the users arranging hotpluggable as ZONE_MOVABLE.
(This has been done by the MOVABLE_NODE functionality in Linux.)

2. when the system is booting, prevent bootmem allocator from allocating hotpluggable memory for the kernel before the memory initialization finishes.
(This is what we are going to do. See below.)

[About this patch-set]

In previous part's patches, we have made the kernel allocate memory near kernel image before SRAT parsed to avoid allocating hotpluggable memory for kernel. So this patch-set does the following things:

1. Improve memblock to support flags, which are used to indicate different memory type.

2. Mark all hotpluggable memory in memblock.memory[].

3. Make the default memblock allocator skip hotpluggable memory.

4. Improve "movable_node" boot option to have higher priority of movablecore and kernelcore boot option.

Change log v1 -> v2:
1. Rebase this part on the v7 version of part1
2. Fix bug: If movable_node boot option not specified, memblock still checks hotpluggable memory when allocating memory.

Tang Chen (7):
memblock, numa: Introduce flag into memblock
memblock, mem_hotplug: Introduce MEMBLOCK_HOTPLUG flag to mark
hotpluggable regions
memblock: Make memblock_set_node() support different memblock_type acpi, numa, mem_hotplug: Mark hotpluggable memory in memblock acpi, numa, mem_hotplug: Mark all nodes the kernel resides
un-hotpluggable
memblock, mem_hotplug: Make memblock skip hotpluggable regions if
needed
x86, numa, acpi, memory-hotplug: Make movable_node have higher
priority

Yasuaki Ishimatsu (1):
x86: get pg_data_t's memory from other node

 arch/metag/mm/init.c      |    3 +-
 arch/metag/mm/numa.c      |    3 +-
 arch/microblaze/mm/init.c |    3 +-
 arch/powerpc/mm/mem.c     |    2 +-
 arch/powerpc/mm/numa.c    |    8 ++-
 arch/sh/kernel/setup.c    |    4 +-
 arch/sparc/mm/init_64.c   |    5 +-
 arch/x86/mm/init_32.c     |    2 +-
 arch/x86/mm/init_64.c     |    2 +-
 arch/x86/mm/numa.c        |   63 +++++++++++++++++++++--
 arch/x86/mm/srat.c        |    5 ++
 include/linux/memblock.h  |   39 ++++++++++++++-
 mm/memblock.c             |  123 ++++++++++++++++++++++++++++++++++++++-------
 mm/memory_hotplug.c       |    1 +
 mm/page_alloc.c           |   28 ++++++++++-
 15 files changed, 252 insertions(+), 39 deletions(-)