mm/demotion: Memory tiers and demotion
Subsystems (12)
v7 cover mm/demotion: Memory tiers and demotion
The current kernel has the basic memory tiering support: Inactive pages on a higher tier NUMA node can be migrated (demoted) to a lower tier NUMA node to make room for new allocations on the higher tier NUMA node. Frequently accessed pages on a lower tier NUMA node can be migrated (promoted) to a higher tier NUMA node to improve the performance.
In the current kernel, memory tiers are defined implicitly via a demotion path relationship between NUMA nodes, which is created during the kernel initialization and updated when a NUMA node is hot-added or hot-removed. The current implementation puts all nodes with CPU into the top tier, and builds the tier hierarchy tier-by-tier by establishing the per-node demotion targets based on the distances between nodes.
This current memory tier kernel interface needs to be improved for several important use cases:
* The current tier initialization code always initializes each memory-only NUMA node into a lower tier. But a memory-only NUMA node may have a high performance memory device (e.g. a DRAM device attached via CXL.mem or a DRAM-backed memory-only node on a virtual machine) and should be put into a higher tier.
* The current tier hierarchy always puts CPU nodes into the top tier. But on a system with HBM (e.g. GPU memory) devices, these memory-only HBM NUMA nodes should be in the top tier, and DRAM nodes with CPUs are better to be placed into the next lower tier.
* Also because the current tier hierarchy always puts CPU nodes into the top tier, when a CPU is hot-added (or hot-removed) and triggers a memory node from CPU-less into a CPU node (or vice versa), the memory tier hierarchy gets changed, even though no memory node is added or removed. This can make the tier hierarchy unstable and make it difficult to support tier-based memory accounting.
* A higher tier node can only be demoted to selected nodes on the next lower tier as defined by the demotion path, not any other node from any lower tier. This strict, hard-coded demotion order does not work in all use cases (e.g. some use cases may want to allow cross-socket demotion to another node in the same demotion tier as a fallback when the preferred demotion node is out of space), and has resulted in the feature request for an interface to override the system-wide, per-node demotion order from the userspace. This demotion order is also inconsistent with the page allocation fallback order when all the nodes in a higher tier are out of space: The page allocation can fall back to any node from any lower tier, whereas the demotion order doesn't allow that.
* There are no interfaces for the userspace to learn about the memory tier hierarchy in order to optimize its memory allocations.
This patch series make the creation of memory tiers explicit under the control of userspace or device driver.
Memory Tier Initialization
==========================
By default, all memory nodes are assigned to the default tier with tier ID value 200.
A device driver can move up or down its memory nodes from the default tier. For example, PMEM can move down its memory nodes below the default tier, whereas GPU can move up its memory nodes above the default tier.
The kernel initialization code makes the decision on which exact tier a memory node should be assigned to based on the requests from the device drivers as well as the memory device hardware information provided by the firmware.
Hot-adding/removing CPUs doesn't affect memory tier hierarchy.
Memory Allocation for Demotion
==============================
This patch series keep the demotion target page allocation logic same. The demotion page allocation pick the closest NUMA node in the next lower tier to the current NUMA node allocating pages from.
This will be later improved to use the same page allocation strategy using fallback list.
Sysfs Interface:
-------------
Listing current list of memory tiers details:
:/sys/devices/system/memtier$ ls default_tier max_tier memtier1 power uevent :/sys/devices/system/memtier$ cat default_tier memtier200 :/sys/devices/system/memtier$ cat max_tier 400 :/sys/devices/system/memtier$
Per node memory tier details:
For a cpu only NUMA node:
:/sys/devices/system/node# cat node0/memtier :/sys/devices/system/node# echo 1 > node0/memtier :/sys/devices/system/node# cat node0/memtier :/sys/devices/system/node#
For a NUMA node with memory:
:/sys/devices/system/node# cat node1/memtier 1 :/sys/devices/system/node# ls ../memtier/ default_tier max_tier memtier1 power uevent :/sys/devices/system/node# echo 2 > node1/memtier :/sys/devices/system/node# :/sys/devices/system/node# ls ../memtier/ default_tier max_tier memtier1 memtier2 power uevent :/sys/devices/system/node# cat node1/memtier 2 :/sys/devices/system/node#
Removing a memory tier
:/sys/devices/system/node# cat node1/memtier 2 :/sys/devices/system/node# echo 1 > node1/memtier :/sys/devices/system/node# :/sys/devices/system/node# cat node1/memtier 1 :/sys/devices/system/node# :/sys/devices/system/node# ls ../memtier/ default_tier max_tier memtier1 power uevent :/sys/devices/system/node#
The above resulted in removal of memtier2 which was created in the earlier step.
Changes from v6:
* Drop the usage of rank.
* Address other review feedback.
Changes from v5:
* Remove patch supporting N_MEMORY node removal from memory tiers. memory tiers are going to be used for features other than demotion. Hence keep all N_MEMORY nodes in memory tiers irrespective of whether they want to participate in promotion or demotion.
* Add NODE_DATA->memtier
* Rearrage patches to add sysfs files later.
* Add support to create memory tiers from userspace.
* Address other review feedback.
Changes from v4:
* Address review feedback.
* Reverse the meaning of "rank": higher rank value means higher tier.
* Add "/sys/devices/system/memtier/default_tier".
* Add node_is_toptier
v4:
Add support for explicit memory tiers and ranks.
v3:
- Modify patch 1 subject to make it more specific
- Remove /sys/kernel/mm/numa/demotion_targets interface, use /sys/devices/system/node/demotion_targets instead and make it writable to override node_states[N_DEMOTION_TARGETS].
- Add support to view per node demotion targets via sysfs
v2:
In v1, only 1st patch of this patch series was sent, which was implemented to avoid some of the limitations on the demotion target sharing, however for certain numa topology, the demotion targets found by that patch was not most optimal, so 1st patch in this series is modified according to suggestions from Huang and Baolin. Different examples of demotion list comparasion between existing implementation and changed implementation can be found in the commit message of 1st patch.
Aneesh Kumar K.V (10):
mm/demotion: Add support for explicit memory tiers mm/demotion: Move memory demotion related code mm/demotion/dax/kmem: Set node's memory tier to MEMORY_TIER_PMEM mm/demotion: Add hotplug callbacks to handle new numa node onlined mm/demotion: Build demotion targets based on explicit memory tiers mm/demotion: Expose memory tier details via sysfs mm/demotion: Add per node memory tier attribute to sysfs mm/demotion: Add pg_data_t member to track node memory tier details mm/demotion: Update node_is_toptier to work with memory tiers mm/demotion: Add sysfs ABI documentation
Jagdish Gediya (2):
mm/demotion: Demote pages according to allocation fallback order mm/demotion: Add documentation for memory tiering
.../ABI/testing/sysfs-kernel-mm-memory-tiers | 61 ++ Documentation/admin-guide/mm/index.rst | 1 + .../admin-guide/mm/memory-tiering.rst | 182 ++++ drivers/base/node.c | 42 + drivers/dax/kmem.c | 6 +- include/linux/memory-tiers.h | 72 ++ include/linux/migrate.h | 15 - include/linux/mmzone.h | 3 + include/linux/node.h | 5 - mm/Makefile | 1 + mm/huge_memory.c | 1 + mm/memory-tiers.c | 791 ++++++++++++++++++ mm/migrate.c | 453 +--------- mm/mprotect.c | 1 + mm/vmscan.c | 57 +- mm/vmstat.c | 4 - 16 files changed, 1204 insertions(+), 491 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers create mode 100644 Documentation/admin-guide/mm/memory-tiering.rst create mode 100644 include/linux/memory-tiers.h create mode 100644 mm/memory-tiers.c
Signature · 1 line
2.36.1
PATCH v7 1/12 mm/demotion: Add support for explicit memory tiers
In the current kernel, memory tiers are defined implicitly via a demotion path relationship between NUMA nodes, which is created during the kernel initialization and updated when a NUMA node is hot-added or hot-removed. The current implementation puts all nodes with CPU into the top tier, and builds the tier hierarchy tier-by-tier by establishing the per-node demotion targets based on the distances between nodes.
This current memory tier kernel interface needs to be improved for several important use cases,
The current tier initialization code always initializes each memory-only NUMA node into a lower tier. But a memory-only NUMA node may have a high performance memory device (e.g. a DRAM device attached via CXL.mem or a DRAM-backed memory-only node on a virtual machine) and should be put into a higher tier.
The current tier hierarchy always puts CPU nodes into the top tier. But on a system with HBM or GPU devices, the memory-only NUMA nodes mapping these devices should be in the top tier, and DRAM nodes with CPUs are better to be placed into the next lower tier.
With current kernel higher tier node can only be demoted to selected nodes on the next lower tier as defined by the demotion path, not any other
node from any lower tier. This strict, hard-coded demotion order does not work in all use cases (e.g. some use cases may want to allow cross-socket demotion to another node in the same demotion tier as a fallback when the preferred demotion node is out of space), This demotion order is also inconsistent with the page allocation fallback order when all the nodes in a higher tier are out of space: The page allocation can fall back to any node from
any lower tier, whereas the demotion order doesn't allow that.
The current kernel also don't provide any interfaces for the userspace to learn about the memory tier hierarchy in order to optimize its memory allocations.
This patch series address the above by defining memory tiers explicitly.
This patch introduce explicity memory tiers. The tier ID value of a memory tier is used to derive the demotion order between NUMA nodes.
For example, if we have 3 memtiers: memtier100, memtier200, memiter300 then the memory tier order is: memtier300 -> memtier200 -> memtier100 where memtier300 is the highest tier and memtier100 is the lowest tier.
While reclaim we migrate pages from fast(higher) tiers to slow(lower) tiers when the fast(higher) tier is under memory pressure.
This patchset introduce 3 memory tiers (memtier100, memtier200 and memtier300) which are created by different kernel subsystems. The default memory tier created by the kernel is memtier200. A kernel parameter is provided to override the default memory tier.
--- include/linux/memory-tiers.h | 15 +++++++ mm/Makefile | 1 + mm/memory-tiers.c | 78 ++++++++++++++++++++++++++++++++++++ 3 files changed, 94 insertions(+) create mode 100644 include/linux/memory-tiers.h create mode 100644 mm/memory-tiers.c
include/linux/memory-tiers.h new file +15 -0
@@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LINUX_MEMORY_TIERS_H +#define _LINUX_MEMORY_TIERS_H + +#ifdef CONFIG_NUMA + +#define MEMORY_TIER_HBM_GPU 300 +#define MEMORY_TIER_DRAM 200 +#define MEMORY_TIER_PMEM 100 + +#define DEFAULT_MEMORY_TIER MEMORY_TIER_DRAM +#define MAX_MEMORY_TIER_ID 400 + +#endif /* CONFIG_NUMA */ +#endif /* _LINUX_MEMORY_TIERS_H */
mm/Makefile +1 -0
@@ -92,6 +92,7 @@ obj-$(CONFIG_KFENCE) += kfence/ obj-$(CONFIG_FAILSLAB) += failslab.o obj-$(CONFIG_MEMTEST) += memtest.o obj-$(CONFIG_MIGRATION) += migrate.o +obj-$(CONFIG_NUMA) += memory-tiers.o obj-$(CONFIG_DEVICE_MIGRATION) += migrate_device.o obj-$(CONFIG_TRANSPARENT_HUGEPAGE) += huge_memory.o khugepaged.o obj-$(CONFIG_PAGE_COUNTER) += page_counter.o
mm/memory-tiers.c new file +78 -0
78 lines not on this page · raw message
Signature · 1 line
2.36.1
PATCH v7 2/12 mm/demotion: Move memory demotion related code
In reply to Aneesh Kumar K.VThis move memory demotion related code to mm/memory-tiers.c. No functional change in this patch.
--- include/linux/memory-tiers.h | 7 ++++ include/linux/migrate.h | 2 -- mm/memory-tiers.c | 63 ++++++++++++++++++++++++++++++++++++ mm/migrate.c | 60 +--------------------------------- mm/vmscan.c | 1 + 5 files changed, 72 insertions(+), 61 deletions(-)
include/linux/memory-tiers.h +7 -0
@@ -2,6 +2,8 @@#ifndef _LINUX_MEMORY_TIERS_H#define _LINUX_MEMORY_TIERS_H +#include <linux/types.h> +#ifdef CONFIG_NUMA #define MEMORY_TIER_HBM_GPU 300
@@ -11,5 +13,10 @@#define DEFAULT_MEMORY_TIER MEMORY_TIER_DRAM#define MAX_MEMORY_TIER_ID 400 +extern bool numa_demotion_enabled; + +#else + +#define numa_demotion_enabled false#endif /* CONFIG_NUMA */ #endif /* _LINUX_MEMORY_TIERS_H */
include/linux/migrate.h +0 -2
@@ -78,7 +78,6 @@ static inline int migrate_huge_page_move_mapping(struct address_space *mapping,#if defined(CONFIG_MIGRATION ) && defined(CONFIG_NUMA )extern void set_migration_target_nodes (void );extern void migrate_on_reclaim_init (void ); -extern bool numa_demotion_enabled;extern int next_demotion_node (int node);#else static inline void set_migration_target_nodes (void ) {}
@@ -87,7 +86,6 @@ static inline int next_demotion_node(int node) {return NUMA_NO_NODE ; } -#define numa_demotion_enabled false#endif #ifdef CONFIG_COMPACTION
mm/memory-tiers.c +63 -0
71 lines not on this page · raw message
mm/migrate.c +1 -59
65 lines not on this page · raw message
mm/vmscan.c +1 -0
@@ -50,6 +50,7 @@#include <linux/printk.h> #include <linux/dax.h> #include <linux/psi.h> +#include <linux/memory-tiers.h> #include <asm/tlbflush.h> #include <asm/div64.h>
Signature · 1 line
2.36.1
PATCH v7 3/12 mm/demotion/dax/kmem: Set node's memory tier to MEMORY_TIER_PMEM
In reply to Aneesh Kumar K.VBy default, all nodes are assigned to DEFAULT_MEMORY_TIER which is the memory tier designated for nodes with DRAM
Set dax kmem device node's tier to MEMORY_TIER_PMEM. MEMORY_TIER_PMEM appears below DEFAULT_MEMORY_TIER in demotion order.
--- drivers/dax/kmem.c | 6 ++- include/linux/memory-tiers.h | 5 +++ mm/memory-tiers.c | 79 ++++++++++++++++++++++++++++++++++++ 3 files changed, 89 insertions(+), 1 deletion(-)
drivers/dax/kmem.c +5 -1
@@ -11,6 +11,7 @@#include <linux/fs.h> #include <linux/mm.h> #include <linux/mman.h> +#include <linux/memory-tiers.h> #include "dax-private.h" #include "bus.h"
@@ -41,6 +42,9 @@ struct dax_kmem_data {struct resource *res[]; }; +static unsigned int dax_kmem_memtier =MEMORY_TIER_PMEM ; +module_param (dax_kmem_memtier, uint,0644 ); +static int dev_dax_kmem_probe (struct dev_dax *dev_dax) {struct device *dev = &dev_dax->dev;
@@ -146,7 +150,7 @@ static int dev_dax_kmem_probe(struct dev_dax *dev_dax) }dev_set_drvdata (dev, data); - +node_create_and_set_memory_tier (numa_node, dax_kmem_memtier);return 0 ; err_request_mem:
include/linux/memory-tiers.h +5 -0
@@ -14,9 +14,14 @@#define MAX_MEMORY_TIER_ID 400extern bool numa_demotion_enabled; +int node_create_and_set_memory_tier (int node,int tier);#else #define numa_demotion_enabled false +static inline int node_create_and_set_memory_tier (int node,int tier) +{ +return 0 ; +}#endif /* CONFIG_NUMA */ #endif /* _LINUX_MEMORY_TIERS_H */
mm/memory-tiers.c +79 -0
85 lines not on this page · raw message
Signature · 1 line
2.36.1
PATCH v7 4/12 mm/demotion: Add hotplug callbacks to handle new numa node onlined
In reply to Aneesh Kumar K.VIf the new NUMA node onlined doesn't have a memory tier assigned, the kernel adds the NUMA node to default memory tier.
--- mm/memory-tiers.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+)
mm/memory-tiers.c +68 -0
@@ -5,6 +5,7 @@#include <linux/slab.h> #include <linux/lockdep.h> #include <linux/moduleparam.h> +#include <linux/memory.h> #include <linux/memory-tiers.h> struct memory_tier {
@@ -130,8 +131,73 @@ int node_create_and_set_memory_tier(int node, int tier) }EXPORT_SYMBOL_GPL (node_create_and_set_memory_tier); +static int __node_set_memory_tier (int node,int tier) +{ +int ret =0 ; +struct memory_tier *memtier; + + memtier =__get_memory_tier_from_id (tier); +if (!memtier) { + ret = -EINVAL ; + goto out; + } +node_set (node, memtier->nodelist); +out: +return ret; +} + +static int node_set_memory_tier (int node,int tier) +{ +struct memory_tier *memtier; +int ret =0 ; + +mutex_lock (&memory_tier_lock); + memtier =__node_get_memory_tier (node); +if (!memtier) + ret =__node_set_memory_tier (node, tier); + +mutex_unlock (&memory_tier_lock); + +return ret; +} +static unsigned int default_memtier =DEFAULT_MEMORY_TIER ;core_param (default_memory_tier, default_memtier, uint,0644 ); +/* +* This runs whether reclaim-based migration is enabled or not, +* which ensures that the user can turn reclaim-based migration +* at any time without needing to recalculate migration targets. +*/ +static int __meminit migrate_on_reclaim_callback (struct notifier_block *self, +unsigned long action,void *_arg) +{ +struct memory_notify *arg = _arg; + +/* +* Only update the node migration order when a node is +* changing status, like online->offline. +*/ +if (arg->status_change_nid <0 ) +return notifier_from_errno (0 ); + +switch (action) { +case MEM_ONLINE : +/* +* We ignore the error here, if the node already have the tier +* registered, we will continue to use that for the new memory +* we are adding here. +*/ +node_set_memory_tier (arg->status_change_nid, default_memtier); +break ; + } + +return notifier_from_errno (0 ); +} + +static void __init migrate_on_reclaim_init (void ) +{ +hotplug_memory_notifier (migrate_on_reclaim_callback,100 ); +}static int __init memory_tier_init (void ) {
@@ -153,6 +219,8 @@ static int __init memory_tier_init(void)/* CPU only nodes are not part of memory tiers. */ memtier->nodelist = node_states[N_MEMORY ];mutex_unlock (&memory_tier_lock); + +migrate_on_reclaim_init ();return 0 ; }subsys_initcall (memory_tier_init);
Signature · 1 line
2.36.1
PATCH v7 5/12 mm/demotion: Build demotion targets based on explicit memory tiers
In reply to Aneesh Kumar K.VThis patch switch the demotion target building logic to use memory tiers instead of NUMA distance. All N_MEMORY NUMA nodes will be placed in the default tier 200 and additional memory tiers will be added by drivers like dax kmem.
This patch builds the demotion target for a NUMA node by looking at all memory tiers below the tier to which the NUMA node belongs. The closest node in the immediately following memory tier is used as a demotion target.
Since we are now only building demotion target for N_MEMORY NUMA nodes the CPU hotplug calls are removed in this patch.
A new memory tier can be inserted into the tier hierarchy for a new set of nodes without affecting the node assignment of any existing memtier, provided that there is enough gap in the tier ID values for the new memtier.
The absolute value of tier ID of a memtier doesn't necessarily carry any meaning. Its value relative to other memtiers decides the level of this memtier in the tier hierarchy.
For now, This patch supports hardcoded tier ID values which are 300, 200 and 100 for memory tiers.
--- include/linux/memory-tiers.h | 13 ++ include/linux/migrate.h | 13 -- mm/memory-tiers.c | 227 ++++++++++++++++++++ mm/migrate.c | 394 ----------------------------------- mm/vmstat.c | 4 - 5 files changed, 240 insertions(+), 411 deletions(-)
include/linux/memory-tiers.h +13 -0
@@ -15,6 +15,14 @@extern bool numa_demotion_enabled;int node_create_and_set_memory_tier (int node,int tier); +#ifdef CONFIG_MIGRATION +int next_demotion_node (int node); +#else +static inline int next_demotion_node (int node) +{ +return NUMA_NO_NODE ; +} +#endif #else
@@ -23,5 +31,10 @@ static inline int node_create_and_set_memory_tier(int node, int tier) {return 0 ; } + +static inline int next_demotion_node (int node) +{ +return NUMA_NO_NODE ; +}#endif /* CONFIG_NUMA */ #endif /* _LINUX_MEMORY_TIERS_H */
include/linux/migrate.h +0 -13
@@ -75,19 +75,6 @@ static inline int migrate_huge_page_move_mapping(struct address_space *mapping,#endif /* CONFIG_MIGRATION */ -#if defined(CONFIG_MIGRATION ) && defined(CONFIG_NUMA ) -extern void set_migration_target_nodes (void ); -extern void migrate_on_reclaim_init (void ); -extern int next_demotion_node (int node); -#else -static inline void set_migration_target_nodes (void ) {} -static inline void migrate_on_reclaim_init (void ) {} -static inline int next_demotion_node (int node) -{ -return NUMA_NO_NODE ; -} -#endif -#ifdef CONFIG_COMPACTION extern int PageMovable (struct page *page);extern void __SetPageMovable (struct page *page,struct address_space *mapping);
mm/memory-tiers.c +227 -0
281 lines not on this page · raw message
mm/migrate.c +0 -394
398 lines not on this page · raw message
mm/vmstat.c +0 -4
@@ -28,7 +28,6 @@#include <linux/mm_inline.h> #include <linux/page_ext.h> #include <linux/page_owner.h> -#include <linux/migrate.h> #include "internal.h"
@@ -2060,7 +2059,6 @@ static int vmstat_cpu_online(unsigned int cpu)if (!node_state (cpu_to_node (cpu),N_CPU )) {node_set_state (cpu_to_node (cpu),N_CPU ); -set_migration_target_nodes (); }return 0 ;
@@ -2085,7 +2083,6 @@ static int vmstat_cpu_dead(unsigned int cpu)return 0 ;node_clear_state (node,N_CPU ); -set_migration_target_nodes ();return 0 ; }
@@ -2118,7 +2115,6 @@ void __init init_mm_internals(void)start_shepherd_timer ();#endif -migrate_on_reclaim_init ();#ifdef CONFIG_PROC_FS proc_create_seq ("buddyinfo" ,0444 ,NULL , &fragmentation_op);proc_create_seq ("pagetypeinfo" ,0400 ,NULL , &pagetypeinfo_op);
Signature · 1 line
2.36.1
PATCH v7 6/12 mm/demotion: Expose memory tier details via sysfs
In reply to Aneesh Kumar K.VThis patch adds /sys/devices/system/memtier/ where all memory tier related details can be found. All created memory tiers will be listed there as /sys/devices/system/memtier/memtierN/
The nodes which are part of a specific memory tier can be listed via /sys/devices/system/memtier/memtierN/nodelist
/sys/devices/system/memtier/max_tier shows the max tier ID value supported.
/sys/devices/system/memtier/default_tier shows the memory tier to which NUMA nodes get added by default if not assigned a specific memory tier.
--- mm/memory-tiers.c | 93 ++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 87 insertions(+), 6 deletions(-)
mm/memory-tiers.c +87 -6
@@ -13,14 +13,15 @@struct memory_tier {struct list_head list; +struct device dev;nodemask_t nodelist; -int id; };struct demotion_nodes {nodemask_t preferred; }; +#define to_memory_tier (device) container_of(device, struct memory_tier, dev)static void establish_migration_targets (void );static DEFINE_MUTEX (memory_tier_lock);static LIST_HEAD (memory_tiers);
@@ -86,6 +87,42 @@ static LIST_HEAD(memory_tiers);*/ static struct demotion_nodes *node_demotion__read_mostly ; +static struct bus_type memory_tier_subsys = { + .name ="memtier" , + .dev_name ="memtier" , +}; + +static ssize_t nodelist_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct memory_tier *memtier =to_memory_tier (dev); + +return sysfs_emit (buf,"%*pbl\n" , +nodemask_pr_args (&memtier->nodelist)); +} +static DEVICE_ATTR_RO (nodelist); + +static struct attribute *memory_tier_dev_attrs[] = { + &dev_attr_nodelist.attr, +NULL +}; + +static const struct attribute_group memory_tier_dev_group = { + .attrs = memory_tier_dev_attrs, +}; + +static const struct attribute_group *memory_tier_dev_groups[] = { + &memory_tier_dev_group, +NULL +}; + +static void memory_tier_device_release (struct device *dev) +{ +struct memory_tier *tier =to_memory_tier (dev); + +kfree (tier); +} +static void insert_memory_tier (struct memory_tier *memtier) {struct list_head *ent;
@@ -95,7 +132,7 @@ static void insert_memory_tier(struct memory_tier *memtier)list_for_each (ent, &memory_tiers) { tmp_memtier = list_entry(ent, struct memory_tier, list); -if (tmp_memtier->id < memtier->id) { +if (tmp_memtier->dev.id < memtier->dev.id) {list_add_tail (&memtier->list, ent);return ; }
@@ -105,6 +142,7 @@ static void insert_memory_tier(struct memory_tier *memtier)static struct memory_tier *register_memory_tier (unsigned int tier) { +int error;struct memory_tier *memtier;if (tier >MAX_MEMORY_TIER_ID )
@@ -114,17 +152,26 @@ static struct memory_tier *register_memory_tier(unsigned int tier)if (!memtier)return ERR_PTR (-ENOMEM ); - memtier->id = tier; + memtier->dev.id = tier; + memtier->dev.bus = &memory_tier_subsys; + memtier->dev.release = memory_tier_device_release; + memtier->dev.groups = memory_tier_dev_groups;insert_memory_tier (memtier); + error =device_register (&memtier->dev); +if (error) { +list_del (&memtier->list); +put_device (&memtier->dev); +return ERR_PTR (error); + }return memtier; }static void unregister_memory_tier (struct memory_tier *memtier) {list_del (&memtier->list); -kfree (memtier); +device_unregister (&memtier->dev); }static struct memory_tier *__node_get_memory_tier (int node)
@@ -143,7 +190,7 @@ static struct memory_tier *__get_memory_tier_from_id(int id)struct memory_tier *memtier;list_for_each_entry (memtier, &memory_tiers, list) { -if (memtier->id == id) +if (memtier->dev.id == id)return memtier; }return NULL ;
@@ -181,7 +228,7 @@ int node_create_and_set_memory_tier(int node, int tier) goto out; } -if (current_tier->id == tier) +if (current_tier->dev.id == tier) goto out;node_clear (node, current_tier->nodelist);
@@ -426,10 +473,44 @@ static void __init migrate_on_reclaim_init(void)hotplug_memory_notifier (migrate_on_reclaim_callback,100 ); } +static ssize_t +max_tier_show (struct device *dev,struct device_attribute *attr,char *buf) +{ +return sysfs_emit (buf,"%d\n" ,MAX_MEMORY_TIER_ID ); +} +static DEVICE_ATTR_RO (max_tier); + +static ssize_t +default_tier_show (struct device *dev,struct device_attribute *attr,char *buf) +{ +return sysfs_emit (buf,"memtier%d\n" , default_memtier); +} +static DEVICE_ATTR_RO (default_tier); + +static struct attribute *memory_tier_attrs[] = { + &dev_attr_max_tier.attr, + &dev_attr_default_tier.attr, +NULL +}; + +static const struct attribute_group memory_tier_attr_group = { + .attrs = memory_tier_attrs, +}; + +static const struct attribute_group *memory_tier_attr_groups[] = { + &memory_tier_attr_group, +NULL , +}; +static int __init memory_tier_init (void ) { +int ret;struct memory_tier *memtier; + ret =subsys_system_register (&memory_tier_subsys, memory_tier_attr_groups); +if (ret) +pr_err ("%s() failed to register subsystem: %d\n" , __func__, ret); +/* * Register only default memory tier to hide all empty * memory tier from sysfs. Since this is early during
Signature · 1 line
2.36.1
PATCH v7 7/12 mm/demotion: Add per node memory tier attribute to sysfs
In reply to Aneesh Kumar K.VAdd support to modify the memory tier for a NUMA node.
/sys/devices/system/node/nodeN/memtier
where N = node id
When read, It list the memory tier that the node belongs to.
When written, the kernel moves the node into the specified memory tier, the tier assignment of all other nodes are not affected.
If the memory tier does not exist, it is created.
--- drivers/base/node.c | 42 ++++++++++++++++++++++++++++++++++++ include/linux/memory-tiers.h | 2 ++ mm/memory-tiers.c | 42 ++++++++++++++++++++++++++++++++++++ 3 files changed, 86 insertions(+)
drivers/base/node.c +42 -0
@@ -20,6 +20,7 @@#include <linux/pm_runtime.h> #include <linux/swap.h> #include <linux/slab.h> +#include <linux/memory-tiers.h> static struct bus_type node_subsys = { .name ="node" ,
@@ -560,11 +561,52 @@ static ssize_t node_read_distance(struct device *dev, } static DEVICE_ATTR(distance, 0444, node_read_distance, NULL); +#ifdef CONFIG_NUMA +static ssize_t memtier_show (struct device *dev, +struct device_attribute *attr, +char *buf) +{ +int node = dev->id; +int tier_index =node_get_memory_tier_id (node); + +/* +* CPU only NUMA node is not part of memory tiers. +*/ +if (tier_index !=-1 ) +return sysfs_emit (buf,"%d\n" , tier_index); +return 0 ; +} + +static ssize_t memtier_store (struct device *dev, +struct device_attribute *attr, +const char *buf,size_t count) +{ +unsigned long tier; +int node = dev->id; +int ret; + + ret =kstrtoul (buf,10 , &tier); +if (ret) +return ret; + + ret =node_update_memory_tier (node, tier); +if (ret) +return ret; + +return count; +} + +static DEVICE_ATTR_RW (memtier); +#endif +static struct attribute *node_dev_attrs[] = { &dev_attr_meminfo.attr, &dev_attr_numastat.attr, &dev_attr_distance.attr, &dev_attr_vmstat.attr, +#ifdef CONFIG_NUMA + &dev_attr_memtier.attr, +#endifNULL };
include/linux/memory-tiers.h +2 -0
@@ -23,6 +23,8 @@ static inline int next_demotion_node(int node) return NUMA_NO_NODE; }#endif +int node_get_memory_tier_id (int node); +int node_update_memory_tier (int node,int tier);#else
mm/memory-tiers.c +42 -0
48 lines not on this page · raw message
Signature · 1 line
2.36.1
PATCH v7 8/12 mm/demotion: Add pg_data_t member to track node memory tier details
In reply to Aneesh Kumar K.VAlso update different helpes to use NODE_DATA()->memtier. Since node specific memtier can change based on the reassignment of NUMA node to a different memory tiers, accessing NODE_DATA()->memtier needs to happen under an rcu read lock or memory_tier_lock.
--- include/linux/memory-tiers.h | 11 ++++ include/linux/mmzone.h | 3 + mm/memory-tiers.c | 104 +++++++++++++++++++++++++---------- 3 files changed, 89 insertions(+), 29 deletions(-)
include/linux/memory-tiers.h +11 -0
@@ -6,6 +6,9 @@#ifdef CONFIG_NUMA +#include <linux/device.h> +#include <linux/nodemask.h> +#define MEMORY_TIER_HBM_GPU 300#define MEMORY_TIER_DRAM 200#define MEMORY_TIER_PMEM 100
@@ -13,6 +16,12 @@#define DEFAULT_MEMORY_TIER MEMORY_TIER_DRAM#define MAX_MEMORY_TIER_ID 400 +struct memory_tier { +struct list_head list; +struct device dev; +nodemask_t nodelist; +}; +extern bool numa_demotion_enabled;int node_create_and_set_memory_tier (int node,int tier);#ifdef CONFIG_MIGRATION
@@ -25,6 +34,8 @@ static inline int next_demotion_node(int node)#endif int node_get_memory_tier_id (int node);int node_update_memory_tier (int node,int tier); +struct memory_tier *node_get_memory_tier (int node); +void node_put_memory_tier (struct memory_tier *memtier);#else
include/linux/mmzone.h +3 -0
@@ -928,6 +928,9 @@ typedef struct pglist_data {/* Per-node vmstats */ struct per_cpu_nodestat __percpu *per_cpu_nodestats;atomic_long_t vm_stat[NR_VM_NODE_STAT_ITEMS ]; +#ifdef CONFIG_NUMA +struct memory_tier *memtier; +#endif } pg_data_t;#define node_present_pages (nid) (NODE_DATA(nid)->node_present_pages)
mm/memory-tiers.c +75 -29
181 lines not on this page · raw message
Signature · 1 line
2.36.1
kernel test robot
build botRe: [PATCH v7 08/12] mm/demotion: Add pg_data_t member to track node memory tier details
I love your patch! Perhaps something to improve:
Hi "Aneesh,
I love your patch! Perhaps something to improve:
[auto build test WARNING on akpm-mm/mm-everything]
url: https://github.com/intel-lab-lkp/linux/commits/Aneesh-Kumar-K-V/mm-demotion-Memory-tiers-and-demotion/20220622-163031 base: https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git mm-everything config: x86_64-rhel-8.3-kselftests (https://download.01.org/0day-ci/archive/20220623/[email protected]/config) compiler: gcc-11 (Debian 11.3.0-3) 11.3.0 reproduce: # apt-get install sparse # sparse version: v0.6.4-31-g4880bd19-dirty # https://github.com/intel-lab-lkp/linux/commit/97a1874c652abe1500768e5cab39b2d3dcdfb046 git remote add linux-review https://github.com/intel-lab-lkp/linux git fetch --no-tags linux-review Aneesh-Kumar-K-V/mm-demotion-Memory-tiers-and-demotion/20220622-163031 git checkout 97a1874c652abe1500768e5cab39b2d3dcdfb046 # save the config file mkdir build_dir && cp config build_dir/.config make W=1 C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' O=build_dir ARCH=x86_64 SHELL=/bin/bash
If you fix the issue, kindly add following tag where applicable
sparse warnings: (new ones prefixed by >>)
>> mm/memory-tiers.c:182:16: sparse: sparse: incompatible types in comparison expression (different address spaces): >> mm/memory-tiers.c:182:16: sparse: struct memory_tier [noderef] __rcu * >> mm/memory-tiers.c:182:16: sparse: struct memory_tier *
mm/memory-tiers.c:214:27: sparse: sparse: incompatible types in comparison expression (different address spaces):
mm/memory-tiers.c:214:27: sparse: struct memory_tier [noderef] __rcu *
mm/memory-tiers.c:214:27: sparse: struct memory_tier *
mm/memory-tiers.c:216:9: sparse: sparse: incompatible types in comparison expression (different address spaces):
mm/memory-tiers.c:216:9: sparse: struct memory_tier [noderef] __rcu *
mm/memory-tiers.c:216:9: sparse: struct memory_tier *
mm/memory-tiers.c:221:9: sparse: sparse: incompatible types in comparison expression (different address spaces):
mm/memory-tiers.c:221:9: sparse: struct memory_tier [noderef] __rcu *
mm/memory-tiers.c:221:9: sparse: struct memory_tier *
mm/memory-tiers.c:361:19: sparse: sparse: incompatible types in comparison expression (different address spaces):
mm/memory-tiers.c:361:19: sparse: struct memory_tier [noderef] __rcu *
mm/memory-tiers.c:361:19: sparse: struct memory_tier *
mm/memory-tiers.c:614:17: sparse: sparse: incompatible types in comparison expression (different address spaces):
mm/memory-tiers.c:614:17: sparse: struct memory_tier [noderef] __rcu *
mm/memory-tiers.c:614:17: sparse: struct memory_tier *
vim +182 mm/memory-tiers.c
169
170 static struct memory_tier *__node_get_memory_tier(int node)
171 {
172 pg_data_t *pgdat;
173
174 pgdat = NODE_DATA(node);
175 if (!pgdat)
176 return NULL;
177 /*
178 * Since we hold memory_tier_lock, we can avoid
179 * RCU read locks when accessing the details. No
180 * parallel updates are possible here.
181 */
> 182 return rcu_dereference_check(pgdat->memtier,
183 lockdep_is_held(&memory_tier_lock));
184 }
185
Signature · 2 lines
0-DAY CI Kernel Test Service https://01.org/lkp
PATCH v7 9/12 mm/demotion: Demote pages according to allocation fallback order
In reply to Aneesh Kumar K.VFrom: Jagdish Gediya <[email protected]>
Currently, a higher tier node can only be demoted to selected nodes on the next lower tier as defined by the demotion path. This strict, hard-coded demotion order does not work in all use cases (e.g. some use cases may want to allow cross-socket demotion to another node in the same demotion tier as a fallback when the preferred demotion node is out of space). This demotion order is also inconsistent with the page allocation fallback order when all the nodes in a higher tier are out of space: The page allocation can fall back to any node from any lower tier, whereas the demotion order doesn't allow that currently.
This patch adds support to get all the allowed demotion targets for a memory tier. demote_page_list() function is now modified to utilize this allowed node mask as the fallback allocation mask.
move allowed mask to memory tier
--- include/linux/memory-tiers.h | 17 +++++++- mm/memory-tiers.c | 76 +++++++++++++++++++++++++++++++++--- mm/vmscan.c | 56 +++++++++++++++++++------- 3 files changed, 128 insertions(+), 21 deletions(-)
include/linux/memory-tiers.h +15 -2
@@ -3,11 +3,12 @@#define _LINUX_MEMORY_TIERS_H#include <linux/types.h> +#include <linux/nodemask.h> +#include <linux/mmzone.h> #ifdef CONFIG_NUMA #include <linux/device.h> -#include <linux/nodemask.h> #define MEMORY_TIER_HBM_GPU 300#define MEMORY_TIER_DRAM 200
@@ -20,18 +21,25 @@ struct memory_tier {struct list_head list;struct device dev;nodemask_t nodelist; +nodemask_t lower_tier_mask; };extern bool numa_demotion_enabled;int node_create_and_set_memory_tier (int node,int tier);#ifdef CONFIG_MIGRATION int next_demotion_node (int node); +void node_get_allowed_targets (pg_data_t *pgdat,nodemask_t *targets);#else static inline int next_demotion_node (int node) {return NUMA_NO_NODE ; } -#endif + +static inline void node_get_allowed_targets (pg_data_t *pgdat,nodemask_t *targets) +{ + *targets =NODE_MASK_NONE ; +} +#endif /* CONFIG_MIGRATION */ int node_get_memory_tier_id (int node);int node_update_memory_tier (int node,int tier);struct memory_tier *node_get_memory_tier (int node);
@@ -49,5 +57,10 @@ static inline int next_demotion_node(int node) {return NUMA_NO_NODE ; } + +static inline void node_get_allowed_targets (pg_data_t *pgdat,nodemask_t *targets) +{ + *targets =NODE_MASK_NONE ; +}#endif /* CONFIG_NUMA */ #endif /* _LINUX_MEMORY_TIERS_H */
mm/memory-tiers.c +71 -5
103 lines not on this page · raw message
mm/vmscan.c +42 -14
77 lines not on this page · raw message
Signature · 1 line
2.36.1
Alistair Popple
reviewerRe: [PATCH v7 09/12] mm/demotion: Demote pages according to allocation fallback order
Quoted 1 line · Aneesh Kumar K.V
From: Jagdish Gediya <[email protected]>
[...]
Quoted 23 lines
mm/vmscan.c +10
-12-static struct page *alloc_demote_page (struct page *page,unsigned long node) +static struct page *alloc_demote_page (struct page *page,unsigned long private) { -struct migration_target_control mtc = { -/* -* Allocate from 'node', or fail quickly and quietly. -* When this happens, 'page' will likely just be discarded -* instead of migrated. -*/ - .gfp_mask = (GFP_HIGHUSER_MOVABLE & ~__GFP_RECLAIM) | - __GFP_THISNODE | __GFP_NOWARN | - __GFP_NOMEMALLOC |GFP_NOWAIT , - .nid = node - }; +struct page *target_page; +nodemask_t *allowed_mask; +struct migration_target_control *mtc; + + mtc = (struct migration_target_control *)private; + + allowed_mask = mtc->nmask; +/* +* make sure we allocate from the target node first also trying to
mm/vmscan.c static void folio_check_dirty_writeback(struct folio *folio, · line 1483
Quoted 10 lines
mm/vmscan.c +10
-0+* reclaim pages from the target node via kswapd if we are low on +* free memory on target node. If we don't do this and if we have low +* free memory on the target memtier, we would start allocating pages +* from higher memory tiers without even forcing a demotion of cold +* pages from the target memtier. This can result in the kernel placing +* hotpages in higher memory tiers. +*/ + mtc->nmask =NULL ; + mtc->gfp_mask |= __GFP_THISNODE; + target_page =alloc_migration_target (page, (unsigned long )&mtc);
I finally managed to get a system setup to start testing some of this out. However it quickly crashed due to the bad pointer in the above call
- you need mtc not &mtc here.
mm/vmscan.c static void folio_check_dirty_writeback(struct folio *folio, · line 1490
Quoted 7 lines
mm/vmscan.c +5
-0+if (target_page) +return target_page; + + mtc->gfp_mask &= ~__GFP_THISNODE; + mtc->nmask = allowed_mask;return alloc_migration_target (page, (unsigned long )&mtc);
And here.
Quoted 36 lines
}
mm/vmscan.c +17
-2@@ -1487,6 +1500,19 @@ static unsigned int demote_page_list(struct list_head *demote_pages, {int target_nid =next_demotion_node (pgdat->node_id);unsigned int nr_succeeded; +nodemask_t allowed_mask; + +struct migration_target_control mtc = { +/* +* Allocate from 'node', or fail quickly and quietly. +* When this happens, 'page' will likely just be discarded +* instead of migrated. +*/ + .gfp_mask = (GFP_HIGHUSER_MOVABLE & ~__GFP_RECLAIM) | __GFP_NOWARN | + __GFP_NOMEMALLOC |GFP_NOWAIT , + .nid = target_nid, + .nmask = &allowed_mask + };if (list_empty (demote_pages))return 0 ;@@ -1494,10 +1520,12 @@ static unsigned int demote_page_list(struct list_head *demote_pages,if (target_nid ==NUMA_NO_NODE )return 0 ; +node_get_allowed_targets (pgdat, &allowed_mask); +/* Demotion ignores all cpuset and mempolicy settings */ migrate_pages (demote_pages, alloc_demote_page,NULL , - target_nid,MIGRATE_ASYNC ,MR_DEMOTION , - &nr_succeeded); + (unsigned long )&mtc,MIGRATE_ASYNC ,MR_DEMOTION , + &nr_succeeded);if (current_is_kswapd ())__count_vm_events (PGDEMOTE_KSWAPD , nr_succeeded);
Re: [PATCH v7 09/12] mm/demotion: Demote pages according to allocation fallback order
Quoted 35 lines · Alistair Popple
Quoted 1 line · Aneesh Kumar K.V
From: Jagdish Gediya <[email protected]>
[...]
Quoted 29 lines
mm/vmscan.c +16
-12-static struct page *alloc_demote_page (struct page *page,unsigned long node) +static struct page *alloc_demote_page (struct page *page,unsigned long private) { -struct migration_target_control mtc = { -/* -* Allocate from 'node', or fail quickly and quietly. -* When this happens, 'page' will likely just be discarded -* instead of migrated. -*/ - .gfp_mask = (GFP_HIGHUSER_MOVABLE & ~__GFP_RECLAIM) | - __GFP_THISNODE | __GFP_NOWARN | - __GFP_NOMEMALLOC |GFP_NOWAIT , - .nid = node - }; +struct page *target_page; +nodemask_t *allowed_mask; +struct migration_target_control *mtc; + + mtc = (struct migration_target_control *)private; + + allowed_mask = mtc->nmask; +/* +* make sure we allocate from the target node first also trying to +* reclaim pages from the target node via kswapd if we are low on +* free memory on target node. If we don't do this and if we have low +* free memory on the target memtier, we would start allocating pages +* from higher memory tiers without even forcing a demotion of cold +* pages from the target memtier. This can result in the kernel placing +* hotpages in higher memory tiers.
Quoted 8 lines
mm/vmscan.c static void folio_check_dirty_writeback(struct folio *folio, · line 1483
Quoted 4 lines
mm/vmscan.c +4
-0+*/ + mtc->nmask =NULL ; + mtc->gfp_mask |= __GFP_THISNODE; + target_page =alloc_migration_target (page, (unsigned long )&mtc);I finally managed to get a system setup to start testing some of this out. However it quickly crashed due to the bad pointer in the above call
- you need mtc not &mtc here.
I remember fixing that during earlier testing. I guess I missed to copy the change from test to my development. Thanks for testing this. I have now also tested the complete series with the above-suggested changes and did make sure we are indeed doing demotion by looking at /proc/vmstat:pgdemote_kswapd/pgdemote_direct
Quoted 11 lines
mm/vmscan.c static void folio_check_dirty_writeback(struct folio *folio, · line 1490
Quoted 8 lines
mm/vmscan.c +5
-0+if (target_page) +return target_page; + + mtc->gfp_mask &= ~__GFP_THISNODE; + mtc->nmask = allowed_mask;return alloc_migration_target (page, (unsigned long )&mtc);And here.
I will fold this changes in and send a v8 after waiting for review feedback from others.
-aneesh
Alistair Popple
reviewerRe: [PATCH v7 09/12] mm/demotion: Demote pages according to allocation fallback order
Quoted 46 lines · Aneesh Kumar K.V
Quoted 35 lines · Alistair Popple
Quoted 1 line · Aneesh Kumar K.V
From: Jagdish Gediya <[email protected]>
[...]
Quoted 29 lines
mm/vmscan.c +16
-12-static struct page *alloc_demote_page (struct page *page,unsigned long node) +static struct page *alloc_demote_page (struct page *page,unsigned long private) { -struct migration_target_control mtc = { -/* -* Allocate from 'node', or fail quickly and quietly. -* When this happens, 'page' will likely just be discarded -* instead of migrated. -*/ - .gfp_mask = (GFP_HIGHUSER_MOVABLE & ~__GFP_RECLAIM) | - __GFP_THISNODE | __GFP_NOWARN | - __GFP_NOMEMALLOC |GFP_NOWAIT , - .nid = node - }; +struct page *target_page; +nodemask_t *allowed_mask; +struct migration_target_control *mtc; + + mtc = (struct migration_target_control *)private; + + allowed_mask = mtc->nmask; +/* +* make sure we allocate from the target node first also trying to +* reclaim pages from the target node via kswapd if we are low on +* free memory on target node. If we don't do this and if we have low +* free memory on the target memtier, we would start allocating pages +* from higher memory tiers without even forcing a demotion of cold +* pages from the target memtier. This can result in the kernel placing +* hotpages in higher memory tiers. Quoted 8 lines
mm/vmscan.c static void folio_check_dirty_writeback(struct folio *folio, · line 1483
Quoted 4 lines
mm/vmscan.c +4
-0+*/ + mtc->nmask =NULL ; + mtc->gfp_mask |= __GFP_THISNODE; + target_page =alloc_migration_target (page, (unsigned long )&mtc);I finally managed to get a system setup to start testing some of this out. However it quickly crashed due to the bad pointer in the above call
- you need mtc not &mtc here.
Quoted 5 lines
I remember fixing that during earlier testing. I guess I missed to copy the change from test to my development. Thanks for testing this. I have now also tested the complete series with the above-suggested changes and did make sure we are indeed doing demotion by looking at /proc/vmstat:pgdemote_kswapd/pgdemote_direct
No worries. I'm still testing but the early results are looking really promising for some of our use cases so thanks for picking up this work.
- Alistair
Quoted 16 lines
Quoted 11 lines
mm/vmscan.c static void folio_check_dirty_writeback(struct folio *folio, · line 1490
Quoted 8 lines
mm/vmscan.c +5
-0+if (target_page) +return target_page; + + mtc->gfp_mask &= ~__GFP_THISNODE; + mtc->nmask = allowed_mask;return alloc_migration_target (page, (unsigned long )&mtc);And here.
I will fold this changes in and send a v8 after waiting for review feedback from others.
-aneesh
PATCH v7 10/12 mm/demotion: Update node_is_toptier to work with memory tiers
In reply to Aneesh Kumar K.VWith memory tiers support we can have memory only NUMA nodes in the top tier from which we want to avoid promotion tracking NUMA faults. Update node_is_toptier to work with memory tiers. All NUMA nodes are by default top tier nodes. With lower memory tiers added we consider all memory tiers above a memory tier having CPU NUMA nodes as a top memory tier
--- include/linux/memory-tiers.h | 6 ++++++ include/linux/node.h | 5 ----- mm/huge_memory.c | 1 + mm/memory-tiers.c | 41 ++++++++++++++++++++++++++++++++++++ mm/migrate.c | 1 + mm/mprotect.c | 1 + 6 files changed, 50 insertions(+), 5 deletions(-)
include/linux/memory-tiers.h +6 -0
@@ -44,6 +44,7 @@ int node_get_memory_tier_id(int node);int node_update_memory_tier (int node,int tier);struct memory_tier *node_get_memory_tier (int node);void node_put_memory_tier (struct memory_tier *memtier); +bool node_is_toptier (int node);#else
@@ -62,5 +63,10 @@ static inline void node_get_allowed_targets(pg_data_t *pgdat, nodemask_t *target { *targets =NODE_MASK_NONE ; } + +static inline bool node_is_toptier (int node) +{ +return true; +}#endif /* CONFIG_NUMA */ #endif /* _LINUX_MEMORY_TIERS_H */
include/linux/node.h +0 -5
@@ -185,9 +185,4 @@ static inline void register_hugetlbfs_with_node(node_registration_func_t reg,#define to_node (device) container_of(device, struct node, dev) -static inline bool node_is_toptier (int node) -{ -return node_state (node,N_CPU ); -} -#endif /* _LINUX_NODE_H_ */
mm/huge_memory.c +1 -0
@@ -35,6 +35,7 @@#include <linux/numa.h> #include <linux/page_owner.h> #include <linux/sched/sysctl.h> +#include <linux/memory-tiers.h> #include <asm/tlb.h> #include <asm/pgalloc.h>
mm/memory-tiers.c +41 -0
59 lines not on this page · raw message
mm/migrate.c +1 -0
@@ -50,6 +50,7 @@#include <linux/memory.h> #include <linux/random.h> #include <linux/sched/sysctl.h> +#include <linux/memory-tiers.h> #include <asm/tlbflush.h>
mm/mprotect.c +1 -0
@@ -31,6 +31,7 @@#include <linux/pgtable.h> #include <linux/sched/sysctl.h> #include <linux/userfaultfd_k.h> +#include <linux/memory-tiers.h> #include <asm/cacheflush.h> #include <asm/mmu_context.h> #include <asm/tlbflush.h>
Signature · 1 line
2.36.1
PATCH v7 11/12 mm/demotion: Add documentation for memory tiering
In reply to Aneesh Kumar K.VFrom: Jagdish Gediya <[email protected]>
All N_MEMORY nodes are divided into 3 memoty tiers with tier ID value MEMORY_TIER_HBM_GPU, MEMORY_TIER_DRAM and MEMORY_TIER_PMEM. By default, all nodes are assigned to default memory tier.
Demotion path for all N_MEMORY nodes is prepared based on the tier ID value of memory tiers.
This patch adds documention for memory tiering introduction, its sysfs interfaces and how demotion is performed based on memory tiers.
--- Documentation/admin-guide/mm/index.rst | 1 + .../admin-guide/mm/memory-tiering.rst | 182 ++++++++++++++++++ 2 files changed, 183 insertions(+) create mode 100644 Documentation/admin-guide/mm/memory-tiering.rst
Documentation/admin-guide/mm/index.rst +1 -0
@@ -32,6 +32,7 @@ the Linux memory management. idle_page_tracking ksm memory-hotplug + memory-tiering nommu-mmap numa_memory_policy numaperf
Documentation/admin-guide/mm/memory-tiering.rst new file +182 -0
182 lines not on this page · raw message
Signature · 1 line
2.36.1
kernel test robot
build botRe: [PATCH v7 11/12] mm/demotion: Add documentation for memory tiering
Thank you for the patch! Yet something to improve:
Hi "Aneesh,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on akpm-mm/mm-everything]
url: https://github.com/intel-lab-lkp/linux/commits/Aneesh-Kumar-K-V/mm-demotion-Memory-tiers-and-demotion/20220622-163031 base: https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git mm-everything reproduce: make htmldocs
If you fix the issue, kindly add following tag where applicable
All errors (new ones prefixed by >>):
>> Documentation/admin-guide/mm/memory-tiering.rst:5: (SEVERE/4) Title overline & underline mismatch.
vim +5 Documentation/admin-guide/mm/memory-tiering.rst
4
> 5 ===========
6 Memory tiers
7 ============
8 Signature · 2 lines
0-DAY CI Kernel Test Service https://01.org/lkp
Re: [PATCH v7 11/12] mm/demotion: Add documentation for memory tiering
Quoted 7 lines · kernel test robot
If you fix the issue, kindly add following tag where applicable
Reported-by kernel test robot <[email protected]>All errors (new ones prefixed by >>):
Quoted 1 line
Quoted 1 line
Documentation/admin-guide/mm/memory-tiering.rst:5: (SEVERE/4) Title overline & underline mismatch.
Quoted 8 lines
vim +5
Documentation/admin-guide/mm/memory-tiering.rst4Quoted 1 line
5 ===========
6 Memory tiers 7 ============ 8
Here is the fixup. Thanks.
---- >8 ----
Quoted 1 line
From
ee8b97451b6ad1869f4d426e2d3825ac20a6e15dMon Sep 17 00:00:00 2001
From: Bagas Sanjaya <[email protected]>
Date: Sat, 25 Jun 2022 09:48:28 +0700
Subject: [PATCH] fixup for "mm/demotion: Add documentation for memory tiering"
Extend the title heading overline by one (=) to match the underline.
--- Documentation/admin-guide/mm/memory-tiering.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
Documentation/admin-guide/mm/memory-tiering.rst +1 -1
@@ -2,7 +2,7 @@ .. _admin_guide_memory_tiering: -=========== +============ Memory tiers ============
Signature · 1 line
An old man doll... just what I always wanted! - Clara
Re: [PATCH v7 11/12] mm/demotion: Add documentation for memory tiering
In reply to Aneesh Kumar K.VQuoted 2 lines · Aneesh Kumar K.V
From: Jagdish Gediya <[email protected]>
Hi Aneesh and Jagdish,
The documentation can be improved, see below.
Quoted 10 lines
All
N_MEMORYnodes are divided into 3 memoty tiers with tier ID valueMEMORY_TIER_HBM_GPU,MEMORY_TIER_DRAMandMEMORY_TIER_PMEM. By default, all nodes are assigned to default memory tier.Demotion path for all
N_MEMORYnodes is prepared based on the tier ID value of memory tiers.This patch adds documention for memory tiering introduction, its sysfs interfaces and how demotion is performed based on memory tiers.
I think the patch message should just be:
"Add documentation for memory tiering. It also covers its sysfs interfaces and how demotion is performed based on memory tiers."
Review
Quoted 7 lines
+===========
(quoted diff) +6
-0+Memory tiers +============ + +This document describes explicit memory tiering support along with +demotion based on memory tiers. +
This causes htmldocs error, for which I have applied the fixup at [1].
Review
Quoted 8 lines
(quoted diff) +8
-0+Memory nodes are divided into 3 types of memory tiers with tier ID +value as shown based on their hardware characteristics. + + +MEMORY_TIER_HBM_GPU +MEMORY_TIER_DRAM +MEMORY_TIER_PMEM +
Use bullet list.
Review
Quoted 7 lines
(quoted diff) +7
-0+Sysfs interfaces +================ + +Nodes belonging to specific tier can be read from, +/sys/devices/system/memtier/memtierN/nodelist (Read-Only) + +Where N is 0 - 2.
The "where" sentence can be compounded into the previous sentence above.
Review
Quoted 12 lines
(quoted diff) +12
-0+ +Example 1: +For a system where Node 0 is CPU + DRAM nodes, Node 1 is HBM node, +node 2 is a PMEM node an ideal tier layout will be + +$ cat /sys/devices/system/memtier/memtier0/nodelist +1 +$ cat /sys/devices/system/memtier/memtier1/nodelist +0 +$ cat /sys/devices/system/memtier/memtier2/nodelist +2 +
The code snippets should have been inside literal code blocks.
Review
Quoted 12 lines
(quoted diff) +12
-0+Example 2: +For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM +nodes. + +$ cat /sys/devices/system/memtier/memtier0/nodelist +cat: /sys/devices/system/memtier/memtier0/nodelist: No such file or +directory +$ cat /sys/devices/system/memtier/memtier1/nodelist +0-1 +$ cat /sys/devices/system/memtier/memtier2/nodelist +2-3 +
Use literal code block.
Quoted 21 lines
(quoted diff) +21
-0+Default memory tier can be read from, +/sys/devices/system/memtier/default_tier (Read-Only) + +e.g. +$ cat /sys/devices/system/memtier/default_tier +memtier200 + +Max memory tier ID supported can be read from, +/sys/devices/system/memtier/max_tier (Read-Only) + +e.g. +$ cat /sys/devices/system/memtier/max_tier +400 + +Individual node's memory tier can be read of set using, +/sys/devices/system/node/nodeN/memtier (Read-Write) + +where N = node id + +When this interface is written, Node is moved from the old memory tier +to new memory tier and demotion targets for all N_MEMORY nodes are
Review
Quoted 10 lines
(quoted diff) +10
-0+built again. + +For example 1 mentioned above, +$ cat /sys/devices/system/node/node0/memtier +1 +$ cat /sys/devices/system/node/node1/memtier +0 +$ cat /sys/devices/system/node/node2/memtier +2 +
The same suggestions above apply here, too.
Review
Quoted 8 lines
(quoted diff) +8
-0+Enable/Disable demotion +----------------------- + +By default demotion is disabled, it can be enabled/disabled using +below sysfs interface, + +$ echo 0/1 or false/true > /sys/kernel/mm/numa/demotion_enabled +
Use literal code block.
Quoted 10 lines
(quoted diff) +10
-0+preferred and allowed demotion nodes +------------------------------------ + +Preferred nodes for a specific N_MEMORY node are the best nodes +from the next possible lower memory tier. Allowed nodes for any +node are all the nodes available in all possible lower memory +tiers. + +Example: +
Review
Quoted 10 lines
(quoted diff) +10
-0+For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM +nodes, + +node distances: +node 0 1 2 3 + 0 10 20 30 40 + 1 20 10 40 30 + 2 30 40 10 40 + 3 40 30 40 10 +
Use reST table.
Review
Quoted 13 lines
(quoted diff) +13
-0+memory_tiers[0] = <empty> +memory_tiers[1] = 0-1 +memory_tiers[2] = 2-3 + +node_demotion[0].preferred = 2 +node_demotion[0].allowed = 2, 3 +node_demotion[1].preferred = 3 +node_demotion[1].allowed = 3, 2 +node_demotion[2].preferred = <empty> +node_demotion[2].allowed = <empty> +node_demotion[3].preferred = <empty> +node_demotion[3].allowed = <empty> +
What are these above? Node properties? BTW, use literal code block.
If you don't understand these suggestions above, here is the diff:
---- >8 ----
Documentation/admin-guide/mm/memory-tiering.rst +91 -81
@@ -14,13 +14,13 @@ Introduction Many systems have multiple types of memory devices e.g. GPU, DRAM and PMEM. The memory subsystem of these systems can be called a memory -tiering system because the performance of the different types of +tiering system because the performance of each type of memory is different. Memory tiers are defined based on the hardware capabilities of memory nodes. Each memory tier is assigned a tier ID value that determines the memory tier position in demotion order. The memory tier assignment of each node is independent of each -other. Moving a node from one tier to another tier doesn't affect +other. Moving a node from one tier to another doesn't affect the tier assignment of any other node. Memory tiers are used to build the demotion targets for nodes. A node
@@ -32,10 +32,9 @@ Memory tier rank Memory nodes are divided into 3 types of memory tiers with tier ID value as shown based on their hardware characteristics. - -MEMORY_TIER_HBM_GPU -MEMORY_TIER_DRAM -MEMORY_TIER_PMEM + * MEMORY_TIER_HBM_GPU + * MEMORY_TIER_DRAM + * MEMORY_TIER_PMEM Memory tiers initialization and (re)assignments ===============================================
@@ -49,68 +48,73 @@ hotplug, the memory tier with default tier ID is assigned to the memory node. Sysfs interfaces ================ -Nodes belonging to specific tier can be read from, -/sys/devices/system/memtier/memtierN/nodelist (Read-Only) +Nodes belonging to specific tier can be read from +/sys/devices/system/memtier/memtierN/nodelist, where N is 0 - 2 (read-only) -Where N is 0 - 2. +Examples: -Example 1: -For a system where Node 0 is CPU + DRAM nodes, Node 1 is HBM node, -node 2 is a PMEM node an ideal tier layout will be +1. On a system where Node 0 is CPU + DRAM nodes, Node 1 is HBM node, + node 2 is a PMEM node an ideal tier layout will be: -$ cat /sys/devices/system/memtier/memtier0/nodelist -1 -$ cat /sys/devices/system/memtier/memtier1/nodelist -0 -$ cat /sys/devices/system/memtier/memtier2/nodelist -2 + .. code-block:: -Example 2: -For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM -nodes. + $ cat /sys/devices/system/memtier/memtier0/nodelist + 1 + $ cat /sys/devices/system/memtier/memtier1/nodelist + 0 + $ cat /sys/devices/system/memtier/memtier2/nodelist + 2 -$ cat /sys/devices/system/memtier/memtier0/nodelist -cat: /sys/devices/system/memtier/memtier0/nodelist: No such file or -directory -$ cat /sys/devices/system/memtier/memtier1/nodelist -0-1 -$ cat /sys/devices/system/memtier/memtier2/nodelist -2-3 +2. On a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM + nodes: -Default memory tier can be read from, -/sys/devices/system/memtier/default_tier (Read-Only) + .. code-block:: -e.g. -$ cat /sys/devices/system/memtier/default_tier -memtier200 + $ cat /sys/devices/system/memtier/memtier0/nodelist + cat: /sys/devices/system/memtier/memtier0/nodelist: No such file or + directory + $ cat /sys/devices/system/memtier/memtier1/nodelist + 0-1 + $ cat /sys/devices/system/memtier/memtier2/nodelist + 2-3 -Max memory tier ID supported can be read from, -/sys/devices/system/memtier/max_tier (Read-Only) +Default memory tier can be read from +/sys/devices/system/memtier/default_tier (read-only), e.g.: -e.g. -$ cat /sys/devices/system/memtier/max_tier -400 +.. code-block:: -Individual node's memory tier can be read of set using, -/sys/devices/system/node/nodeN/memtier (Read-Write) + $ cat /sys/devices/system/memtier/default_tier + memtier200 -where N = node id +Max memory tier ID supported can be read from +/sys/devices/system/memtier/max_tier (read-only), e.g.: -When this interface is written, Node is moved from the old memory tier +.. code-block:: + + $ cat /sys/devices/system/memtier/max_tier + 400 + +Individual node's memory tier can be read or set using +/sys/devices/system/node/nodeN/memtier (read-write), where N = node id. + +When this interface is written, node is moved from the old memory tier to new memory tier and demotion targets for all N_MEMORY nodes are built again. -For example 1 mentioned above, -$ cat /sys/devices/system/node/node0/memtier -1 -$ cat /sys/devices/system/node/node1/memtier -0 -$ cat /sys/devices/system/node/node2/memtier -2 +For example 1 mentioned above: + +.. code-block:: + + $ cat /sys/devices/system/node/node0/memtier + 1 + $ cat /sys/devices/system/node/node1/memtier + 0 + $ cat /sys/devices/system/node/node2/memtier + 2 Additional memory tiers can be created by writing a tier ID value to this file. -This results in a new memory tier creation and moving the specific NUMA node to -that memory tier. +This results into creating a new tier and moving the specific NUMA node to +that tier. Demotion ========
@@ -128,19 +132,20 @@ be used. Instead of a page being discarded during reclaim, it can be moved to persistent memory. Allowing page migration during reclaim enables -these systems to migrate pages from fast(higher) tiers to slow(lower) -tiers when the fast(higher) tier is under pressure. +these systems to migrate pages from fast (higher) tiers to slow (lower) +tiers when the fast (higher) tier is under pressure. Enable/Disable demotion ----------------------- -By default demotion is disabled, it can be enabled/disabled using -below sysfs interface, +By default demotion is disabled. It can be toggled by: -$ echo 0/1 or false/true > /sys/kernel/mm/numa/demotion_enabled +.. code-block:: -preferred and allowed demotion nodes + $ echo 0/1 or false/true > /sys/kernel/mm/numa/demotion_enabled + +Preferred and allowed demotion nodes ------------------------------------ Preferred nodes for a specific N_MEMORY node are the best nodes
@@ -148,35 +153,40 @@ from the next possible lower memory tier. Allowed nodes for any node are all the nodes available in all possible lower memory tiers. -Example: +For example, on a system where Node 0 & 1 are CPU + DRAM nodes, +node 2 & 3 are PMEM nodes: -For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM -nodes, + * node distances -node distances: -node 0 1 2 3 - 0 10 20 30 40 - 1 20 10 40 30 - 2 30 40 10 40 - 3 40 30 40 10 + ==== == == == == + node 0 1 2 3 + ==== == == == == + 0 10 20 30 40 + 1 20 10 40 30 + 2 30 40 10 40 + 3 40 30 40 10 + ==== == == == == -memory_tiers[0] = <empty> -memory_tiers[1] = 0-1 -memory_tiers[2] = 2-3 + * node properties -node_demotion[0].preferred = 2 -node_demotion[0].allowed = 2, 3 -node_demotion[1].preferred = 3 -node_demotion[1].allowed = 3, 2 -node_demotion[2].preferred = <empty> -node_demotion[2].allowed = <empty> -node_demotion[3].preferred = <empty> -node_demotion[3].allowed = <empty> + .. code-block:: + + memory_tiers[0] = <empty> + memory_tiers[1] = 0-1 + memory_tiers[2] = 2-3 + + node_demotion[0].preferred = 2 + node_demotion[0].allowed = 2, 3 + node_demotion[1].preferred = 3 + node_demotion[1].allowed = 3, 2 + node_demotion[2].preferred = <empty> + node_demotion[2].allowed = <empty> + node_demotion[3].preferred = <empty> + node_demotion[3].allowed = <empty> Memory allocation for demotion ------------------------------ -If a page needs to be demoted from any node, the kernel 1st tries -to allocate a new page from the node's preferred node and fallbacks to -node's allowed targets in allocation fallback order. - +If a page needs to be demoted from any node, the kernel first tries +to allocate a new page from the node's preferred target node and fallbacks +to node's allowed targets in allocation fallback order.
Thanks.
[1]: https://lore.kernel.org/linux-doc/[email protected]/
Signature · 1 line
An old man doll... just what I always wanted! - Clara
Re: [PATCH v7 11/12] mm/demotion: Add documentation for memory tiering
Quoted 168 lines · Bagas Sanjaya
Quoted 2 lines · Aneesh Kumar K.V
From: Jagdish Gediya <[email protected]>
Hi Aneesh and Jagdish,
The documentation can be improved, see below.
Quoted 10 lines
All
N_MEMORYnodes are divided into 3 memoty tiers with tier ID valueMEMORY_TIER_HBM_GPU,MEMORY_TIER_DRAMandMEMORY_TIER_PMEM. By default, all nodes are assigned to default memory tier.Demotion path for all
N_MEMORYnodes is prepared based on the tier ID value of memory tiers.This patch adds documention for memory tiering introduction, its sysfs interfaces and how demotion is performed based on memory tiers.
I think the patch message should just be:
"Add documentation for memory tiering. It also covers its sysfs interfaces and how demotion is performed based on memory tiers."Review
Quoted 7 lines
+===========
(quoted diff) +6
-0+Memory tiers +============ + +This document describes explicit memory tiering support along with +demotion based on memory tiers. +This causes htmldocs error, for which I have applied the fixup at [1].
Review
Quoted 8 lines
(quoted diff) +8
-0+Memory nodes are divided into 3 types of memory tiers with tier ID +value as shown based on their hardware characteristics. + + +MEMORY_TIER_HBM_GPU +MEMORY_TIER_DRAM +MEMORY_TIER_PMEM +Use bullet list.
Review
Quoted 7 lines
(quoted diff) +7
-0+Sysfs interfaces +================ + +Nodes belonging to specific tier can be read from, +/sys/devices/system/memtier/memtierN/nodelist (Read-Only) + +Where N is 0 - 2.The "where" sentence can be compounded into the previous sentence above.
Documentation/admin-guide/mm/memory-tiering.rst hotplug, the memory tier with default tier ID is assigned to the memory node. · line 93
Quoted 12 lines
Documentation/admin-guide/mm/memory-tiering.rst +12
-0+ +Example 1: +For a system where Node 0 is CPU + DRAM nodes, Node 1 is HBM node, +node 2 is a PMEM node an ideal tier layout will be + +$ cat /sys/devices/system/memtier/memtier0/nodelist +1 +$ cat /sys/devices/system/memtier/memtier1/nodelist +0 +$ cat /sys/devices/system/memtier/memtier2/nodelist +2 +The code snippets should have been inside literal code blocks.
Documentation/admin-guide/mm/memory-tiering.rst hotplug, the memory tier with default tier ID is assigned to the memory node. · line 93
Quoted 12 lines
Documentation/admin-guide/mm/memory-tiering.rst +12
-0+Example 2: +For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM +nodes. + +$ cat /sys/devices/system/memtier/memtier0/nodelist +cat: /sys/devices/system/memtier/memtier0/nodelist: No such file or +directory +$ cat /sys/devices/system/memtier/memtier1/nodelist +0-1 +$ cat /sys/devices/system/memtier/memtier2/nodelist +2-3 +Use literal code block.
Quoted 21 lines
(quoted diff) +21
-0+Default memory tier can be read from, +/sys/devices/system/memtier/default_tier (Read-Only) + +e.g. +$ cat /sys/devices/system/memtier/default_tier +memtier200 + +Max memory tier ID supported can be read from, +/sys/devices/system/memtier/max_tier (Read-Only) + +e.g. +$ cat /sys/devices/system/memtier/max_tier +400 + +Individual node's memory tier can be read of set using, +/sys/devices/system/node/nodeN/memtier (Read-Write) + +where N = node id + +When this interface is written, Node is moved from the old memory tier +to new memory tier and demotion targets for all N_MEMORY nodes areReview
Quoted 10 lines
(quoted diff) +10
-0+built again. + +For example 1 mentioned above, +$ cat /sys/devices/system/node/node0/memtier +1 +$ cat /sys/devices/system/node/node1/memtier +0 +$ cat /sys/devices/system/node/node2/memtier +2 +The same suggestions above apply here, too.
Review
Quoted 8 lines
(quoted diff) +8
-0+Enable/Disable demotion +----------------------- + +By default demotion is disabled, it can be enabled/disabled using +below sysfs interface, + +$ echo 0/1 or false/true > /sys/kernel/mm/numa/demotion_enabled +Use literal code block.
Quoted 10 lines
(quoted diff) +10
-0+preferred and allowed demotion nodes +------------------------------------ + +Preferred nodes for a specific N_MEMORY node are the best nodes +from the next possible lower memory tier. Allowed nodes for any +node are all the nodes available in all possible lower memory +tiers. + +Example: +Review
Quoted 10 lines
(quoted diff) +10
-0+For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM +nodes, + +node distances: +node 0 1 2 3 + 0 10 20 30 40 + 1 20 10 40 30 + 2 30 40 10 40 + 3 40 30 40 10 +Use reST table.
Documentation/admin-guide/mm/memory-tiering.rst from the next possible lower memory tier. Allowed nodes for any
Quoted 13 lines
Documentation/admin-guide/mm/memory-tiering.rst +13
-0+memory_tiers[0] = <empty> +memory_tiers[1] = 0-1 +memory_tiers[2] = 2-3 + +node_demotion[0].preferred = 2 +node_demotion[0].allowed = 2, 3 +node_demotion[1].preferred = 3 +node_demotion[1].allowed = 3, 2 +node_demotion[2].preferred = <empty> +node_demotion[2].allowed = <empty> +node_demotion[3].preferred = <empty> +node_demotion[3].allowed = <empty> +What are these above? Node properties? BTW, use literal code block.
Quoted 1 line
If you don't understand these suggestions above, here is the diff:
I got with the below diff.
patch: **** malformed patch at line 180: @@ -148,35 +153,40 @@ from the next possible lower memory tier. Allowed nodes for any
But I did modify the documentation based on your feedback and it is much better than what I had. Thanks for the review. I will send v8 with the changes folded. I did add the below to commit message. Hope that is ok.
[update doc format by Bagas Sanjaya <[email protected]>]
Quoted 256 lines
---- >8 ----
Documentation/admin-guide/mm/memory-tiering.rst +91
-81@@ -14,13 +14,13 @@ Introduction Many systems have multiple types of memory devices e.g. GPU, DRAM and PMEM. The memory subsystem of these systems can be called a memory -tiering system because the performance of the different types of +tiering system because the performance of each type of memory is different. Memory tiers are defined based on the hardware capabilities of memory nodes. Each memory tier is assigned a tier ID value that determines the memory tier position in demotion order. The memory tier assignment of each node is independent of each -other. Moving a node from one tier to another tier doesn't affect +other. Moving a node from one tier to another doesn't affect the tier assignment of any other node. Memory tiers are used to build the demotion targets for nodes. A node@@ -32,10 +32,9 @@ Memory tier rank Memory nodes are divided into 3 types of memory tiers with tier ID value as shown based on their hardware characteristics. - -MEMORY_TIER_HBM_GPU -MEMORY_TIER_DRAM -MEMORY_TIER_PMEM + * MEMORY_TIER_HBM_GPU + * MEMORY_TIER_DRAM + * MEMORY_TIER_PMEM Memory tiers initialization and (re)assignments ===============================================@@ -49,68 +48,73 @@ hotplug, the memory tier with default tier ID is assigned to the memory node. Sysfs interfaces ================ -Nodes belonging to specific tier can be read from, -/sys/devices/system/memtier/memtierN/nodelist (Read-Only) +Nodes belonging to specific tier can be read from +/sys/devices/system/memtier/memtierN/nodelist, where N is 0 - 2 (read-only) -Where N is 0 - 2. +Examples: -Example 1: -For a system where Node 0 is CPU + DRAM nodes, Node 1 is HBM node, -node 2 is a PMEM node an ideal tier layout will be +1. On a system where Node 0 is CPU + DRAM nodes, Node 1 is HBM node, + node 2 is a PMEM node an ideal tier layout will be: -$ cat /sys/devices/system/memtier/memtier0/nodelist -1 -$ cat /sys/devices/system/memtier/memtier1/nodelist -0 -$ cat /sys/devices/system/memtier/memtier2/nodelist -2 + .. code-block:: -Example 2: -For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM -nodes. + $ cat /sys/devices/system/memtier/memtier0/nodelist + 1 + $ cat /sys/devices/system/memtier/memtier1/nodelist + 0 + $ cat /sys/devices/system/memtier/memtier2/nodelist + 2 -$ cat /sys/devices/system/memtier/memtier0/nodelist -cat: /sys/devices/system/memtier/memtier0/nodelist: No such file or -directory -$ cat /sys/devices/system/memtier/memtier1/nodelist -0-1 -$ cat /sys/devices/system/memtier/memtier2/nodelist -2-3 +2. On a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM + nodes: -Default memory tier can be read from, -/sys/devices/system/memtier/default_tier (Read-Only) + .. code-block:: -e.g. -$ cat /sys/devices/system/memtier/default_tier -memtier200 + $ cat /sys/devices/system/memtier/memtier0/nodelist + cat: /sys/devices/system/memtier/memtier0/nodelist: No such file or + directory + $ cat /sys/devices/system/memtier/memtier1/nodelist + 0-1 + $ cat /sys/devices/system/memtier/memtier2/nodelist + 2-3 -Max memory tier ID supported can be read from, -/sys/devices/system/memtier/max_tier (Read-Only) +Default memory tier can be read from +/sys/devices/system/memtier/default_tier (read-only), e.g.: -e.g. -$ cat /sys/devices/system/memtier/max_tier -400 +.. code-block:: -Individual node's memory tier can be read of set using, -/sys/devices/system/node/nodeN/memtier (Read-Write) + $ cat /sys/devices/system/memtier/default_tier + memtier200 -where N = node id +Max memory tier ID supported can be read from +/sys/devices/system/memtier/max_tier (read-only), e.g.: -When this interface is written, Node is moved from the old memory tier +.. code-block:: + + $ cat /sys/devices/system/memtier/max_tier + 400 + +Individual node's memory tier can be read or set using +/sys/devices/system/node/nodeN/memtier (read-write), where N = node id. + +When this interface is written, node is moved from the old memory tier to new memory tier and demotion targets for all N_MEMORY nodes are built again. -For example 1 mentioned above, -$ cat /sys/devices/system/node/node0/memtier -1 -$ cat /sys/devices/system/node/node1/memtier -0 -$ cat /sys/devices/system/node/node2/memtier -2 +For example 1 mentioned above: + +.. code-block:: + + $ cat /sys/devices/system/node/node0/memtier + 1 + $ cat /sys/devices/system/node/node1/memtier + 0 + $ cat /sys/devices/system/node/node2/memtier + 2 Additional memory tiers can be created by writing a tier ID value to this file. -This results in a new memory tier creation and moving the specific NUMA node to -that memory tier. +This results into creating a new tier and moving the specific NUMA node to +that tier. Demotion ========@@ -128,19 +132,20 @@ be used. Instead of a page being discarded during reclaim, it can be moved to persistent memory. Allowing page migration during reclaim enables -these systems to migrate pages from fast(higher) tiers to slow(lower) -tiers when the fast(higher) tier is under pressure. +these systems to migrate pages from fast (higher) tiers to slow (lower) +tiers when the fast (higher) tier is under pressure. Enable/Disable demotion ----------------------- -By default demotion is disabled, it can be enabled/disabled using -below sysfs interface, +By default demotion is disabled. It can be toggled by: -$ echo 0/1 or false/true > /sys/kernel/mm/numa/demotion_enabled +.. code-block:: -preferred and allowed demotion nodes + $ echo 0/1 or false/true > /sys/kernel/mm/numa/demotion_enabled + +Preferred and allowed demotion nodes ------------------------------------ Preferred nodes for a specific N_MEMORY node are the best nodes@@ -148,35 +153,40 @@ from the next possible lower memory tier. Allowed nodes for any node are all the nodes available in all possible lower memory tiers. -Example: +For example, on a system where Node 0 & 1 are CPU + DRAM nodes, +node 2 & 3 are PMEM nodes: -For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM -nodes, + * node distances -node distances: -node 0 1 2 3 - 0 10 20 30 40 - 1 20 10 40 30 - 2 30 40 10 40 - 3 40 30 40 10 + ==== == == == == + node 0 1 2 3 + ==== == == == == + 0 10 20 30 40 + 1 20 10 40 30 + 2 30 40 10 40 + 3 40 30 40 10 + ==== == == == == -memory_tiers[0] = <empty> -memory_tiers[1] = 0-1 -memory_tiers[2] = 2-3 + * node properties -node_demotion[0].preferred = 2 -node_demotion[0].allowed = 2, 3 -node_demotion[1].preferred = 3 -node_demotion[1].allowed = 3, 2 -node_demotion[2].preferred = <empty> -node_demotion[2].allowed = <empty> -node_demotion[3].preferred = <empty> -node_demotion[3].allowed = <empty> + .. code-block:: + + memory_tiers[0] = <empty> + memory_tiers[1] = 0-1 + memory_tiers[2] = 2-3 + + node_demotion[0].preferred = 2 + node_demotion[0].allowed = 2, 3 + node_demotion[1].preferred = 3 + node_demotion[1].allowed = 3, 2 + node_demotion[2].preferred = <empty> + node_demotion[2].allowed = <empty> + node_demotion[3].preferred = <empty> + node_demotion[3].allowed = <empty> Memory allocation for demotion ------------------------------ -If a page needs to be demoted from any node, the kernel 1st tries -to allocate a new page from the node's preferred node and fallbacks to -node's allowed targets in allocation fallback order. - +If a page needs to be demoted from any node, the kernel first tries +to allocate a new page from the node's preferred target node and fallbacks +to node's allowed targets in allocation fallback order.Thanks.
[1]: https://lore.kernel.org/linux-doc/[email protected]/
Signature · 1 line
An old man doll... just what I always wanted! - Clara
Re: [PATCH v7 11/12] mm/demotion: Add documentation for memory tiering
In reply to Aneesh Kumar K.VQuoted 4 lines · Aneesh Kumar K.V
From: Jagdish Gediya <[email protected]>
All
N_MEMORYnodes are divided into 3 memoty tiers with tier ID value
s /memoty/ memory
Quoted 2 lines
MEMORY_TIER_HBM_GPU,MEMORY_TIER_DRAMandMEMORY_TIER_PMEM. By default, all nodes are assigned to default memory tier.
I think adding the default memory tier name will be helpful.
Quoted 220 lines
Demotion path for all
N_MEMORYnodes is prepared based on the tier ID value of memory tiers.This patch adds documention for memory tiering introduction, its sysfs interfaces and how demotion is performed based on memory tiers.
Suggested-by Wei Xu <[email protected]>Signed-off-by Jagdish Gediya <[email protected]>Signed-off-by Aneesh Kumar K.V <[email protected]>--- Documentation/admin-guide/mm/index.rst | 1 + .../admin-guide/mm/memory-tiering.rst | 182 ++++++++++++++++++ 2 files changed, 183 insertions(+) create mode 100644 Documentation/admin-guide/mm/memory-tiering.rstDocumentation/admin-guide/mm/index.rst +1
-0@@ -32,6 +32,7 @@ the Linux memory management. idle_page_tracking ksm memory-hotplug + memory-tiering nommu-mmap numa_memory_policy numaperfDocumentation/admin-guide/mm/memory-tiering.rst new file +182
-1@@ -0,0 +1,182 @@ +.. SPDX-License-Identifier: GPL-2.0 + +.. _admin_guide_memory_tiering: + +=========== +Memory tiers +============ + +This document describes explicit memory tiering support along with +demotion based on memory tiers. + +Introduction +============ + +Many systems have multiple types of memory devices e.g. GPU, DRAM and +PMEM. The memory subsystem of these systems can be called a memory +tiering system because the performance of the different types of +memory is different. Memory tiers are defined based on the hardware +capabilities of memory nodes. Each memory tier is assigned a tier ID +value that determines the memory tier position in demotion order. + +The memory tier assignment of each node is independent of each +other. Moving a node from one tier to another tier doesn't affect +the tier assignment of any other node. + +Memory tiers are used to build the demotion targets for nodes. A node +can demote its pages to any node of any lower tiers. + +Memory tier rank +================= + +Memory nodes are divided into 3 types of memory tiers with tier ID +value as shown based on their hardware characteristics. + + +MEMORY_TIER_HBM_GPU +MEMORY_TIER_DRAM +MEMORY_TIER_PMEM + +Memory tiers initialization and (re)assignments +=============================================== + +By default, all nodes are assigned to the memory tier with the default tier ID +DEFAULT_MEMORY_TIER which is 200 (MEMORY_TIER_DRAM). The memory tier of +the memory node can be either modified through sysfs or from the driver. On +hotplug, the memory tier with default tier ID is assigned to the memory node. + + +Sysfs interfaces +================ + +Nodes belonging to specific tier can be read from, +/sys/devices/system/memtier/memtierN/nodelist (Read-Only) + +Where N is 0 - 2. + +Example 1: +For a system where Node 0 is CPU + DRAM nodes, Node 1 is HBM node, +node 2 is a PMEM node an ideal tier layout will be + +$ cat /sys/devices/system/memtier/memtier0/nodelist +1 +$ cat /sys/devices/system/memtier/memtier1/nodelist +0 +$ cat /sys/devices/system/memtier/memtier2/nodelist +2 + +Example 2: +For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM +nodes. + +$ cat /sys/devices/system/memtier/memtier0/nodelist +cat: /sys/devices/system/memtier/memtier0/nodelist: No such file or +directory +$ cat /sys/devices/system/memtier/memtier1/nodelist +0-1 +$ cat /sys/devices/system/memtier/memtier2/nodelist +2-3 + +Default memory tier can be read from, +/sys/devices/system/memtier/default_tier (Read-Only) + +e.g. +$ cat /sys/devices/system/memtier/default_tier +memtier200 + +Max memory tier ID supported can be read from, +/sys/devices/system/memtier/max_tier (Read-Only) + +e.g. +$ cat /sys/devices/system/memtier/max_tier +400 + +Individual node's memory tier can be read of set using, +/sys/devices/system/node/nodeN/memtier (Read-Write) + +where N = node id + +When this interface is written, Node is moved from the old memory tier +to new memory tier and demotion targets for all N_MEMORY nodes are +built again. + +For example 1 mentioned above, +$ cat /sys/devices/system/node/node0/memtier +1 +$ cat /sys/devices/system/node/node1/memtier +0 +$ cat /sys/devices/system/node/node2/memtier +2 + +Additional memory tiers can be created by writing a tier ID value to this file. +This results in a new memory tier creation and moving the specific NUMA node to +that memory tier. + +Demotion +======== + +In a system with DRAM and persistent memory, once DRAM +fills up, reclaim will start and some of the DRAM contents will be +thrown out even if there is a space in persistent memory. +Consequently, allocations will, at some point, start falling over to the slower +persistent memory. + +That has two nasty properties. First, the newer allocations can end up in +the slower persistent memory. Second, reclaimed data in DRAM are just +discarded even if there are gobs of space in persistent memory that could +be used. + +Instead of a page being discarded during reclaim, it can be moved to +persistent memory. Allowing page migration during reclaim enables +these systems to migrate pages from fast(higher) tiers to slow(lower) +tiers when the fast(higher) tier is under pressure. + + +Enable/Disable demotion +----------------------- + +By default demotion is disabled, it can be enabled/disabled using +below sysfs interface, + +$ echo 0/1 or false/true > /sys/kernel/mm/numa/demotion_enabled + +preferred and allowed demotion nodes +------------------------------------ + +Preferred nodes for a specific N_MEMORY node are the best nodes +from the next possible lower memory tier. Allowed nodes for any +node are all the nodes available in all possible lower memory +tiers. + +Example: + +For a system where Node 0 & 1 are CPU + DRAM nodes, node 2 & 3 are PMEM +nodes, + +node distances: +node 0 1 2 3 + 0 10 20 30 40 + 1 20 10 40 30 + 2 30 40 10 40 + 3 40 30 40 10 + +memory_tiers[0] = <empty> +memory_tiers[1] = 0-1 +memory_tiers[2] = 2-3 + +node_demotion[0].preferred = 2 +node_demotion[0].allowed = 2, 3 +node_demotion[1].preferred = 3 +node_demotion[1].allowed = 3, 2 +node_demotion[2].preferred = <empty> +node_demotion[2].allowed = <empty> +node_demotion[3].preferred = <empty> +node_demotion[3].allowed = <empty> + +Memory allocation for demotion +------------------------------ + +If a page needs to be demoted from any node, the kernel 1st tries +to allocate a new page from the node's preferred node and fallbacks to +node's allowed targets in allocation fallback order. + --2.36.1
PATCH v7 12/12 mm/demotion: Add sysfs ABI documentation
In reply to Aneesh Kumar K.VAdd sysfs ABI documentation.
--- .../ABI/testing/sysfs-kernel-mm-memory-tiers | 61 +++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers
Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers new file +61 -0
@@ -0,0 +1,61 @@ +What: /sys/devices/system/memtier/ +Date: June 2022 +Contact: Linux memory management mailing list <[email protected]> +Description: Interface for tiered memory + + This is the directory containing the information about memory tiers. + + Each memory tier has its own subdirectory. + + The order of memory tiers is determined by their tier ID value. + A higher tier ID value means a higher tier. memtier300 is higher + memory tier compared to memtier 100. + +What: /sys/devices/system/memtier/default_tier +Date: June 2022 +Contact: Linux memory management mailing list <[email protected]> +Description: Default memory tier + + The default memory tier to which memory would get added via hotplug + if the NUMA node is not part of any memory tier + +What: /sys/devices/system/memtier/max_tier +Date: June 2022 +Contact: Linux memory management mailing list <[email protected]> +Description: Maximum memory tier ID supported + + The max memory tier device ID we can create. Users can create memory + tiers in range [0 - max_tier] + +What: /sys/devices/system/memtier/memtierN/ +Date: June 2022 +Contact: Linux memory management mailing list <[email protected]> +Description: Directory with details of a specific memory tier + + This is the directory containing the information about a particular + memory tier, memtierN, where N is the memtier device ID (e.g. 0, 1). + + The memtier device ID number itself is just an identifier and has no + special meaning. Its value relative to other memtiers decides the level + of this memtier in the tier hierarchy. + + +What: /sys/devices/system/memtier/memtierN/nodelist +Date: June 2022 +Contact: Linux memory management mailing list <[email protected]> +Description: Memory tier nodelist + + + When read, list the memory nodes in the specified tier. + +What: /sys/devices/system/node/nodeN/memtier +Date: June 2022 +Contact: Linux memory management mailing list <[email protected]> +Description: Memory tier details for node N + + When read, list the device ID of the memory tier that the node belongs + to. Its value is empty for a CPU-only NUMA node. + + When written, the kernel moves the node into the specified memory + tier if the move is allowed. The tier assignments of all other + nodes are not affected.
Signature · 1 line
2.36.1
Forgot to Cc: Johannes.
Quoted 211 lines · Aneesh Kumar K.V
The current kernel has the basic memory tiering support: Inactive pages on a higher tier NUMA node can be migrated (demoted) to a lower tier NUMA node to make room for new allocations on the higher tier NUMA node. Frequently accessed pages on a lower tier NUMA node can be migrated (promoted) to a higher tier NUMA node to improve the performance.
In the current kernel, memory tiers are defined implicitly via a demotion path relationship between NUMA nodes, which is created during the kernel initialization and updated when a NUMA node is hot-added or hot-removed. The current implementation puts all nodes with CPU into the top tier, and builds the tier hierarchy tier-by-tier by establishing the per-node demotion targets based on the distances between nodes.
This current memory tier kernel interface needs to be improved for several important use cases:
* The current tier initialization code always initializes each memory-only NUMA node into a lower tier. But a memory-only NUMA node may have a high performance memory device (e.g. a DRAM device attached via CXL.mem or a DRAM-backed memory-only node on a virtual machine) and should be put into a higher tier.
* The current tier hierarchy always puts CPU nodes into the top tier. But on a system with HBM (e.g. GPU memory) devices, these memory-only HBM NUMA nodes should be in the top tier, and DRAM nodes with CPUs are better to be placed into the next lower tier.
* Also because the current tier hierarchy always puts CPU nodes into the top tier, when a CPU is hot-added (or hot-removed) and triggers a memory node from CPU-less into a CPU node (or vice versa), the memory tier hierarchy gets changed, even though no memory node is added or removed. This can make the tier hierarchy unstable and make it difficult to support tier-based memory accounting.
* A higher tier node can only be demoted to selected nodes on the next lower tier as defined by the demotion path, not any other node from any lower tier. This strict, hard-coded demotion order does not work in all use cases (e.g. some use cases may want to allow cross-socket demotion to another node in the same demotion tier as a fallback when the preferred demotion node is out of space), and has resulted in the feature request for an interface to override the system-wide, per-node demotion order from the userspace. This demotion order is also inconsistent with the page allocation fallback order when all the nodes in a higher tier are out of space: The page allocation can fall back to any node from any lower tier, whereas the demotion order doesn't allow that.
* There are no interfaces for the userspace to learn about the memory tier hierarchy in order to optimize its memory allocations.
This patch series make the creation of memory tiers explicit under the control of userspace or device driver.
Memory Tier Initialization
==========================By default, all memory nodes are assigned to the default tier with tier ID value 200.
A device driver can move up or down its memory nodes from the default tier. For example, PMEM can move down its memory nodes below the default tier, whereas GPU can move up its memory nodes above the default tier.
The kernel initialization code makes the decision on which exact tier a memory node should be assigned to based on the requests from the device drivers as well as the memory device hardware information provided by the firmware.
Hot-adding/removing CPUs doesn't affect memory tier hierarchy.
Memory Allocation for Demotion
==============================
This patch series keep the demotion target page allocation logic same. The demotion page allocation pick the closest NUMA node in the next lower tier to the current NUMA node allocating pages from.This will be later improved to use the same page allocation strategy using fallback list.
Sysfs Interface:
-------------
Listing current list of memory tiers details::/sys/devices/system/memtier$ ls default_tier max_tier memtier1 power uevent :/sys/devices/system/memtier$ cat default_tier memtier200 :/sys/devices/system/memtier$ cat max_tier 400 :/sys/devices/system/memtier$Per node memory tier details:
For a cpu only NUMA node:
:/sys/devices/system/node# cat node0/memtier :/sys/devices/system/node# echo 1 > node0/memtier :/sys/devices/system/node# cat node0/memtier :/sys/devices/system/node#For a NUMA node with memory:
:/sys/devices/system/node# cat node1/memtier 1 :/sys/devices/system/node# ls ../memtier/ default_tier max_tier memtier1 power uevent :/sys/devices/system/node# echo 2 > node1/memtier :/sys/devices/system/node# :/sys/devices/system/node# ls ../memtier/ default_tier max_tier memtier1 memtier2 power uevent :/sys/devices/system/node# cat node1/memtier 2 :/sys/devices/system/node#Removing a memory tier
:/sys/devices/system/node# cat node1/memtier 2 :/sys/devices/system/node# echo 1 > node1/memtier :/sys/devices/system/node# :/sys/devices/system/node# cat node1/memtier 1 :/sys/devices/system/node# :/sys/devices/system/node# ls ../memtier/ default_tier max_tier memtier1 power uevent :/sys/devices/system/node#The above resulted in removal of memtier2 which was created in the earlier step.
Changes from v6:
* Drop the usage of rank.
* Address other review feedback.Changes from v5:
* Remove patch supportingN_MEMORYnode removal from memory tiers. memory tiers are going to be used for features other than demotion. Hence keep allN_MEMORYnodes in memory tiers irrespective of whether they want to participate in promotion or demotion.
* AddNODE_DATA->memtier
* Rearrage patches to add sysfs files later.
* Add support to create memory tiers from userspace.
* Address other review feedback.Changes from v4:
* Address review feedback.
* Reverse the meaning of "rank": higher rank value means higher tier.
* Add "/sys/devices/system/memtier/default_tier".
* Addnode_is_toptierv4:
Add support for explicit memory tiers and ranks.v3:
- Modify patch 1 subject to make it more specific
- Remove/sys/kernel/mm/numa/demotion_targetsinterface, use/sys/devices/system/node/demotion_targetsinstead and make it writable to override node_states[N_DEMOTION_TARGETS].
- Add support to view per node demotion targets via sysfsv2:
In v1, only 1st patch of this patch series was sent, which was implemented to avoid some of the limitations on the demotion target sharing, however for certain numa topology, the demotion targets found by that patch was not most optimal, so 1st patch in this series is modified according to suggestions from Huang and Baolin. Different examples of demotion list comparasion between existing implementation and changed implementation can be found in the commit message of 1st patch.Aneesh Kumar K.V (10):
mm/demotion: Add support for explicit memory tiers mm/demotion: Move memory demotion related codemm/demotion/dax/kmem: Set node's memory tier toMEMORY_TIER_PMEMmm/demotion: Add hotplug callbacks to handle new numa node onlined mm/demotion: Build demotion targets based on explicit memory tiers mm/demotion: Expose memory tier details via sysfs mm/demotion: Add per node memory tier attribute to sysfs mm/demotion: Addpg_data_tmember to track node memory tier details mm/demotion: Updatenode_is_toptierto work with memory tiers mm/demotion: Add sysfs ABI documentationJagdish Gediya (2):
mm/demotion: Demote pages according to allocation fallback order mm/demotion: Add documentation for memory tiering.../ABI/testing/sysfs-kernel-mm-memory-tiers | 61 ++ Documentation/admin-guide/mm/index.rst | 1 + .../admin-guide/mm/memory-tiering.rst | 182 ++++ drivers/base/node.c | 42 + drivers/dax/kmem.c | 6 +- include/linux/memory-tiers.h | 72 ++ include/linux/migrate.h | 15 - include/linux/mmzone.h | 3 + include/linux/node.h | 5 - mm/Makefile | 1 + mm/huge_memory.c | 1 + mm/memory-tiers.c | 791 ++++++++++++++++++ mm/migrate.c | 453 +--------- mm/mprotect.c | 1 + mm/vmscan.c | 57 +- mm/vmstat.c | 4 - 16 files changed, 1204 insertions(+), 491 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers create mode 100644 Documentation/admin-guide/mm/memory-tiering.rst create mode 100644 include/linux/memory-tiers.h create mode 100644 mm/memory-tiers.cSignature · 1 line
2.36.1