intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-07 04:48:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor PhysicalAddressAllocator

Browse Source 
- create allocator dynamically in AUB & TBX CSRs

Change-Id: I3b01a3fc2f4824b552ef27cbda5bdcc140e92e53
This commit is contained in:
Hoppe, Mateusz
2018-09-20 13:54:19 -07:00
committed by sys_ocldev
parent 328ecae57d
commit 91aaa92fb6
18 changed files with 191 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
unit_tests/aub_tests/command_stream/aub_command_stream_fixture.h
View File

@@ -11,6 +11,7 @@
#include "runtime/command_stream/aub_command_stream_receiver_hw.h"
#include "runtime/command_stream/command_stream_receiver_with_aub_dump.h"
#include "runtime/command_stream/tbx_command_stream_receiver_hw.h"
#include "runtime/memory_manager/memory_banks.h"
#include "unit_tests/command_stream/command_stream_fixture.h"
#include "unit_tests/tests_configuration.h"
@@ -68,7 +69,7 @@ class AUBCommandStreamFixture : public CommandStreamFixture {
aubCsr->getAddressSpaceFromPTEBits(entryBits));
};
aubCsr->ppgtt->pageWalk(reinterpret_cast<uintptr_t>(gfxAddress), length, 0, PageTableEntry::nonValidBits, walker, PageTableHelper::memoryBankNotSpecified);
aubCsr->ppgtt->pageWalk(reinterpret_cast<uintptr_t>(gfxAddress), length, 0, PageTableEntry::nonValidBits, walker, MemoryBanks::BankNotSpecified);
}
CommandStreamReceiver *pCommandStreamReceiver = nullptr;

14
unit_tests/command_stream/aub_command_stream_receiver_tests.cpp
View File

