Lines Matching +full:range +full:- +full:double
1 // SPDX-License-Identifier: GPL-2.0-or-later
57 ASSERT_EQ(rgn->base, r.base); in memblock_add_simple_check()
58 ASSERT_EQ(rgn->size, r.size); in memblock_add_simple_check()
90 ASSERT_EQ(rgn->base, r.base); in memblock_add_node_simple_check()
91 ASSERT_EQ(rgn->size, r.size); in memblock_add_node_simple_check()
93 ASSERT_EQ(rgn->nid, 1); in memblock_add_node_simple_check()
95 ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG); in memblock_add_node_simple_check()
109 * | +--------+ +--------+ |
111 * +--------+--------+--------+--------+--+
139 ASSERT_EQ(rgn1->base, r1.base); in memblock_add_disjoint_check()
140 ASSERT_EQ(rgn1->size, r1.size); in memblock_add_disjoint_check()
142 ASSERT_EQ(rgn2->base, r2.base); in memblock_add_disjoint_check()
143 ASSERT_EQ(rgn2->size, r2.size); in memblock_add_disjoint_check()
157 * | +----+----+------------+ |
159 * +----+----+----+------------+----------+
188 total_size = (r1.base - r2.base) + r1.size; in memblock_add_overlap_top_check()
194 ASSERT_EQ(rgn->base, r2.base); in memblock_add_overlap_top_check()
195 ASSERT_EQ(rgn->size, total_size); in memblock_add_overlap_top_check()
209 * | +--+------+----------+ |
211 * +--+--+------+----------+--------------+
240 total_size = (r2.base - r1.base) + r2.size; in memblock_add_overlap_bottom_check()
246 ASSERT_EQ(rgn->base, r1.base); in memblock_add_overlap_bottom_check()
247 ASSERT_EQ(rgn->size, total_size); in memblock_add_overlap_bottom_check()
259 * within the range of r1 (that is r1.base < r2.base &&
262 * | +-------+--+-----------------------+
264 * +---+-------+--+-----------------------+
293 ASSERT_EQ(rgn->base, r1.base); in memblock_add_within_check()
294 ASSERT_EQ(rgn->size, r1.size); in memblock_add_within_check()
334 * | +--------+--------+--------+ |
336 * +--------+--------+--------+--------+--+
371 ASSERT_EQ(rgn->base, r1.base); in memblock_add_between_check()
372 ASSERT_EQ(rgn->size, total_size); in memblock_add_between_check()
386 * +--------+
388 * +--------+
389 * | +----+
391 * +----------------------------+----+
393 * Expect to add a memory block of size PHYS_ADDR_MAX - r.base. Expect the
404 .base = PHYS_ADDR_MAX - SZ_1M, in memblock_add_near_max_check()
410 total_size = PHYS_ADDR_MAX - r.base; in memblock_add_near_max_check()
415 ASSERT_EQ(rgn->base, r.base); in memblock_add_near_max_check()
416 ASSERT_EQ(rgn->size, total_size); in memblock_add_near_max_check()
428 * Expect to trigger memblock_double_array() to double the
505 * The current memory.regions is occupying a range of memory that in memblock_add_many_check()
508 * the tests can run as normal and not affected by the double array. in memblock_add_many_check()
562 ASSERT_EQ(rgn->base, r.base); in memblock_reserve_simple_check()
563 ASSERT_EQ(rgn->size, r.size); in memblock_reserve_simple_check()
573 * | +--+ +----------------+ |
575 * +--------+--+------+----------------+--+
603 ASSERT_EQ(rgn1->base, r1.base); in memblock_reserve_disjoint_check()
604 ASSERT_EQ(rgn1->size, r1.size); in memblock_reserve_disjoint_check()
606 ASSERT_EQ(rgn2->base, r2.base); in memblock_reserve_disjoint_check()
607 ASSERT_EQ(rgn2->size, r2.size); in memblock_reserve_disjoint_check()
622 * | +--------------+--+--------------+ |
624 * +--+--------------+--+--------------+--+
653 total_size = (r1.base - r2.base) + r1.size; in memblock_reserve_overlap_top_check()
659 ASSERT_EQ(rgn->base, r2.base); in memblock_reserve_overlap_top_check()
660 ASSERT_EQ(rgn->size, total_size); in memblock_reserve_overlap_top_check()
675 * | +--------------+--+--------------+ |
677 * +--+--------------+--+--------------+--+
706 total_size = (r2.base - r1.base) + r2.size; in memblock_reserve_overlap_bottom_check()
712 ASSERT_EQ(rgn->base, r1.base); in memblock_reserve_overlap_bottom_check()
713 ASSERT_EQ(rgn->size, total_size); in memblock_reserve_overlap_bottom_check()
725 * where r2 is within the range of r1 (that is
728 * | +-----+--+---------------------------|
730 * +-+-----+--+---------------------------+
761 ASSERT_EQ(rgn->base, r1.base); in memblock_reserve_within_check()
762 ASSERT_EQ(rgn->size, r1.size); in memblock_reserve_within_check()
803 * | +--------+--------+--------+ |
805 * +--------+--------+--------+--------+--+
840 ASSERT_EQ(rgn->base, r1.base); in memblock_reserve_between_check()
841 ASSERT_EQ(rgn->size, total_size); in memblock_reserve_between_check()
855 * +--------+
857 * +--------+
858 * | +----+
860 * +----------------------------+----+
862 * Expect to reserve a memory block of size PHYS_ADDR_MAX - r.base. Expect the
873 .base = PHYS_ADDR_MAX - SZ_1M, in memblock_reserve_near_max_check()
879 total_size = PHYS_ADDR_MAX - r.base; in memblock_reserve_near_max_check()
884 ASSERT_EQ(rgn->base, r.base); in memblock_reserve_near_max_check()
885 ASSERT_EQ(rgn->size, total_size); in memblock_reserve_near_max_check()
897 * Expect to trigger memblock_double_array() to double the
934 /* This reserve the 129 memory_region, and makes it double array. */ in memblock_reserve_many_check()
972 * The current reserved.regions is occupying a range of memory that in memblock_reserve_many_check()
975 * the tests can run as normal and not affected by the double array. in memblock_reserve_many_check()
988 * Expect to trigger memblock_double_array() to double the
992 * +-------+ +-------+ +-------+ +-------+
994 * +-------+-------+-------+-------+-------+ +-------+
995 * |<-32K->| |<-32K->|
1039 /* This reserve the 129 memory_region, and makes it double array. */ in memblock_reserve_all_locations_check()
1077 * The current reserved.regions is occupying a range of memory that in memblock_reserve_all_locations_check()
1080 * the tests can run as normal and not affected by the double array. in memblock_reserve_all_locations_check()
1093 * Expect to trigger memblock_double_array() to double the
1095 * sure it doesn't conflict with the range we want to reserve.
1099 * an available range in memory for the new array. We intended to put two
1100 * ranges in memory with one is the exact range of the skipped one. Before
1102 * reserved array"), the new array would sits in the skipped range which is a
1106 * memory +-------+ +-------+
1108 * +-------+ ------+-------+-------+-------+
1109 * |<-32K->|<-32K->|<-32K->|
1112 * reserved +-------+ ......... +-------+
1114 * +-------+-------+-------+ +-------+
1115 * |<-32K->|
1135 * +---+ +---+ +---+ in memblock_reserve_many_may_conflict_check()
1137 * +---+ +---+ +---+ in memblock_reserve_many_may_conflict_check()
1139 * Pre-allocate the range for 129 memory block + one range for double in memblock_reserve_many_may_conflict_check()
1173 ASSERT_EQ(memblock.reserved.cnt, i - 1); in memblock_reserve_many_may_conflict_check()
1174 ASSERT_EQ(memblock.reserved.total_size, (i - 1) * MEM_SIZE); in memblock_reserve_many_may_conflict_check()
1180 /* This reserve the 129 memory_region, and makes it double array. */ in memblock_reserve_many_may_conflict_check()
1202 * The first reserved region is allocated for double array in memblock_reserve_many_may_conflict_check()
1204 * MEMORY_BASE_OFFSET(0, offset) + SZ_32K - new_reserved_regions_size in memblock_reserve_many_may_conflict_check()
1225 * The current reserved.regions is occupying a range of memory that in memblock_reserve_many_may_conflict_check()
1228 * the tests can run as normal and not affected by the double array. in memblock_reserve_many_may_conflict_check()
1269 * | ...... +----------------+ |
1271 * +--+----+----------+----------------+--+
1302 ASSERT_EQ(rgn->base, r2.base); in memblock_remove_simple_check()
1303 ASSERT_EQ(rgn->size, r2.size); in memblock_remove_simple_check()
1317 * +----------------+
1319 * +----------------+
1320 * | +----+ |
1322 * +--+----+------------------------------+
1350 ASSERT_EQ(rgn->base, r1.base); in memblock_remove_absent_check()
1351 ASSERT_EQ(rgn->size, r1.size); in memblock_remove_absent_check()
1366 * +-----------------+
1368 * +-----------------+
1369 * | .........+--------+ |
1371 * +-----------------+--------+--------+--+
1400 total_size = r1_end - r2_end; in memblock_remove_overlap_top_check()
1406 ASSERT_EQ(rgn->base, r1.base + r2.base); in memblock_remove_overlap_top_check()
1407 ASSERT_EQ(rgn->size, total_size); in memblock_remove_overlap_top_check()
1421 * +--------------------------------+
1423 * +--------------------------------+
1424 * | +---+..... |
1426 * +-+---+----+---------------------------+
1452 total_size = r2.base - r1.base; in memblock_remove_overlap_bottom_check()
1458 ASSERT_EQ(rgn->base, r1.base); in memblock_remove_overlap_bottom_check()
1459 ASSERT_EQ(rgn->size, total_size); in memblock_remove_overlap_bottom_check()
1470 * A test that tries to remove a region r2 that is within the range of
1474 * +----+
1476 * +----+
1477 * | +-------------+....+---------------+ |
1479 * +-+-------------+----+---------------+-+
1484 * Expect that the region is split into two - one that ends at r2.base and
1507 r1_size = r2.base - r1.base; in memblock_remove_within_check()
1508 r2_size = (r1.base + r1.size) - (r2.base + r2.size); in memblock_remove_within_check()
1515 ASSERT_EQ(rgn1->base, r1.base); in memblock_remove_within_check()
1516 ASSERT_EQ(rgn1->size, r1_size); in memblock_remove_within_check()
1518 ASSERT_EQ(rgn2->base, r2.base + r2.size); in memblock_remove_within_check()
1519 ASSERT_EQ(rgn2->size, r2_size); in memblock_remove_within_check()
1553 ASSERT_EQ(rgn->base, 0); in memblock_remove_only_region_check()
1554 ASSERT_EQ(rgn->size, 0); in memblock_remove_only_region_check()
1568 * +--------+
1570 * +--------+
1571 * | +---+....+
1573 * +------------------------+---+----+
1587 .base = PHYS_ADDR_MAX - SZ_2M, in memblock_remove_near_max_check()
1592 .base = PHYS_ADDR_MAX - SZ_1M, in memblock_remove_near_max_check()
1598 total_size = r1.size - (PHYS_ADDR_MAX - r2.base); in memblock_remove_near_max_check()
1604 ASSERT_EQ(rgn->base, r1.base); in memblock_remove_near_max_check()
1605 ASSERT_EQ(rgn->size, total_size); in memblock_remove_near_max_check()
1619 * +----------------+
1621 * +----------------+
1622 * | +----+..... ........+--------+
1624 * +----+----+----+---+-------+--------+-----+
1655 new_r1_size = r3.base - r1.base; in memblock_remove_overlap_two_check()
1656 new_r2_size = r2_end - r3_end; in memblock_remove_overlap_two_check()
1664 ASSERT_EQ(rgn1->base, r1.base); in memblock_remove_overlap_two_check()
1665 ASSERT_EQ(rgn1->size, new_r1_size); in memblock_remove_overlap_two_check()
1667 ASSERT_EQ(rgn2->base, r3_end); in memblock_remove_overlap_two_check()
1668 ASSERT_EQ(rgn2->size, new_r2_size); in memblock_remove_overlap_two_check()
1703 * | ...... +----+ |
1705 * +--------------+----+-----------+----+-+
1735 ASSERT_EQ(rgn->base, r2.base); in memblock_free_simple_check()
1736 ASSERT_EQ(rgn->size, r2.size); in memblock_free_simple_check()
1750 * +----------------+
1752 * +----------------+
1753 * | +----+ |
1755 * +--+----+------------------------------+
1783 ASSERT_EQ(rgn->base, r1.base); in memblock_free_absent_check()
1784 ASSERT_EQ(rgn->size, r1.size); in memblock_free_absent_check()
1798 * +----+
1800 * +----+
1801 * | ...+--------------+ |
1803 * +----+--+--------------+---------------+
1831 total_size = (r1.size + r1.base) - (r2.base + r2.size); in memblock_free_overlap_top_check()
1837 ASSERT_EQ(rgn->base, r2.base + r2.size); in memblock_free_overlap_top_check()
1838 ASSERT_EQ(rgn->size, total_size); in memblock_free_overlap_top_check()
1852 * +----------------+
1854 * +----------------+
1855 * | +-----------+..... |
1857 * +----+-----------+----+----------------+
1880 total_size = r2.base - r1.base; in memblock_free_overlap_bottom_check()
1886 ASSERT_EQ(rgn->base, r1.base); in memblock_free_overlap_bottom_check()
1887 ASSERT_EQ(rgn->size, total_size); in memblock_free_overlap_bottom_check()
1898 * A test that tries to free a region r2 that is within the range of the
1902 * +----+
1904 * +----+
1905 * | +------------+....+---------------+
1907 * +----+------------+----+---------------+
1912 * Expect that the region is split into two - one that ends at r2.base and
1935 r1_size = r2.base - r1.base; in memblock_free_within_check()
1936 r2_size = (r1.base + r1.size) - (r2.base + r2.size); in memblock_free_within_check()
1943 ASSERT_EQ(rgn1->base, r1.base); in memblock_free_within_check()
1944 ASSERT_EQ(rgn1->size, r1_size); in memblock_free_within_check()
1946 ASSERT_EQ(rgn2->base, r2.base + r2.size); in memblock_free_within_check()
1947 ASSERT_EQ(rgn2->size, r2_size); in memblock_free_within_check()
1981 ASSERT_EQ(rgn->base, 0); in memblock_free_only_region_check()
1982 ASSERT_EQ(rgn->size, 0); in memblock_free_only_region_check()
1995 * +--------+
1997 * +--------+
1998 * | +---+....+
2000 * +------------------------+---+----+
2014 .base = PHYS_ADDR_MAX - SZ_2M, in memblock_free_near_max_check()
2019 .base = PHYS_ADDR_MAX - SZ_1M, in memblock_free_near_max_check()
2025 total_size = r1.size - (PHYS_ADDR_MAX - r2.base); in memblock_free_near_max_check()
2031 ASSERT_EQ(rgn->base, r1.base); in memblock_free_near_max_check()
2032 ASSERT_EQ(rgn->size, total_size); in memblock_free_near_max_check()
2046 * +----------------+
2048 * +----------------+
2049 * | +----+..... ........+--------+
2051 * +----+----+----+---+-------+--------+-----+
2082 new_r1_size = r3.base - r1.base; in memblock_free_overlap_two_check()
2083 new_r2_size = r2_end - r3_end; in memblock_free_overlap_two_check()
2091 ASSERT_EQ(rgn1->base, r1.base); in memblock_free_overlap_two_check()
2092 ASSERT_EQ(rgn1->size, new_r1_size); in memblock_free_overlap_two_check()
2094 ASSERT_EQ(rgn2->base, r3_end); in memblock_free_overlap_two_check()
2095 ASSERT_EQ(rgn2->size, new_r2_size); in memblock_free_overlap_two_check()
2192 ASSERT_EQ(rgn->base, r.base); in memblock_trim_memory_aligned_check()
2193 ASSERT_EQ(rgn->size, r.size); in memblock_trim_memory_aligned_check()
2208 * |--------|
2209 * | +-----------------+ +------+ |
2211 * +--------+-----------------+--------+------+---+
2233 .size = alignment - SZ_2 in memblock_trim_memory_too_small_check()
2243 ASSERT_EQ(rgn->base, r1.base); in memblock_trim_memory_too_small_check()
2244 ASSERT_EQ(rgn->size, r1.size); in memblock_trim_memory_too_small_check()
2261 * | +-----------------+ +---------------+ |
2263 * +--------+-----------------+----------+---------------+---+
2288 .size = alignment * 2 - offset in memblock_trim_memory_unaligned_base_check()
2293 new_r2_base = r2.base + (alignment - offset); in memblock_trim_memory_unaligned_base_check()
2294 new_r2_size = r2.size - (alignment - offset); in memblock_trim_memory_unaligned_base_check()
2301 ASSERT_EQ(rgn1->base, r1.base); in memblock_trim_memory_unaligned_base_check()
2302 ASSERT_EQ(rgn1->size, r1.size); in memblock_trim_memory_unaligned_base_check()
2304 ASSERT_EQ(rgn2->base, new_r2_base); in memblock_trim_memory_unaligned_base_check()
2305 ASSERT_EQ(rgn2->size, new_r2_size); in memblock_trim_memory_unaligned_base_check()
2322 * | +-----------------+ +---------------+ |
2324 * +--------+-----------------+--------+---------------+---+
2349 .size = alignment * 2 - offset in memblock_trim_memory_unaligned_end_check()
2354 new_r2_size = r2.size - (alignment - offset); in memblock_trim_memory_unaligned_end_check()
2361 ASSERT_EQ(rgn1->base, r1.base); in memblock_trim_memory_unaligned_end_check()
2362 ASSERT_EQ(rgn1->size, r1.size); in memblock_trim_memory_unaligned_end_check()
2364 ASSERT_EQ(rgn2->base, r2.base); in memblock_trim_memory_unaligned_end_check()
2365 ASSERT_EQ(rgn2->size, new_r2_size); in memblock_trim_memory_unaligned_end_check()
2407 ASSERT_FALSE(memblock_overlaps_region(&memblock.memory, SZ_1G - SZ_1M, SZ_1M)); in memblock_overlaps_region_check()
2411 ASSERT_TRUE(memblock_overlaps_region(&memblock.memory, SZ_1G - SZ_1M, SZ_2M)); in memblock_overlaps_region_check()
2416 ASSERT_TRUE(memblock_overlaps_region(&memblock.memory, SZ_1G - SZ_2M, SZ_8M)); in memblock_overlaps_region_check()
2453 /* Equally Split range to node 0 and 1*/ in memblock_set_node_check()
2461 ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); in memblock_set_node_check()
2462 ASSERT_EQ(rgn->size, memblock_phys_mem_size() / 2); in memblock_set_node_check()
2465 ASSERT_EQ(rgn->base, memblock_start_of_DRAM() + memblock_phys_mem_size() / 2); in memblock_set_node_check()
2466 ASSERT_EQ(rgn->size, memblock_phys_mem_size() / 2); in memblock_set_node_check()
2473 memblock_reserve(memblock_start_of_DRAM() + memblock_phys_mem_size() / 2 - SZ_8, in memblock_set_node_check()
2479 * But it may miss some region if memblock_set_node() double the in memblock_set_node_check()
2489 memblock_set_node(rgn->base, rgn->size, &memblock.reserved, nid); in memblock_set_node_check()
2497 if (rgn == (memblock.reserved.regions + memblock.reserved.cnt - 1)) in memblock_set_node_check()
2506 * The current reserved.regions is occupying a range of memory that in memblock_set_node_check()
2509 * the tests can run as normal and not affected by the double array. in memblock_set_node_check()