Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove duplicated tests in drm files 2/n 

Signed-off-by: Szymon Morek <szymon.morek@intel.com>
This commit is contained in:
Szymon Morek 2021-10-07 15:52:56 +00:00 committed by Compute-Runtime-Automation
parent fc86810978
commit f4acbd9447
3 changed files with 457 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

454
opencl/test/unit_test/os_interface/linux/drm_memory_manager_localmem_tests.cpp
View File

@ -169,34 +169,6 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenDrmMemoryManagerWhenCreateBufferObj
EXPECT_EQ(size, bo->peekSize());
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenDrmMemoryManagerWhenCreateBufferObjectInMemoryRegionIsCalledWithoutMemoryInfoThenNullBufferObjectIsReturned) {
mock->memoryInfo.reset(nullptr);
auto gpuAddress = 0x1234u;
auto size = MemoryConstants::pageSize;
auto bo = std::unique_ptr<BufferObject>(memoryManager->createBufferObjectInMemoryRegion(&memoryManager->getDrm(0),
gpuAddress,
size,
MemoryBanks::MainBank,
1));
EXPECT_EQ(nullptr, bo);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenDrmMemoryManagerWhenCreateBufferObjectInMemoryRegionIsCalledWithZeroSizeThenNullBufferObjectIsReturned) {
mock->memoryInfo.reset(new MockMemoryInfo());
auto gpuAddress = 0x1234u;
auto size = 0u;
auto bo = std::unique_ptr<BufferObject>(memoryManager->createBufferObjectInMemoryRegion(&memoryManager->getDrm(0),
gpuAddress,
size,
MemoryBanks::MainBank,
1));
EXPECT_EQ(nullptr, bo);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenMultiRootDeviceEnvironmentAndMemoryInfoWhenCreateMultiGraphicsAllocationThenImportAndExportIoctlAreUsed) {
uint32_t rootDevicesNumber = 3u;
MultiGraphicsAllocation multiGraphics(rootDevicesNumber);
@ -485,20 +457,6 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenMemoryInfoAndFailedGemCreateExtWhen
mock->gemCreateExtRetVal = 0;
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenUseSystemMemoryFlagWhenGraphicsAllocationInDevicePoolIsAllocatedThenNullptrIsReturned) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = MemoryConstants::pageSize;
allocData.flags.useSystemMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
EXPECT_EQ(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::RetryInNonDevicePool, status);
}
class DrmMemoryManagerLocalMemoryMemoryBankMock : public TestedDrmMemoryManager {
public:
DrmMemoryManagerLocalMemoryMemoryBankMock(bool enableLocalMemory,
@ -698,63 +656,6 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenNotSetUseSystemMemoryWhenGraphicsAl
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenSvmGpuAllocationWhenHostPtrProvidedThenUseHostPtrAsGpuVa) {
size_t size = 2 * MemoryConstants::megaByte;
AllocationProperties properties{0, false, size, GraphicsAllocation::AllocationType::SVM_GPU, false, {}};
properties.alignment = size;
void *svmPtr = reinterpret_cast<void *>(2 * size);
auto allocation = static_cast<DrmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties(properties, svmPtr));
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(size, allocation->getUnderlyingBufferSize());
EXPECT_EQ(nullptr, allocation->getUnderlyingBuffer());
EXPECT_EQ(nullptr, allocation->getDriverAllocatedCpuPtr());
EXPECT_EQ(svmPtr, reinterpret_cast<void *>(allocation->getGpuAddress()));
EXPECT_EQ(0u, allocation->getReservedAddressSize());
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenAllowed32BitAndForce32BitWhenGraphicsAllocationInDevicePoolIsAllocatedThenNullptrIsReturned) {
memoryManager->setForce32BitAllocations(true);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = MemoryConstants::pageSize;
allocData.flags.allow32Bit = true;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
EXPECT_EQ(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::RetryInNonDevicePool, status);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenAllowed32BitWhen32BitIsNotForcedThenGraphicsAllocationInDevicePoolReturnsLocalMemoryAllocation) {
memoryManager->setForce32BitAllocations(false);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = MemoryConstants::pageSize;
allocData.flags.allow32Bit = true;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, status);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenCpuAccessRequiredWhenAllocatingInDevicePoolThenAllocationIsLocked) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
@ -812,37 +713,6 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenWriteCombinedAllocationWhenAllocati
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenAllocationWithKernelIsaWhenAllocatingInDevicePoolOnAllMemoryBanksThenCreateFourBufferObjectsWithSameGpuVirtualAddressAndSize) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = 3 * MemoryConstants::pageSize64k;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::KERNEL_ISA;
allocData.storageInfo.multiStorage = false;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, status);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
EXPECT_NE(0u, allocation->getGpuAddress());
EXPECT_EQ(1u, allocation->getNumGmms());
auto drmAllocation = static_cast<DrmAllocation *>(allocation);
auto &bos = drmAllocation->getBOs();
auto boAddress = drmAllocation->getGpuAddress();
auto bo = bos[0];
ASSERT_NE(nullptr, bo);
auto boSize = allocation->getGmm(0)->gmmResourceInfo->getSizeAllocation();
EXPECT_EQ(boAddress, bo->peekAddress());
EXPECT_EQ(boSize, bo->peekSize());
EXPECT_EQ(boSize, 3 * MemoryConstants::pageSize64k);
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenSupportedTypeWhenAllocatingInDevicePoolThenSuccessStatusAndNonNullPtrIsReturned) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
@ -916,231 +786,6 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenSupportedTypeWhenAllocatingInDevice
}
}
struct DrmMemoryManagerLocalMemoryAlignmentTest : DrmMemoryManagerLocalMemoryTest {
std::unique_ptr<TestedDrmMemoryManager> createMemoryManager() {
return std::make_unique<TestedDrmMemoryManager>(true, false, false, *executionEnvironment);
}
bool isAllocationWithinHeap(MemoryManager &memoryManager, const GraphicsAllocation &allocation, HeapIndex heap) {
const auto allocationStart = allocation.getGpuAddress();
const auto allocationEnd = allocationStart + allocation.getUnderlyingBufferSize();
const auto heapStart = GmmHelper::canonize(memoryManager.getGfxPartition(rootDeviceIndex)->getHeapBase(heap));
const auto heapEnd = GmmHelper::canonize(memoryManager.getGfxPartition(rootDeviceIndex)->getHeapLimit(heap));
return heapStart <= allocationStart && allocationEnd <= heapEnd;
}
const uint32_t rootDeviceIndex = 0u;
DebugManagerStateRestore restore{};
};
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, given2MbAlignmentAllowedWhenAllocatingAllocationLessThen2MbThenUse64kbHeap) {
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.size = MemoryConstants::pageSize;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = true;
MemoryManager::AllocationStatus allocationStatus;
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(-1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(0);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, given2MbAlignmentAllowedWhenAllocatingAllocationBiggerThan2MbThenUse2MbHeap) {
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.size = 2 * MemoryConstants::megaByte;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = true;
MemoryManager::AllocationStatus allocationStatus;
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(-1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(0);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), MemoryConstants::pageSize2Mb));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, givenExtendedHeapPreferredAnd2MbAlignmentAllowedWhenAllocatingAllocationBiggerThenUseExtendedHeap) {
if (memoryManager->getGfxPartition(0)->getHeapLimit(HeapIndex::HEAP_EXTENDED) == 0) {
GTEST_SKIP();
}
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.size = 2 * MemoryConstants::megaByte;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = false;
MemoryManager::AllocationStatus allocationStatus;
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(-1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), MemoryConstants::pageSize2Mb));
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_EXTENDED));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(0);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_EXTENDED));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_EXTENDED));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), MemoryConstants::pageSize2Mb));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, givenCustomAlignmentWhenAllocatingAllocationBiggerThanTheAlignmentThenAlignProperly) {
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = true;
MemoryManager::AllocationStatus allocationStatus;
{
// size==2MB, use 2MB heap
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(2 * MemoryConstants::megaByte);
allocationData.size = 2 * MemoryConstants::megaByte;
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), 2 * MemoryConstants::megaByte));
memoryManager->freeGraphicsMemory(allocation);
}
{
// size > 2MB, use 2MB heap
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(16 * MemoryConstants::megaByte);
allocationData.size = 16 * MemoryConstants::megaByte;
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), 16 * MemoryConstants::megaByte));
memoryManager->freeGraphicsMemory(allocation);
}
{
// size < 2MB, use 64KB heap
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(8 * MemoryConstants::pageSize64k);
allocationData.size = 8 * MemoryConstants::pageSize64k;
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), 8 * MemoryConstants::pageSize64k));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, givenCustomAlignmentWhenAllocatingAllocationLessThanTheAlignmentThenIgnoreCustomAlignment) {
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.size = 3 * MemoryConstants::megaByte;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = true;
MemoryManager::AllocationStatus allocationStatus;
{
// Too small allocation, fallback to 2MB heap
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(0);
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(32 * MemoryConstants::megaByte);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
memoryManager->freeGraphicsMemory(allocation);
}
{
// Too small allocation, fallback to 2MB heap
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(1);
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(32 * MemoryConstants::megaByte);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenUnsupportedTypeWhenAllocatingInDevicePoolThenRetryInNonDevicePoolStatusAndNullptrIsReturned) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
@ -1595,105 +1240,6 @@ TEST_F(DrmMemoryManagerLocalMemoryTest, givenAlignmentAndSizeWhenMmapReturnsAlig
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenAllocationWithLargeBufferWhenAllocatingInDevicePoolOnAllMemoryBanksThenCreateFourBufferObjectsWithDifferentGpuVirtualAddressesAndPartialSizes) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = 18 * MemoryConstants::pageSize64k;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.storageInfo.memoryBanks = maxNBitValue(MemoryBanks::getBankForLocalMemory(3));
allocData.storageInfo.multiStorage = true;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, status);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
EXPECT_NE(0u, allocation->getGpuAddress());
EXPECT_EQ(EngineLimits::maxHandleCount, allocation->getNumGmms());
auto drmAllocation = static_cast<DrmAllocation *>(allocation);
auto &bos = drmAllocation->getBOs();
auto boAddress = drmAllocation->getGpuAddress();
for (auto handleId = 0u; handleId < EngineLimits::maxHandleCount; handleId++) {
auto bo = bos[handleId];
ASSERT_NE(nullptr, bo);
auto boSize = allocation->getGmm(handleId)->gmmResourceInfo->getSizeAllocation();
EXPECT_EQ(boAddress, bo->peekAddress());
EXPECT_EQ(boSize, bo->peekSize());
EXPECT_EQ(boSize, handleId == 0 || handleId == 1 ? 5 * MemoryConstants::pageSize64k : 4 * MemoryConstants::pageSize64k);
boAddress += boSize;
}
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenAllocationWithLargeBufferWhenAllocatingInDevicePoolOnAllMemoryBanksWithoutMultiStorageThenCreateFourBufferObjectsWithDifferentGpuVirtualAddressesAndPartialSizes) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = 3 * MemoryConstants::pageSize64k;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.storageInfo.memoryBanks = maxNBitValue(MemoryBanks::getBankForLocalMemory(3));
allocData.storageInfo.multiStorage = false;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, status);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
EXPECT_NE(0u, allocation->getGpuAddress());
EXPECT_EQ(EngineLimits::maxHandleCount, allocation->getNumGmms());
auto drmAllocation = static_cast<DrmAllocation *>(allocation);
auto &bos = drmAllocation->getBOs();
auto boAddress = drmAllocation->getGpuAddress();
for (auto handleId = 0u; handleId < EngineLimits::maxHandleCount; handleId++) {
auto bo = bos[handleId];
ASSERT_NE(nullptr, bo);
auto boSize = allocation->getGmm(handleId)->gmmResourceInfo->getSizeAllocation();
EXPECT_EQ(boAddress, bo->peekAddress());
EXPECT_EQ(boSize, bo->peekSize());
EXPECT_EQ(boSize, 3 * MemoryConstants::pageSize64k);
}
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenAllocationWithKernelIsaWhenAllocationInDevicePoolAndDeviceBitfieldWithHolesThenCorrectAllocationCreated) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = MemoryConstants::pageSize;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::KERNEL_ISA;
allocData.storageInfo.memoryBanks = 0b1011;
allocData.storageInfo.multiStorage = false;
allocData.rootDeviceIndex = rootDeviceIndex;
auto kernelIsaAllocation = static_cast<DrmAllocation *>(memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status));
EXPECT_NE(nullptr, kernelIsaAllocation);
auto gpuAddress = kernelIsaAllocation->getGpuAddress();
auto &bos = kernelIsaAllocation->getBOs();
EXPECT_NE(nullptr, bos[0]);
EXPECT_EQ(gpuAddress, bos[0]->peekAddress());
EXPECT_NE(nullptr, bos[1]);
EXPECT_EQ(gpuAddress, bos[1]->peekAddress());
EXPECT_EQ(nullptr, bos[2]);
EXPECT_NE(nullptr, bos[3]);
EXPECT_EQ(gpuAddress, bos[3]->peekAddress());
auto &storageInfo = kernelIsaAllocation->storageInfo;
EXPECT_EQ(0b1011u, storageInfo.memoryBanks.to_ulong());
memoryManager->freeGraphicsMemory(kernelIsaAllocation);
}
TEST_F(DrmMemoryManagerLocalMemoryTest, givenAllocationWithInvalidCacheRegionWhenAllocatingInDevicePoolThenReturnNullptr) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;

