memblock tests: add tests for memblock_alloc_exact_nid_raw
v3 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
v1 -> v2
PATCH 0:
- Add missing memblock_alloc_exact_nid_raw to subject line
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
---
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 | 542 ++++---- tools/testing/memblock/tests/alloc_nid_api.h | 1 + tools/testing/memblock/tests/common.h | 2 + 8 files changed, 1425 insertions(+), 269 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 v3 1/5 memblock tests: introduce range tests for memblock_alloc_exact_nid_raw
Add 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 | 542 +++++++++--------- tools/testing/memblock/tests/alloc_nid_api.h | 1 + tools/testing/memblock/tests/common.h | 2 + 7 files changed, 317 insertions(+), 263 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 +280 -262
1,290 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
@@ -18,6 +18,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.25.1
PATCH v3 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
@@ -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.25.1
PATCH v3 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.25.1
PATCH v3 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.25.1
PATCH v3 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
Hi Mike,
I noticed that the memblock tree has been updated since I sent this patch set. Do you want me to send an updated patch set applied on top of the current tree?
Quoted 48 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.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.---
Changelogv1 -> v2
PATCH 0:
- Add missingmemblock_alloc_exact_nid_rawto subject linev2 -> v3
Based on feedback from David Hildenbrand:
PATCH 1:
-alloc_nid_api.c,alloc_nid_api.h,common.h:
+ AddTEST_F_EXACTflag so that tests inalloc_nid_api.ccan be run with that flag to testmemblock_alloc_exact_nid_raw()
-alloc_exact_nid_api.c:
+ Update to run range tests inalloc_nid_api.cwithTEST_F_EXACTflag 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
---Rebecca Mckeever (5):
memblock tests: introduce range tests formemblock_alloc_exact_nid_rawmemblock 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
Quoted 15 lines
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 | 542 ++++---- tools/testing/memblock/tests/alloc_nid_api.h | 1 + tools/testing/memblock/tests/common.h | 2 + 8 files changed, 1425 insertions(+), 269 deletions(-) create mode 100644 tools/testing/memblock/tests/alloc_exact_nid_api.c create mode 100644 tools/testing/memblock/tests/alloc_exact_nid_api.hSignature · 1 line
2.25.1
Thanks,
Rebecca
Mike Rapoport
maintainerHi Rebecca,
Quoted 5 lines · Rebecca Mckeever
Hi Mike,
I noticed that the memblock tree has been updated since I sent this patch set. Do you want me to send an updated patch set applied on top of the current tree?
No need, the only actual conflict is in TODO, I'll fix it while applying.
Quoted 66 lines · Rebecca Mckeever
Quoted 48 lines
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.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.---
Changelogv1 -> v2
PATCH 0:
- Add missingmemblock_alloc_exact_nid_rawto subject linev2 -> v3
Based on feedback from David Hildenbrand:
PATCH 1:
-alloc_nid_api.c,alloc_nid_api.h,common.h:
+ AddTEST_F_EXACTflag so that tests inalloc_nid_api.ccan be run with that flag to testmemblock_alloc_exact_nid_raw()
-alloc_exact_nid_api.c:
+ Update to run range tests inalloc_nid_api.cwithTEST_F_EXACTflag 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
---Rebecca Mckeever (5):
memblock tests: introduce range tests formemblock_alloc_exact_nid_rawmemblock 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 itemQuoted 15 lines
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 | 542 ++++---- tools/testing/memblock/tests/alloc_nid_api.h | 1 + tools/testing/memblock/tests/common.h | 2 + 8 files changed, 1425 insertions(+), 269 deletions(-) create mode 100644 tools/testing/memblock/tests/alloc_exact_nid_api.c create mode 100644 tools/testing/memblock/tests/alloc_exact_nid_api.hSignature · 1 line
2.25.1Thanks,
Rebecca
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v3 1/5] memblock tests: introduce range tests for memblock_alloc_exact_nid_raw
In reply to Rebecca MckeeverQuoted 12 lines · Rebecca Mckeever
Add
TEST_F_EXACTflag, which specifies that tests should runmemblock_alloc_exact_nid_raw(). Introduce range tests formemblock_alloc_exact_nid_raw()by using theTEST_F_EXACTflag to run the range tests inalloc_nid_api.c, sincememblock_alloc_exact_nid_raw()andmemblock_alloc_try_nid_raw()behave the same way when nid =NUMA_NO_NODE.Rename tests and other functions in
alloc_nid_api.cby 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.Signed-off-by Rebecca Mckeever <[email protected]>
[...]
Quoted 17 lines
tools/testing/memblock/tests/alloc_nid_api.c +3
-1@@ -18,18 +18,27 @@ static const unsigned int node_fractions[] = { 625, /* 1/16 */ }; -static inline const char *const get_memblock_alloc_try_nid_name (int flags) +static inline const char *const get_memblock_alloc_nid_name (int flags) { +if (flags &TEST_F_EXACT ) +return "memblock_alloc_exact_nid_raw" ;if (flags &TEST_F_RAW )return "memblock_alloc_try_nid_raw" ;return "memblock_alloc_try_nid" ; }
tools/testing/memblock/tests/alloc_nid_api.c static const unsigned int node_fractions[] = { · line 34
Quoted 10 lines
tools/testing/memblock/tests/alloc_nid_api.c +4
-4-static inline void *run_memblock_alloc_try_nid (phys_addr_t size, -phys_addr_t align, -phys_addr_t min_addr, -phys_addr_t max_addr,int nid) +static inline void *run_memblock_alloc_nid (phys_addr_t size, +phys_addr_t align, +phys_addr_t min_addr, +phys_addr_t max_addr,int nid) {
I think we want to assert here that TEST_F_EXACT without TEST_F_RAW is not set --- because there is no API to support it.
Apart from that
Thanks!
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v3 2/5] memblock tests: add top-down NUMA tests for memblock_alloc_exact_nid_raw
In reply to Rebecca MckeeverQuoted 22 lines · Rebecca Mckeever
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 spaceRange restricted:
- region can be allocated in the specific node requested after droppingmin_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 beforemin_addr
+ range overlaps with multiple nodes along node boundaries, and the requested node ends beforemin_addr
Quoted 2 lines
Signed-off-by Rebecca Mckeever <[email protected]>---
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v3 3/5] memblock tests: add bottom-up NUMA tests for memblock_alloc_exact_nid_raw
In reply to Rebecca MckeeverQuoted 22 lines · Rebecca Mckeever
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 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 spaceRange restricted:
- region can be allocated in the specific node requested after droppingmin_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 beforemin_addr
+ range overlaps with multiple nodes along node boundaries, and the requested node ends beforemin_addr
Quoted 2 lines
Signed-off-by Rebecca Mckeever <[email protected]>---
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v3 4/5] memblock tests: add generic NUMA tests for memblock_alloc_exact_nid_raw
In reply to Rebecca MckeeverQuoted 30 lines · Rebecca Mckeever
Add 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 regionRange restricted:
- region can be allocated in the specific node requested without droppingmin_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 aftermax_addr
+ nid is set toNUMA_NO_NODEand the total range can fit the region, but the range is split between two nodes and everything else is reserved
Quoted 2 lines
Signed-off-by Rebecca Mckeever <[email protected]>---
Signature · 3 lines
Thanks, David / dhildenb
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.
Thanks a lot Rebecca for moving forward with these changes even after your Outreachy internship ended!
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v3 1/5] memblock tests: introduce range tests for memblock_alloc_exact_nid_raw
In reply to David HildenbrandQuoted 36 lines · David Hildenbrand
Quoted 12 lines · Rebecca Mckeever
Add
TEST_F_EXACTflag, which specifies that tests should runmemblock_alloc_exact_nid_raw(). Introduce range tests formemblock_alloc_exact_nid_raw()by using theTEST_F_EXACTflag to run the range tests inalloc_nid_api.c, sincememblock_alloc_exact_nid_raw()andmemblock_alloc_try_nid_raw()behave the same way when nid =NUMA_NO_NODE.Rename tests and other functions in
alloc_nid_api.cby 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.Signed-off-by Rebecca Mckeever <[email protected]>[...]
Quoted 20 lines
tools/testing/memblock/tests/alloc_nid_api.c +3
-5@@ -18,18 +18,27 @@ static const unsigned int node_fractions[] = { 625, /* 1/16 */ }; -static inline const char *const get_memblock_alloc_try_nid_name (int flags) +static inline const char *const get_memblock_alloc_nid_name (int flags) { +if (flags &TEST_F_EXACT ) +return "memblock_alloc_exact_nid_raw" ;if (flags &TEST_F_RAW )return "memblock_alloc_try_nid_raw" ;return "memblock_alloc_try_nid" ; } -static inline void *run_memblock_alloc_try_nid (phys_addr_t size, -phys_addr_t align, -phys_addr_t min_addr, -phys_addr_t max_addr,int nid)
Quoted 9 lines
tools/testing/memblock/tests/alloc_nid_api.c static const unsigned int node_fractions[] = { · line 34
Quoted 5 lines
tools/testing/memblock/tests/alloc_nid_api.c +4
-0+static inline void *run_memblock_alloc_nid (phys_addr_t size, +phys_addr_t align, +phys_addr_t min_addr, +phys_addr_t max_addr,int nid) {I think we want to assert here that
TEST_F_EXACTwithoutTEST_F_RAWis not set --- because there is no API to support it.
Good idea. Thanks for pointing this out. I will add an assert.
Quoted 12 lines
Apart from that
Thanks!
Signature · 3 lines
Thanks, David / dhildenb
Thanks,
Rebecca