| // Copyright 2024 The Fuchsia Authors | |
| // | |
| // Use of this source code is governed by a MIT-style | |
| // license that can be found in the LICENSE file or at | |
| // https://opensource.org/licenses/MIT | |
| #include <lib/memalloc/range.h> | |
| #include <lib/memalloc/testing/range.h> | |
| #include <span> | |
| #include <vector> | |
| #include <gtest/gtest.h> | |
| namespace { | |
| using Range = memalloc::Range; | |
| using Type = memalloc::Type; | |
| constexpr uint64_t kChunkSize = 0x1000; | |
| TEST(MemallocRangeTests, NormalizeRanges) { | |
| static constexpr Range kRanges[] = { | |
| // RAM: [0, kChunkSize) | |
| { | |
| .addr = 0, | |
| .size = kChunkSize, | |
| .type = Type::kPoolBookkeeping, | |
| }, | |
| // data ZBI: [kChunkSize, 2*kChunkSize) | |
| { | |
| .addr = kChunkSize, | |
| .size = kChunkSize, | |
| .type = Type::kDataZbi, | |
| }, | |
| // test payload: [2*kChunkSize, 3*kChunkSize) | |
| { | |
| .addr = 2 * kChunkSize, | |
| .size = kChunkSize, | |
| .type = Type::kPoolTestPayload, | |
| }, | |
| // peripheral: [3*kChunkSize, 4*kChunkSize) | |
| { | |
| .addr = 3 * kChunkSize, | |
| .size = kChunkSize, | |
| .type = Type::kPeripheral, | |
| }, | |
| // test payload: [5*kChunkSize, 6*kChunkSize) | |
| { | |
| .addr = 5 * kChunkSize, | |
| .size = kChunkSize, | |
| .type = Type::kPoolTestPayload, | |
| }, | |
| // phys kernel: [6*kChunkSize, 7*kChunkSize) | |
| { | |
| .addr = 6 * kChunkSize, | |
| .size = kChunkSize, | |
| .type = Type::kPhysKernel, | |
| }, | |
| }; | |
| // Normalize away all ranges. | |
| { | |
| std::vector<Range> normalized; | |
| memalloc::NormalizeRanges( | |
| std::span{kRanges}, | |
| [&normalized](const Range& range) { | |
| normalized.push_back(range); | |
| return true; | |
| }, | |
| [](Type) { return std::nullopt; }); | |
| EXPECT_TRUE(normalized.empty()); | |
| } | |
| // Bail after the first range. | |
| { | |
| std::vector<Range> normalized; | |
| memalloc::NormalizeRanges( | |
| std::span{kRanges}, | |
| [&normalized](const Range& range) { | |
| normalized.push_back(range); | |
| return false; | |
| }, | |
| [](Type type) { return type; }); | |
| EXPECT_EQ(1u, normalized.size()); | |
| } | |
| // Normalize just RAM. | |
| { | |
| std::vector<Range> normalized; | |
| memalloc::NormalizeRam(std::span{kRanges}, [&normalized](const Range& range) { | |
| normalized.push_back(range); | |
| return true; | |
| }); | |
| constexpr Range kExpected[] = { | |
| { | |
| .addr = 0, | |
| .size = 3 * kChunkSize, | |
| .type = Type::kFreeRam, | |
| }, | |
| { | |
| .addr = 5 * kChunkSize, | |
| .size = 2 * kChunkSize, | |
| .type = Type::kFreeRam, | |
| }, | |
| }; | |
| memalloc::testing::CompareRanges(std::span{kExpected}, {normalized}); | |
| } | |
| // Discard RAM. | |
| { | |
| std::vector<Range> normalized; | |
| memalloc::NormalizeRanges( | |
| std::span{kRanges}, | |
| [&normalized](const Range& range) { | |
| normalized.push_back(range); | |
| return true; | |
| }, | |
| [](Type type) { | |
| return (IsAllocatedType(type) || type == Type::kFreeRam) ? std::nullopt | |
| : std::make_optional(type); | |
| }); | |
| constexpr Range kExpected[] = { | |
| { | |
| .addr = 3 * kChunkSize, | |
| .size = kChunkSize, | |
| .type = Type::kPeripheral, | |
| }, | |
| }; | |
| memalloc::testing::CompareRanges(std::span{kExpected}, {normalized}); | |
| } | |
| // Just keep pool test payloads and bookkeeping. | |
| { | |
| std::vector<Range> normalized; | |
| memalloc::NormalizeRanges( | |
| std::span{kRanges}, | |
| [&normalized](const Range& range) { | |
| normalized.push_back(range); | |
| return true; | |
| }, | |
| [](Type type) { | |
| return (type == Type::kPoolBookkeeping || type == Type::kPoolTestPayload) | |
| ? std::make_optional(type) | |
| : std::nullopt; | |
| }); | |
| constexpr Range kExpected[] = { | |
| { | |
| .addr = 0, | |
| .size = kChunkSize, | |
| .type = Type::kPoolBookkeeping, | |
| }, | |
| { | |
| .addr = 2 * kChunkSize, | |
| .size = kChunkSize, | |
| .type = Type::kPoolTestPayload, | |
| }, | |
| { | |
| .addr = 5 * kChunkSize, | |
| .size = kChunkSize, | |
| .type = Type::kPoolTestPayload, | |
| }, | |
| }; | |
| memalloc::testing::CompareRanges(std::span{kExpected}, {normalized}); | |
| } | |
| // Zero-sized ranges are skipped and do not break up merging. | |
| { | |
| constexpr Range kWithEmpty[] = { | |
| { | |
| .addr = 0x1000, | |
| .size = 2 * kChunkSize, | |
| .type = Type::kFreeRam, | |
| }, | |
| { | |
| .addr = 0x3000, | |
| .size = 0, | |
| .type = Type::kPoolTestPayload, | |
| }, | |
| { | |
| .addr = 0x3000, | |
| .size = 3 * kChunkSize, | |
| .type = Type::kFreeRam, | |
| }, | |
| }; | |
| std::vector<Range> normalized; | |
| memalloc::NormalizeRanges( | |
| std::span{kWithEmpty}, | |
| [&normalized](const Range& range) { | |
| normalized.push_back(range); | |
| return true; | |
| }, | |
| [](Type type) { return std::make_optional(type); }); | |
| constexpr Range kExpected[] = { | |
| { | |
| .addr = 0x1000, | |
| .size = 5 * kChunkSize, | |
| .type = Type::kFreeRam, | |
| }, | |
| }; | |
| memalloc::testing::CompareRanges(std::span{kExpected}, {normalized}); | |
| } | |
| // Verify constexpr evaluation. | |
| { | |
| constexpr auto count_ram_ranges = [] { | |
| size_t count = 0; | |
| memalloc::NormalizeRam(std::span{kRanges}, [&count](const Range&) { | |
| ++count; | |
| return true; | |
| }); | |
| return count; | |
| }; | |
| static_assert(count_ram_ranges() == 2); | |
| } | |
| } | |
| } // namespace |