memblock tests: add tests for memblock_alloc_exact_nid_raw
v4 cover memblock tests: add tests for memblock_alloc_exact_nid_raw
These patches add tests for memblock_alloc_exact_nid_raw(). There are two sets of tests: range tests and NUMA tests. The range tests use a normal (i.e., UMA) simulated physical memory and set the nid to NUMA_NO_NODE. The NUMA tests use a simulated physical memory that is set up with multiple NUMA nodes. Additionally, most of the NUMA tests set nid != NUMA_NO_NODE.
For the range tests, the TEST_F_EXACT flag is used to run the same set of range tests used for memblock_alloc_try_nid_raw(). The NUMA tests have the same setup as the corresponding test for memblock_alloc_try_nid_raw(), but several of the memblock_alloc_exact_nid_raw() tests fail to allocate memory in setups where the memblock_alloc_try_nid_raw() test would allocate memory. Also, some memblock_alloc_exact_nid_raw() tests drop the lower limit of the requested range in order to allocate within the requested node, but the same setup in a memblock_alloc_try_nid_raw() test allocates within the requested range.
---
Changelog
v3 -> v4
Based on feedback from David Hildenbrand:
PATCH 1:
- alloc_nid_api.c:
+ Add assert to ensure that TEST_F_EXACT flag only occurs with TEST_F_RAW flag
v2 -> v3
Based on feedback from David Hildenbrand:
PATCH 1:
- alloc_nid_api.c, alloc_nid_api.h, common.h:
+ Add TEST_F_EXACT flag so that tests in alloc_nid_api.c can be run with that flag to test memblock_alloc_exact_nid_raw()
- alloc_exact_nid_api.c:
+ Update to run range tests in alloc_nid_api.c with TEST_F_EXACT flag instead of using a separate set of tests
- alloc_nid_api.c:
+ Rename tests and other functions by removing "_try" so that the function names are general enough to refer to any of the memblock_alloc_*nid*() functions of the memblock API
v1 -> v2
PATCH 0:
- Add missing memblock_alloc_exact_nid_raw to subject line
---
Rebecca Mckeever (5):
memblock tests: introduce range tests for memblock_alloc_exact_nid_raw memblock tests: add top-down NUMA tests for
memblock_alloc_exact_nid_raw
memblock tests: add bottom-up NUMA tests for
memblock_alloc_exact_nid_raw
memblock tests: add generic NUMA tests for
memblock_alloc_exact_nid_raw
memblock tests: remove completed TODO item
tools/testing/memblock/Makefile | 2 +- tools/testing/memblock/TODO | 7 +- tools/testing/memblock/main.c | 2 + .../memblock/tests/alloc_exact_nid_api.c | 1113 +++++++++++++++++ .../memblock/tests/alloc_exact_nid_api.h | 25 + tools/testing/memblock/tests/alloc_nid_api.c | 546 ++++---- tools/testing/memblock/tests/alloc_nid_api.h | 1 + tools/testing/memblock/tests/common.h | 2 + 8 files changed, 1428 insertions(+), 270 deletions(-) create mode 100644 tools/testing/memblock/tests/alloc_exact_nid_api.c create mode 100644 tools/testing/memblock/tests/alloc_exact_nid_api.h
Signature · 1 line
2.34.1
PATCH v4 2/5 memblock tests: add top-down NUMA tests for memblock_alloc_exact_nid_raw
Add tests for memblock_alloc_exact_nid_raw() where the simulated physical memory is set up with multiple NUMA nodes. Additionally, all of these tests set nid != NUMA_NO_NODE. These tests are run with a top-down allocation direction.
The tested scenarios are:
Range unrestricted:
- region can be allocated in the specific node requested:
+ there are no previously reserved regions
+ the requested node is partially reserved but has enough space
Range restricted:
- region can be allocated in the specific node requested after dropping min_addr:
+ range partially overlaps with two different nodes, where the first node is the requested node
+ range partially overlaps with two different nodes, where the requested node ends before min_addr
+ range overlaps with multiple nodes along node boundaries, and the requested node ends before min_addr
--- .../memblock/tests/alloc_exact_nid_api.c | 344 ++++++++++++++++++ .../memblock/tests/alloc_exact_nid_api.h | 16 + 2 files changed, 360 insertions(+)
tools/testing/memblock/tests/alloc_exact_nid_api.c +344 -0
@@ -4,6 +4,349 @@#define FUNC_NAME "memblock_alloc_exact_nid_raw" +/* +* contains the fraction of MEM_SIZE contained in each node in basis point +* units (one hundredth of 1% or 1/10000) +*/ +static const unsigned int node_fractions[] = { +2500 ,/* 1/4 */ +625 ,/* 1/16 */ +1250 ,/* 1/8 */ +1250 ,/* 1/8 */ +625 ,/* 1/16 */ +625 ,/* 1/16 */ +2500 ,/* 1/4 */ +625 ,/* 1/16 */ +}; + +/* +* A test that tries to allocate a memory region in a specific NUMA node that +* has enough memory to allocate a region of the requested size. +* Expect to allocate an aligned region at the end of the requested node. +*/ +static int alloc_exact_nid_top_down_numa_simple_check (void ) +{ +int nid_req =3 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + +ASSERT_LE (SZ_4 , req_node->size); + size = req_node->size /SZ_4 ; + min_addr =memblock_start_of_DRAM (); + max_addr =memblock_end_of_DRAM (); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base,region_end (req_node) - size); +ASSERT_LE (req_node->base, new_rgn->base); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region in a specific NUMA node that +* is partially reserved but has enough memory for the allocated region: +* +* | +---------------------------------------+ | +* | | requested | | +* +-----------+---------------------------------------+----------+ +* +* | +------------------+ +-----+ | +* | | reserved | | new | | +* +-----------+------------------+--------------+-----+----------+ +* +* Expect to allocate an aligned region at the end of the requested node. The +* region count and total size get updated. +*/ +static int alloc_exact_nid_top_down_numa_part_reserved_check (void ) +{ +int nid_req =4 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[1 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +struct region r1; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + +ASSERT_LE (SZ_8 , req_node->size); + r1.base = req_node->base; + r1.size = req_node->size /SZ_2 ; + size = r1.size /SZ_4 ; + min_addr =memblock_start_of_DRAM (); + max_addr =memblock_end_of_DRAM (); + +memblock_reserve (r1.base, r1.size); + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base,region_end (req_node) - size); +ASSERT_LE (req_node->base, new_rgn->base); + +ASSERT_EQ (memblock.reserved.cnt,2 ); +ASSERT_EQ (memblock.reserved.total_size, size + r1.size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region that spans over the min_addr +* and max_addr range and overlaps with two different nodes, where the first +* node is the requested node: +* +* min_addr +* | max_addr +* | | +* v v +* | +-----------------------+-----------+ | +* | | requested | node3 | | +* +-----------+-----------------------+-----------+--------------+ +* + + +* | +-----------+ | +* | | rgn | | +* +-----------------------+-----------+--------------------------+ +* +* Expect to drop the lower limit and allocate a memory region that ends at +* the end of the requested node. +*/ +static int alloc_exact_nid_top_down_numa_split_range_low_check (void ) +{ +int nid_req =2 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +phys_addr_t size =SZ_512 ; +phys_addr_t min_addr; +phys_addr_t max_addr; +phys_addr_t req_node_end; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + req_node_end =region_end (req_node); + min_addr = req_node_end -SZ_256 ; + max_addr = min_addr + size; + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base, req_node_end - size); +ASSERT_LE (req_node->base, new_rgn->base); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region that spans over the min_addr +* and max_addr range and overlaps with two different nodes, where the requested +* node ends before min_addr: +* +* min_addr +* | max_addr +* | | +* v v +* | +---------------+ +-------------+---------+ | +* | | requested | | node1 | node2 | | +* +----+---------------+--------+-------------+---------+----------+ +* + + +* | +---------+ | +* | | rgn | | +* +----------+---------+-------------------------------------------+ +* +* Expect to drop the lower limit and allocate a memory region that ends at +* the end of the requested node. +*/ +static int alloc_exact_nid_top_down_numa_no_overlap_split_check (void ) +{ +int nid_req =2 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +struct memblock_region *node2 = &memblock.memory.regions[6 ]; +void *allocated_ptr =NULL ; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + size =SZ_512 ; + min_addr = node2->base -SZ_256 ; + max_addr = min_addr + size; + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base,region_end (req_node) - size); +ASSERT_LE (req_node->base, new_rgn->base); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate memory within min_addr and max_add range when +* the requested node and the range do not overlap, and requested node ends +* before min_addr. The range overlaps with multiple nodes along node +* boundaries: +* +* min_addr +* | max_addr +* | | +* v v +* |-----------+ +----------+----...----+----------+ | +* | requested | | min node | ... | max node | | +* +-----------+-----------+----------+----...----+----------+------+ +* + + +* | +-----+ | +* | | rgn | | +* +-----+-----+----------------------------------------------------+ +* +* Expect to drop the lower limit and allocate a memory region that ends at +* the end of the requested node. +*/ +static int alloc_exact_nid_top_down_numa_no_overlap_low_check (void ) +{ +int nid_req =0 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +struct memblock_region *min_node = &memblock.memory.regions[2 ]; +struct memblock_region *max_node = &memblock.memory.regions[5 ]; +void *allocated_ptr =NULL ; +phys_addr_t size =SZ_64 ; +phys_addr_t max_addr; +phys_addr_t min_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + min_addr = min_node->base; + max_addr =region_end (max_node); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base,region_end (req_node) - size); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, size); + +test_pass_pop (); + +return 0 ; +} + +/* Test case wrappers for NUMA tests */ +static int alloc_exact_nid_numa_simple_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +memblock_set_bottom_up (false); +alloc_exact_nid_top_down_numa_simple_check (); + +return 0 ; +} + +static int alloc_exact_nid_numa_part_reserved_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +memblock_set_bottom_up (false); +alloc_exact_nid_top_down_numa_part_reserved_check (); + +return 0 ; +} + +static int alloc_exact_nid_numa_split_range_low_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +memblock_set_bottom_up (false); +alloc_exact_nid_top_down_numa_split_range_low_check (); + +return 0 ; +} + +static int alloc_exact_nid_numa_no_overlap_split_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +memblock_set_bottom_up (false); +alloc_exact_nid_top_down_numa_no_overlap_split_check (); + +return 0 ; +} + +static int alloc_exact_nid_numa_no_overlap_low_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +memblock_set_bottom_up (false); +alloc_exact_nid_top_down_numa_no_overlap_low_check (); + +return 0 ; +} + +int __memblock_alloc_exact_nid_numa_checks (void ) +{ +test_print ("Running %s NUMA tests...\n" ,FUNC_NAME ); + +alloc_exact_nid_numa_simple_check (); +alloc_exact_nid_numa_part_reserved_check (); +alloc_exact_nid_numa_split_range_low_check (); +alloc_exact_nid_numa_no_overlap_split_check (); +alloc_exact_nid_numa_no_overlap_low_check (); + +return 0 ; +} +int memblock_alloc_exact_nid_checks (void ) {prefix_reset ();
@@ -13,6 +356,7 @@ int memblock_alloc_exact_nid_checks(void)dummy_physical_memory_init ();memblock_alloc_exact_nid_range_checks (); +memblock_alloc_exact_nid_numa_checks ();dummy_physical_memory_cleanup ();
tools/testing/memblock/tests/alloc_exact_nid_api.h +16 -0
@@ -5,5 +5,21 @@#include "common.h" int memblock_alloc_exact_nid_checks (void ); +int __memblock_alloc_exact_nid_numa_checks (void ); + +#ifdef CONFIG_NUMA +static inline int memblock_alloc_exact_nid_numa_checks (void ) +{ +__memblock_alloc_exact_nid_numa_checks (); +return 0 ; +} + +#else +static inline int memblock_alloc_exact_nid_numa_checks (void ) +{ +return 0 ; +} + +#endif /* CONFIG_NUMA */ #endif
Signature · 1 line
2.34.1
PATCH v4 5/5 memblock tests: remove completed TODO item
In reply to Rebecca MckeeverRemove completed item from TODO list.
--- tools/testing/memblock/TODO | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-)
tools/testing/memblock/TODO +1 -6
@@ -1,10 +1,5 @@ TODO ===== -1. Add test cases using this functions (implement them for both directions): - + memblock_alloc_raw() - + memblock_alloc_exact_nid_raw() - + memblock_alloc_try_nid_raw() - -2. Add tests for memblock_alloc_node() to check if the correct NUMA node is set +1. Add tests for memblock_alloc_node() to check if the correct NUMA node is set for the new region
Signature · 1 line
2.34.1
PATCH v4 1/5 memblock tests: introduce range tests for memblock_alloc_exact_nid_raw
In reply to Rebecca MckeeverAdd TEST_F_EXACT flag, which specifies that tests should run memblock_alloc_exact_nid_raw(). Introduce range tests for memblock_alloc_exact_nid_raw() by using the TEST_F_EXACT flag to run the range tests in alloc_nid_api.c, since memblock_alloc_exact_nid_raw() and memblock_alloc_try_nid_raw() behave the same way when nid = NUMA_NO_NODE.
Rename tests and other functions in alloc_nid_api.c by removing "_try". Since the test names will be displayed in verbose output, they need to be general enough to refer to any of the memblock functions that the tests may run.
--- tools/testing/memblock/Makefile | 2 +- tools/testing/memblock/main.c | 2 + .../memblock/tests/alloc_exact_nid_api.c | 22 + .../memblock/tests/alloc_exact_nid_api.h | 9 + tools/testing/memblock/tests/alloc_nid_api.c | 546 +++++++++--------- tools/testing/memblock/tests/alloc_nid_api.h | 1 + tools/testing/memblock/tests/common.h | 2 + 7 files changed, 320 insertions(+), 264 deletions(-) create mode 100644 tools/testing/memblock/tests/alloc_exact_nid_api.c create mode 100644 tools/testing/memblock/tests/alloc_exact_nid_api.h
tools/testing/memblock/Makefile +1 -1
@@ -7,7 +7,7 @@ CFLAGS += -I. -I../../include -Wall -O2 -fsanitize=address \ LDFLAGS += -fsanitize=address -fsanitize=undefined TARGETS = main TEST_OFILES = tests/alloc_nid_api.o tests/alloc_helpers_api.o tests/alloc_api.o \ - tests/basic_api.o tests/common.o + tests/basic_api.o tests/common.o tests/alloc_exact_nid_api.o DEP_OFILES = memblock.o lib/slab.o mmzone.o slab.o OFILES = main.o $(DEP_OFILES) $(TEST_OFILES) EXTR_SRC = ../../../mm/memblock.c
tools/testing/memblock/main.c +2 -0
@@ -3,6 +3,7 @@#include "tests/alloc_api.h" #include "tests/alloc_helpers_api.h" #include "tests/alloc_nid_api.h" +#include "tests/alloc_exact_nid_api.h" #include "tests/common.h" int main (int argc,char **argv)
@@ -12,6 +13,7 @@ int main(int argc, char **argv)memblock_alloc_checks ();memblock_alloc_helpers_checks ();memblock_alloc_nid_checks (); +memblock_alloc_exact_nid_checks ();return 0 ; }
tools/testing/memblock/tests/alloc_exact_nid_api.c new file +22 -0
@@ -0,0 +1,22 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +#include "alloc_exact_nid_api.h" +#include "alloc_nid_api.h" + +#define FUNC_NAME "memblock_alloc_exact_nid_raw" + +int memblock_alloc_exact_nid_checks (void ) +{ +prefix_reset (); +prefix_push (FUNC_NAME ); + +reset_memblock_attributes (); +dummy_physical_memory_init (); + +memblock_alloc_exact_nid_range_checks (); + +dummy_physical_memory_cleanup (); + +prefix_pop (); + +return 0 ; +}
tools/testing/memblock/tests/alloc_exact_nid_api.h new file +9 -0
@@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +#ifndef _MEMBLOCK_ALLOC_EXACT_NID_H +#define _MEMBLOCK_ALLOC_EXACT_NID_H + +#include "common.h" + +int memblock_alloc_exact_nid_checks (void ); + +#endif
tools/testing/memblock/tests/alloc_nid_api.c +283 -263
1,293 lines not on this page · raw message
tools/testing/memblock/tests/alloc_nid_api.h +1 -0
@@ -5,6 +5,7 @@#include "common.h" int memblock_alloc_nid_checks (void ); +int memblock_alloc_exact_nid_range_checks (void );int __memblock_alloc_nid_numa_checks (void );#ifdef CONFIG_NUMA
tools/testing/memblock/tests/common.h +2 -0
@@ -21,6 +21,8 @@ enum test_flags {TEST_F_NONE =0x0 ,/* Perform raw allocations (no zeroing of memory). */ TEST_F_RAW =0x1 , +/* Perform allocations on the exact node specified. */ + TEST_F_EXACT = 0x2 };/**
Signature · 1 line
2.34.1
PATCH v4 3/5 memblock tests: add bottom-up NUMA tests for memblock_alloc_exact_nid_raw
In reply to Rebecca MckeeverAdd tests for memblock_alloc_exact_nid_raw() where the simulated physical memory is set up with multiple NUMA nodes. Additionally, all of these tests set nid != NUMA_NO_NODE. These tests are run with a bottom-up allocation direction.
The tested scenarios are:
Range unrestricted:
- region can be allocated in the specific node requested:
+ there are no previously reserved regions
+ the requested node is partially reserved but has enough space
Range restricted:
- region can be allocated in the specific node requested after dropping min_addr:
+ range partially overlaps with two different nodes, where the first node is the requested node
+ range partially overlaps with two different nodes, where the requested node ends before min_addr
+ range overlaps with multiple nodes along node boundaries, and the requested node ends before min_addr
--- .../memblock/tests/alloc_exact_nid_api.c | 282 ++++++++++++++++++ 1 file changed, 282 insertions(+)
tools/testing/memblock/tests/alloc_exact_nid_api.c +282 -0
@@ -288,12 +288,286 @@ static int alloc_exact_nid_top_down_numa_no_overlap_low_check(void)return 0 ; } +/* +* A test that tries to allocate a memory region in a specific NUMA node that +* has enough memory to allocate a region of the requested size. +* Expect to allocate an aligned region at the beginning of the requested node. +*/ +static int alloc_exact_nid_bottom_up_numa_simple_check (void ) +{ +int nid_req =3 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + +ASSERT_LE (SZ_4 , req_node->size); + size = req_node->size /SZ_4 ; + min_addr =memblock_start_of_DRAM (); + max_addr =memblock_end_of_DRAM (); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base, req_node->base); +ASSERT_LE (region_end (new_rgn),region_end (req_node)); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region in a specific NUMA node that +* is partially reserved but has enough memory for the allocated region: +* +* | +---------------------------------------+ | +* | | requested | | +* +-----------+---------------------------------------+---------+ +* +* | +------------------+-----+ | +* | | reserved | new | | +* +-----------+------------------+-----+------------------------+ +* +* Expect to allocate an aligned region in the requested node that merges with +* the existing reserved region. The total size gets updated. +*/ +static int alloc_exact_nid_bottom_up_numa_part_reserved_check (void ) +{ +int nid_req =4 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +struct region r1; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; +phys_addr_t total_size; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + +ASSERT_LE (SZ_8 , req_node->size); + r1.base = req_node->base; + r1.size = req_node->size /SZ_2 ; + size = r1.size /SZ_4 ; + min_addr =memblock_start_of_DRAM (); + max_addr =memblock_end_of_DRAM (); + total_size = size + r1.size; + +memblock_reserve (r1.base, r1.size); + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, total_size); +ASSERT_EQ (new_rgn->base, req_node->base); +ASSERT_LE (region_end (new_rgn),region_end (req_node)); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, total_size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region that spans over the min_addr +* and max_addr range and overlaps with two different nodes, where the first +* node is the requested node: +* +* min_addr +* | max_addr +* | | +* v v +* | +-----------------------+-----------+ | +* | | requested | node3 | | +* +-----------+-----------------------+-----------+--------------+ +* + + +* | +-----------+ | +* | | rgn | | +* +-----------+-----------+--------------------------------------+ +* +* Expect to drop the lower limit and allocate a memory region at the beginning +* of the requested node. +*/ +static int alloc_exact_nid_bottom_up_numa_split_range_low_check (void ) +{ +int nid_req =2 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +phys_addr_t size =SZ_512 ; +phys_addr_t min_addr; +phys_addr_t max_addr; +phys_addr_t req_node_end; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + req_node_end =region_end (req_node); + min_addr = req_node_end -SZ_256 ; + max_addr = min_addr + size; + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base, req_node->base); +ASSERT_LE (region_end (new_rgn), req_node_end); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region that spans over the min_addr +* and max_addr range and overlaps with two different nodes, where the requested +* node ends before min_addr: +* +* min_addr +* | max_addr +* | | +* v v +* | +---------------+ +-------------+---------+ | +* | | requested | | node1 | node2 | | +* +----+---------------+--------+-------------+---------+---------+ +* + + +* | +---------+ | +* | | rgn | | +* +----+---------+------------------------------------------------+ +* +* Expect to drop the lower limit and allocate a memory region that starts at +* the beginning of the requested node. +*/ +static int alloc_exact_nid_bottom_up_numa_no_overlap_split_check (void ) +{ +int nid_req =2 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +struct memblock_region *node2 = &memblock.memory.regions[6 ]; +void *allocated_ptr =NULL ; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + size =SZ_512 ; + min_addr = node2->base -SZ_256 ; + max_addr = min_addr + size; + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base, req_node->base); +ASSERT_LE (region_end (new_rgn),region_end (req_node)); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate memory within min_addr and max_add range when +* the requested node and the range do not overlap, and requested node ends +* before min_addr. The range overlaps with multiple nodes along node +* boundaries: +* +* min_addr +* | max_addr +* | | +* v v +* |-----------+ +----------+----...----+----------+ | +* | requested | | min node | ... | max node | | +* +-----------+-----------+----------+----...----+----------+------+ +* + + +* |-----+ | +* | rgn | | +* +-----+----------------------------------------------------------+ +* +* Expect to drop the lower limit and allocate a memory region that starts at +* the beginning of the requested node. +*/ +static int alloc_exact_nid_bottom_up_numa_no_overlap_low_check (void ) +{ +int nid_req =0 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +struct memblock_region *min_node = &memblock.memory.regions[2 ]; +struct memblock_region *max_node = &memblock.memory.regions[5 ]; +void *allocated_ptr =NULL ; +phys_addr_t size =SZ_64 ; +phys_addr_t max_addr; +phys_addr_t min_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + min_addr = min_node->base; + max_addr =region_end (max_node); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, size); +ASSERT_EQ (new_rgn->base, req_node->base); +ASSERT_LE (region_end (new_rgn),region_end (req_node)); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, size); + +test_pass_pop (); + +return 0 ; +} +/* Test case wrappers for NUMA tests */ static int alloc_exact_nid_numa_simple_check (void ) {test_print ("\tRunning %s...\n" , __func__);memblock_set_bottom_up (false);alloc_exact_nid_top_down_numa_simple_check (); +memblock_set_bottom_up (true); +alloc_exact_nid_bottom_up_numa_simple_check ();return 0 ; }
@@ -303,6 +577,8 @@ static int alloc_exact_nid_numa_part_reserved_check(void)test_print ("\tRunning %s...\n" , __func__);memblock_set_bottom_up (false);alloc_exact_nid_top_down_numa_part_reserved_check (); +memblock_set_bottom_up (true); +alloc_exact_nid_bottom_up_numa_part_reserved_check ();return 0 ; }
@@ -312,6 +588,8 @@ static int alloc_exact_nid_numa_split_range_low_check(void)test_print ("\tRunning %s...\n" , __func__);memblock_set_bottom_up (false);alloc_exact_nid_top_down_numa_split_range_low_check (); +memblock_set_bottom_up (true); +alloc_exact_nid_bottom_up_numa_split_range_low_check ();return 0 ; }
@@ -321,6 +599,8 @@ static int alloc_exact_nid_numa_no_overlap_split_check(void)test_print ("\tRunning %s...\n" , __func__);memblock_set_bottom_up (false);alloc_exact_nid_top_down_numa_no_overlap_split_check (); +memblock_set_bottom_up (true); +alloc_exact_nid_bottom_up_numa_no_overlap_split_check ();return 0 ; }
@@ -330,6 +610,8 @@ static int alloc_exact_nid_numa_no_overlap_low_check(void)test_print ("\tRunning %s...\n" , __func__);memblock_set_bottom_up (false);alloc_exact_nid_top_down_numa_no_overlap_low_check (); +memblock_set_bottom_up (true); +alloc_exact_nid_bottom_up_numa_no_overlap_low_check ();return 0 ; }
Signature · 1 line
2.34.1
PATCH v4 4/5 memblock tests: add generic NUMA tests for memblock_alloc_exact_nid_raw
In reply to Rebecca MckeeverAdd tests for memblock_alloc_exact_nid_raw() where the simulated physical memory is set up with multiple NUMA nodes. Additionally, all but one of these tests set nid != NUMA_NO_NODE. All tests are run for both top-down and bottom-up allocation directions.
The tested scenarios are:
Range unrestricted:
- region cannot be allocated:
+ there are no previously reserved regions, but requested node is too small
+ the requested node is fully reserved
+ the requested node is partially reserved and does not have enough space
+ none of the nodes have enough memory to allocate the region
Range restricted:
- region can be allocated in the specific node requested without dropping min_addr:
+ the range fully overlaps with the node, and there are adjacent reserved regions
- region cannot be allocated:
+ range partially overlaps with two different nodes, where the second node is the requested node
+ range overlaps with multiple nodes along node boundaries, and the requested node starts after max_addr
+ nid is set to NUMA_NO_NODE and the total range can fit the region, but the range is split between two nodes and everything else is reserved
--- .../memblock/tests/alloc_exact_nid_api.c | 465 ++++++++++++++++++ 1 file changed, 465 insertions(+)
tools/testing/memblock/tests/alloc_exact_nid_api.c +465 -0
@@ -560,6 +560,390 @@ static int alloc_exact_nid_bottom_up_numa_no_overlap_low_check(void)return 0 ; } +/* +* A test that tries to allocate a memory region in a specific NUMA node that +* does not have enough memory to allocate a region of the requested size: +* +* | +-----+ | +* | | req | | +* +---+-----+----------------------------+ +* +* +---------+ +* | rgn | +* +---------+ +* +* Expect no allocation to happen. +*/ +static int alloc_exact_nid_numa_small_node_generic_check (void ) +{ +int nid_req =1 ; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + size =SZ_2 * req_node->size; + min_addr =memblock_start_of_DRAM (); + max_addr =memblock_end_of_DRAM (); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_EQ (allocated_ptr,NULL ); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region in a specific NUMA node that +* is fully reserved: +* +* | +---------+ | +* | |requested| | +* +--------------+---------+-------------+ +* +* | +---------+ | +* | | reserved| | +* +--------------+---------+-------------+ +* +* Expect no allocation to happen. +*/ +static int alloc_exact_nid_numa_node_reserved_generic_check (void ) +{ +int nid_req =2 ; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + size = req_node->size; + min_addr =memblock_start_of_DRAM (); + max_addr =memblock_end_of_DRAM (); + +memblock_reserve (req_node->base, req_node->size); + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_EQ (allocated_ptr,NULL ); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region in a specific NUMA node that +* is partially reserved and does not have enough contiguous memory for the +* allocated region: +* +* | +-----------------------+ | +* | | requested | | +* +-----------+-----------------------+----+ +* +* | +----------+ | +* | | reserved | | +* +-----------------+----------+-----------+ +* +* Expect no allocation to happen. +*/ +static int alloc_exact_nid_numa_part_reserved_fail_generic_check (void ) +{ +int nid_req =4 ; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +struct region r1; +phys_addr_t size; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + +ASSERT_LE (SZ_4 , req_node->size); + size = req_node->size /SZ_2 ; + r1.base = req_node->base + (size /SZ_2 ); + r1.size = size; + + min_addr =memblock_start_of_DRAM (); + max_addr =memblock_end_of_DRAM (); + +memblock_reserve (r1.base, r1.size); + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_EQ (allocated_ptr,NULL ); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region that spans over the min_addr +* and max_addr range and overlaps with two different nodes, where the second +* node is the requested node: +* +* min_addr +* | max_addr +* | | +* v v +* | +--------------------------+---------+ | +* | | first node |requested| | +* +------+--------------------------+---------+----------------+ +* +* Expect no allocation to happen. +*/ +static int alloc_exact_nid_numa_split_range_high_generic_check (void ) +{ +int nid_req =3 ; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +void *allocated_ptr =NULL ; +phys_addr_t size =SZ_512 ; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + min_addr = req_node->base -SZ_256 ; + max_addr = min_addr + size; + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_EQ (allocated_ptr,NULL ); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate memory within min_addr and max_add range when +* the requested node and the range do not overlap, and requested node starts +* after max_addr. The range overlaps with multiple nodes along node +* boundaries: +* +* min_addr +* | max_addr +* | | +* v v +* | +----------+----...----+----------+ +-----------+ | +* | | min node | ... | max node | | requested | | +* +-----+----------+----...----+----------+--------+-----------+---+ +* +* Expect no allocation to happen. +*/ +static int alloc_exact_nid_numa_no_overlap_high_generic_check (void ) +{ +int nid_req =7 ; +struct memblock_region *min_node = &memblock.memory.regions[2 ]; +struct memblock_region *max_node = &memblock.memory.regions[5 ]; +void *allocated_ptr =NULL ; +phys_addr_t size =SZ_64 ; +phys_addr_t max_addr; +phys_addr_t min_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + min_addr = min_node->base; + max_addr =region_end (max_node); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_EQ (allocated_ptr,NULL ); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate a memory region in a specific NUMA node that +* does not have enough memory to allocate a region of the requested size. +* Additionally, none of the nodes have enough memory to allocate the region: +* +* +-----------------------------------+ +* | new | +* +-----------------------------------+ +* |-------+-------+-------+-------+-------+-------+-------+-------| +* | node0 | node1 | node2 | node3 | node4 | node5 | node6 | node7 | +* +-------+-------+-------+-------+-------+-------+-------+-------+ +* +* Expect no allocation to happen. +*/ +static int alloc_exact_nid_numa_large_region_generic_check (void ) +{ +int nid_req =3 ; +void *allocated_ptr =NULL ; +phys_addr_t size =MEM_SIZE /SZ_2 ; +phys_addr_t min_addr; +phys_addr_t max_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + min_addr =memblock_start_of_DRAM (); + max_addr =memblock_end_of_DRAM (); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); +ASSERT_EQ (allocated_ptr,NULL ); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate memory within min_addr and max_addr range when +* there are two reserved regions at the borders. The requested node starts at +* min_addr and ends at max_addr and is the same size as the region to be +* allocated: +* +* min_addr +* | max_addr +* | | +* v v +* | +-----------+-----------------------+-----------------------| +* | | node5 | requested | node7 | +* +------+-----------+-----------------------+-----------------------+ +* + + +* | +----+-----------------------+----+ | +* | | r2 | new | r1 | | +* +-------------+----+-----------------------+----+------------------+ +* +* Expect to merge all of the regions into one. The region counter and total +* size fields get updated. +*/ +static int alloc_exact_nid_numa_reserved_full_merge_generic_check (void ) +{ +int nid_req =6 ; +int nid_next = nid_req +1 ; +struct memblock_region *new_rgn = &memblock.reserved.regions[0 ]; +struct memblock_region *req_node = &memblock.memory.regions[nid_req]; +struct memblock_region *next_node = &memblock.memory.regions[nid_next]; +void *allocated_ptr =NULL ; +struct region r1, r2; +phys_addr_t size = req_node->size; +phys_addr_t total_size; +phys_addr_t max_addr; +phys_addr_t min_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + r1.base = next_node->base; + r1.size =SZ_128 ; + + r2.size =SZ_128 ; + r2.base = r1.base - (size + r2.size); + + total_size = r1.size + r2.size + size; + min_addr = r2.base + r2.size; + max_addr = r1.base; + +memblock_reserve (r1.base, r1.size); +memblock_reserve (r2.base, r2.size); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, + nid_req); + +ASSERT_NE (allocated_ptr,NULL ); +ASSERT_MEM_NE (allocated_ptr,0 , size); + +ASSERT_EQ (new_rgn->size, total_size); +ASSERT_EQ (new_rgn->base, r2.base); + +ASSERT_LE (new_rgn->base, req_node->base); +ASSERT_LE (region_end (req_node),region_end (new_rgn)); + +ASSERT_EQ (memblock.reserved.cnt,1 ); +ASSERT_EQ (memblock.reserved.total_size, total_size); + +test_pass_pop (); + +return 0 ; +} + +/* +* A test that tries to allocate memory within min_addr and max_add range, +* where the total range can fit the region, but it is split between two nodes +* and everything else is reserved. Additionally, nid is set to NUMA_NO_NODE +* instead of requesting a specific node: +* +* +-----------+ +* | new | +* +-----------+ +* | +---------------------+-----------| +* | | prev node | next node | +* +------+---------------------+-----------+ +* + + +* |----------------------+ +-----| +* | r1 | | r2 | +* +----------------------+-----------+-----+ +* ^ ^ +* | | +* | max_addr +* | +* min_addr +* +* Expect no allocation to happen. +*/ +static int alloc_exact_nid_numa_split_all_reserved_generic_check (void ) +{ +void *allocated_ptr =NULL ; +struct memblock_region *next_node = &memblock.memory.regions[7 ]; +struct region r1, r2; +phys_addr_t size =SZ_256 ; +phys_addr_t max_addr; +phys_addr_t min_addr; + +PREFIX_PUSH (); +setup_numa_memblock (node_fractions); + + r2.base = next_node->base +SZ_128 ; + r2.size =memblock_end_of_DRAM () - r2.base; + + r1.size =MEM_SIZE - (r2.size + size); + r1.base =memblock_start_of_DRAM (); + + min_addr = r1.base + r1.size; + max_addr = r2.base; + +memblock_reserve (r1.base, r1.size); +memblock_reserve (r2.base, r2.size); + + allocated_ptr =memblock_alloc_exact_nid_raw (size,SMP_CACHE_BYTES , + min_addr, max_addr, +NUMA_NO_NODE ); + +ASSERT_EQ (allocated_ptr,NULL ); + +test_pass_pop (); + +return 0 ; +} +/* Test case wrappers for NUMA tests */ static int alloc_exact_nid_numa_simple_check (void ) {
@@ -616,6 +1000,78 @@ static int alloc_exact_nid_numa_no_overlap_low_check(void)return 0 ; } +static int alloc_exact_nid_numa_small_node_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +run_top_down (alloc_exact_nid_numa_small_node_generic_check); +run_bottom_up (alloc_exact_nid_numa_small_node_generic_check); + +return 0 ; +} + +static int alloc_exact_nid_numa_node_reserved_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +run_top_down (alloc_exact_nid_numa_node_reserved_generic_check); +run_bottom_up (alloc_exact_nid_numa_node_reserved_generic_check); + +return 0 ; +} + +static int alloc_exact_nid_numa_part_reserved_fail_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +run_top_down (alloc_exact_nid_numa_part_reserved_fail_generic_check); +run_bottom_up (alloc_exact_nid_numa_part_reserved_fail_generic_check); + +return 0 ; +} + +static int alloc_exact_nid_numa_split_range_high_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +run_top_down (alloc_exact_nid_numa_split_range_high_generic_check); +run_bottom_up (alloc_exact_nid_numa_split_range_high_generic_check); + +return 0 ; +} + +static int alloc_exact_nid_numa_no_overlap_high_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +run_top_down (alloc_exact_nid_numa_no_overlap_high_generic_check); +run_bottom_up (alloc_exact_nid_numa_no_overlap_high_generic_check); + +return 0 ; +} + +static int alloc_exact_nid_numa_large_region_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +run_top_down (alloc_exact_nid_numa_large_region_generic_check); +run_bottom_up (alloc_exact_nid_numa_large_region_generic_check); + +return 0 ; +} + +static int alloc_exact_nid_numa_reserved_full_merge_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +run_top_down (alloc_exact_nid_numa_reserved_full_merge_generic_check); +run_bottom_up (alloc_exact_nid_numa_reserved_full_merge_generic_check); + +return 0 ; +} + +static int alloc_exact_nid_numa_split_all_reserved_check (void ) +{ +test_print ("\tRunning %s...\n" , __func__); +run_top_down (alloc_exact_nid_numa_split_all_reserved_generic_check); +run_bottom_up (alloc_exact_nid_numa_split_all_reserved_generic_check); + +return 0 ; +} +int __memblock_alloc_exact_nid_numa_checks (void ) {test_print ("Running %s NUMA tests...\n" ,FUNC_NAME );
@@ -626,6 +1082,15 @@ int __memblock_alloc_exact_nid_numa_checks(void)alloc_exact_nid_numa_no_overlap_split_check ();alloc_exact_nid_numa_no_overlap_low_check (); +alloc_exact_nid_numa_small_node_check (); +alloc_exact_nid_numa_node_reserved_check (); +alloc_exact_nid_numa_part_reserved_fail_check (); +alloc_exact_nid_numa_split_range_high_check (); +alloc_exact_nid_numa_no_overlap_high_check (); +alloc_exact_nid_numa_large_region_check (); +alloc_exact_nid_numa_reserved_full_merge_check (); +alloc_exact_nid_numa_split_all_reserved_check (); +return 0 ; }
Signature · 1 line
2.34.1
Quoted 6 lines · Rebecca Mckeever
These patches add tests for
memblock_alloc_exact_nid_raw(). There are two sets of tests: range tests and NUMA tests. The range tests use a normal (i.e., UMA) simulated physical memory and set the nid toNUMA_NO_NODE. The NUMA tests use a simulated physical memory that is set up with multiple NUMA nodes. Additionally, most of the NUMA tests set nid !=NUMA_NO_NODE.
Quoted 9 lines
For the range tests, the
TEST_F_EXACTflag is used to run the same set of range tests used formemblock_alloc_try_nid_raw(). The NUMA tests have the same setup as the corresponding test formemblock_alloc_try_nid_raw(), but several of thememblock_alloc_exact_nid_raw()tests fail to allocate memory in setups where thememblock_alloc_try_nid_raw()test would allocate memory. Also, somememblock_alloc_exact_nid_raw()tests drop the lower limit of the requested range in order to allocate within the requested node, but the same setup in amemblock_alloc_try_nid_raw()test allocates within the requested range.
Applied, thanks!
Signature · 2 lines
Sincerely yours, Mike.