418
opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp
View File

@ -64,6 +64,7 @@ AllocationProperties createAllocationProperties(uint32_t rootDeviceIndex, size_t
typedef Test<DrmMemoryManagerFixture> DrmMemoryManagerTest;
typedef Test<DrmMemoryManagerWithLocalMemoryFixture> DrmMemoryManagerWithLocalMemoryTest;
typedef Test<DrmMemoryManagerFixtureWithoutQuietIoctlExpectation> DrmMemoryManagerWithExplicitExpectationsTest;
typedef Test<DrmMemoryManagerFixtureWithLocalMemoryAndWithoutQuietIoctlExpectation> DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest;
TEST_F(DrmMemoryManagerTest, givenEnableDirectSubmissionWhenCreateDrmMemoryManagerThenGemCloseWorkerInactive) {
DebugManagerStateRestore dbgState;
@ -4730,4 +4731,421 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenSetMemAdviseIsCalledThenUp
}
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenDrmMemoryManagerWhenCreateBufferObjectInMemoryRegionIsCalledWithoutMemoryInfoThenNullBufferObjectIsReturned) {
mock->memoryInfo.reset(nullptr);
auto gpuAddress = 0x1234u;
auto size = MemoryConstants::pageSize;
auto bo = std::unique_ptr<BufferObject>(memoryManager->createBufferObjectInMemoryRegion(&memoryManager->getDrm(0), gpuAddress, size, MemoryBanks::MainBank, 1));
EXPECT_EQ(nullptr, bo);
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenDrmMemoryManagerWhenCreateBufferObjectInMemoryRegionIsCalledWithZeroSizeThenNullBufferObjectIsReturned) {
auto gpuAddress = 0x1234u;
auto size = 0u;
auto bo = std::unique_ptr<BufferObject>(memoryManager->createBufferObjectInMemoryRegion(&memoryManager->getDrm(0), gpuAddress, size, MemoryBanks::MainBank, 1));
EXPECT_EQ(nullptr, bo);
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenUseSystemMemoryFlagWhenGraphicsAllocationInDevicePoolIsAllocatedThenNullptrIsReturned) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = MemoryConstants::pageSize;
allocData.flags.useSystemMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
EXPECT_EQ(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::RetryInNonDevicePool, status);
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenSvmGpuAllocationWhenHostPtrProvidedThenUseHostPtrAsGpuVa) {
size_t size = 2 * MemoryConstants::megaByte;
AllocationProperties properties{rootDeviceIndex, false, size, GraphicsAllocation::AllocationType::SVM_GPU, false, mockDeviceBitfield};
properties.alignment = size;
void *svmPtr = reinterpret_cast<void *>(2 * size);
auto allocation = static_cast<DrmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties(properties, svmPtr));
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(size, allocation->getUnderlyingBufferSize());
EXPECT_EQ(nullptr, allocation->getUnderlyingBuffer());
EXPECT_EQ(nullptr, allocation->getDriverAllocatedCpuPtr());
EXPECT_EQ(svmPtr, reinterpret_cast<void *>(allocation->getGpuAddress()));
EXPECT_EQ(0u, allocation->getReservedAddressSize());
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenAllowed32BitAndForce32BitWhenGraphicsAllocationInDevicePoolIsAllocatedThenNullptrIsReturned) {
memoryManager->setForce32BitAllocations(true);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = MemoryConstants::pageSize;
allocData.flags.allow32Bit = true;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
EXPECT_EQ(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::RetryInNonDevicePool, status);
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenAllowed32BitWhen32BitIsNotForcedThenGraphicsAllocationInDevicePoolReturnsLocalMemoryAllocation) {
memoryManager->setForce32BitAllocations(false);
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = MemoryConstants::pageSize;
allocData.flags.allow32Bit = true;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, status);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenAllocationWithKernelIsaWhenAllocatingInDevicePoolOnAllMemoryBanksThenCreateFourBufferObjectsWithSameGpuVirtualAddressAndSize) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = 3 * MemoryConstants::pageSize64k;
allocData.flags.allocateMemory = true;
allocData.storageInfo.memoryBanks = maxNBitValue(MemoryBanks::getBankForLocalMemory(3));
allocData.storageInfo.multiStorage = false;
allocData.rootDeviceIndex = rootDeviceIndex;
GraphicsAllocation::AllocationType isaTypes[] = {GraphicsAllocation::AllocationType::KERNEL_ISA, GraphicsAllocation::AllocationType::KERNEL_ISA_INTERNAL};
for (uint32_t i = 0; i < 2; i++) {
allocData.type = isaTypes[i];
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, status);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
EXPECT_NE(0u, allocation->getGpuAddress());
EXPECT_EQ(EngineLimits::maxHandleCount, allocation->getNumGmms());
auto drmAllocation = static_cast<DrmAllocation *>(allocation);
auto &bos = drmAllocation->getBOs();
auto boAddress = drmAllocation->getGpuAddress();
for (auto handleId = 0u; handleId < EngineLimits::maxHandleCount; handleId++) {
auto bo = bos[handleId];
ASSERT_NE(nullptr, bo);
auto boSize = allocation->getGmm(handleId)->gmmResourceInfo->getSizeAllocation();
EXPECT_EQ(boAddress, bo->peekAddress());
EXPECT_EQ(boSize, bo->peekSize());
EXPECT_EQ(boSize, 3 * MemoryConstants::pageSize64k);
}
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenAllocationWithLargeBufferWhenAllocatingInDevicePoolOnAllMemoryBanksThenCreateFourBufferObjectsWithDifferentGpuVirtualAddressesAndPartialSizes) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = 18 * MemoryConstants::pageSize64k;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::BUFFER;
allocData.storageInfo.memoryBanks = maxNBitValue(MemoryBanks::getBankForLocalMemory(3));
allocData.storageInfo.multiStorage = true;
allocData.rootDeviceIndex = rootDeviceIndex;
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, status);
EXPECT_EQ(MemoryPool::LocalMemory, allocation->getMemoryPool());
EXPECT_NE(0u, allocation->getGpuAddress());
EXPECT_EQ(EngineLimits::maxHandleCount, allocation->getNumGmms());
auto drmAllocation = static_cast<DrmAllocation *>(allocation);
auto &bos = drmAllocation->getBOs();
auto boAddress = drmAllocation->getGpuAddress();
for (auto handleId = 0u; handleId < EngineLimits::maxHandleCount; handleId++) {
auto bo = bos[handleId];
ASSERT_NE(nullptr, bo);
auto boSize = allocation->getGmm(handleId)->gmmResourceInfo->getSizeAllocation();
EXPECT_EQ(boAddress, bo->peekAddress());
EXPECT_EQ(boSize, bo->peekSize());
EXPECT_EQ(boSize, handleId == 0 || handleId == 1 ? 5 * MemoryConstants::pageSize64k : 4 * MemoryConstants::pageSize64k);
boAddress += boSize;
}
memoryManager->freeGraphicsMemory(allocation);
}
TEST_F(DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest, givenAllocationWithKernelIsaWhenAllocationInDevicePoolAndDeviceBitfieldWithHolesThenCorrectAllocationCreated) {
MemoryManager::AllocationStatus status = MemoryManager::AllocationStatus::Success;
AllocationData allocData;
allocData.allFlags = 0;
allocData.size = MemoryConstants::pageSize;
allocData.flags.allocateMemory = true;
allocData.type = GraphicsAllocation::AllocationType::KERNEL_ISA;
allocData.storageInfo.memoryBanks = 0b1011;
allocData.storageInfo.multiStorage = false;
allocData.rootDeviceIndex = rootDeviceIndex;
auto kernelIsaAllocation = static_cast<DrmAllocation *>(memoryManager->allocateGraphicsMemoryInDevicePool(allocData, status));
EXPECT_NE(nullptr, kernelIsaAllocation);
auto gpuAddress = kernelIsaAllocation->getGpuAddress();
auto &bos = kernelIsaAllocation->getBOs();
EXPECT_NE(nullptr, bos[0]);
EXPECT_EQ(gpuAddress, bos[0]->peekAddress());
EXPECT_NE(nullptr, bos[1]);
EXPECT_EQ(gpuAddress, bos[1]->peekAddress());
EXPECT_EQ(nullptr, bos[2]);
EXPECT_NE(nullptr, bos[3]);
EXPECT_EQ(gpuAddress, bos[3]->peekAddress());
auto &storageInfo = kernelIsaAllocation->storageInfo;
EXPECT_EQ(0b1011u, storageInfo.memoryBanks.to_ulong());
memoryManager->freeGraphicsMemory(kernelIsaAllocation);
}
struct DrmMemoryManagerLocalMemoryAlignmentTest : DrmMemoryManagerWithLocalMemoryAndExplicitExpectationsTest {
std::unique_ptr<TestedDrmMemoryManager> createMemoryManager() {
return std::make_unique<TestedDrmMemoryManager>(true, false, false, *executionEnvironment);
}
bool isAllocationWithinHeap(MemoryManager &memoryManager, const GraphicsAllocation &allocation, HeapIndex heap) {
const auto allocationStart = allocation.getGpuAddress();
const auto allocationEnd = allocationStart + allocation.getUnderlyingBufferSize();
const auto heapStart = GmmHelper::canonize(memoryManager.getGfxPartition(rootDeviceIndex)->getHeapBase(heap));
const auto heapEnd = GmmHelper::canonize(memoryManager.getGfxPartition(rootDeviceIndex)->getHeapLimit(heap));
return heapStart <= allocationStart && allocationEnd <= heapEnd;
}
const uint32_t rootDeviceIndex = 1u;
DebugManagerStateRestore restore{};
};
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, given2MbAlignmentAllowedWhenAllocatingAllocationLessThen2MbThenUse64kbHeap) {
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.size = MemoryConstants::pageSize;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = true;
MemoryManager::AllocationStatus allocationStatus;
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(-1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(0);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, given2MbAlignmentAllowedWhenAllocatingAllocationBiggerThan2MbThenUse2MbHeap) {
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.size = 2 * MemoryConstants::megaByte;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = true;
MemoryManager::AllocationStatus allocationStatus;
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(-1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(0);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), MemoryConstants::pageSize2Mb));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, givenExtendedHeapPreferredAnd2MbAlignmentAllowedWhenAllocatingAllocationBiggerThenUseExtendedHeap) {
if (memoryManager->getGfxPartition(0)->getHeapLimit(HeapIndex::HEAP_EXTENDED) == 0) {
GTEST_SKIP();
}
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.size = 2 * MemoryConstants::megaByte;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = false;
MemoryManager::AllocationStatus allocationStatus;
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(-1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), MemoryConstants::pageSize2Mb));
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_EXTENDED));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(0);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_EXTENDED));
memoryManager->freeGraphicsMemory(allocation);
}
{
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(1);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_EXTENDED));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), MemoryConstants::pageSize2Mb));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, givenCustomAlignmentWhenAllocatingAllocationBiggerThanTheAlignmentThenAlignProperly) {
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = true;
MemoryManager::AllocationStatus allocationStatus;
{
// size==2MB, use 2MB heap
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(2 * MemoryConstants::megaByte);
allocationData.size = 2 * MemoryConstants::megaByte;
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), 2 * MemoryConstants::megaByte));
memoryManager->freeGraphicsMemory(allocation);
}
{
// size > 2MB, use 2MB heap
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(16 * MemoryConstants::megaByte);
allocationData.size = 16 * MemoryConstants::megaByte;
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), 16 * MemoryConstants::megaByte));
memoryManager->freeGraphicsMemory(allocation);
}
{
// size < 2MB, use 64KB heap
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(8 * MemoryConstants::pageSize64k);
allocationData.size = 8 * MemoryConstants::pageSize64k;
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD64KB));
EXPECT_TRUE(isAligned(allocation->getGpuAddress(), 8 * MemoryConstants::pageSize64k));
memoryManager->freeGraphicsMemory(allocation);
}
}
TEST_F(DrmMemoryManagerLocalMemoryAlignmentTest, givenCustomAlignmentWhenAllocatingAllocationLessThanTheAlignmentThenIgnoreCustomAlignment) {
AllocationData allocationData;
allocationData.allFlags = 0;
allocationData.size = 3 * MemoryConstants::megaByte;
allocationData.flags.allocateMemory = true;
allocationData.rootDeviceIndex = rootDeviceIndex;
allocationData.type = GraphicsAllocation::AllocationType::BUFFER;
allocationData.flags.resource48Bit = true;
MemoryManager::AllocationStatus allocationStatus;
{
// Too small allocation, fallback to 2MB heap
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(0);
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(32 * MemoryConstants::megaByte);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
memoryManager->freeGraphicsMemory(allocation);
}
{
// Too small allocation, fallback to 2MB heap
DebugManager.flags.AlignLocalMemoryVaTo2MB.set(1);
DebugManager.flags.ExperimentalEnableCustomLocalMemoryAlignment.set(32 * MemoryConstants::megaByte);
auto memoryManager = createMemoryManager();
auto allocation = memoryManager->allocateGraphicsMemoryInDevicePool(allocationData, allocationStatus);
ASSERT_NE(nullptr, allocation);
EXPECT_EQ(MemoryManager::AllocationStatus::Success, allocationStatus);
EXPECT_TRUE(isAllocationWithinHeap(*memoryManager, *allocation, HeapIndex::HEAP_STANDARD2MB));
memoryManager->freeGraphicsMemory(allocation);
}
}
} // namespace NEO

