| Message ID | ebbd1fd2c2a3d223a744adf24b4293a559a7003a.1660454730.git.remckee0@gmail.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | memblock tests: update and extend memblock simulator | expand |
On 8/14/2022 1:54 PM, Rebecca Mckeever wrote: > Add tests for memblock_trim_memory() for the following scenarios: > - all regions aligned > - one region unalign that is smaller than the alignment > - one region unaligned at the base > - one region unaligned at the end > > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com> > --- > tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++ > 1 file changed, 223 insertions(+) > > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c > index d7f008e7a12a..c8bb44f20846 100644 > --- a/tools/testing/memblock/tests/basic_api.c > +++ b/tools/testing/memblock/tests/basic_api.c > @@ -8,6 +8,7 @@ > #define FUNC_RESERVE "memblock_reserve" > #define FUNC_REMOVE "memblock_remove" > #define FUNC_FREE "memblock_free" > +#define FUNC_TRIM "memblock_trim_memory" > > static int memblock_initialization_check(void) > { > @@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void) > return 0; > } > > +/* > + * A test that tries to trim memory when both ends of the memory region are > + * aligned. Expect that the memory will not be trimmed. Expect the counter to > + * not be updated. > + */ > +static int memblock_trim_memory_aligned_check(void) > +{ > + struct memblock_region *rgn; > + phys_addr_t alignment = SMP_CACHE_BYTES; > + > + rgn = &memblock.memory.regions[0]; > + > + struct region r = { > + .base = alignment, > + .size = alignment * 4 > + }; > + > + PREFIX_PUSH(); > + > + reset_memblock_regions(); > + memblock_add(r.base, r.size); > + memblock_trim_memory(alignment); > + > + ASSERT_EQ(rgn->base, r.base); > + ASSERT_EQ(rgn->size, r.size); > + > + ASSERT_EQ(memblock.memory.cnt, 1); > + > + test_pass_pop(); > + > + return 0; > +} > + > +/* > + * A test that tries to trim memory when there are two available regions, r1 and > + * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end > + * and smaller than the alignment: > + * > + * alignment > + * |--------| > + * | +-----------------+ +------+ | > + * | | r1 | | r2 | | > + * +--------+-----------------+--------+------+---+ > + * ^ ^ ^ ^ ^ > + * |________|________|________| | > + * | Unaligned address > + * Aligned addresses > + * > + * Expect that r1 will not be trimmed and r2 will be removed. Expect the > + * counter to be updated. > + */ > +static int memblock_trim_memory_too_small_check(void) > +{ > + struct memblock_region *rgn; > + phys_addr_t alignment = SMP_CACHE_BYTES; > + > + rgn = &memblock.memory.regions[0]; > + > + struct region r1 = { > + .base = alignment, > + .size = alignment * 2 > + }; > + struct region r2 = { > + .base = alignment * 4, > + .size = alignment - SZ_2 > + }; > + > + PREFIX_PUSH(); > + > + reset_memblock_regions(); > + memblock_add(r1.base, r1.size); > + memblock_add(r2.base, r2.size); > + memblock_trim_memory(alignment); > + > + ASSERT_EQ(rgn->base, r1.base); > + ASSERT_EQ(rgn->size, r1.size); > + > + ASSERT_EQ(memblock.memory.cnt, 1); > + > + test_pass_pop(); > + > + return 0; > +} > + > +/* > + * A test that tries to trim memory when there are two available regions, r1 and > + * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base > + * and aligned at the end: > + * > + * Unaligned address > + * | > + * v > + * | +-----------------+ +---------------+ | > + * | | r1 | | r2 | | > + * +--------+-----------------+----------+---------------+---+ > + * ^ ^ ^ ^ ^ ^ > + * |________|________|________|________|________| > + * | > + * Aligned addresses > + * > + * Expect that r1 will not be trimmed and r2 will be trimmed at the base. > + * Expect the counter to not be updated. > + */ > +static int memblock_trim_memory_unaligned_base_check(void) > +{ > + struct memblock_region *rgn1, *rgn2; > + phys_addr_t alignment = SMP_CACHE_BYTES; > + phys_addr_t offset = SZ_2; > + phys_addr_t r2_base, r2_size; > + > + rgn1 = &memblock.memory.regions[0]; > + rgn2 = &memblock.memory.regions[1]; > + > + struct region r1 = { > + .base = alignment, > + .size = alignment * 2 > + }; > + struct region r2 = { > + .base = alignment * 4 + offset, > + .size = alignment * 2 - offset > + }; > + > + PREFIX_PUSH(); > + > + r2_base = r2.base + (alignment - offset); > + r2_size = r2.size - (alignment - offset); Also the variable name. > + > + reset_memblock_regions(); > + memblock_add(r1.base, r1.size); > + memblock_add(r2.base, r2.size); > + memblock_trim_memory(alignment); > + > + ASSERT_EQ(rgn1->base, r1.base); > + ASSERT_EQ(rgn1->size, r1.size); > + > + ASSERT_EQ(rgn2->base, r2_base); > + ASSERT_EQ(rgn2->size, r2_size); > + > + ASSERT_EQ(memblock.memory.cnt, 2); > + > + test_pass_pop(); > + > + return 0; > +} > + > +/* > + * A test that tries to trim memory when there are two available regions, r1 and > + * r2. Region r1 is aligned on both ends and region r2 is aligned at the base > + * and unaligned at the end: > + * > + * Unaligned address > + * | > + * v > + * | +-----------------+ +---------------+ | > + * | | r1 | | r2 | | > + * +--------+-----------------+--------+---------------+---+ > + * ^ ^ ^ ^ ^ ^ > + * |________|________|________|________|________| > + * | > + * Aligned addresses > + * > + * Expect that r1 will not be trimmed and r2 will be trimmed at the base. ^ at the end. > + * Expect the counter to not be updated. > + */ > +static int memblock_trim_memory_unaligned_end_check(void) > +{ > + struct memblock_region *rgn1, *rgn2; > + phys_addr_t alignment = SMP_CACHE_BYTES; > + phys_addr_t offset = SZ_2; > + phys_addr_t r2_size; > + > + rgn1 = &memblock.memory.regions[0]; > + rgn2 = &memblock.memory.regions[1]; > + > + struct region r1 = { > + .base = alignment, > + .size = alignment * 2 > + }; > + struct region r2 = { > + .base = alignment * 4, > + .size = alignment * 2 - offset > + }; > + > + PREFIX_PUSH(); > + > + r2_size = r2.size - (alignment - offset); > + > + reset_memblock_regions(); > + memblock_add(r1.base, r1.size); > + memblock_add(r2.base, r2.size); > + memblock_trim_memory(alignment); > + > + ASSERT_EQ(rgn1->base, r1.base); > + ASSERT_EQ(rgn1->size, r1.size); > + > + ASSERT_EQ(rgn2->base, r2.base); > + ASSERT_EQ(rgn2->size, r2_size); > + > + ASSERT_EQ(memblock.memory.cnt, 2); > + > + test_pass_pop(); > + > + return 0; > +} > + > +static int memblock_trim_memory_checks(void) > +{ > + prefix_reset(); > + prefix_push(FUNC_TRIM); > + test_print("Running %s tests...\n", FUNC_TRIM); > + > + memblock_trim_memory_aligned_check(); > + memblock_trim_memory_too_small_check(); > + memblock_trim_memory_unaligned_base_check(); > + memblock_trim_memory_unaligned_end_check(); > + > + prefix_pop(); > + > + return 0; > +} > + > int memblock_basic_checks(void) > { > memblock_initialization_check(); > @@ -1731,6 +1953,7 @@ int memblock_basic_checks(void) > memblock_remove_checks(); > memblock_free_checks(); > memblock_bottom_up_checks(); > + memblock_trim_memory_checks(); > > return 0; > } Others looks good.
On Tue, Aug 16, 2022 at 09:46:11AM +0800, Huang, Shaoqin wrote: > > > On 8/14/2022 1:54 PM, Rebecca Mckeever wrote: > > Add tests for memblock_trim_memory() for the following scenarios: > > - all regions aligned > > - one region unalign that is smaller than the alignment > > - one region unaligned at the base > > - one region unaligned at the end > > > > Signed-off-by: Rebecca Mckeever <remckee0@gmail.com> > > --- > > tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++ > > 1 file changed, 223 insertions(+) > > > > diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c > > index d7f008e7a12a..c8bb44f20846 100644 > > --- a/tools/testing/memblock/tests/basic_api.c > > +++ b/tools/testing/memblock/tests/basic_api.c > > @@ -8,6 +8,7 @@ > > #define FUNC_RESERVE "memblock_reserve" > > #define FUNC_REMOVE "memblock_remove" > > #define FUNC_FREE "memblock_free" > > +#define FUNC_TRIM "memblock_trim_memory" > > static int memblock_initialization_check(void) > > { > > @@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void) > > return 0; > > } > > +/* > > + * A test that tries to trim memory when both ends of the memory region are > > + * aligned. Expect that the memory will not be trimmed. Expect the counter to > > + * not be updated. > > + */ > > +static int memblock_trim_memory_aligned_check(void) > > +{ > > + struct memblock_region *rgn; > > + phys_addr_t alignment = SMP_CACHE_BYTES; > > + > > + rgn = &memblock.memory.regions[0]; > > + > > + struct region r = { > > + .base = alignment, > > + .size = alignment * 4 > > + }; > > + > > + PREFIX_PUSH(); > > + > > + reset_memblock_regions(); > > + memblock_add(r.base, r.size); > > + memblock_trim_memory(alignment); > > + > > + ASSERT_EQ(rgn->base, r.base); > > + ASSERT_EQ(rgn->size, r.size); > > + > > + ASSERT_EQ(memblock.memory.cnt, 1); > > + > > + test_pass_pop(); > > + > > + return 0; > > +} > > + > > +/* > > + * A test that tries to trim memory when there are two available regions, r1 and > > + * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end > > + * and smaller than the alignment: > > + * > > + * alignment > > + * |--------| > > + * | +-----------------+ +------+ | > > + * | | r1 | | r2 | | > > + * +--------+-----------------+--------+------+---+ > > + * ^ ^ ^ ^ ^ > > + * |________|________|________| | > > + * | Unaligned address > > + * Aligned addresses > > + * > > + * Expect that r1 will not be trimmed and r2 will be removed. Expect the > > + * counter to be updated. > > + */ > > +static int memblock_trim_memory_too_small_check(void) > > +{ > > + struct memblock_region *rgn; > > + phys_addr_t alignment = SMP_CACHE_BYTES; > > + > > + rgn = &memblock.memory.regions[0]; > > + > > + struct region r1 = { > > + .base = alignment, > > + .size = alignment * 2 > > + }; > > + struct region r2 = { > > + .base = alignment * 4, > > + .size = alignment - SZ_2 > > + }; > > + > > + PREFIX_PUSH(); > > + > > + reset_memblock_regions(); > > + memblock_add(r1.base, r1.size); > > + memblock_add(r2.base, r2.size); > > + memblock_trim_memory(alignment); > > + > > + ASSERT_EQ(rgn->base, r1.base); > > + ASSERT_EQ(rgn->size, r1.size); > > + > > + ASSERT_EQ(memblock.memory.cnt, 1); > > + > > + test_pass_pop(); > > + > > + return 0; > > +} > > + > > +/* > > + * A test that tries to trim memory when there are two available regions, r1 and > > + * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base > > + * and aligned at the end: > > + * > > + * Unaligned address > > + * | > > + * v > > + * | +-----------------+ +---------------+ | > > + * | | r1 | | r2 | | > > + * +--------+-----------------+----------+---------------+---+ > > + * ^ ^ ^ ^ ^ ^ > > + * |________|________|________|________|________| > > + * | > > + * Aligned addresses > > + * > > + * Expect that r1 will not be trimmed and r2 will be trimmed at the base. > > + * Expect the counter to not be updated. > > + */ > > +static int memblock_trim_memory_unaligned_base_check(void) > > +{ > > + struct memblock_region *rgn1, *rgn2; > > + phys_addr_t alignment = SMP_CACHE_BYTES; > > + phys_addr_t offset = SZ_2; > > + phys_addr_t r2_base, r2_size; > > + > > + rgn1 = &memblock.memory.regions[0]; > > + rgn2 = &memblock.memory.regions[1]; > > + > > + struct region r1 = { > > + .base = alignment, > > + .size = alignment * 2 > > + }; > > + struct region r2 = { > > + .base = alignment * 4 + offset, > > + .size = alignment * 2 - offset > > + }; > > + > > + PREFIX_PUSH(); > > + > > + r2_base = r2.base + (alignment - offset); > > + r2_size = r2.size - (alignment - offset); > > Also the variable name. > > > + > > + reset_memblock_regions(); > > + memblock_add(r1.base, r1.size); > > + memblock_add(r2.base, r2.size); > > + memblock_trim_memory(alignment); > > + > > + ASSERT_EQ(rgn1->base, r1.base); > > + ASSERT_EQ(rgn1->size, r1.size); > > + > > + ASSERT_EQ(rgn2->base, r2_base); > > + ASSERT_EQ(rgn2->size, r2_size); > > + > > + ASSERT_EQ(memblock.memory.cnt, 2); > > + > > + test_pass_pop(); > > + > > + return 0; > > +} > > + > > +/* > > + * A test that tries to trim memory when there are two available regions, r1 and > > + * r2. Region r1 is aligned on both ends and region r2 is aligned at the base > > + * and unaligned at the end: > > + * > > + * Unaligned address > > + * | > > + * v > > + * | +-----------------+ +---------------+ | > > + * | | r1 | | r2 | | > > + * +--------+-----------------+--------+---------------+---+ > > + * ^ ^ ^ ^ ^ ^ > > + * |________|________|________|________|________| > > + * | > > + * Aligned addresses > > + * > > + * Expect that r1 will not be trimmed and r2 will be trimmed at the base. > ^ > at the end. I forgot to make this change in v2. I will include it in v3. > > + * Expect the counter to not be updated. > > + */ > > +static int memblock_trim_memory_unaligned_end_check(void) > > +{ > > + struct memblock_region *rgn1, *rgn2; > > + phys_addr_t alignment = SMP_CACHE_BYTES; > > + phys_addr_t offset = SZ_2; > > + phys_addr_t r2_size; > > + > > + rgn1 = &memblock.memory.regions[0]; > > + rgn2 = &memblock.memory.regions[1]; > > + > > + struct region r1 = { > > + .base = alignment, > > + .size = alignment * 2 > > + }; > > + struct region r2 = { > > + .base = alignment * 4, > > + .size = alignment * 2 - offset > > + }; > > + > > + PREFIX_PUSH(); > > + > > + r2_size = r2.size - (alignment - offset); > > + > > + reset_memblock_regions(); > > + memblock_add(r1.base, r1.size); > > + memblock_add(r2.base, r2.size); > > + memblock_trim_memory(alignment); > > + > > + ASSERT_EQ(rgn1->base, r1.base); > > + ASSERT_EQ(rgn1->size, r1.size); > > + > > + ASSERT_EQ(rgn2->base, r2.base); > > + ASSERT_EQ(rgn2->size, r2_size); > > + > > + ASSERT_EQ(memblock.memory.cnt, 2); > > + > > + test_pass_pop(); > > + > > + return 0; > > +} > > + > > +static int memblock_trim_memory_checks(void) > > +{ > > + prefix_reset(); > > + prefix_push(FUNC_TRIM); > > + test_print("Running %s tests...\n", FUNC_TRIM); > > + > > + memblock_trim_memory_aligned_check(); > > + memblock_trim_memory_too_small_check(); > > + memblock_trim_memory_unaligned_base_check(); > > + memblock_trim_memory_unaligned_end_check(); > > + > > + prefix_pop(); > > + > > + return 0; > > +} > > + > > int memblock_basic_checks(void) > > { > > memblock_initialization_check(); > > @@ -1731,6 +1953,7 @@ int memblock_basic_checks(void) > > memblock_remove_checks(); > > memblock_free_checks(); > > memblock_bottom_up_checks(); > > + memblock_trim_memory_checks(); > > return 0; > > } > > Others looks good. Thanks, Rebecca
diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/memblock/tests/basic_api.c index d7f008e7a12a..c8bb44f20846 100644 --- a/tools/testing/memblock/tests/basic_api.c +++ b/tools/testing/memblock/tests/basic_api.c @@ -8,6 +8,7 @@ #define FUNC_RESERVE "memblock_reserve" #define FUNC_REMOVE "memblock_remove" #define FUNC_FREE "memblock_free" +#define FUNC_TRIM "memblock_trim_memory" static int memblock_initialization_check(void) { @@ -1723,6 +1724,227 @@ static int memblock_bottom_up_checks(void) return 0; } +/* + * A test that tries to trim memory when both ends of the memory region are + * aligned. Expect that the memory will not be trimmed. Expect the counter to + * not be updated. + */ +static int memblock_trim_memory_aligned_check(void) +{ + struct memblock_region *rgn; + phys_addr_t alignment = SMP_CACHE_BYTES; + + rgn = &memblock.memory.regions[0]; + + struct region r = { + .base = alignment, + .size = alignment * 4 + }; + + PREFIX_PUSH(); + + reset_memblock_regions(); + memblock_add(r.base, r.size); + memblock_trim_memory(alignment); + + ASSERT_EQ(rgn->base, r.base); + ASSERT_EQ(rgn->size, r.size); + + ASSERT_EQ(memblock.memory.cnt, 1); + + test_pass_pop(); + + return 0; +} + +/* + * A test that tries to trim memory when there are two available regions, r1 and + * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end + * and smaller than the alignment: + * + * alignment + * |--------| + * | +-----------------+ +------+ | + * | | r1 | | r2 | | + * +--------+-----------------+--------+------+---+ + * ^ ^ ^ ^ ^ + * |________|________|________| | + * | Unaligned address + * Aligned addresses + * + * Expect that r1 will not be trimmed and r2 will be removed. Expect the + * counter to be updated. + */ +static int memblock_trim_memory_too_small_check(void) +{ + struct memblock_region *rgn; + phys_addr_t alignment = SMP_CACHE_BYTES; + + rgn = &memblock.memory.regions[0]; + + struct region r1 = { + .base = alignment, + .size = alignment * 2 + }; + struct region r2 = { + .base = alignment * 4, + .size = alignment - SZ_2 + }; + + PREFIX_PUSH(); + + reset_memblock_regions(); + memblock_add(r1.base, r1.size); + memblock_add(r2.base, r2.size); + memblock_trim_memory(alignment); + + ASSERT_EQ(rgn->base, r1.base); + ASSERT_EQ(rgn->size, r1.size); + + ASSERT_EQ(memblock.memory.cnt, 1); + + test_pass_pop(); + + return 0; +} + +/* + * A test that tries to trim memory when there are two available regions, r1 and + * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base + * and aligned at the end: + * + * Unaligned address + * | + * v + * | +-----------------+ +---------------+ | + * | | r1 | | r2 | | + * +--------+-----------------+----------+---------------+---+ + * ^ ^ ^ ^ ^ ^ + * |________|________|________|________|________| + * | + * Aligned addresses + * + * Expect that r1 will not be trimmed and r2 will be trimmed at the base. + * Expect the counter to not be updated. + */ +static int memblock_trim_memory_unaligned_base_check(void) +{ + struct memblock_region *rgn1, *rgn2; + phys_addr_t alignment = SMP_CACHE_BYTES; + phys_addr_t offset = SZ_2; + phys_addr_t r2_base, r2_size; + + rgn1 = &memblock.memory.regions[0]; + rgn2 = &memblock.memory.regions[1]; + + struct region r1 = { + .base = alignment, + .size = alignment * 2 + }; + struct region r2 = { + .base = alignment * 4 + offset, + .size = alignment * 2 - offset + }; + + PREFIX_PUSH(); + + r2_base = r2.base + (alignment - offset); + r2_size = r2.size - (alignment - offset); + + reset_memblock_regions(); + memblock_add(r1.base, r1.size); + memblock_add(r2.base, r2.size); + memblock_trim_memory(alignment); + + ASSERT_EQ(rgn1->base, r1.base); + ASSERT_EQ(rgn1->size, r1.size); + + ASSERT_EQ(rgn2->base, r2_base); + ASSERT_EQ(rgn2->size, r2_size); + + ASSERT_EQ(memblock.memory.cnt, 2); + + test_pass_pop(); + + return 0; +} + +/* + * A test that tries to trim memory when there are two available regions, r1 and + * r2. Region r1 is aligned on both ends and region r2 is aligned at the base + * and unaligned at the end: + * + * Unaligned address + * | + * v + * | +-----------------+ +---------------+ | + * | | r1 | | r2 | | + * +--------+-----------------+--------+---------------+---+ + * ^ ^ ^ ^ ^ ^ + * |________|________|________|________|________| + * | + * Aligned addresses + * + * Expect that r1 will not be trimmed and r2 will be trimmed at the base. + * Expect the counter to not be updated. + */ +static int memblock_trim_memory_unaligned_end_check(void) +{ + struct memblock_region *rgn1, *rgn2; + phys_addr_t alignment = SMP_CACHE_BYTES; + phys_addr_t offset = SZ_2; + phys_addr_t r2_size; + + rgn1 = &memblock.memory.regions[0]; + rgn2 = &memblock.memory.regions[1]; + + struct region r1 = { + .base = alignment, + .size = alignment * 2 + }; + struct region r2 = { + .base = alignment * 4, + .size = alignment * 2 - offset + }; + + PREFIX_PUSH(); + + r2_size = r2.size - (alignment - offset); + + reset_memblock_regions(); + memblock_add(r1.base, r1.size); + memblock_add(r2.base, r2.size); + memblock_trim_memory(alignment); + + ASSERT_EQ(rgn1->base, r1.base); + ASSERT_EQ(rgn1->size, r1.size); + + ASSERT_EQ(rgn2->base, r2.base); + ASSERT_EQ(rgn2->size, r2_size); + + ASSERT_EQ(memblock.memory.cnt, 2); + + test_pass_pop(); + + return 0; +} + +static int memblock_trim_memory_checks(void) +{ + prefix_reset(); + prefix_push(FUNC_TRIM); + test_print("Running %s tests...\n", FUNC_TRIM); + + memblock_trim_memory_aligned_check(); + memblock_trim_memory_too_small_check(); + memblock_trim_memory_unaligned_base_check(); + memblock_trim_memory_unaligned_end_check(); + + prefix_pop(); + + return 0; +} + int memblock_basic_checks(void) { memblock_initialization_check(); @@ -1731,6 +1953,7 @@ int memblock_basic_checks(void) memblock_remove_checks(); memblock_free_checks(); memblock_bottom_up_checks(); + memblock_trim_memory_checks(); return 0; }
Add tests for memblock_trim_memory() for the following scenarios: - all regions aligned - one region unalign that is smaller than the alignment - one region unaligned at the base - one region unaligned at the end Signed-off-by: Rebecca Mckeever <remckee0@gmail.com> --- tools/testing/memblock/tests/basic_api.c | 223 +++++++++++++++++++++++ 1 file changed, 223 insertions(+)