@@ -12,6 +12,7 @@
#include "runtime/helpers/dispatch_info.h"
#include "runtime/helpers/flat_batch_buffer_helper_hw.h"
#include "runtime/helpers/hw_info.h"
#include "runtime/memory_manager/memory_banks.h"
#include "runtime/memory_manager/memory_manager.h"
#include "runtime/os_interface/debug_settings_manager.h"
#include "test.h"
@@ -1806,6 +1807,15 @@ HWTEST_F(AubCommandStreamReceiverTests, givenPhysicalAddressWhenSetGttEntryIsCal
EXPECT_FALSE(entry.pageConfig.LocalMemory);
}
HWTEST_F(AubCommandStreamReceiverTests, whenGetMemoryBankForGttIsCalledThenCorrectBankIsReturned) {
const HardwareInfo &hwInfoIn = *platformDevices[0];
std::unique_ptr<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(hwInfoIn, "", true, *pDevice->executionEnvironment));
aubCsr->localMemoryEnabled = false;
auto bank = aubCsr->getMemoryBankForGtt();
EXPECT_EQ(MemoryBanks::MainBank, bank);
}
HWTEST_F(AubCommandStreamReceiverTests, givenEntryBitsPresentAndWritableWhenGetAddressSpaceFromPTEBitsIsCalledThenTraceNonLocalIsReturned) {
const HardwareInfo &hwInfoIn = *platformDevices[0];
std::unique_ptr<MockAubCsr<FamilyType>> aubCsr(new MockAubCsr<FamilyType>(hwInfoIn, "", true, *pDevice->executionEnvironment));
@@ -1950,10 +1960,10 @@ HWTEST_F(AubCommandStreamReceiverTests, whenAubCommandStreamReceiverIsCreatedThe
ASSERT_NE(nullptr, aubCsr->ggtt.get());
uintptr_t address = 0x20000;
auto physicalAddress = aubCsr->ppgtt->map(address, MemoryConstants::pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto physicalAddress = aubCsr->ppgtt->map(address, MemoryConstants::pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(0u, physicalAddress);
physicalAddress = aubCsr->ggtt->map(address, MemoryConstants::pageSize, 0, PageTableHelper::memoryBankNotSpecified);
physicalAddress = aubCsr->ggtt->map(address, MemoryConstants::pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(0u, physicalAddress);
}

5
unit_tests/command_stream/tbx_command_stream_tests.cpp
View File

@@ -10,6 +10,7 @@
#include "runtime/command_stream/tbx_command_stream_receiver_hw.h"
#include "runtime/command_stream/command_stream_receiver_hw.h"
#include "runtime/helpers/ptr_math.h"
#include "runtime/memory_manager/memory_banks.h"
#include "runtime/os_interface/debug_settings_manager.h"
#include "gen_cmd_parse.h"
#include "unit_tests/command_queue/command_queue_fixture.h"
@@ -323,9 +324,9 @@ HWTEST_F(TbxCommandSteamSimpleTest, whenTbxCommandStreamReceiverIsCreatedThenPPG
MockTbxCsr<FamilyType> tbxCsr(*platformDevices[0], *pDevice->executionEnvironment);
uintptr_t address = 0x20000;
auto physicalAddress = tbxCsr.ppgtt->map(address, MemoryConstants::pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto physicalAddress = tbxCsr.ppgtt->map(address, MemoryConstants::pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(0u, physicalAddress);
physicalAddress = tbxCsr.ggtt->map(address, MemoryConstants::pageSize, 0, PageTableHelper::memoryBankNotSpecified);
physicalAddress = tbxCsr.ggtt->map(address, MemoryConstants::pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(0u, physicalAddress);
}

1
unit_tests/memory_manager/CMakeLists.txt
View File

@@ -20,3 +20,4 @@ set(IGDRCL_SRCS_tests_memory_manager
${CMAKE_CURRENT_SOURCE_DIR}/svm_memory_manager.cpp
)
target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_memory_manager})
add_subdirectories()

12
unit_tests/memory_manager/memory_manager_tests.cpp
View File

@@ -25,6 +25,7 @@
#include "unit_tests/mocks/mock_deferred_deleter.h"
#include "unit_tests/mocks/mock_device.h"
#include "unit_tests/mocks/mock_gmm.h"
#include "unit_tests/mocks/mock_graphics_allocation.h"
#include "unit_tests/mocks/mock_kernel.h"
#include "unit_tests/mocks/mock_mdi.h"
#include "unit_tests/mocks/mock_memory_manager.h"
@@ -38,6 +39,17 @@ using namespace OCLRT;
typedef Test<MemoryAllocatorFixture> MemoryAllocatorTest;
TEST(MemoryBank, givenDifferentDeviceOrdinalsWhenGettingBankThenCorrectBanksAreReturned) {
auto bank = MemoryBanks::getBank(0);
EXPECT_EQ(MemoryBanks::MainBank, bank);
bank = MemoryBanks::getBank(1);
EXPECT_EQ(MemoryBanks::MainBank, bank);
bank = MemoryBanks::getBank(100);
EXPECT_EQ(MemoryBanks::MainBank, bank);
}
TEST(GraphicsAllocationTest, defaultTypeTraits) {
EXPECT_FALSE(std::is_copy_constructible<GraphicsAllocation>::value);
EXPECT_FALSE(std::is_copy_assignable<GraphicsAllocation>::value);

96
unit_tests/memory_manager/page_table_tests.cpp
View File

@@ -8,6 +8,7 @@
#include "runtime/aub_mem_dump/page_table_entry_bits.h"
#include "runtime/helpers/ptr_math.h"
#include "runtime/helpers/selectors.h"
#include "runtime/memory_manager/memory_banks.h"
#include "runtime/memory_manager/page_table.h"
#include "runtime/memory_manager/page_table.inl"
#include "test.h"
@@ -148,21 +149,19 @@ TEST_F(PageTableTests48, dummy) {
PageWalker walker = [&](uint64_t physAddress, size_t size, size_t offset, uint64_t entryBits) {
};
pt.pageWalk(0, pageSize, 0, 0, walker, PageTableHelper::memoryBankNotSpecified);
pt.pageWalk(0, pageSize, 0, 0, walker, MemoryBanks::MainBank);
}
TEST_F(PageTableTests48, newIsEmpty) {
std::unique_ptr<PPGTTPageTable> pageTable(new PPGTTPageTable(&allocator));
EXPECT_TRUE(pageTable->isEmpty());
EXPECT_EQ(allocator.initialPageAddress, allocator.nextPageAddress);
}
TEST_F(PageTableTests48, DISABLED_mapSizeZero) {
std::unique_ptr<PPGTTPageTable> pageTable(new PPGTTPageTable(&allocator));
EXPECT_TRUE(pageTable->isEmpty());
EXPECT_EQ(allocator.initialPageAddress, allocator.nextPageAddress);
auto phys1 = pageTable->map(0x0, 0x0, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(0x0, 0x0, 0, MemoryBanks::MainBank);
std::cerr << phys1 << std::endl;
}
@@ -180,7 +179,7 @@ TEST_F(PageTableTests48, pageWalkSimple) {
walked += size;
lastOffset += size;
};
pageTable->pageWalk(addr1, lSize, 0, 0, walker, PageTableHelper::memoryBankNotSpecified);
pageTable->pageWalk(addr1, lSize, 0, 0, walker, MemoryBanks::MainBank);
EXPECT_EQ(lSize, walked);
}
@@ -196,12 +195,12 @@ TEST_F(PageTableTests48, givenReservedPhysicalAddressWhenPageWalkIsCalledThenPag
size_t size = 10 * pageSize;
size_t walked = 0u;
auto address = allocator.nextPageAddress.load();
auto address = allocator.mainAllocator.load();
PageWalker walker = [&](uint64_t physAddress, size_t size, size_t offset, uint64_t entryBits) {
walked += size;
};
pageTable->pageWalk(gpuVa, size, 0, 0, walker, PageTableHelper::memoryBankNotSpecified);
pageTable->pageWalk(gpuVa, size, 0, 0, walker, MemoryBanks::MainBank);
EXPECT_EQ(size, walked);
@@ -225,12 +224,12 @@ TEST_F(PageTableTests48, givenZeroEntryBitsWhenPageWalkIsCalledThenPageTableEntr
size_t size = pageSize;
size_t walked = 0u;
auto address = allocator.nextPageAddress.load();
auto address = allocator.mainAllocator.load();
PageWalker walker = [&](uint64_t physAddress, size_t size, size_t offset, uint64_t entryBits) {
walked += size;
};
pageTable->pageWalk(gpuVa, size, 0, 0, walker, PageTableHelper::memoryBankNotSpecified);
pageTable->pageWalk(gpuVa, size, 0, 0, walker, MemoryBanks::MainBank);
EXPECT_EQ(size, walked);
ASSERT_NE(nullptr, pageTable->entries[0]);
@@ -243,9 +242,9 @@ TEST_F(PageTableTests48, givenZeroEntryBitsWhenMapIsCalledThenPageTableEntryHasP
pageTable(std::make_unique<TypeSelector<MockPML4, MockPDPE, sizeof(void *) == 8>::type>(&allocator));
uintptr_t gpuVa = 0x1000;
size_t size = pageSize;
auto address = allocator.nextPageAddress.load();
auto address = allocator.mainAllocator.load();
pageTable->map(gpuVa, size, 0, 0);
pageTable->map(gpuVa, size, 0, MemoryBanks::MainBank);
ASSERT_NE(nullptr, pageTable->entries[0]);
PageTableEntryChecker::testEntry<TypeSelector<MockPML4, MockPDPE, sizeof(void *) == 8>::type>(pageTable.get(), 1, static_cast<uintptr_t>(address | 0x1));
@@ -265,7 +264,7 @@ TEST_F(PageTableTests48, givenEntryBitsWhenPageWalkIsCalledThenEntryBitsArePasse
walked += size;
entryBitsPassed = entryBits;
};
pageTable->pageWalk(gpuVa, size, 0, ppgttBits, walker, PageTableHelper::memoryBankNotSpecified);
pageTable->pageWalk(gpuVa, size, 0, ppgttBits, walker, MemoryBanks::MainBank);
ppgttBits |= 0x1;
EXPECT_EQ(ppgttBits, entryBitsPassed);
@@ -285,13 +284,13 @@ TEST_F(PageTableTests48, givenTwoPageWalksWhenSecondWalkHasDifferentEntryBitsThe
walked += size;
entryBitsPassed = entryBits;
};
pageTable->pageWalk(gpuVa, size, 0, ppgttBits, walker, PageTableHelper::memoryBankNotSpecified);
pageTable->pageWalk(gpuVa, size, 0, ppgttBits, walker, MemoryBanks::MainBank);
ppgttBits |= 0x1;
EXPECT_EQ(ppgttBits, entryBitsPassed);
ppgttBits = 0x345;
pageTable->pageWalk(gpuVa, size, 0, ppgttBits, walker, PageTableHelper::memoryBankNotSpecified);
pageTable->pageWalk(gpuVa, size, 0, ppgttBits, walker, MemoryBanks::MainBank);
EXPECT_EQ(ppgttBits, entryBitsPassed);
}
@@ -331,8 +330,7 @@ TEST_F(PageTableTests48, givenTwoMapsWhenSecondMapHasDifferentEntryBitsThenEntry
uintptr_t gpuVa = 0x1000;
size_t size = pageSize;
uint64_t ppgttBits = 0xabc;
auto address = allocator.nextPageAddress.load();
auto address = allocator.mainAllocator.load();
pageTable->map(gpuVa, size, ppgttBits, 0);
ASSERT_NE(nullptr, pageTable->entries[0]);
@@ -349,7 +347,7 @@ TEST_F(PageTableTests48, givenTwoMapsWhenSecondMapHasNonValidEntryBitsThenEntryI
uintptr_t gpuVa = 0x1000;
size_t size = pageSize;
uint64_t ppgttBits = 0xabc;
auto address = allocator.nextPageAddress.load();
auto address = allocator.mainAllocator.load();
pageTable->map(gpuVa, size, ppgttBits, 0);
ASSERT_NE(nullptr, pageTable->entries[0]);
@@ -368,33 +366,33 @@ TEST_F(PageTableTests48, givenPageTableWhenMappingTheSameAddressMultipleTimesThe
auto initialAddress = allocator.initialPageAddress;
auto phys1 = pageTable->map(address, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(address, pageSize, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1);
auto phys1_1 = pageTable->map(address, 1, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1_1 = pageTable->map(address, 1, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1_1);
auto phys2 = pageTable->map(address, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys2 = pageTable->map(address, pageSize, 0, MemoryBanks::MainBank);
EXPECT_EQ(phys1, phys2);
address = ptrOffset(address, pageSize);
auto phys3 = pageTable->map(address, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys3 = pageTable->map(address, pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(phys1, phys3);
address = ptrOffset(address, pageSize);
auto phys4 = pageTable->map(address, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys4 = pageTable->map(address, pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(phys3, phys4);
auto nextFreeAddress = initialAddress + ptrDiff(phys4 + pageSize, initialAddress);
EXPECT_EQ(nextFreeAddress, allocator.nextPageAddress.load());
EXPECT_EQ(nextFreeAddress, allocator.mainAllocator.load());
}
TEST_F(PageTableTests48, physicalAddressesInAUBCantStartAt0) {
std::unique_ptr<PPGTTPageTable> pageTable(new PPGTTPageTable(&allocator));
uintptr_t addr1 = refAddr;
auto phys1 = pageTable->map(addr1, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(addr1, pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(0u, phys1);
}
@@ -402,50 +400,50 @@ TEST_F(PageTableTests48, mapPageMapByteInMapped) {
std::unique_ptr<PPGTTPageTable> pageTable(new PPGTTPageTable(&allocator));
uintptr_t addr1 = refAddr;
auto phys1 = pageTable->map(addr1, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(addr1, pageSize, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.nextPageAddress);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.mainAllocator);
auto phys1_1 = pageTable->map(addr1, 1, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1_1 = pageTable->map(addr1, 1, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1_1);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.nextPageAddress);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.mainAllocator);
}
TEST_F(PageTableTests48, mapsCorrectlyEvenMultipleCalls) {
std::unique_ptr<PPGTTPageTable> pageTable(new PPGTTPageTable(&allocator));
uintptr_t addr1 = refAddr;
auto phys1 = pageTable->map(addr1, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(addr1, pageSize, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.nextPageAddress);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.mainAllocator);
auto phys1_1 = pageTable->map(addr1, 1, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1_1 = pageTable->map(addr1, 1, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1_1);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.nextPageAddress);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.mainAllocator);
auto phys2 = pageTable->map(addr1, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys2 = pageTable->map(addr1, pageSize, 0, MemoryBanks::MainBank);
EXPECT_EQ(phys1, phys2);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.nextPageAddress);
EXPECT_EQ(allocator.initialPageAddress + pageSize, allocator.mainAllocator);
auto phys3 = pageTable->map(addr1 + pageSize, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys3 = pageTable->map(addr1 + pageSize, pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(phys1, phys3);
EXPECT_EQ(allocator.initialPageAddress + 2 * pageSize, allocator.nextPageAddress);
EXPECT_EQ(allocator.initialPageAddress + 2 * pageSize, allocator.mainAllocator);
auto phys4 = pageTable->map(addr1 + pageSize, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys4 = pageTable->map(addr1 + pageSize, pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(phys1, phys3);
EXPECT_EQ(phys3, phys4);
auto addr2 = addr1 + pageSize + pageSize;
auto phys5 = pageTable->map(addr2, 2 * pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys5 = pageTable->map(addr2, 2 * pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(phys1, phys5);
EXPECT_NE(phys3, phys5);
auto phys6 = pageTable->map(addr2, 2 * pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys6 = pageTable->map(addr2, 2 * pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(phys1, phys6);
EXPECT_NE(phys3, phys6);
EXPECT_EQ(phys5, phys6);
auto phys7 = pageTable->map(addr2 + pageSize, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys7 = pageTable->map(addr2 + pageSize, pageSize, 0, MemoryBanks::MainBank);
EXPECT_NE(0u, phys7);
EXPECT_NE(phys1, phys7);
EXPECT_NE(phys3, phys7);
@@ -460,7 +458,7 @@ TEST_F(PageTableTests48, mapsPagesOnTableBoundary) {
size_t pages = (1 << 9) * 2;
size_t size = pages * pageSize;
auto phys1 = pageTable->map(addr1, size, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(addr1, size, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1);
}
@@ -470,10 +468,10 @@ TEST_F(PageTableTests48, mapsPagesOnTableBoundary2ndAllocation) {
size_t pages = (1 << 9) * 2;
size_t size = pages * pageSize;
auto phys1 = pageTable->map(0x0, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(0x0, pageSize, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1);
auto phys2 = pageTable->map(addr1, size, 0, PageTableHelper::memoryBankNotSpecified);
auto phys2 = pageTable->map(addr1, size, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress + pageSize, phys2);
}
@@ -486,10 +484,10 @@ TEST_F(PageTableTestsGPU, mapsPagesOnTableBoundary) {
size_t pages = (1 << 9) * 2;
size_t size = pages * pageSize;
auto phys32 = ggtt->map(addrGGTT, size, 0, PageTableHelper::memoryBankNotSpecified);
auto phys32 = ggtt->map(addrGGTT, size, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys32);
auto phys48 = ppgtt->map(addrPPGTT, size, 0, PageTableHelper::memoryBankNotSpecified);
auto phys48 = ppgtt->map(addrPPGTT, size, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress + size, phys48);
}
@@ -503,7 +501,7 @@ TEST_F(PageTableTestsGPU, newIsEmpty) {
TEST_F(PageTableTests32, level0) {
std::unique_ptr<PageTable<void, 0, 9>> pt(new PageTable<void, 0, 9>(&allocator));
auto phys = pt->map(0x10000, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys = pt->map(0x10000, pageSize, 0, MemoryBanks::MainBank);
EXPECT_EQ(0u, phys);
}
@@ -518,7 +516,7 @@ TEST_F(PageTableTests32, mapsPagesOnTableBoundary) {
size_t pages = (1 << 9) * 2;
size_t size = pages * pageSize;
auto phys1 = pageTable->map(addr1, size, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(addr1, size, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1);
}
@@ -528,9 +526,9 @@ TEST_F(PageTableTests32, mapsPagesOnTableBoundary2ndAllocation) {
size_t pages = (1 << 9) * 2;
size_t size = pages * pageSize;
auto phys1 = pageTable->map(0x0, pageSize, 0, PageTableHelper::memoryBankNotSpecified);
auto phys1 = pageTable->map(0x0, pageSize, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress, phys1);
auto phys2 = pageTable->map(addr1, size, 0, PageTableHelper::memoryBankNotSpecified);
auto phys2 = pageTable->map(addr1, size, 0, MemoryBanks::MainBank);
EXPECT_EQ(startAddress + pageSize, phys2);
}

9
unit_tests/memory_manager/physical_address_allocator_tests.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "runtime/memory_manager/memory_banks.h"
#include "runtime/memory_manager/page_table.h"
#include "unit_tests/mocks/mock_physical_address_allocator.h"
#include "gtest/gtest.h"
@@ -13,17 +14,17 @@ using namespace OCLRT;
TEST(PhysicalAddressAllocator, givenPhysicalAddressesAllocatorWhenReservingFirstPageThenNonZeroAddressIsReturned) {
MockPhysicalAddressAllocator allocator;
auto physAddress = allocator.reservePage(PageTableHelper::memoryBankNotSpecified);
auto physAddress = allocator.reservePage(MemoryBanks::MainBank);
EXPECT_NE(0u, physAddress);
}
TEST(PhysicalAddressAllocator, givenPhysicalAddressesAllocatorWhenReservingConsecutivePagesThenReturnedAddressesAreDifferent) {
MockPhysicalAddressAllocator allocator;
auto physAddress = allocator.reservePage(PageTableHelper::memoryBankNotSpecified);
auto physAddress = allocator.reservePage(MemoryBanks::MainBank);
EXPECT_NE(0u, physAddress);
auto physAddress1 = allocator.reservePage(PageTableHelper::memoryBankNotSpecified);
auto physAddress1 = allocator.reservePage(MemoryBanks::MainBank);
EXPECT_NE(physAddress, physAddress1);
auto physAddress2 = allocator.reservePage(PageTableHelper::memoryBankNotSpecified);
auto physAddress2 = allocator.reservePage(MemoryBanks::MainBank);
EXPECT_NE(physAddress1, physAddress2);
}

3
unit_tests/mocks/mock_physical_address_allocator.h
View File

@@ -13,5 +13,6 @@ using namespace OCLRT;
class MockPhysicalAddressAllocator : public PhysicalAddressAllocator {
public:
using PhysicalAddressAllocator::initialPageAddress;
using PhysicalAddressAllocator::nextPageAddress;
using PhysicalAddressAllocator::mainAllocator;
using PhysicalAddressAllocator::PhysicalAddressAllocator;
};