memblock tests: add tests for
cover memblock tests: add tests for
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 these tests set nid != NUMA_NO_NODE.
The range tests are very similar to the range tests 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.
Rebecca Mckeever (5):
memblock tests: add 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 | 2299 +++++++++++++++++ .../memblock/tests/alloc_exact_nid_api.h | 25 + 5 files changed, 2328 insertions(+), 7 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.25.1
PATCH 1/5 memblock tests: add range tests for memblock_alloc_exact_nid_raw
Add tests for memblock_alloc_exact_nid_raw() that are very similar to the range tests for memblock_alloc_try_nid_raw().
--- tools/testing/memblock/Makefile | 2 +- tools/testing/memblock/main.c | 2 + .../memblock/tests/alloc_exact_nid_api.c | 1208 +++++++++++++++++ .../memblock/tests/alloc_exact_nid_api.h | 9 + 4 files changed, 1220 insertions(+), 1 deletion(-) 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 +1208 -0
1,208 lines not on this page · raw message
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
Signature · 1 line
2.25.1
PATCH 2/5 memblock tests: add top-down 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 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
@@ -3,6 +3,21 @@#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 simple test that tries to allocate a memory region within min_addr and * max_addr range:
@@ -1190,6 +1205,334 @@ static int memblock_alloc_exact_nid_range_checks(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 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 ();
@@ -1199,6 +1542,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.25.1
PATCH 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
@@ -1474,12 +1474,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 ; }
@@ -1489,6 +1763,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 ; }
@@ -1498,6 +1774,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 ; }
@@ -1507,6 +1785,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 ; }
@@ -1516,6 +1796,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.25.1
PATCH 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
@@ -1746,6 +1746,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 ) {
@@ -1802,6 +2186,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 );
@@ -1812,6 +2268,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.25.1
PATCH 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
@@ -8,10 +8,5 @@ TODO likely that the current MEM_SIZE won't be enough for these test cases. Use realloc to adjust the size accordingly. -2. Add test cases using this functions (implement them for both directions): - + memblock_alloc_raw() - + memblock_alloc_exact_nid_raw() - + memblock_alloc_try_nid_raw() - -3. Add tests for memblock_alloc_node() to check if the correct NUMA node is set +2. Add tests for memblock_alloc_node() to check if the correct NUMA node is set for the new region
Signature · 1 line
2.25.1