40
opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.h
View File

@ -7,6 +7,7 @@
#pragma once
#include "shared/source/os_interface/linux/drm_memory_operations_handler.h"
#include "shared/source/os_interface/linux/memory_info.h"
#include "shared/source/os_interface/os_interface.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/ult_hw_config.h"
@ -143,12 +144,38 @@ class DrmMemoryManagerWithLocalMemoryFixture : public DrmMemoryManagerFixture {
std::unique_ptr<VariableBackup<UltHwConfig>> backup;
};
struct MockMemoryInfoImpl : public NEO::MemoryInfo {
MockMemoryInfoImpl() {}
~MockMemoryInfoImpl() override{};
size_t getMemoryRegionSize(uint32_t memoryBank) override {
return 1024u;
}
uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override {
if (allocSize == 0) {
return EINVAL;
}
handle = 1u;
return 0u;
}
uint32_t createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle) override {
if (allocSize == 0) {
return EINVAL;
}
handle = 1u;
return 0u;
}
};
class DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
public:
std::unique_ptr<TestedDrmMemoryManager> memoryManager;
DrmMockCustom *mock;
void SetUp() {
SetUp(false);
}
void SetUp(bool enableLocalMem) {
DebugManager.flags.DeferOsContextInitialization.set(0);
executionEnvironment = new ExecutionEnvironment;
@ -162,8 +189,9 @@ class DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
i++;
}
mock = static_cast<DrmMockCustom *>(executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface->getDriverModel()->as<Drm>());
mock->memoryInfo.reset(new MockMemoryInfoImpl());
constructPlatform()->peekExecutionEnvironment()->rootDeviceEnvironments[0]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*mock, 0u);
memoryManager.reset(new TestedDrmMemoryManager(*executionEnvironment));
memoryManager.reset(new TestedDrmMemoryManager(enableLocalMem, false, false, *executionEnvironment));
ASSERT_NE(nullptr, memoryManager);
if (memoryManager->getgemCloseWorker()) {
@ -183,4 +211,14 @@ class DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
const uint32_t rootDeviceIndex = 1u;
const uint32_t numRootDevices = 2u;
};
class DrmMemoryManagerFixtureWithLocalMemoryAndWithoutQuietIoctlExpectation : public DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
public:
void SetUp() {
DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::SetUp(true);
}
void TearDown() {
DrmMemoryManagerFixtureWithoutQuietIoctlExpectation::TearDown();
}
};
} // namespace NEO