2019-05-19 06:07:45 -06:00
|
|
|
# SPDX-License-Identifier: GPL-2.0-only
|
2018-07-31 05:39:35 -06:00
|
|
|
|
|
|
|
|
menu "Memory Management options"
|
|
|
|
|
|
2005-06-23 01:07:49 -06:00
|
|
|
config SELECT_MEMORY_MODEL
|
|
|
|
|
def_bool y
|
2013-01-16 19:54:17 -07:00
|
|
|
depends on ARCH_SELECT_MEMORY_MODEL
|
2005-06-23 01:07:49 -06:00
|
|
|
|
2005-06-23 01:07:42 -06:00
|
|
|
choice
|
|
|
|
|
prompt "Memory model"
|
2005-06-23 01:07:49 -06:00
|
|
|
depends on SELECT_MEMORY_MODEL
|
|
|
|
|
default DISCONTIGMEM_MANUAL if ARCH_DISCONTIGMEM_DEFAULT
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
default SPARSEMEM_MANUAL if ARCH_SPARSEMEM_DEFAULT
|
2005-06-23 01:07:49 -06:00
|
|
|
default FLATMEM_MANUAL
|
2019-05-13 18:23:05 -06:00
|
|
|
help
|
|
|
|
|
This option allows you to change some of the ways that
|
|
|
|
|
Linux manages its memory internally. Most users will
|
|
|
|
|
only have one option here selected by the architecture
|
|
|
|
|
configuration. This is normal.
|
2005-06-23 01:07:42 -06:00
|
|
|
|
2005-06-23 01:07:49 -06:00
|
|
|
config FLATMEM_MANUAL
|
2005-06-23 01:07:42 -06:00
|
|
|
bool "Flat Memory"
|
2006-01-06 01:12:07 -07:00
|
|
|
depends on !(ARCH_DISCONTIGMEM_ENABLE || ARCH_SPARSEMEM_ENABLE) || ARCH_FLATMEM_ENABLE
|
2005-06-23 01:07:42 -06:00
|
|
|
help
|
2019-05-13 18:23:05 -06:00
|
|
|
This option is best suited for non-NUMA systems with
|
|
|
|
|
flat address space. The FLATMEM is the most efficient
|
|
|
|
|
system in terms of performance and resource consumption
|
|
|
|
|
and it is the best option for smaller systems.
|
|
|
|
|
|
|
|
|
|
For systems that have holes in their physical address
|
|
|
|
|
spaces and for features like NUMA and memory hotplug,
|
|
|
|
|
choose "Sparse Memory"
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
|
|
|
|
|
If unsure, choose this option (Flat Memory) over any other.
|
2005-06-23 01:07:42 -06:00
|
|
|
|
2005-06-23 01:07:49 -06:00
|
|
|
config DISCONTIGMEM_MANUAL
|
2005-09-16 20:27:54 -06:00
|
|
|
bool "Discontiguous Memory"
|
2005-06-23 01:07:42 -06:00
|
|
|
depends on ARCH_DISCONTIGMEM_ENABLE
|
|
|
|
|
help
|
2005-06-23 01:07:50 -06:00
|
|
|
This option provides enhanced support for discontiguous
|
|
|
|
|
memory systems, over FLATMEM. These systems have holes
|
|
|
|
|
in their physical address spaces, and this option provides
|
2019-05-13 18:23:05 -06:00
|
|
|
more efficient handling of these holes.
|
2005-06-23 01:07:50 -06:00
|
|
|
|
2019-05-13 18:23:05 -06:00
|
|
|
Although "Discontiguous Memory" is still used by several
|
|
|
|
|
architectures, it is considered deprecated in favor of
|
|
|
|
|
"Sparse Memory".
|
2005-06-23 01:07:50 -06:00
|
|
|
|
2019-05-13 18:23:05 -06:00
|
|
|
If unsure, choose "Sparse Memory" over this option.
|
2005-06-23 01:07:42 -06:00
|
|
|
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
config SPARSEMEM_MANUAL
|
|
|
|
|
bool "Sparse Memory"
|
|
|
|
|
depends on ARCH_SPARSEMEM_ENABLE
|
|
|
|
|
help
|
|
|
|
|
This will be the only option for some systems, including
|
2019-05-13 18:23:05 -06:00
|
|
|
memory hot-plug systems. This is normal.
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
|
2019-05-13 18:23:05 -06:00
|
|
|
This option provides efficient support for systems with
|
|
|
|
|
holes is their physical address space and allows memory
|
|
|
|
|
hot-plug and hot-remove.
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
|
2019-05-13 18:23:05 -06:00
|
|
|
If unsure, choose "Flat Memory" over this option.
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
|
2005-06-23 01:07:42 -06:00
|
|
|
endchoice
|
|
|
|
|
|
2005-06-23 01:07:49 -06:00
|
|
|
config DISCONTIGMEM
|
|
|
|
|
def_bool y
|
|
|
|
|
depends on (!SELECT_MEMORY_MODEL && ARCH_DISCONTIGMEM_ENABLE) || DISCONTIGMEM_MANUAL
|
|
|
|
|
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
config SPARSEMEM
|
|
|
|
|
def_bool y
|
2009-10-26 17:50:12 -06:00
|
|
|
depends on (!SELECT_MEMORY_MODEL && ARCH_SPARSEMEM_ENABLE) || SPARSEMEM_MANUAL
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
|
2005-06-23 01:07:49 -06:00
|
|
|
config FLATMEM
|
|
|
|
|
def_bool y
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
depends on (!DISCONTIGMEM && !SPARSEMEM) || FLATMEM_MANUAL
|
|
|
|
|
|
|
|
|
|
config FLAT_NODE_MEM_MAP
|
|
|
|
|
def_bool y
|
|
|
|
|
depends on !SPARSEMEM
|
2005-06-23 01:07:49 -06:00
|
|
|
|
2005-06-23 01:07:47 -06:00
|
|
|
#
|
|
|
|
|
# Both the NUMA code and DISCONTIGMEM use arrays of pg_data_t's
|
|
|
|
|
# to represent different areas of memory. This variable allows
|
|
|
|
|
# those dependencies to exist individually.
|
|
|
|
|
#
|
|
|
|
|
config NEED_MULTIPLE_NODES
|
|
|
|
|
def_bool y
|
|
|
|
|
depends on DISCONTIGMEM || NUMA
|
2005-06-23 01:07:53 -06:00
|
|
|
|
|
|
|
|
config HAVE_MEMORY_PRESENT
|
|
|
|
|
def_bool y
|
[PATCH] sparsemem memory model
Sparsemem abstracts the use of discontiguous mem_maps[]. This kind of
mem_map[] is needed by discontiguous memory machines (like in the old
CONFIG_DISCONTIGMEM case) as well as memory hotplug systems. Sparsemem
replaces DISCONTIGMEM when enabled, and it is hoped that it can eventually
become a complete replacement.
A significant advantage over DISCONTIGMEM is that it's completely separated
from CONFIG_NUMA. When producing this patch, it became apparent in that NUMA
and DISCONTIG are often confused.
Another advantage is that sparse doesn't require each NUMA node's ranges to be
contiguous. It can handle overlapping ranges between nodes with no problems,
where DISCONTIGMEM currently throws away that memory.
Sparsemem uses an array to provide different pfn_to_page() translations for
each SECTION_SIZE area of physical memory. This is what allows the mem_map[]
to be chopped up.
In order to do quick pfn_to_page() operations, the section number of the page
is encoded in page->flags. Part of the sparsemem infrastructure enables
sharing of these bits more dynamically (at compile-time) between the
page_zone() and sparsemem operations. However, on 32-bit architectures, the
number of bits is quite limited, and may require growing the size of the
page->flags type in certain conditions. Several things might force this to
occur: a decrease in the SECTION_SIZE (if you want to hotplug smaller areas of
memory), an increase in the physical address space, or an increase in the
number of used page->flags.
One thing to note is that, once sparsemem is present, the NUMA node
information no longer needs to be stored in the page->flags. It might provide
speed increases on certain platforms and will be stored there if there is
room. But, if out of room, an alternate (theoretically slower) mechanism is
used.
This patch introduces CONFIG_FLATMEM. It is used in almost all cases where
there used to be an #ifndef DISCONTIG, because SPARSEMEM and DISCONTIGMEM
often have to compile out the same areas of code.
Signed-off-by: Andy Whitcroft <apw@shadowen.org>
Signed-off-by: Dave Hansen <haveblue@us.ibm.com>
Signed-off-by: Martin Bligh <mbligh@aracnet.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Yasunori Goto <y-goto@jp.fujitsu.com>
Signed-off-by: Bob Picco <bob.picco@hp.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 01:07:54 -06:00
|
|
|
depends on ARCH_HAVE_MEMORY_PRESENT || SPARSEMEM
|
2005-09-03 16:54:26 -06:00
|
|
|
|
2005-09-03 16:54:28 -06:00
|
|
|
#
|
|
|
|
|
# SPARSEMEM_EXTREME (which is the default) does some bootmem
|
2006-10-03 14:53:09 -06:00
|
|
|
# allocations when memory_present() is called. If this cannot
|
2005-09-03 16:54:28 -06:00
|
|
|
# be done on your architecture, select this option. However,
|
|
|
|
|
# statically allocating the mem_section[] array can potentially
|
|
|
|
|
# consume vast quantities of .bss, so be careful.
|
|
|
|
|
#
|
|
|
|
|
# This option will also potentially produce smaller runtime code
|
|
|
|
|
# with gcc 3.4 and later.
|
|
|
|
|
#
|
|
|
|
|
config SPARSEMEM_STATIC
|
2008-10-15 23:01:38 -06:00
|
|
|
bool
|
2005-09-03 16:54:28 -06:00
|
|
|
|
2005-09-03 16:54:26 -06:00
|
|
|
#
|
2006-10-03 14:34:14 -06:00
|
|
|
# Architecture platforms which require a two level mem_section in SPARSEMEM
|
2005-09-03 16:54:26 -06:00
|
|
|
# must select this option. This is usually for architecture platforms with
|
|
|
|
|
# an extremely sparse physical address space.
|
|
|
|
|
#
|
2005-09-03 16:54:28 -06:00
|
|
|
config SPARSEMEM_EXTREME
|
|
|
|
|
def_bool y
|
|
|
|
|
depends on SPARSEMEM && !SPARSEMEM_STATIC
|
[PATCH] mm: split page table lock
Christoph Lameter demonstrated very poor scalability on the SGI 512-way, with
a many-threaded application which concurrently initializes different parts of
a large anonymous area.
This patch corrects that, by using a separate spinlock per page table page, to
guard the page table entries in that page, instead of using the mm's single
page_table_lock. (But even then, page_table_lock is still used to guard page
table allocation, and anon_vma allocation.)
In this implementation, the spinlock is tucked inside the struct page of the
page table page: with a BUILD_BUG_ON in case it overflows - which it would in
the case of 32-bit PA-RISC with spinlock debugging enabled.
Splitting the lock is not quite for free: another cacheline access. Ideally,
I suppose we would use split ptlock only for multi-threaded processes on
multi-cpu machines; but deciding that dynamically would have its own costs.
So for now enable it by config, at some number of cpus - since the Kconfig
language doesn't support inequalities, let preprocessor compare that with
NR_CPUS. But I don't think it's worth being user-configurable: for good
testing of both split and unsplit configs, split now at 4 cpus, and perhaps
change that to 8 later.
There is a benefit even for singly threaded processes: kswapd can be attacking
one part of the mm while another part is busy faulting.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 19:16:40 -06:00
|
|
|
|
2007-10-16 02:24:14 -06:00
|
|
|
config SPARSEMEM_VMEMMAP_ENABLE
|
2008-10-15 23:01:38 -06:00
|
|
|
bool
|
2007-10-16 02:24:14 -06:00
|
|
|
|
|
|
|
|
config SPARSEMEM_VMEMMAP
|
2007-12-17 17:19:53 -07:00
|
|
|
bool "Sparse Memory virtual memmap"
|
|
|
|
|
depends on SPARSEMEM && SPARSEMEM_VMEMMAP_ENABLE
|
|
|
|
|
default y
|
|
|
|
|
help
|
|
|
|
|
SPARSEMEM_VMEMMAP uses a virtually mapped memmap to optimise
|
|
|
|
|
pfn_to_page and page_to_pfn operations. This is the most
|
|
|
|
|
efficient option when sufficient kernel resources are available.
|
2007-10-16 02:24:14 -06:00
|
|
|
|
2011-07-14 03:43:42 -06:00
|
|
|
config HAVE_MEMBLOCK_NODE_MAP
|
2014-12-20 13:41:11 -07:00
|
|
|
bool
|
2011-07-14 03:43:42 -06:00
|
|
|
|
2014-01-29 10:16:01 -07:00
|
|
|
config HAVE_MEMBLOCK_PHYS_MAP
|
2014-12-20 13:41:11 -07:00
|
|
|
bool
|
2014-01-29 10:16:01 -07:00
|
|
|
|
2019-07-11 21:57:14 -06:00
|
|
|
config HAVE_FAST_GUP
|
2019-07-11 21:57:21 -06:00
|
|
|
depends on MMU
|
2014-12-20 13:41:11 -07:00
|
|
|
bool
|
2014-10-09 16:29:14 -06:00
|
|
|
|
2019-05-13 18:22:59 -06:00
|
|
|
config ARCH_KEEP_MEMBLOCK
|
2014-12-20 13:41:11 -07:00
|
|
|
bool
|
2011-07-14 03:46:03 -06:00
|
|
|
|
2012-07-31 17:43:50 -06:00
|
|
|
config MEMORY_ISOLATION
|
2014-12-20 13:41:11 -07:00
|
|
|
bool
|
2012-07-31 17:43:50 -06:00
|
|
|
|
2013-02-22 17:33:00 -07:00
|
|
|
#
|
|
|
|
|
# Only be set on architectures that have completely implemented memory hotplug
|
|
|
|
|
# feature. If you are not sure, don't touch it.
|
|
|
|
|
#
|
|
|
|
|
config HAVE_BOOTMEM_INFO_NODE
|
|
|
|
|
def_bool n
|
|
|
|
|
|
2005-10-29 19:16:54 -06:00
|
|
|
# eventually, we can have this option just 'select SPARSEMEM'
|
|
|
|
|
config MEMORY_HOTPLUG
|
|
|
|
|
bool "Allow for memory hot-add"
|
2006-10-01 00:27:05 -06:00
|
|
|
depends on SPARSEMEM || X86_64_ACPI_NUMA
|
2013-05-20 21:49:35 -06:00
|
|
|
depends on ARCH_ENABLE_MEMORY_HOTPLUG
|
2005-10-29 19:16:54 -06:00
|
|
|
|
2006-10-01 00:27:05 -06:00
|
|
|
config MEMORY_HOTPLUG_SPARSE
|
|
|
|
|
def_bool y
|
|
|
|
|
depends on SPARSEMEM && MEMORY_HOTPLUG
|
|
|
|
|
|
2016-05-19 18:13:03 -06:00
|
|
|
config MEMORY_HOTPLUG_DEFAULT_ONLINE
|
|
|
|
|
bool "Online the newly added memory blocks by default"
|
|
|
|
|
depends on MEMORY_HOTPLUG
|
|
|
|
|
help
|
|
|
|
|
This option sets the default policy setting for memory hotplug
|
|
|
|
|
onlining policy (/sys/devices/system/memory/auto_online_blocks) which
|
|
|
|
|
determines what happens to newly added memory regions. Policy setting
|
|
|
|
|
can always be changed at runtime.
|
2019-06-07 12:54:32 -06:00
|
|
|
See Documentation/admin-guide/mm/memory-hotplug.rst for more information.
|
2016-05-19 18:13:03 -06:00
|
|
|
|
|
|
|
|
Say Y here if you want all hot-plugged memory blocks to appear in
|
|
|
|
|
'online' state by default.
|
|
|
|
|
Say N here if you want the default policy to keep all hot-plugged
|
|
|
|
|
memory blocks in 'offline' state.
|
|
|
|
|
|
2007-10-16 02:26:12 -06:00
|
|
|
config MEMORY_HOTREMOVE
|
|
|
|
|
bool "Allow for memory hot remove"
|
2013-02-22 17:33:00 -07:00
|
|
|
select MEMORY_ISOLATION
|
2013-09-27 09:18:09 -06:00
|
|
|
select HAVE_BOOTMEM_INFO_NODE if (X86_64 || PPC64)
|
2007-10-16 02:26:12 -06:00
|
|
|
depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE
|
|
|
|
|
depends on MIGRATION
|
|
|
|
|
|
[PATCH] mm: split page table lock
Christoph Lameter demonstrated very poor scalability on the SGI 512-way, with
a many-threaded application which concurrently initializes different parts of
a large anonymous area.
This patch corrects that, by using a separate spinlock per page table page, to
guard the page table entries in that page, instead of using the mm's single
page_table_lock. (But even then, page_table_lock is still used to guard page
table allocation, and anon_vma allocation.)
In this implementation, the spinlock is tucked inside the struct page of the
page table page: with a BUILD_BUG_ON in case it overflows - which it would in
the case of 32-bit PA-RISC with spinlock debugging enabled.
Splitting the lock is not quite for free: another cacheline access. Ideally,
I suppose we would use split ptlock only for multi-threaded processes on
multi-cpu machines; but deciding that dynamically would have its own costs.
So for now enable it by config, at some number of cpus - since the Kconfig
language doesn't support inequalities, let preprocessor compare that with
NR_CPUS. But I don't think it's worth being user-configurable: for good
testing of both split and unsplit configs, split now at 4 cpus, and perhaps
change that to 8 later.
There is a benefit even for singly threaded processes: kswapd can be attacking
one part of the mm while another part is busy faulting.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 19:16:40 -06:00
|
|
|
# Heavily threaded applications may benefit from splitting the mm-wide
|
|
|
|
|
# page_table_lock, so that faults on different parts of the user address
|
|
|
|
|
# space can be handled with less contention: split it at this NR_CPUS.
|
|
|
|
|
# Default to 4 for wider testing, though 8 might be more appropriate.
|
|
|
|
|
# ARM's adjust_pte (unused if VIPT) depends on mm-wide page_table_lock.
|
2005-11-23 14:37:37 -07:00
|
|
|
# PA-RISC 7xxx's spinlock_t would enlarge struct page from 32 to 44 bytes.
|
2009-12-14 18:59:02 -07:00
|
|
|
# DEBUG_SPINLOCK and DEBUG_LOCK_ALLOC spinlock_t also enlarge struct page.
|
[PATCH] mm: split page table lock
Christoph Lameter demonstrated very poor scalability on the SGI 512-way, with
a many-threaded application which concurrently initializes different parts of
a large anonymous area.
This patch corrects that, by using a separate spinlock per page table page, to
guard the page table entries in that page, instead of using the mm's single
page_table_lock. (But even then, page_table_lock is still used to guard page
table allocation, and anon_vma allocation.)
In this implementation, the spinlock is tucked inside the struct page of the
page table page: with a BUILD_BUG_ON in case it overflows - which it would in
the case of 32-bit PA-RISC with spinlock debugging enabled.
Splitting the lock is not quite for free: another cacheline access. Ideally,
I suppose we would use split ptlock only for multi-threaded processes on
multi-cpu machines; but deciding that dynamically would have its own costs.
So for now enable it by config, at some number of cpus - since the Kconfig
language doesn't support inequalities, let preprocessor compare that with
NR_CPUS. But I don't think it's worth being user-configurable: for good
testing of both split and unsplit configs, split now at 4 cpus, and perhaps
change that to 8 later.
There is a benefit even for singly threaded processes: kswapd can be attacking
one part of the mm while another part is busy faulting.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 19:16:40 -06:00
|
|
|
#
|
|
|
|
|
config SPLIT_PTLOCK_CPUS
|
|
|
|
|
int
|
2014-04-07 16:37:14 -06:00
|
|
|
default "999999" if !MMU
|
2009-12-14 18:59:02 -07:00
|
|
|
default "999999" if ARM && !CPU_CACHE_VIPT
|
|
|
|
|
default "999999" if PARISC && !PA20
|
[PATCH] mm: split page table lock
Christoph Lameter demonstrated very poor scalability on the SGI 512-way, with
a many-threaded application which concurrently initializes different parts of
a large anonymous area.
This patch corrects that, by using a separate spinlock per page table page, to
guard the page table entries in that page, instead of using the mm's single
page_table_lock. (But even then, page_table_lock is still used to guard page
table allocation, and anon_vma allocation.)
In this implementation, the spinlock is tucked inside the struct page of the
page table page: with a BUILD_BUG_ON in case it overflows - which it would in
the case of 32-bit PA-RISC with spinlock debugging enabled.
Splitting the lock is not quite for free: another cacheline access. Ideally,
I suppose we would use split ptlock only for multi-threaded processes on
multi-cpu machines; but deciding that dynamically would have its own costs.
So for now enable it by config, at some number of cpus - since the Kconfig
language doesn't support inequalities, let preprocessor compare that with
NR_CPUS. But I don't think it's worth being user-configurable: for good
testing of both split and unsplit configs, split now at 4 cpus, and perhaps
change that to 8 later.
There is a benefit even for singly threaded processes: kswapd can be attacking
one part of the mm while another part is busy faulting.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-29 19:16:40 -06:00
|
|
|
default "4"
|
2006-01-08 02:00:49 -07:00
|
|
|
|
2013-11-14 15:31:07 -07:00
|
|
|
config ARCH_ENABLE_SPLIT_PMD_PTLOCK
|
2014-12-20 13:41:11 -07:00
|
|
|
bool
|
2013-11-14 15:31:07 -07:00
|
|
|
|
2014-10-09 16:29:32 -06:00
|
|
|
#
|
|
|
|
|
# support for memory balloon
|
|
|
|
|
config MEMORY_BALLOON
|
2014-12-20 13:41:11 -07:00
|
|
|
bool
|
2014-10-09 16:29:32 -06:00
|
|
|
|
2012-12-11 17:02:38 -07:00
|
|
|
#
|
|
|
|
|
# support for memory balloon compaction
|
|
|
|
|
config BALLOON_COMPACTION
|
|
|
|
|
bool "Allow for balloon memory compaction/migration"
|
|
|
|
|
def_bool y
|
2014-10-09 16:29:32 -06:00
|
|
|
depends on COMPACTION && MEMORY_BALLOON
|
2012-12-11 17:02:38 -07:00
|
|
|
help
|
|
|
|
|
Memory fragmentation introduced by ballooning might reduce
|
|
|
|
|
significantly the number of 2MB contiguous memory blocks that can be
|
|
|
|
|
used within a guest, thus imposing performance penalties associated
|
|
|
|
|
with the reduced number of transparent huge pages that could be used
|
|
|
|
|
by the guest workload. Allowing the compaction & migration for memory
|
|
|
|
|
pages enlisted as being part of memory balloon devices avoids the
|
|
|
|
|
scenario aforementioned and helps improving memory defragmentation.
|
|
|
|
|
|
2010-05-24 15:32:21 -06:00
|
|
|
#
|
|
|
|
|
# support for memory compaction
|
|
|
|
|
config COMPACTION
|
|
|
|
|
bool "Allow for memory compaction"
|
2012-10-08 17:33:03 -06:00
|
|
|
def_bool y
|
2010-05-24 15:32:21 -06:00
|
|
|
select MIGRATION
|
2011-01-25 16:07:25 -07:00
|
|
|
depends on MMU
|
2010-05-24 15:32:21 -06:00
|
|
|
help
|
2016-08-25 16:17:05 -06:00
|
|
|
Compaction is the only memory management component to form
|
|
|
|
|
high order (larger physically contiguous) memory blocks
|
|
|
|
|
reliably. The page allocator relies on compaction heavily and
|
|
|
|
|
the lack of the feature can lead to unexpected OOM killer
|
|
|
|
|
invocations for high order memory requests. You shouldn't
|
|
|
|
|
disable this option unless there really is a strong reason for
|
|
|
|
|
it and then we would be really interested to hear about that at
|
|
|
|
|
linux-mm@kvack.org.
|
2010-05-24 15:32:21 -06:00
|
|
|
|
2006-01-08 02:00:49 -07:00
|
|
|
#
|
|
|
|
|
# support for page migration
|
|
|
|
|
#
|
|
|
|
|
config MIGRATION
|
2006-03-22 01:09:12 -07:00
|
|
|
bool "Page migration"
|
2006-06-23 03:03:37 -06:00
|
|
|
def_bool y
|
2013-09-12 16:14:08 -06:00
|
|
|
depends on (NUMA || ARCH_ENABLE_MEMORY_HOTREMOVE || COMPACTION || CMA) && MMU
|
2006-03-22 01:09:12 -07:00
|
|
|
help
|
|
|
|
|
Allows the migration of the physical location of pages of processes
|
2010-05-24 15:32:21 -06:00
|
|
|
while the virtual addresses are not changed. This is useful in
|
|
|
|
|
two situations. The first is on NUMA systems to put pages nearer
|
|
|
|
|
to the processors accessing. The second is when allocating huge
|
|
|
|
|
pages as migration can relocate pages to satisfy a huge page
|
|
|
|
|
allocation instead of reclaiming.
|
2006-06-12 18:11:31 -06:00
|
|
|
|
2014-06-04 17:05:35 -06:00
|
|
|
config ARCH_ENABLE_HUGEPAGE_MIGRATION
|
2014-12-20 13:41:11 -07:00
|
|
|
bool
|
2014-06-04 17:05:35 -06:00
|
|
|
|
2017-09-08 17:10:53 -06:00
|
|
|
config ARCH_ENABLE_THP_MIGRATION
|
|
|
|
|
bool
|
|
|
|
|
|
2019-05-13 18:19:00 -06:00
|
|
|
config CONTIG_ALLOC
|
|
|
|
|
def_bool (MEMORY_ISOLATION && COMPACTION) || CMA
|
|
|
|
|
|
2008-09-11 02:31:45 -06:00
|
|
|
config PHYS_ADDR_T_64BIT
|
2018-04-03 08:24:20 -06:00
|
|
|
def_bool 64BIT
|
2008-09-11 02:31:45 -06:00
|
|
|
|
2007-07-17 05:03:37 -06:00
|
|
|
config BOUNCE
|
2013-04-29 16:08:55 -06:00
|
|
|
bool "Enable bounce buffers"
|
|
|
|
|
default y
|
2007-07-17 05:03:37 -06:00
|
|
|
depends on BLOCK && MMU && (ZONE_DMA || HIGHMEM)
|
2013-04-29 16:08:55 -06:00
|
|
|
help
|
|
|
|
|
Enable bounce buffers for devices that cannot access
|
|
|
|
|
the full range of memory available to the CPU. Enabled
|
|
|
|
|
by default when ZONE_DMA or HIGHMEM is selected, but you
|
|
|
|
|
may say n to override this.
|
2007-07-17 05:03:37 -06:00
|
|
|
|
2007-07-16 00:40:05 -06:00
|
|
|
config VIRT_TO_BUS
|
2013-03-06 21:48:16 -07:00
|
|
|
bool
|
|
|
|
|
help
|
|
|
|
|
An architecture should select this if it implements the
|
|
|
|
|
deprecated interface virt_to_bus(). All new architectures
|
|
|
|
|
should probably not select this.
|
|
|
|
|
|
mmu-notifiers: core
With KVM/GFP/XPMEM there isn't just the primary CPU MMU pointing to pages.
There are secondary MMUs (with secondary sptes and secondary tlbs) too.
sptes in the kvm case are shadow pagetables, but when I say spte in
mmu-notifier context, I mean "secondary pte". In GRU case there's no
actual secondary pte and there's only a secondary tlb because the GRU
secondary MMU has no knowledge about sptes and every secondary tlb miss
event in the MMU always generates a page fault that has to be resolved by
the CPU (this is not the case of KVM where the a secondary tlb miss will
walk sptes in hardware and it will refill the secondary tlb transparently
to software if the corresponding spte is present). The same way
zap_page_range has to invalidate the pte before freeing the page, the spte
(and secondary tlb) must also be invalidated before any page is freed and
reused.
Currently we take a page_count pin on every page mapped by sptes, but that
means the pages can't be swapped whenever they're mapped by any spte
because they're part of the guest working set. Furthermore a spte unmap
event can immediately lead to a page to be freed when the pin is released
(so requiring the same complex and relatively slow tlb_gather smp safe
logic we have in zap_page_range and that can be avoided completely if the
spte unmap event doesn't require an unpin of the page previously mapped in
the secondary MMU).
The mmu notifiers allow kvm/GRU/XPMEM to attach to the tsk->mm and know
when the VM is swapping or freeing or doing anything on the primary MMU so
that the secondary MMU code can drop sptes before the pages are freed,
avoiding all page pinning and allowing 100% reliable swapping of guest
physical address space. Furthermore it avoids the code that teardown the
mappings of the secondary MMU, to implement a logic like tlb_gather in
zap_page_range that would require many IPI to flush other cpu tlbs, for
each fixed number of spte unmapped.
To make an example: if what happens on the primary MMU is a protection
downgrade (from writeable to wrprotect) the secondary MMU mappings will be
invalidated, and the next secondary-mmu-page-fault will call
get_user_pages and trigger a do_wp_page through get_user_pages if it
called get_user_pages with write=1, and it'll re-establishing an updated
spte or secondary-tlb-mapping on the copied page. Or it will setup a
readonly spte or readonly tlb mapping if it's a guest-read, if it calls
get_user_pages with write=0. This is just an example.
This allows to map any page pointed by any pte (and in turn visible in the
primary CPU MMU), into a secondary MMU (be it a pure tlb like GRU, or an
full MMU with both sptes and secondary-tlb like the shadow-pagetable layer
with kvm), or a remote DMA in software like XPMEM (hence needing of
schedule in XPMEM code to send the invalidate to the remote node, while no
need to schedule in kvm/gru as it's an immediate event like invalidating
primary-mmu pte).
At least for KVM without this patch it's impossible to swap guests
reliably. And having this feature and removing the page pin allows
several other optimizations that simplify life considerably.
Dependencies:
1) mm_take_all_locks() to register the mmu notifier when the whole VM
isn't doing anything with "mm". This allows mmu notifier users to keep
track if the VM is in the middle of the invalidate_range_begin/end
critical section with an atomic counter incraese in range_begin and
decreased in range_end. No secondary MMU page fault is allowed to map
any spte or secondary tlb reference, while the VM is in the middle of
range_begin/end as any page returned by get_user_pages in that critical
section could later immediately be freed without any further
->invalidate_page notification (invalidate_range_begin/end works on
ranges and ->invalidate_page isn't called immediately before freeing
the page). To stop all page freeing and pagetable overwrites the
mmap_sem must be taken in write mode and all other anon_vma/i_mmap
locks must be taken too.
2) It'd be a waste to add branches in the VM if nobody could possibly
run KVM/GRU/XPMEM on the kernel, so mmu notifiers will only enabled if
CONFIG_KVM=m/y. In the current kernel kvm won't yet take advantage of
mmu notifiers, but this already allows to compile a KVM external module
against a kernel with mmu notifiers enabled and from the next pull from
kvm.git we'll start using them. And GRU/XPMEM will also be able to
continue the development by enabling KVM=m in their config, until they
submit all GRU/XPMEM GPLv2 code to the mainline kernel. Then they can
also enable MMU_NOTIFIERS in the same way KVM does it (even if KVM=n).
This guarantees nobody selects MMU_NOTIFIER=y if KVM and GRU and XPMEM
are all =n.
The mmu_notifier_register call can fail because mm_take_all_locks may be
interrupted by a signal and return -EINTR. Because mmu_notifier_reigster
is used when a driver startup, a failure can be gracefully handled. Here
an example of the change applied to kvm to register the mmu notifiers.
Usually when a driver startups other allocations are required anyway and
-ENOMEM failure paths exists already.
struct kvm *kvm_arch_create_vm(void)
{
struct kvm *kvm = kzalloc(sizeof(struct kvm), GFP_KERNEL);
+ int err;
if (!kvm)
return ERR_PTR(-ENOMEM);
INIT_LIST_HEAD(&kvm->arch.active_mmu_pages);
+ kvm->arch.mmu_notifier.ops = &kvm_mmu_notifier_ops;
+ err = mmu_notifier_register(&kvm->arch.mmu_notifier, current->mm);
+ if (err) {
+ kfree(kvm);
+ return ERR_PTR(err);
+ }
+
return kvm;
}
mmu_notifier_unregister returns void and it's reliable.
The patch also adds a few needed but missing includes that would prevent
kernel to compile after these changes on non-x86 archs (x86 didn't need
them by luck).
[akpm@linux-foundation.org: coding-style fixes]
[akpm@linux-foundation.org: fix mm/filemap_xip.c build]
[akpm@linux-foundation.org: fix mm/mmu_notifier.c build]
Signed-off-by: Andrea Arcangeli <andrea@qumranet.com>
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Jack Steiner <steiner@sgi.com>
Cc: Robin Holt <holt@sgi.com>
Cc: Nick Piggin <npiggin@suse.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Kanoj Sarcar <kanojsarcar@yahoo.com>
Cc: Roland Dreier <rdreier@cisco.com>
Cc: Steve Wise <swise@opengridcomputing.com>
Cc: Avi Kivity <avi@qumranet.com>
Cc: Hugh Dickins <hugh@veritas.com>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Anthony Liguori <aliguori@us.ibm.com>
Cc: Chris Wright <chrisw@redhat.com>
Cc: Marcelo Tosatti <marcelo@kvack.org>
Cc: Eric Dumazet <dada1@cosmosbay.com>
Cc: "Paul E. McKenney" <paulmck@us.ibm.com>
Cc: Izik Eidus <izike@qumranet.com>
Cc: Anthony Liguori <aliguori@us.ibm.com>
Cc: Rik van Riel <riel@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-28 16:46:29 -06:00
|
|
|
|
|
|
|
|
config MMU_NOTIFIER
|
|
|
|
|
bool
|
2014-12-05 09:24:45 -07:00
|
|
|
select SRCU
|
2009-05-06 17:03:05 -06:00
|
|
|
|
2009-09-21 18:01:57 -06:00
|
|
|
config KSM
|
|
|
|
|
bool "Enable KSM for page merging"
|
|
|
|
|
depends on MMU
|
2018-12-28 01:34:05 -07:00
|
|
|
select XXHASH
|
2009-09-21 18:01:57 -06:00
|
|
|
help
|
|
|
|
|
Enable Kernel Samepage Merging: KSM periodically scans those areas
|
|
|
|
|
of an application's address space that an app has advised may be
|
|
|
|
|
mergeable. When it finds pages of identical content, it replaces
|
2009-12-14 18:59:34 -07:00
|
|
|
the many instances by a single page with that content, so
|
2009-09-21 18:01:57 -06:00
|
|
|
saving memory until one or another app needs to modify the content.
|
|
|
|
|
Recommended for use with KVM, or with other duplicative applications.
|
2018-03-21 13:22:47 -06:00
|
|
|
See Documentation/vm/ksm.rst for more information: KSM is inactive
|
2009-10-07 17:32:22 -06:00
|
|
|
until a program has madvised that an area is MADV_MERGEABLE, and
|
|
|
|
|
root has set /sys/kernel/mm/ksm/run to 1 (if CONFIG_SYSFS is set).
|
2009-09-21 18:01:57 -06:00
|
|
|
|
2009-06-03 14:04:31 -06:00
|
|
|
config DEFAULT_MMAP_MIN_ADDR
|
|
|
|
|
int "Low address space to protect from user allocation"
|
2009-12-15 12:27:45 -07:00
|
|
|
depends on MMU
|
2009-06-03 14:04:31 -06:00
|
|
|
default 4096
|
|
|
|
|
help
|
|
|
|
|
This is the portion of low virtual memory which should be protected
|
|
|
|
|
from userspace allocation. Keeping a user from writing to low pages
|
|
|
|
|
can help reduce the impact of kernel NULL pointer bugs.
|
|
|
|
|
|
|
|
|
|
For most ia64, ppc64 and x86 users with lots of address space
|
|
|
|
|
a value of 65536 is reasonable and should cause no problems.
|
|
|
|
|
On arm and other archs it should not be higher than 32768.
|
2009-07-31 10:54:11 -06:00
|
|
|
Programs which use vm86 functionality or have some need to map
|
|
|
|
|
this low address space will need CAP_SYS_RAWIO or disable this
|
|
|
|
|
protection by setting the value to 0.
|
2009-06-03 14:04:31 -06:00
|
|
|
|
|
|
|
|
This value can be changed after boot using the
|
|
|
|
|
/proc/sys/vm/mmap_min_addr tunable.
|
|
|
|
|
|
2009-09-26 10:35:07 -06:00
|
|
|
config ARCH_SUPPORTS_MEMORY_FAILURE
|
|
|
|
|
bool
|
2009-06-03 14:04:31 -06:00
|
|
|
|
2009-09-16 03:50:15 -06:00
|
|
|
config MEMORY_FAILURE
|
|
|
|
|
depends on MMU
|
2009-09-26 10:35:07 -06:00
|
|
|
depends on ARCH_SUPPORTS_MEMORY_FAILURE
|
2009-09-16 03:50:15 -06:00
|
|
|
bool "Enable recovery from hardware memory errors"
|
2012-07-31 17:43:50 -06:00
|
|
|
select MEMORY_ISOLATION
|
2015-06-24 17:57:36 -06:00
|
|
|
select RAS
|
2009-09-16 03:50:15 -06:00
|
|
|
help
|
|
|
|
|
Enables code to recover from some memory failures on systems
|
|
|
|
|
with MCA recovery. This allows a system to continue running
|
|
|
|
|
even when some of its memory has uncorrected errors. This requires
|
|
|
|
|
special hardware support and typically ECC memory.
|
|
|
|
|
|
2009-09-16 03:50:17 -06:00
|
|
|
config HWPOISON_INJECT
|
2009-12-16 04:20:00 -07:00
|
|
|
tristate "HWPoison pages injector"
|
2009-12-21 11:56:42 -07:00
|
|
|
depends on MEMORY_FAILURE && DEBUG_KERNEL && PROC_FS
|
2009-12-16 04:19:59 -07:00
|
|
|
select PROC_PAGE_MONITOR
|
2009-09-16 03:50:17 -06:00
|
|
|
|
2009-05-06 17:03:05 -06:00
|
|
|
config NOMMU_INITIAL_TRIM_EXCESS
|
|
|
|
|
int "Turn on mmap() excess space trimming before booting"
|
|
|
|
|
depends on !MMU
|
|
|
|
|
default 1
|
|
|
|
|
help
|
|
|
|
|
The NOMMU mmap() frequently needs to allocate large contiguous chunks
|
|
|
|
|
of memory on which to store mappings, but it can only ask the system
|
|
|
|
|
allocator for chunks in 2^N*PAGE_SIZE amounts - which is frequently
|
|
|
|
|
more than it requires. To deal with this, mmap() is able to trim off
|
|
|
|
|
the excess and return it to the allocator.
|
|
|
|
|
|
|
|
|
|
If trimming is enabled, the excess is trimmed off and returned to the
|
|
|
|
|
system allocator, which can cause extra fragmentation, particularly
|
|
|
|
|
if there are a lot of transient processes.
|
|
|
|
|
|
|
|
|
|
If trimming is disabled, the excess is kept, but not used, which for
|
|
|
|
|
long-term mappings means that the space is wasted.
|
|
|
|
|
|
|
|
|
|
Trimming can be dynamically controlled through a sysctl option
|
|
|
|
|
(/proc/sys/vm/nr_trim_pages) which specifies the minimum number of
|
|
|
|
|
excess pages there must be before trimming should occur, or zero if
|
|
|
|
|
no trimming is to occur.
|
|
|
|
|
|
|
|
|
|
This option specifies the initial value of this option. The default
|
|
|
|
|
of 1 says that all excess pages should be trimmed.
|
|
|
|
|
|
|
|
|
|
See Documentation/nommu-mmap.txt for more information.
|
2010-09-03 10:22:48 -06:00
|
|
|
|
2011-01-13 16:46:39 -07:00
|
|
|
config TRANSPARENT_HUGEPAGE
|
2011-01-13 16:47:07 -07:00
|
|
|
bool "Transparent Hugepage Support"
|
2012-10-08 17:30:04 -06:00
|
|
|
depends on HAVE_ARCH_TRANSPARENT_HUGEPAGE
|
2011-01-13 16:47:07 -07:00
|
|
|
select COMPACTION
|
2018-09-22 14:14:30 -06:00
|
|
|
select XARRAY_MULTI
|
2011-01-13 16:46:39 -07:00
|
|
|
help
|
|
|
|
|
Transparent Hugepages allows the kernel to use huge pages and
|
|
|
|
|
huge tlb transparently to the applications whenever possible.
|
|
|
|
|
This feature can improve computing performance to certain
|
|
|
|
|
applications by speeding up page faults during memory
|
|
|
|
|
allocation, by reducing the number of tlb misses and by speeding
|
|
|
|
|
up the pagetable walking.
|
|
|
|
|
|
|
|
|
|
If memory constrained on embedded, you may want to say N.
|
|
|
|
|
|
2011-01-13 16:47:07 -07:00
|
|
|
choice
|
|
|
|
|
prompt "Transparent Hugepage Support sysfs defaults"
|
|
|
|
|
depends on TRANSPARENT_HUGEPAGE
|
|
|
|
|
default TRANSPARENT_HUGEPAGE_ALWAYS
|
|
|
|
|
help
|
|
|
|
|
Selects the sysfs defaults for Transparent Hugepage Support.
|
|
|
|
|
|
|
|
|
|
config TRANSPARENT_HUGEPAGE_ALWAYS
|
|
|
|
|
bool "always"
|
|
|
|
|
help
|
|
|
|
|
Enabling Transparent Hugepage always, can increase the
|
|
|
|
|
memory footprint of applications without a guaranteed
|
|
|
|
|
benefit but it will work automatically for all applications.
|
|
|
|
|
|
|
|
|
|
config TRANSPARENT_HUGEPAGE_MADVISE
|
|
|
|
|
bool "madvise"
|
|
|
|
|
help
|
|
|
|
|
Enabling Transparent Hugepage madvise, will only provide a
|
|
|
|
|
performance improvement benefit to the applications using
|
|
|
|
|
madvise(MADV_HUGEPAGE) but it won't risk to increase the
|
|
|
|
|
memory footprint of applications without a guaranteed
|
|
|
|
|
benefit.
|
|
|
|
|
endchoice
|
|
|
|
|
|
mm, THP, swap: delay splitting THP during swap out
Patch series "THP swap: Delay splitting THP during swapping out", v11.
This patchset is to optimize the performance of Transparent Huge Page
(THP) swap.
Recently, the performance of the storage devices improved so fast that
we cannot saturate the disk bandwidth with single logical CPU when do
page swap out even on a high-end server machine. Because the
performance of the storage device improved faster than that of single
logical CPU. And it seems that the trend will not change in the near
future. On the other hand, the THP becomes more and more popular
because of increased memory size. So it becomes necessary to optimize
THP swap performance.
The advantages of the THP swap support include:
- Batch the swap operations for the THP to reduce lock
acquiring/releasing, including allocating/freeing the swap space,
adding/deleting to/from the swap cache, and writing/reading the swap
space, etc. This will help improve the performance of the THP swap.
- The THP swap space read/write will be 2M sequential IO. It is
particularly helpful for the swap read, which are usually 4k random
IO. This will improve the performance of the THP swap too.
- It will help the memory fragmentation, especially when the THP is
heavily used by the applications. The 2M continuous pages will be
free up after THP swapping out.
- It will improve the THP utilization on the system with the swap
turned on. Because the speed for khugepaged to collapse the normal
pages into the THP is quite slow. After the THP is split during the
swapping out, it will take quite long time for the normal pages to
collapse back into the THP after being swapped in. The high THP
utilization helps the efficiency of the page based memory management
too.
There are some concerns regarding THP swap in, mainly because possible
enlarged read/write IO size (for swap in/out) may put more overhead on
the storage device. To deal with that, the THP swap in should be turned
on only when necessary. For example, it can be selected via
"always/never/madvise" logic, to be turned on globally, turned off
globally, or turned on only for VMA with MADV_HUGEPAGE, etc.
This patchset is the first step for the THP swap support. The plan is
to delay splitting THP step by step, finally avoid splitting THP during
the THP swapping out and swap out/in the THP as a whole.
As the first step, in this patchset, the splitting huge page is delayed
from almost the first step of swapping out to after allocating the swap
space for the THP and adding the THP into the swap cache. This will
reduce lock acquiring/releasing for the locks used for the swap cache
management.
With the patchset, the swap out throughput improves 15.5% (from about
3.73GB/s to about 4.31GB/s) in the vm-scalability swap-w-seq test case
with 8 processes. The test is done on a Xeon E5 v3 system. The swap
device used is a RAM simulated PMEM (persistent memory) device. To test
the sequential swapping out, the test case creates 8 processes, which
sequentially allocate and write to the anonymous pages until the RAM and
part of the swap device is used up.
This patch (of 5):
In this patch, splitting huge page is delayed from almost the first step
of swapping out to after allocating the swap space for the THP
(Transparent Huge Page) and adding the THP into the swap cache. This
will batch the corresponding operation, thus improve THP swap out
throughput.
This is the first step for the THP swap optimization. The plan is to
delay splitting the THP step by step and avoid splitting the THP
finally.
In this patch, one swap cluster is used to hold the contents of each THP
swapped out. So, the size of the swap cluster is changed to that of the
THP (Transparent Huge Page) on x86_64 architecture (512). For other
architectures which want such THP swap optimization,
ARCH_USES_THP_SWAP_CLUSTER needs to be selected in the Kconfig file for
the architecture. In effect, this will enlarge swap cluster size by 2
times on x86_64. Which may make it harder to find a free cluster when
the swap space becomes fragmented. So that, this may reduce the
continuous swap space allocation and sequential write in theory. The
performance test in 0day shows no regressions caused by this.
In the future of THP swap optimization, some information of the swapped
out THP (such as compound map count) will be recorded in the
swap_cluster_info data structure.
The mem cgroup swap accounting functions are enhanced to support charge
or uncharge a swap cluster backing a THP as a whole.
The swap cluster allocate/free functions are added to allocate/free a
swap cluster for a THP. A fair simple algorithm is used for swap
cluster allocation, that is, only the first swap device in priority list
will be tried to allocate the swap cluster. The function will fail if
the trying is not successful, and the caller will fallback to allocate a
single swap slot instead. This works good enough for normal cases. If
the difference of the number of the free swap clusters among multiple
swap devices is significant, it is possible that some THPs are split
earlier than necessary. For example, this could be caused by big size
difference among multiple swap devices.
The swap cache functions is enhanced to support add/delete THP to/from
the swap cache as a set of (HPAGE_PMD_NR) sub-pages. This may be
enhanced in the future with multi-order radix tree. But because we will
split the THP soon during swapping out, that optimization doesn't make
much sense for this first step.
The THP splitting functions are enhanced to support to split THP in swap
cache during swapping out. The page lock will be held during allocating
the swap cluster, adding the THP into the swap cache and splitting the
THP. So in the code path other than swapping out, if the THP need to be
split, the PageSwapCache(THP) will be always false.
The swap cluster is only available for SSD, so the THP swap optimization
in this patchset has no effect for HDD.
[ying.huang@intel.com: fix two issues in THP optimize patch]
Link: http://lkml.kernel.org/r/87k25ed8zo.fsf@yhuang-dev.intel.com
[hannes@cmpxchg.org: extensive cleanups and simplifications, reduce code size]
Link: http://lkml.kernel.org/r/20170515112522.32457-2-ying.huang@intel.com
Signed-off-by: "Huang, Ying" <ying.huang@intel.com>
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Suggested-by: Andrew Morton <akpm@linux-foundation.org> [for config option]
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> [for changes in huge_memory.c and huge_mm.h]
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Ebru Akagunduz <ebru.akagunduz@gmail.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Tejun Heo <tj@kernel.org>
Cc: Hugh Dickins <hughd@google.com>
Cc: Shaohua Li <shli@kernel.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Rik van Riel <riel@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-07-06 16:37:18 -06:00
|
|
|
config ARCH_WANTS_THP_SWAP
|
|
|
|
|
def_bool n
|
|
|
|
|
|
|
|
|
|
config THP_SWAP
|
|
|
|
|
def_bool y
|
2018-08-17 16:49:41 -06:00
|
|
|
depends on TRANSPARENT_HUGEPAGE && ARCH_WANTS_THP_SWAP && SWAP
|
mm, THP, swap: delay splitting THP during swap out
Patch series "THP swap: Delay splitting THP during swapping out", v11.
This patchset is to optimize the performance of Transparent Huge Page
(THP) swap.
Recently, the performance of the storage devices improved so fast that
we cannot saturate the disk bandwidth with single logical CPU when do
page swap out even on a high-end server machine. Because the
performance of the storage device improved faster than that of single
logical CPU. And it seems that the trend will not change in the near
future. On the other hand, the THP becomes more and more popular
because of increased memory size. So it becomes necessary to optimize
THP swap performance.
The advantages of the THP swap support include:
- Batch the swap operations for the THP to reduce lock
acquiring/releasing, including allocating/freeing the swap space,
adding/deleting to/from the swap cache, and writing/reading the swap
space, etc. This will help improve the performance of the THP swap.
- The THP swap space read/write will be 2M sequential IO. It is
particularly helpful for the swap read, which are usually 4k random
IO. This will improve the performance of the THP swap too.
- It will help the memory fragmentation, especially when the THP is
heavily used by the applications. The 2M continuous pages will be
free up after THP swapping out.
- It will improve the THP utilization on the system with the swap
turned on. Because the speed for khugepaged to collapse the normal
pages into the THP is quite slow. After the THP is split during the
swapping out, it will take quite long time for the normal pages to
collapse back into the THP after being swapped in. The high THP
utilization helps the efficiency of the page based memory management
too.
There are some concerns regarding THP swap in, mainly because possible
enlarged read/write IO size (for swap in/out) may put more overhead on
the storage device. To deal with that, the THP swap in should be turned
on only when necessary. For example, it can be selected via
"always/never/madvise" logic, to be turned on globally, turned off
globally, or turned on only for VMA with MADV_HUGEPAGE, etc.
This patchset is the first step for the THP swap support. The plan is
to delay splitting THP step by step, finally avoid splitting THP during
the THP swapping out and swap out/in the THP as a whole.
As the first step, in this patchset, the splitting huge page is delayed
from almost the first step of swapping out to after allocating the swap
space for the THP and adding the THP into the swap cache. This will
reduce lock acquiring/releasing for the locks used for the swap cache
management.
With the patchset, the swap out throughput improves 15.5% (from about
3.73GB/s to about 4.31GB/s) in the vm-scalability swap-w-seq test case
with 8 processes. The test is done on a Xeon E5 v3 system. The swap
device used is a RAM simulated PMEM (persistent memory) device. To test
the sequential swapping out, the test case creates 8 processes, which
sequentially allocate and write to the anonymous pages until the RAM and
part of the swap device is used up.
This patch (of 5):
In this patch, splitting huge page is delayed from almost the first step
of swapping out to after allocating the swap space for the THP
(Transparent Huge Page) and adding the THP into the swap cache. This
will batch the corresponding operation, thus improve THP swap out
throughput.
This is the first step for the THP swap optimization. The plan is to
delay splitting the THP step by step and avoid splitting the THP
finally.
In this patch, one swap cluster is used to hold the contents of each THP
swapped out. So, the size of the swap cluster is changed to that of the
THP (Transparent Huge Page) on x86_64 architecture (512). For other
architectures which want such THP swap optimization,
ARCH_USES_THP_SWAP_CLUSTER needs to be selected in the Kconfig file for
the architecture. In effect, this will enlarge swap cluster size by 2
times on x86_64. Which may make it harder to find a free cluster when
the swap space becomes fragmented. So that, this may reduce the
continuous swap space allocation and sequential write in theory. The
performance test in 0day shows no regressions caused by this.
In the future of THP swap optimization, some information of the swapped
out THP (such as compound map count) will be recorded in the
swap_cluster_info data structure.
The mem cgroup swap accounting functions are enhanced to support charge
or uncharge a swap cluster backing a THP as a whole.
The swap cluster allocate/free functions are added to allocate/free a
swap cluster for a THP. A fair simple algorithm is used for swap
cluster allocation, that is, only the first swap device in priority list
will be tried to allocate the swap cluster. The function will fail if
the trying is not successful, and the caller will fallback to allocate a
single swap slot instead. This works good enough for normal cases. If
the difference of the number of the free swap clusters among multiple
swap devices is significant, it is possible that some THPs are split
earlier than necessary. For example, this could be caused by big size
difference among multiple swap devices.
The swap cache functions is enhanced to support add/delete THP to/from
the swap cache as a set of (HPAGE_PMD_NR) sub-pages. This may be
enhanced in the future with multi-order radix tree. But because we will
split the THP soon during swapping out, that optimization doesn't make
much sense for this first step.
The THP splitting functions are enhanced to support to split THP in swap
cache during swapping out. The page lock will be held during allocating
the swap cluster, adding the THP into the swap cache and splitting the
THP. So in the code path other than swapping out, if the THP need to be
split, the PageSwapCache(THP) will be always false.
The swap cluster is only available for SSD, so the THP swap optimization
in this patchset has no effect for HDD.
[ying.huang@intel.com: fix two issues in THP optimize patch]
Link: http://lkml.kernel.org/r/87k25ed8zo.fsf@yhuang-dev.intel.com
[hannes@cmpxchg.org: extensive cleanups and simplifications, reduce code size]
Link: http://lkml.kernel.org/r/20170515112522.32457-2-ying.huang@intel.com
Signed-off-by: "Huang, Ying" <ying.huang@intel.com>
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Suggested-by: Andrew Morton <akpm@linux-foundation.org> [for config option]
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> [for changes in huge_memory.c and huge_mm.h]
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Ebru Akagunduz <ebru.akagunduz@gmail.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Tejun Heo <tj@kernel.org>
Cc: Hugh Dickins <hughd@google.com>
Cc: Shaohua Li <shli@kernel.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Rik van Riel <riel@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-07-06 16:37:18 -06:00
|
|
|
help
|
|
|
|
|
Swap transparent huge pages in one piece, without splitting.
|
2018-08-17 16:49:41 -06:00
|
|
|
XXX: For now, swap cluster backing transparent huge page
|
|
|
|
|
will be split after swapout.
|
mm, THP, swap: delay splitting THP during swap out
Patch series "THP swap: Delay splitting THP during swapping out", v11.
This patchset is to optimize the performance of Transparent Huge Page
(THP) swap.
Recently, the performance of the storage devices improved so fast that
we cannot saturate the disk bandwidth with single logical CPU when do
page swap out even on a high-end server machine. Because the
performance of the storage device improved faster than that of single
logical CPU. And it seems that the trend will not change in the near
future. On the other hand, the THP becomes more and more popular
because of increased memory size. So it becomes necessary to optimize
THP swap performance.
The advantages of the THP swap support include:
- Batch the swap operations for the THP to reduce lock
acquiring/releasing, including allocating/freeing the swap space,
adding/deleting to/from the swap cache, and writing/reading the swap
space, etc. This will help improve the performance of the THP swap.
- The THP swap space read/write will be 2M sequential IO. It is
particularly helpful for the swap read, which are usually 4k random
IO. This will improve the performance of the THP swap too.
- It will help the memory fragmentation, especially when the THP is
heavily used by the applications. The 2M continuous pages will be
free up after THP swapping out.
- It will improve the THP utilization on the system with the swap
turned on. Because the speed for khugepaged to collapse the normal
pages into the THP is quite slow. After the THP is split during the
swapping out, it will take quite long time for the normal pages to
collapse back into the THP after being swapped in. The high THP
utilization helps the efficiency of the page based memory management
too.
There are some concerns regarding THP swap in, mainly because possible
enlarged read/write IO size (for swap in/out) may put more overhead on
the storage device. To deal with that, the THP swap in should be turned
on only when necessary. For example, it can be selected via
"always/never/madvise" logic, to be turned on globally, turned off
globally, or turned on only for VMA with MADV_HUGEPAGE, etc.
This patchset is the first step for the THP swap support. The plan is
to delay splitting THP step by step, finally avoid splitting THP during
the THP swapping out and swap out/in the THP as a whole.
As the first step, in this patchset, the splitting huge page is delayed
from almost the first step of swapping out to after allocating the swap
space for the THP and adding the THP into the swap cache. This will
reduce lock acquiring/releasing for the locks used for the swap cache
management.
With the patchset, the swap out throughput improves 15.5% (from about
3.73GB/s to about 4.31GB/s) in the vm-scalability swap-w-seq test case
with 8 processes. The test is done on a Xeon E5 v3 system. The swap
device used is a RAM simulated PMEM (persistent memory) device. To test
the sequential swapping out, the test case creates 8 processes, which
sequentially allocate and write to the anonymous pages until the RAM and
part of the swap device is used up.
This patch (of 5):
In this patch, splitting huge page is delayed from almost the first step
of swapping out to after allocating the swap space for the THP
(Transparent Huge Page) and adding the THP into the swap cache. This
will batch the corresponding operation, thus improve THP swap out
throughput.
This is the first step for the THP swap optimization. The plan is to
delay splitting the THP step by step and avoid splitting the THP
finally.
In this patch, one swap cluster is used to hold the contents of each THP
swapped out. So, the size of the swap cluster is changed to that of the
THP (Transparent Huge Page) on x86_64 architecture (512). For other
architectures which want such THP swap optimization,
ARCH_USES_THP_SWAP_CLUSTER needs to be selected in the Kconfig file for
the architecture. In effect, this will enlarge swap cluster size by 2
times on x86_64. Which may make it harder to find a free cluster when
the swap space becomes fragmented. So that, this may reduce the
continuous swap space allocation and sequential write in theory. The
performance test in 0day shows no regressions caused by this.
In the future of THP swap optimization, some information of the swapped
out THP (such as compound map count) will be recorded in the
swap_cluster_info data structure.
The mem cgroup swap accounting functions are enhanced to support charge
or uncharge a swap cluster backing a THP as a whole.
The swap cluster allocate/free functions are added to allocate/free a
swap cluster for a THP. A fair simple algorithm is used for swap
cluster allocation, that is, only the first swap device in priority list
will be tried to allocate the swap cluster. The function will fail if
the trying is not successful, and the caller will fallback to allocate a
single swap slot instead. This works good enough for normal cases. If
the difference of the number of the free swap clusters among multiple
swap devices is significant, it is possible that some THPs are split
earlier than necessary. For example, this could be caused by big size
difference among multiple swap devices.
The swap cache functions is enhanced to support add/delete THP to/from
the swap cache as a set of (HPAGE_PMD_NR) sub-pages. This may be
enhanced in the future with multi-order radix tree. But because we will
split the THP soon during swapping out, that optimization doesn't make
much sense for this first step.
The THP splitting functions are enhanced to support to split THP in swap
cache during swapping out. The page lock will be held during allocating
the swap cluster, adding the THP into the swap cache and splitting the
THP. So in the code path other than swapping out, if the THP need to be
split, the PageSwapCache(THP) will be always false.
The swap cluster is only available for SSD, so the THP swap optimization
in this patchset has no effect for HDD.
[ying.huang@intel.com: fix two issues in THP optimize patch]
Link: http://lkml.kernel.org/r/87k25ed8zo.fsf@yhuang-dev.intel.com
[hannes@cmpxchg.org: extensive cleanups and simplifications, reduce code size]
Link: http://lkml.kernel.org/r/20170515112522.32457-2-ying.huang@intel.com
Signed-off-by: "Huang, Ying" <ying.huang@intel.com>
Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Suggested-by: Andrew Morton <akpm@linux-foundation.org> [for config option]
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> [for changes in huge_memory.c and huge_mm.h]
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Ebru Akagunduz <ebru.akagunduz@gmail.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Tejun Heo <tj@kernel.org>
Cc: Hugh Dickins <hughd@google.com>
Cc: Shaohua Li <shli@kernel.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Rik van Riel <riel@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-07-06 16:37:18 -06:00
|
|
|
|
|
|
|
|
For selection by architectures with reasonable THP sizes.
|
|
|
|
|
|
2016-07-26 16:26:35 -06:00
|
|
|
config TRANSPARENT_HUGE_PAGECACHE
|
|
|
|
|
def_bool y
|
2016-12-12 17:44:32 -07:00
|
|
|
depends on TRANSPARENT_HUGEPAGE
|
2016-07-26 16:26:35 -06:00
|
|
|
|
2010-09-03 10:22:48 -06:00
|
|
|
#
|
|
|
|
|
# UP and nommu archs use km based percpu allocator
|
|
|
|
|
#
|
|
|
|
|
config NEED_PER_CPU_KM
|
|
|
|
|
depends on !SMP
|
|
|
|
|
bool
|
|
|
|
|
default y
|
2011-05-26 10:01:36 -06:00
|
|
|
|
|
|
|
|
config CLEANCACHE
|
|
|
|
|
bool "Enable cleancache driver to cache clean pages if tmem is present"
|
|
|
|
|
help
|
|
|
|
|
Cleancache can be thought of as a page-granularity victim cache
|
|
|
|
|
for clean pages that the kernel's pageframe replacement algorithm
|
|
|
|
|
(PFRA) would like to keep around, but can't since there isn't enough
|
|
|
|
|
memory. So when the PFRA "evicts" a page, it first attempts to use
|
2011-06-09 21:57:26 -06:00
|
|
|
cleancache code to put the data contained in that page into
|
2011-05-26 10:01:36 -06:00
|
|
|
"transcendent memory", memory that is not directly accessible or
|
|
|
|
|
addressable by the kernel and is of unknown and possibly
|
|
|
|
|
time-varying size. And when a cleancache-enabled
|
|
|
|
|
filesystem wishes to access a page in a file on disk, it first
|
|
|
|
|
checks cleancache to see if it already contains it; if it does,
|
|
|
|
|
the page is copied into the kernel and a disk access is avoided.
|
|
|
|
|
When a transcendent memory driver is available (such as zcache or
|
|
|
|
|
Xen transcendent memory), a significant I/O reduction
|
|
|
|
|
may be achieved. When none is available, all cleancache calls
|
|
|
|
|
are reduced to a single pointer-compare-against-NULL resulting
|
|
|
|
|
in a negligible performance hit.
|
|
|
|
|
|
|
|
|
|
If unsure, say Y to enable cleancache
|
2012-04-09 17:10:34 -06:00
|
|
|
|
|
|
|
|
config FRONTSWAP
|
|
|
|
|
bool "Enable frontswap to cache swap pages if tmem is present"
|
|
|
|
|
depends on SWAP
|
|
|
|
|
help
|
|
|
|
|
Frontswap is so named because it can be thought of as the opposite
|
|
|
|
|
of a "backing" store for a swap device. The data is stored into
|
|
|
|
|
"transcendent memory", memory that is not directly accessible or
|
|
|
|
|
addressable by the kernel and is of unknown and possibly
|
|
|
|
|
time-varying size. When space in transcendent memory is available,
|
|
|
|
|
a significant swap I/O reduction may be achieved. When none is
|
|
|
|
|
available, all frontswap calls are reduced to a single pointer-
|
|
|
|
|
compare-against-NULL resulting in a negligible performance hit
|
|
|
|
|
and swap data is stored as normal on the matching swap device.
|
|
|
|
|
|
|
|
|
|
If unsure, say Y to enable frontswap.
|
2013-07-01 23:45:15 -06:00
|
|
|
|
|
|
|
|
config CMA
|
|
|
|
|
bool "Contiguous Memory Allocator"
|
2018-10-30 16:07:44 -06:00
|
|
|
depends on MMU
|
2013-07-01 23:45:15 -06:00
|
|
|
select MIGRATION
|
|
|
|
|
select MEMORY_ISOLATION
|
|
|
|
|
help
|
|
|
|
|
This enables the Contiguous Memory Allocator which allows other
|
|
|
|
|
subsystems to allocate big physically-contiguous blocks of memory.
|
|
|
|
|
CMA reserves a region of memory and allows only movable pages to
|
|
|
|
|
be allocated from it. This way, the kernel can use the memory for
|
|
|
|
|
pagecache and when a subsystem requests for contiguous area, the
|
|
|
|
|
allocated pages are migrated away to serve the contiguous request.
|
|
|
|
|
|
|
|
|
|
If unsure, say "n".
|
|
|
|
|
|
|
|
|
|
config CMA_DEBUG
|
|
|
|
|
bool "CMA debug messages (DEVELOPMENT)"
|
|
|
|
|
depends on DEBUG_KERNEL && CMA
|
|
|
|
|
help
|
|
|
|
|
Turns on debug messages in CMA. This produces KERN_DEBUG
|
|
|
|
|
messages for every CMA call as well as various messages while
|
|
|
|
|
processing calls such as dma_alloc_from_contiguous().
|
|
|
|
|
This option does not affect warning and error messages.
|
2013-08-28 16:41:59 -06:00
|
|
|
|
2015-04-14 16:44:57 -06:00
|
|
|
config CMA_DEBUGFS
|
|
|
|
|
bool "CMA debugfs interface"
|
|
|
|
|
depends on CMA && DEBUG_FS
|
|
|
|
|
help
|
|
|
|
|
Turns on the DebugFS interface for CMA.
|
|
|
|
|
|
2014-08-06 17:05:25 -06:00
|
|
|
config CMA_AREAS
|
|
|
|
|
int "Maximum count of the CMA areas"
|
|
|
|
|
depends on CMA
|
|
|
|
|
default 7
|
|
|
|
|
help
|
|
|
|
|
CMA allows to create CMA areas for particular purpose, mainly,
|
|
|
|
|
used as device private area. This parameter sets the maximum
|
|
|
|
|
number of CMA area in the system.
|
|
|
|
|
|
|
|
|
|
If unsure, leave the default value "7".
|
|
|
|
|
|
2014-08-06 17:08:36 -06:00
|
|
|
config MEM_SOFT_DIRTY
|
|
|
|
|
bool "Track memory changes"
|
|
|
|
|
depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS
|
|
|
|
|
select PROC_PAGE_MONITOR
|
2013-07-10 17:04:55 -06:00
|
|
|
help
|
2014-08-06 17:08:36 -06:00
|
|
|
This option enables memory changes tracking by introducing a
|
|
|
|
|
soft-dirty bit on pte-s. This bit it set when someone writes
|
|
|
|
|
into a page just as regular dirty bit, but unlike the latter
|
|
|
|
|
it can be cleared by hands.
|
|
|
|
|
|
2018-04-18 02:07:49 -06:00
|
|
|
See Documentation/admin-guide/mm/soft-dirty.rst for more details.
|
2013-07-10 17:04:55 -06:00
|
|
|
|
2013-07-10 17:05:03 -06:00
|
|
|
config ZSWAP
|
|
|
|
|
bool "Compressed cache for swap pages (EXPERIMENTAL)"
|
|
|
|
|
depends on FRONTSWAP && CRYPTO=y
|
|
|
|
|
select CRYPTO_LZO
|
2014-08-06 17:08:40 -06:00
|
|
|
select ZPOOL
|
2013-07-10 17:05:03 -06:00
|
|
|
help
|
|
|
|
|
A lightweight compressed cache for swap pages. It takes
|
|
|
|
|
pages that are in the process of being swapped out and attempts to
|
|
|
|
|
compress them into a dynamically allocated RAM-based memory pool.
|
|
|
|
|
This can result in a significant I/O reduction on swap device and,
|
|
|
|
|
in the case where decompressing from RAM is faster that swap device
|
|
|
|
|
reads, can also improve workload performance.
|
|
|
|
|
|
|
|
|
|
This is marked experimental because it is a new feature (as of
|
|
|
|
|
v3.11) that interacts heavily with memory reclaim. While these
|
|
|
|
|
interactions don't cause any known issues on simple memory setups,
|
|
|
|
|
they have not be fully explored on the large set of potential
|
|
|
|
|
configurations and workloads that exist.
|
|
|
|
|
|
2014-08-06 17:08:36 -06:00
|
|
|
config ZPOOL
|
|
|
|
|
tristate "Common API for compressed memory storage"
|
mm: soft-dirty bits for user memory changes tracking
The soft-dirty is a bit on a PTE which helps to track which pages a task
writes to. In order to do this tracking one should
1. Clear soft-dirty bits from PTEs ("echo 4 > /proc/PID/clear_refs)
2. Wait some time.
3. Read soft-dirty bits (55'th in /proc/PID/pagemap2 entries)
To do this tracking, the writable bit is cleared from PTEs when the
soft-dirty bit is. Thus, after this, when the task tries to modify a
page at some virtual address the #PF occurs and the kernel sets the
soft-dirty bit on the respective PTE.
Note, that although all the task's address space is marked as r/o after
the soft-dirty bits clear, the #PF-s that occur after that are processed
fast. This is so, since the pages are still mapped to physical memory,
and thus all the kernel does is finds this fact out and puts back
writable, dirty and soft-dirty bits on the PTE.
Another thing to note, is that when mremap moves PTEs they are marked
with soft-dirty as well, since from the user perspective mremap modifies
the virtual memory at mremap's new address.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Cc: Matt Mackall <mpm@selenic.com>
Cc: Xiao Guangrong <xiaoguangrong@linux.vnet.ibm.com>
Cc: Glauber Costa <glommer@parallels.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@gmail.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-03 16:01:20 -06:00
|
|
|
help
|
2014-08-06 17:08:36 -06:00
|
|
|
Compressed memory storage API. This allows using either zbud or
|
|
|
|
|
zsmalloc.
|
mm: soft-dirty bits for user memory changes tracking
The soft-dirty is a bit on a PTE which helps to track which pages a task
writes to. In order to do this tracking one should
1. Clear soft-dirty bits from PTEs ("echo 4 > /proc/PID/clear_refs)
2. Wait some time.
3. Read soft-dirty bits (55'th in /proc/PID/pagemap2 entries)
To do this tracking, the writable bit is cleared from PTEs when the
soft-dirty bit is. Thus, after this, when the task tries to modify a
page at some virtual address the #PF occurs and the kernel sets the
soft-dirty bit on the respective PTE.
Note, that although all the task's address space is marked as r/o after
the soft-dirty bits clear, the #PF-s that occur after that are processed
fast. This is so, since the pages are still mapped to physical memory,
and thus all the kernel does is finds this fact out and puts back
writable, dirty and soft-dirty bits on the PTE.
Another thing to note, is that when mremap moves PTEs they are marked
with soft-dirty as well, since from the user perspective mremap modifies
the virtual memory at mremap's new address.
Signed-off-by: Pavel Emelyanov <xemul@parallels.com>
Cc: Matt Mackall <mpm@selenic.com>
Cc: Xiao Guangrong <xiaoguangrong@linux.vnet.ibm.com>
Cc: Glauber Costa <glommer@parallels.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@gmail.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-07-03 16:01:20 -06:00
|
|
|
|
2014-08-06 17:08:36 -06:00
|
|
|
config ZBUD
|
2016-05-20 17:58:30 -06:00
|
|
|
tristate "Low (Up to 2x) density storage for compressed pages"
|
2014-08-06 17:08:36 -06:00
|
|
|
help
|
|
|
|
|
A special purpose allocator for storing compressed pages.
|
|
|
|
|
It is designed to store up to two compressed pages per physical
|
|
|
|
|
page. While this design limits storage density, it has simple and
|
|
|
|
|
deterministic reclaim properties that make it preferable to a higher
|
|
|
|
|
density approach when reclaim will be used.
|
2014-01-30 16:45:50 -07:00
|
|
|
|
2016-05-20 17:58:30 -06:00
|
|
|
config Z3FOLD
|
|
|
|
|
tristate "Up to 3x density storage for compressed pages"
|
|
|
|
|
depends on ZPOOL
|
|
|
|
|
help
|
|
|
|
|
A special purpose allocator for storing compressed pages.
|
|
|
|
|
It is designed to store up to three compressed pages per physical
|
|
|
|
|
page. It is a ZBUD derivative so the simplicity and determinism are
|
|
|
|
|
still there.
|
|
|
|
|
|
2014-01-30 16:45:50 -07:00
|
|
|
config ZSMALLOC
|
2014-06-04 17:11:10 -06:00
|
|
|
tristate "Memory allocator for compressed pages"
|
2014-01-30 16:45:50 -07:00
|
|
|
depends on MMU
|
|
|
|
|
help
|
|
|
|
|
zsmalloc is a slab-based memory allocator designed to store
|
|
|
|
|
compressed RAM pages. zsmalloc uses virtual memory mapping
|
|
|
|
|
in order to reduce fragmentation. However, this results in a
|
|
|
|
|
non-standard allocator interface where a handle, not a pointer, is
|
|
|
|
|
returned by an alloc(). This handle must be mapped in order to
|
|
|
|
|
access the allocated space.
|
|
|
|
|
|
2015-02-12 16:00:54 -07:00
|
|
|
config ZSMALLOC_STAT
|
|
|
|
|
bool "Export zsmalloc statistics"
|
|
|
|
|
depends on ZSMALLOC
|
|
|
|
|
select DEBUG_FS
|
|
|
|
|
help
|
|
|
|
|
This option enables code in the zsmalloc to collect various
|
|
|
|
|
statistics about whats happening in zsmalloc and exports that
|
|
|
|
|
information to userspace via debugfs.
|
|
|
|
|
If unsure, say N.
|
|
|
|
|
|
2014-04-07 16:39:48 -06:00
|
|
|
config GENERIC_EARLY_IOREMAP
|
|
|
|
|
bool
|
2014-04-30 15:26:02 -06:00
|
|
|
|
|
|
|
|
config MAX_STACK_SIZE_MB
|
|
|
|
|
int "Maximum user stack size for 32-bit processes (MB)"
|
|
|
|
|
default 80
|
|
|
|
|
range 8 2048
|
|
|
|
|
depends on STACK_GROWSUP && (!64BIT || COMPAT)
|
|
|
|
|
help
|
|
|
|
|
This is the maximum stack size in Megabytes in the VM layout of 32-bit
|
|
|
|
|
user processes when the stack grows upwards (currently only on parisc
|
2017-10-24 09:52:32 -06:00
|
|
|
arch). The stack will be located at the highest memory address minus
|
|
|
|
|
the given value, unless the RLIMIT_STACK hard limit is changed to a
|
|
|
|
|
smaller value in which case that is used.
|
2014-04-30 15:26:02 -06:00
|
|
|
|
|
|
|
|
A sane initial value is 80 MB.
|
2015-06-30 15:57:02 -06:00
|
|
|
|
|
|
|
|
config DEFERRED_STRUCT_PAGE_INIT
|
2016-02-05 16:36:21 -07:00
|
|
|
bool "Defer initialisation of struct pages to kthreads"
|
mm: make DEFERRED_STRUCT_PAGE_INIT explicitly depend on SPARSEMEM
The deferred memory initialization relies on section definitions, e.g
PAGES_PER_SECTION, that are only available when CONFIG_SPARSEMEM=y on
most architectures.
Initially DEFERRED_STRUCT_PAGE_INIT depended on explicit
ARCH_SUPPORTS_DEFERRED_STRUCT_PAGE_INIT configuration option, but since
the commit 2e3ca40f03bb13709df4 ("mm: relax deferred struct page
requirements") this requirement was relaxed and now it is possible to
enable DEFERRED_STRUCT_PAGE_INIT on architectures that support
DISCONTINGMEM and NO_BOOTMEM which causes build failures.
For instance, setting SMP=y and DEFERRED_STRUCT_PAGE_INIT=y on arc
causes the following build failure:
CC mm/page_alloc.o
mm/page_alloc.c: In function 'update_defer_init':
mm/page_alloc.c:321:14: error: 'PAGES_PER_SECTION'
undeclared (first use in this function); did you mean 'USEC_PER_SEC'?
(pfn & (PAGES_PER_SECTION - 1)) == 0) {
^~~~~~~~~~~~~~~~~
USEC_PER_SEC
mm/page_alloc.c:321:14: note: each undeclared identifier is reported only once for each function it appears in
In file included from include/linux/cache.h:5:0,
from include/linux/printk.h:9,
from include/linux/kernel.h:14,
from include/asm-generic/bug.h:18,
from arch/arc/include/asm/bug.h:32,
from include/linux/bug.h:5,
from include/linux/mmdebug.h:5,
from include/linux/mm.h:9,
from mm/page_alloc.c:18:
mm/page_alloc.c: In function 'deferred_grow_zone':
mm/page_alloc.c:1624:52: error: 'PAGES_PER_SECTION' undeclared (first use in this function); did you mean 'USEC_PER_SEC'?
unsigned long nr_pages_needed = ALIGN(1 << order, PAGES_PER_SECTION);
^
include/uapi/linux/kernel.h:11:47: note: in definition of macro '__ALIGN_KERNEL_MASK'
#define __ALIGN_KERNEL_MASK(x, mask) (((x) + (mask)) & ~(mask))
^~~~
include/linux/kernel.h:58:22: note: in expansion of macro '__ALIGN_KERNEL'
#define ALIGN(x, a) __ALIGN_KERNEL((x), (a))
^~~~~~~~~~~~~~
mm/page_alloc.c:1624:34: note: in expansion of macro 'ALIGN'
unsigned long nr_pages_needed = ALIGN(1 << order, PAGES_PER_SECTION);
^~~~~
In file included from include/asm-generic/bug.h:18:0,
from arch/arc/include/asm/bug.h:32,
from include/linux/bug.h:5,
from include/linux/mmdebug.h:5,
from include/linux/mm.h:9,
from mm/page_alloc.c:18:
mm/page_alloc.c: In function 'free_area_init_node':
mm/page_alloc.c:6379:50: error: 'PAGES_PER_SECTION' undeclared (first use in this function); did you mean 'USEC_PER_SEC'?
pgdat->static_init_pgcnt = min_t(unsigned long, PAGES_PER_SECTION,
^
include/linux/kernel.h:812:22: note: in definition of macro '__typecheck'
(!!(sizeof((typeof(x) *)1 == (typeof(y) *)1)))
^
include/linux/kernel.h:836:24: note: in expansion of macro '__safe_cmp'
__builtin_choose_expr(__safe_cmp(x, y), \
^~~~~~~~~~
include/linux/kernel.h:904:27: note: in expansion of macro '__careful_cmp'
#define min_t(type, x, y) __careful_cmp((type)(x), (type)(y), <)
^~~~~~~~~~~~~
mm/page_alloc.c:6379:29: note: in expansion of macro 'min_t'
pgdat->static_init_pgcnt = min_t(unsigned long, PAGES_PER_SECTION,
^~~~~
include/linux/kernel.h:836:2: error: first argument to '__builtin_choose_expr' not a constant
__builtin_choose_expr(__safe_cmp(x, y), \
^
include/linux/kernel.h:904:27: note: in expansion of macro '__careful_cmp'
#define min_t(type, x, y) __careful_cmp((type)(x), (type)(y), <)
^~~~~~~~~~~~~
mm/page_alloc.c:6379:29: note: in expansion of macro 'min_t'
pgdat->static_init_pgcnt = min_t(unsigned long, PAGES_PER_SECTION,
^~~~~
scripts/Makefile.build:317: recipe for target 'mm/page_alloc.o' failed
Let's make the DEFERRED_STRUCT_PAGE_INIT explicitly depend on SPARSEMEM
as the systems that support DISCONTIGMEM do not seem to have that huge
amounts of memory that would make DEFERRED_STRUCT_PAGE_INIT relevant.
Link: http://lkml.kernel.org/r/1530279308-24988-1-git-send-email-rppt@linux.vnet.ibm.com
Signed-off-by: Mike Rapoport <rppt@linux.vnet.ibm.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Reviewed-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Tested-by: Randy Dunlap <rdunlap@infradead.org>
Cc: Pasha Tatashin <Pavel.Tatashin@microsoft.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2018-08-17 16:47:07 -06:00
|
|
|
depends on SPARSEMEM
|
2018-05-18 17:09:13 -06:00
|
|
|
depends on !NEED_PER_CPU_KM
|
2018-09-20 13:22:30 -06:00
|
|
|
depends on 64BIT
|
2015-06-30 15:57:02 -06:00
|
|
|
help
|
|
|
|
|
Ordinarily all struct pages are initialised during early boot in a
|
|
|
|
|
single thread. On very large machines this can take a considerable
|
|
|
|
|
amount of time. If this option is set, large machines will bring up
|
|
|
|
|
a subset of memmap at boot and then initialise the rest in parallel
|
2016-02-05 16:36:21 -07:00
|
|
|
by starting one-off "pgdatinitX" kernel thread for each node X. This
|
|
|
|
|
has a potential performance impact on processes running early in the
|
|
|
|
|
lifetime of the system until these kthreads finish the
|
|
|
|
|
initialisation.
|
2015-08-09 13:29:06 -06:00
|
|
|
|
mm: introduce idle page tracking
Knowing the portion of memory that is not used by a certain application or
memory cgroup (idle memory) can be useful for partitioning the system
efficiently, e.g. by setting memory cgroup limits appropriately.
Currently, the only means to estimate the amount of idle memory provided
by the kernel is /proc/PID/{clear_refs,smaps}: the user can clear the
access bit for all pages mapped to a particular process by writing 1 to
clear_refs, wait for some time, and then count smaps:Referenced. However,
this method has two serious shortcomings:
- it does not count unmapped file pages
- it affects the reclaimer logic
To overcome these drawbacks, this patch introduces two new page flags,
Idle and Young, and a new sysfs file, /sys/kernel/mm/page_idle/bitmap.
A page's Idle flag can only be set from userspace by setting bit in
/sys/kernel/mm/page_idle/bitmap at the offset corresponding to the page,
and it is cleared whenever the page is accessed either through page tables
(it is cleared in page_referenced() in this case) or using the read(2)
system call (mark_page_accessed()). Thus by setting the Idle flag for
pages of a particular workload, which can be found e.g. by reading
/proc/PID/pagemap, waiting for some time to let the workload access its
working set, and then reading the bitmap file, one can estimate the amount
of pages that are not used by the workload.
The Young page flag is used to avoid interference with the memory
reclaimer. A page's Young flag is set whenever the Access bit of a page
table entry pointing to the page is cleared by writing to the bitmap file.
If page_referenced() is called on a Young page, it will add 1 to its
return value, therefore concealing the fact that the Access bit was
cleared.
Note, since there is no room for extra page flags on 32 bit, this feature
uses extended page flags when compiled on 32 bit.
[akpm@linux-foundation.org: fix build]
[akpm@linux-foundation.org: kpageidle requires an MMU]
[akpm@linux-foundation.org: decouple from page-flags rework]
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Reviewed-by: Andres Lagar-Cavilla <andreslc@google.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Raghavendra K T <raghavendra.kt@linux.vnet.ibm.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Greg Thelen <gthelen@google.com>
Cc: Michel Lespinasse <walken@google.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Pavel Emelyanov <xemul@parallels.com>
Cc: Cyrill Gorcunov <gorcunov@openvz.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-09-09 16:35:45 -06:00
|
|
|
config IDLE_PAGE_TRACKING
|
|
|
|
|
bool "Enable idle page tracking"
|
|
|
|
|
depends on SYSFS && MMU
|
|
|
|
|
select PAGE_EXTENSION if !64BIT
|
|
|
|
|
help
|
|
|
|
|
This feature allows to estimate the amount of user pages that have
|
|
|
|
|
not been touched during a given period of time. This information can
|
|
|
|
|
be useful to tune memory cgroup limits and/or for job placement
|
|
|
|
|
within a compute cluster.
|
|
|
|
|
|
2018-04-18 02:07:49 -06:00
|
|
|
See Documentation/admin-guide/mm/idle_page_tracking.rst for
|
|
|
|
|
more details.
|
mm: introduce idle page tracking
Knowing the portion of memory that is not used by a certain application or
memory cgroup (idle memory) can be useful for partitioning the system
efficiently, e.g. by setting memory cgroup limits appropriately.
Currently, the only means to estimate the amount of idle memory provided
by the kernel is /proc/PID/{clear_refs,smaps}: the user can clear the
access bit for all pages mapped to a particular process by writing 1 to
clear_refs, wait for some time, and then count smaps:Referenced. However,
this method has two serious shortcomings:
- it does not count unmapped file pages
- it affects the reclaimer logic
To overcome these drawbacks, this patch introduces two new page flags,
Idle and Young, and a new sysfs file, /sys/kernel/mm/page_idle/bitmap.
A page's Idle flag can only be set from userspace by setting bit in
/sys/kernel/mm/page_idle/bitmap at the offset corresponding to the page,
and it is cleared whenever the page is accessed either through page tables
(it is cleared in page_referenced() in this case) or using the read(2)
system call (mark_page_accessed()). Thus by setting the Idle flag for
pages of a particular workload, which can be found e.g. by reading
/proc/PID/pagemap, waiting for some time to let the workload access its
working set, and then reading the bitmap file, one can estimate the amount
of pages that are not used by the workload.
The Young page flag is used to avoid interference with the memory
reclaimer. A page's Young flag is set whenever the Access bit of a page
table entry pointing to the page is cleared by writing to the bitmap file.
If page_referenced() is called on a Young page, it will add 1 to its
return value, therefore concealing the fact that the Access bit was
cleared.
Note, since there is no room for extra page flags on 32 bit, this feature
uses extended page flags when compiled on 32 bit.
[akpm@linux-foundation.org: fix build]
[akpm@linux-foundation.org: kpageidle requires an MMU]
[akpm@linux-foundation.org: decouple from page-flags rework]
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Reviewed-by: Andres Lagar-Cavilla <andreslc@google.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Raghavendra K T <raghavendra.kt@linux.vnet.ibm.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Greg Thelen <gthelen@google.com>
Cc: Michel Lespinasse <walken@google.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Pavel Emelyanov <xemul@parallels.com>
Cc: Cyrill Gorcunov <gorcunov@openvz.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-09-09 16:35:45 -06:00
|
|
|
|
2019-07-16 17:30:47 -06:00
|
|
|
config ARCH_HAS_PTE_DEVMAP
|
2017-06-27 19:32:31 -06:00
|
|
|
bool
|
|
|
|
|
|
2015-08-09 13:29:06 -06:00
|
|
|
config ZONE_DEVICE
|
2017-09-08 17:11:43 -06:00
|
|
|
bool "Device memory (pmem, HMM, etc...) hotplug support"
|
2015-08-09 13:29:06 -06:00
|
|
|
depends on MEMORY_HOTPLUG
|
|
|
|
|
depends on MEMORY_HOTREMOVE
|
2016-03-17 15:19:58 -06:00
|
|
|
depends on SPARSEMEM_VMEMMAP
|
2019-07-16 17:30:47 -06:00
|
|
|
depends on ARCH_HAS_PTE_DEVMAP
|
2018-09-22 14:14:30 -06:00
|
|
|
select XARRAY_MULTI
|
2015-08-09 13:29:06 -06:00
|
|
|
|
|
|
|
|
help
|
|
|
|
|
Device memory hotplug support allows for establishing pmem,
|
|
|
|
|
or other device driver discovered memory regions, in the
|
|
|
|
|
memmap. This allows pfn_to_page() lookups of otherwise
|
|
|
|
|
"device-physical" addresses which is needed for using a DAX
|
|
|
|
|
mapping in an O_DIRECT operation, among other things.
|
|
|
|
|
|
|
|
|
|
If FS_DAX is enabled, then say Y.
|
2015-09-11 17:42:39 -06:00
|
|
|
|
2018-05-16 12:46:08 -06:00
|
|
|
config DEV_PAGEMAP_OPS
|
|
|
|
|
bool
|
|
|
|
|
|
2019-08-06 10:05:52 -06:00
|
|
|
#
|
|
|
|
|
# Helpers to mirror range of the CPU page tables of a process into device page
|
|
|
|
|
# tables.
|
|
|
|
|
#
|
2017-09-08 17:11:27 -06:00
|
|
|
config HMM_MIRROR
|
2019-08-06 10:05:52 -06:00
|
|
|
bool
|
2019-08-06 10:05:51 -06:00
|
|
|
depends on MMU
|
2019-08-06 10:05:52 -06:00
|
|
|
depends on MMU_NOTIFIER
|
2017-09-08 17:11:27 -06:00
|
|
|
|
2017-09-08 17:11:43 -06:00
|
|
|
config DEVICE_PRIVATE
|
|
|
|
|
bool "Unaddressable device memory (GPU memory, ...)"
|
2019-06-26 06:27:22 -06:00
|
|
|
depends on ZONE_DEVICE
|
2018-05-16 12:46:08 -06:00
|
|
|
select DEV_PAGEMAP_OPS
|
2017-09-08 17:11:43 -06:00
|
|
|
|
|
|
|
|
help
|
|
|
|
|
Allows creation of struct pages to represent unaddressable device
|
|
|
|
|
memory; i.e., memory that is only accessible from the device (or
|
|
|
|
|
group of devices). You likely also want to select HMM_MIRROR.
|
|
|
|
|
|
2015-07-13 08:55:44 -06:00
|
|
|
config FRAME_VECTOR
|
|
|
|
|
bool
|
2016-02-12 14:02:08 -07:00
|
|
|
|
|
|
|
|
config ARCH_USES_HIGH_VMA_FLAGS
|
|
|
|
|
bool
|
2016-02-12 14:02:32 -07:00
|
|
|
config ARCH_HAS_PKEYS
|
|
|
|
|
bool
|
2017-06-19 17:28:31 -06:00
|
|
|
|
|
|
|
|
config PERCPU_STATS
|
|
|
|
|
bool "Collect percpu memory statistics"
|
|
|
|
|
help
|
|
|
|
|
This feature collects and exposes statistics via debugfs. The
|
|
|
|
|
information includes global and per chunk statistics, which can
|
|
|
|
|
be used to help understand percpu memory usage.
|
2017-11-17 16:31:22 -07:00
|
|
|
|
|
|
|
|
config GUP_BENCHMARK
|
|
|
|
|
bool "Enable infrastructure for get_user_pages_fast() benchmarking"
|
|
|
|
|
help
|
|
|
|
|
Provides /sys/kernel/debug/gup_benchmark that helps with testing
|
|
|
|
|
performance of get_user_pages_fast().
|
|
|
|
|
|
|
|
|
|
See tools/testing/selftests/vm/gup_benchmark.c
|
2018-06-07 18:06:08 -06:00
|
|
|
|
2019-07-11 21:56:49 -06:00
|
|
|
config GUP_GET_PTE_LOW_HIGH
|
|
|
|
|
bool
|
|
|
|
|
|
2019-09-23 16:38:00 -06:00
|
|
|
config READ_ONLY_THP_FOR_FS
|
|
|
|
|
bool "Read-only THP for filesystems (EXPERIMENTAL)"
|
|
|
|
|
depends on TRANSPARENT_HUGE_PAGECACHE && SHMEM
|
|
|
|
|
|
|
|
|
|
help
|
|
|
|
|
Allow khugepaged to put read-only file-backed pages in THP.
|
|
|
|
|
|
|
|
|
|
This is marked experimental because it is a new feature. Write
|
|
|
|
|
support of file THPs will be developed in the next few release
|
|
|
|
|
cycles.
|
|
|
|
|
|
2018-06-07 18:06:08 -06:00
|
|
|
config ARCH_HAS_PTE_SPECIAL
|
|
|
|
|
bool
|
2018-07-31 05:39:35 -06:00
|
|
|
|
2019-07-11 21:57:28 -06:00
|
|
|
#
|
|
|
|
|
# Some architectures require a special hugepage directory format that is
|
|
|
|
|
# required to support multiple hugepage sizes. For example a4fe3ce76
|
|
|
|
|
# "powerpc/mm: Allow more flexible layouts for hugepage pagetables"
|
|
|
|
|
# introduced it on powerpc. This allows for a more flexible hugepage
|
|
|
|
|
# pagetable layouts.
|
|
|
|
|
#
|
|
|
|
|
config ARCH_HAS_HUGEPD
|
|
|
|
|
bool
|
|
|
|
|
|
2018-07-31 05:39:35 -06:00
|
|
|
endmenu
|