From 5d24d51ea6c1c2d6a235cb23e01675871f902590 Mon Sep 17 00:00:00 2001 From: Andrzej Swierczynski Date: Tue, 16 Jun 2020 15:46:15 +0200 Subject: [PATCH] Correct tests: pass valid device bitfield [4/n] Related-To: NEO-4645 Change-Id: Ib105d811711b7a4fdfad91ac93606cfdeb6d4ccb Signed-off-by: Andrzej Swierczynski --- .../tbx_command_stream_tests.cpp | 12 ++-- opencl/test/unit_test/event/event_tests.cpp | 4 +- .../hardware_commands_helper_tests.cpp | 2 +- .../memory_manager/memory_manager_tests.cpp | 36 ++++++------ .../unified_memory_manager_tests.cpp | 58 +++++++++++++------ .../linux/drm_memory_manager_tests.cpp | 22 +++---- .../windows/device_command_stream_tests.cpp | 28 ++++----- .../windows/wddm_memory_manager_tests.cpp | 12 ++-- .../memory_manager/allocation_properties.h | 6 +- 9 files changed, 104 insertions(+), 76 deletions(-) diff --git a/opencl/test/unit_test/command_stream/tbx_command_stream_tests.cpp b/opencl/test/unit_test/command_stream/tbx_command_stream_tests.cpp index 515643fefc..7231aa671d 100644 --- a/opencl/test/unit_test/command_stream/tbx_command_stream_tests.cpp +++ b/opencl/test/unit_test/command_stream/tbx_command_stream_tests.cpp @@ -400,7 +400,7 @@ HWTEST_F(TbxCommandSteamSimpleTest, givenTbxCsrWhenCallingWaitForTaskCountWithKm MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false); uint32_t tag = 0u; tbxCsr.setupContext(osContext); - tbxCsr.setTagAllocation(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), false, sizeof(tag)}, &tag)); + tbxCsr.setTagAllocation(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), false, sizeof(tag), pDevice->getDeviceBitfield()}, &tag)); tbxCsr.latestFlushedTaskCount = 1u; MockGraphicsAllocation allocation1, allocation2, allocation3; @@ -425,7 +425,7 @@ HWTEST_F(TbxCommandSteamSimpleTest, givenTbxCsrWhenCallingWaitForCompletionWithT MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false); uint32_t tag = 0u; tbxCsr.setupContext(osContext); - tbxCsr.setTagAllocation(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), false, sizeof(tag)}, &tag)); + tbxCsr.setTagAllocation(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), false, sizeof(tag), pDevice->getDeviceBitfield()}, &tag)); tbxCsr.latestFlushedTaskCount = 1u; MockGraphicsAllocation allocation1, allocation2, allocation3; @@ -451,7 +451,7 @@ HWTEST_F(TbxCommandSteamSimpleTest, givenTbxCsrWhenDownloadAllocatoinsCalledThen MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false); uint32_t tag = 0u; tbxCsr.setupContext(osContext); - tbxCsr.setTagAllocation(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), false, sizeof(tag)}, &tag)); + tbxCsr.setTagAllocation(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), false, sizeof(tag), pDevice->getDeviceBitfield()}, &tag)); MockGraphicsAllocation allocation1, allocation2, allocation3; tbxCsr.allocationsForDownload = {&allocation1, &allocation2, &allocation3}; @@ -495,7 +495,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenFlushIsCalledTh tbxCsr.setupContext(osContext); auto mockHardwareContext = static_cast(tbxCsr.hardwareContextController->hardwareContexts[0].get()); - auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize}); + auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize, pDevice->getDeviceBitfield()}); LinearStream cs(commandBuffer); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 1, 0, nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(), &cs, nullptr}; @@ -521,7 +521,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverInBatchedModeWhenFl MockOsContext osContext(0, 1, aub_stream::ENGINE_RCS, PreemptionMode::Disabled, false, false, false); tbxCsr.setupContext(osContext); - auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize}); + auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize, pDevice->getDeviceBitfield()}); LinearStream cs(commandBuffer); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 1, 0, nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(), &cs, nullptr}; @@ -540,7 +540,7 @@ HWTEST_F(TbxCommandStreamTests, givenTbxCommandStreamReceiverWhenFlushIsCalledWi tbxCsr.setupContext(osContext); auto mockHardwareContext = static_cast(tbxCsr.hardwareContextController->hardwareContexts[0].get()); - auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize}); + auto commandBuffer = pDevice->executionEnvironment->memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{pDevice->getRootDeviceIndex(), MemoryConstants::pageSize, pDevice->getDeviceBitfield()}); LinearStream cs(commandBuffer); BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, QueueSliceCount::defaultSliceCount, cs.getUsed(), &cs, nullptr}; diff --git a/opencl/test/unit_test/event/event_tests.cpp b/opencl/test/unit_test/event/event_tests.cpp index 26b0f41702..f64f34097d 100644 --- a/opencl/test/unit_test/event/event_tests.cpp +++ b/opencl/test/unit_test/event/event_tests.cpp @@ -417,7 +417,7 @@ struct UpdateEventTest : public ::testing::Test { TEST_F(UpdateEventTest, givenEventContainingCommandQueueWhenItsStatusIsUpdatedToCompletedThenTemporaryAllocationsAreDeleted) { void *ptr = (void *)0x1000; size_t size = 4096; - auto temporary = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, size}, ptr); + auto temporary = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, size, device->getDeviceBitfield()}, ptr); temporary->updateTaskCount(3, commandQueue->getGpgpuCommandStreamReceiver().getOsContext().getContextId()); commandQueue->getGpgpuCommandStreamReceiver().getInternalAllocationStorage()->storeAllocation(std::unique_ptr(temporary), TEMPORARY_ALLOCATION); Event event(commandQueue.get(), CL_COMMAND_NDRANGE_KERNEL, 3, 3); @@ -464,7 +464,7 @@ TEST_F(InternalsEventTest, GivenSubmitCommandFalseWhenSubmittingCommandsThenRefA MockCommandQueue cmdQ(mockContext, pClDevice, nullptr); MockEvent event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0); - auto cmdStream = new LinearStream(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties({pDevice->getRootDeviceIndex(), 4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER})); + auto cmdStream = new LinearStream(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties({pDevice->getRootDeviceIndex(), true, 4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER, false, pDevice->getDeviceBitfield()})); IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr; cmdQ.allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 4096u, dsh); cmdQ.allocateHeapMemory(IndirectHeap::INDIRECT_OBJECT, 4096u, ioh); diff --git a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp index 0e4bf2d873..0af0503d62 100644 --- a/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp +++ b/opencl/test/unit_test/helpers/hardware_commands_helper_tests.cpp @@ -216,7 +216,7 @@ HWTEST_F(HardwareCommandsTest, givenIndirectHeapNotAllocatedFromInternalPoolWhen } HWTEST_F(HardwareCommandsTest, givenIndirectHeapAllocatedFromInternalPoolWhenSendCrossThreadDataIsCalledThenHeapBaseOffsetIsReturned) { - auto internalAllocation = pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties(pDevice->getRootDeviceIndex(), true, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::INTERNAL_HEAP)); + auto internalAllocation = pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties(pDevice->getRootDeviceIndex(), true, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::INTERNAL_HEAP, pDevice->getDeviceBitfield())); IndirectHeap indirectHeap(internalAllocation, true); auto expectedOffset = internalAllocation->getGpuAddressToPatch(); diff --git a/opencl/test/unit_test/memory_manager/memory_manager_tests.cpp b/opencl/test/unit_test/memory_manager/memory_manager_tests.cpp index 9847fcc402..94b20e2c92 100644 --- a/opencl/test/unit_test/memory_manager/memory_manager_tests.cpp +++ b/opencl/test/unit_test/memory_manager/memory_manager_tests.cpp @@ -250,7 +250,7 @@ TEST_F(MemoryAllocatorTest, GivenAlignedHostPtrWithAlignedSizeWhenAllocatingGrap auto ptr = (void *)0x1000; MockMemoryManager mockMemoryManager(*executionEnvironment); auto hostPtrManager = static_cast(mockMemoryManager.getHostPtrManager()); - auto graphicsAllocation = mockMemoryManager.allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, 4096}, ptr); + auto graphicsAllocation = mockMemoryManager.allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, 4096, device->getDeviceBitfield()}, ptr); EXPECT_NE(nullptr, graphicsAllocation); EXPECT_EQ(1u, hostPtrManager->getFragmentCount()); @@ -267,7 +267,7 @@ TEST_F(MemoryAllocatorTest, GivenAlignedHostPtrAndCacheAlignedSizeWhenAskedForL3 auto ptr = (void *)0x1000; auto alignedSize = MemoryConstants::cacheLineSize; - auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, alignedSize}, ptr); + auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, alignedSize, device->getDeviceBitfield()}, ptr); EXPECT_TRUE(isL3Capable(*graphicsAllocation)); @@ -278,7 +278,7 @@ TEST_F(MemoryAllocatorTest, GivenAlignedHostPtrAndNotCacheAlignedSizeWhenAskedFo auto ptr = (void *)0x1000; auto alignedSize = MemoryConstants::cacheLineSize - 1; - auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, alignedSize}, ptr); + auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, alignedSize, device->getDeviceBitfield()}, ptr); EXPECT_FALSE(isL3Capable(*graphicsAllocation)); @@ -289,7 +289,7 @@ TEST_F(MemoryAllocatorTest, GivenMisAlignedHostPtrAndNotCacheAlignedSizeWhenAske auto ptr = (void *)0x1001; auto alignedSize = MemoryConstants::cacheLineSize - 1; - auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, alignedSize}, ptr); + auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, alignedSize, device->getDeviceBitfield()}, ptr); EXPECT_FALSE(isL3Capable(*graphicsAllocation)); @@ -300,7 +300,7 @@ TEST_F(MemoryAllocatorTest, GivenHostPtrAlignedToCacheLineWhenAskedForL3Allowanc auto ptr = (void *)0x1040; auto alignedSize = MemoryConstants::cacheLineSize; - auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, alignedSize}, ptr); + auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, alignedSize, device->getDeviceBitfield()}, ptr); EXPECT_TRUE(isL3Capable(*graphicsAllocation)); @@ -370,7 +370,7 @@ TEST_F(MemoryAllocatorTest, GivenEmptyMemoryManagerAndMisalingedHostPtrWithHugeS ASSERT_EQ(3u, reqs.requiredFragmentsCount); - auto graphicsAllocation = mockMemoryManager.allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, size}, cpuPtr); + auto graphicsAllocation = mockMemoryManager.allocateGraphicsMemoryWithProperties(MockAllocationProperties{device->getRootDeviceIndex(), false, size, device->getDeviceBitfield()}, cpuPtr); for (int i = 0; i < maxFragmentsCount; i++) { EXPECT_NE(nullptr, graphicsAllocation->fragmentsStorage.fragmentStorageData[i].osHandleStorage); EXPECT_EQ(reqs.allocationFragments[i].allocationPtr, graphicsAllocation->fragmentsStorage.fragmentStorageData[i].cpuPtr); @@ -461,7 +461,7 @@ TEST_F(MemoryAllocatorTest, givenMemoryManagerWhenAskedFor32bitAllocationWithPtr TEST_F(MemoryAllocatorTest, givenAllocationWithFragmentsWhenCallingFreeGraphicsMemoryThenDoNotCallHandleFenceCompletion) { auto size = 3u * MemoryConstants::pageSize; auto *ptr = reinterpret_cast(0xbeef1); - AllocationProperties properties{0, false, size, GraphicsAllocation::AllocationType::BUFFER, false, {}}; + AllocationProperties properties{mockRootDeviceIndex, false, size, GraphicsAllocation::AllocationType::BUFFER, false, mockDeviceBitfield}; auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(properties, ptr); EXPECT_EQ(3u, allocation->fragmentsStorage.fragmentCount); @@ -849,7 +849,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocateGraphicsMemoryWithPt void *ptr = reinterpret_cast(0x1001); auto size = MemoryConstants::pageSize; - auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(MockAllocationProperties{0, false, size}, ptr); + auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(MockAllocationProperties{mockRootDeviceIndex, false, size, mockDeviceBitfield}, ptr); ASSERT_NE(nullptr, allocation); EXPECT_EQ(MemoryPool::System4KBPages, allocation->getMemoryPool()); @@ -863,7 +863,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocate32BitGraphicsMemoryW void *ptr = reinterpret_cast(0x1001); auto size = MemoryConstants::pageSize; - auto allocation = memoryManager.allocate32BitGraphicsMemory(0, size, ptr, GraphicsAllocation::AllocationType::BUFFER); + auto allocation = memoryManager.allocate32BitGraphicsMemory(mockRootDeviceIndex, size, ptr, GraphicsAllocation::AllocationType::BUFFER); ASSERT_NE(nullptr, allocation); EXPECT_EQ(MemoryPool::System4KBPagesWith32BitGpuAddressing, allocation->getMemoryPool()); @@ -877,7 +877,7 @@ TEST(OsAgnosticMemoryManager, givenMemoryManagerWhenAllocate32BitGraphicsMemoryW void *ptr = nullptr; auto size = MemoryConstants::pageSize; - auto allocation = memoryManager.allocate32BitGraphicsMemory(0, size, ptr, GraphicsAllocation::AllocationType::BUFFER); + auto allocation = memoryManager.allocate32BitGraphicsMemory(mockRootDeviceIndex, size, ptr, GraphicsAllocation::AllocationType::BUFFER); ASSERT_NE(nullptr, allocation); EXPECT_EQ(MemoryPool::System4KBPagesWith32BitGpuAddressing, allocation->getMemoryPool()); @@ -906,7 +906,7 @@ TEST(OsAgnosticMemoryManager, givenDefaultMemoryManagerWhenCreateGraphicsAllocat MemoryManagerCreate memoryManager(false, false, executionEnvironment); osHandle handle = 1; auto size = 4096u; - AllocationProperties properties(0, false, size, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(mockRootDeviceIndex, false, size, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto sharedAllocation = memoryManager.createGraphicsAllocationFromSharedHandle(handle, properties, false); EXPECT_NE(nullptr, sharedAllocation); EXPECT_FALSE(sharedAllocation->isCoherent()); @@ -922,8 +922,8 @@ TEST(OsAgnosticMemoryManager, givenDefaultMemoryManagerWhenCreateGraphicsAllocat MemoryManagerCreate memoryManager(false, false, executionEnvironment); osHandle handle = 1; auto size = 4096u; - AllocationProperties properties(0u, false, size, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, false, 0u); - EXPECT_TRUE(properties.subDevicesBitfield.none()); + AllocationProperties properties(mockRootDeviceIndex, false, size, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, false, mockDeviceBitfield); + EXPECT_EQ(properties.subDevicesBitfield, mockDeviceBitfield); EXPECT_EQ(properties.rootDeviceIndex, 0u); auto sharedAllocation = memoryManager.createGraphicsAllocationFromSharedHandle(handle, properties, false); @@ -942,7 +942,7 @@ TEST(OsAgnosticMemoryManager, givenDefaultMemoryManagerWhenCreateGraphicsAllocat MemoryManagerCreate memoryManager(false, false, executionEnvironment); osHandle handle = 1; auto size = 4096u; - AllocationProperties properties(0, false, size, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(mockRootDeviceIndex, false, size, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto sharedAllocation = memoryManager.createGraphicsAllocationFromSharedHandle(handle, properties, true); EXPECT_NE(nullptr, sharedAllocation); EXPECT_TRUE(sharedAllocation->is32BitAllocation()); @@ -1162,7 +1162,7 @@ TEST(OsAgnosticMemoryManager, givenPointerAndSizeWhenCreateInternalAllocationIsC MockMemoryManager memoryManager(false, false, executionEnvironment); auto ptr = (void *)0x100000; size_t allocationSize = 4096; - auto graphicsAllocation = memoryManager.allocate32BitGraphicsMemory(0, allocationSize, ptr, GraphicsAllocation::AllocationType::INTERNAL_HEAP); + auto graphicsAllocation = memoryManager.allocate32BitGraphicsMemory(mockRootDeviceIndex, allocationSize, ptr, GraphicsAllocation::AllocationType::INTERNAL_HEAP); EXPECT_EQ(ptr, graphicsAllocation->getUnderlyingBuffer()); EXPECT_EQ(allocationSize, graphicsAllocation->getUnderlyingBufferSize()); memoryManager.freeGraphicsMemory(graphicsAllocation); @@ -1192,7 +1192,7 @@ TEST_P(OsAgnosticMemoryManagerWithParams, givenReducedGpuAddressSpaceWhenAllocat } OsAgnosticMemoryManager memoryManager(executionEnvironment); auto hostPtr = reinterpret_cast(0x5001); - AllocationProperties properties{0, false, 13, GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR, false, {}}; + AllocationProperties properties{0, false, 13, GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR, false, mockDeviceBitfield}; properties.flags.flushL3RequiredForRead = properties.flags.flushL3RequiredForWrite = requiresL3Flush; auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties, hostPtr); EXPECT_NE(nullptr, allocation); @@ -1211,7 +1211,7 @@ TEST_P(OsAgnosticMemoryManagerWithParams, givenFullGpuAddressSpaceWhenAllocateGr } OsAgnosticMemoryManager memoryManager(executionEnvironment); auto hostPtr = reinterpret_cast(0x5001); - AllocationProperties properties{0, false, 13, GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR, false, {}}; + AllocationProperties properties{0, false, 13, GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR, false, mockDeviceBitfield}; properties.flags.flushL3RequiredForRead = properties.flags.flushL3RequiredForWrite = requiresL3Flush; auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties, hostPtr); EXPECT_NE(nullptr, allocation); @@ -1238,7 +1238,7 @@ TEST_P(OsAgnosticMemoryManagerWithParams, givenDisabledHostPtrTrackingWhenAlloca OsAgnosticMemoryManager memoryManager(executionEnvironment); auto hostPtr = reinterpret_cast(0x5001); - AllocationProperties properties{0, false, 13, GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR, false, {}}; + AllocationProperties properties{0, false, 13, GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR, false, mockDeviceBitfield}; properties.flags.flushL3RequiredForRead = properties.flags.flushL3RequiredForWrite = requiresL3Flush; auto allocation = memoryManager.allocateGraphicsMemoryWithProperties(properties, hostPtr); EXPECT_NE(nullptr, allocation); diff --git a/opencl/test/unit_test/memory_manager/unified_memory_manager_tests.cpp b/opencl/test/unit_test/memory_manager/unified_memory_manager_tests.cpp index e32276c332..717d0c9849 100644 --- a/opencl/test/unit_test/memory_manager/unified_memory_manager_tests.cpp +++ b/opencl/test/unit_test/memory_manager/unified_memory_manager_tests.cpp @@ -8,6 +8,8 @@ #include "shared/source/command_stream/command_stream_receiver.h" #include "shared/source/memory_manager/allocations_list.h" #include "shared/test/unit_test/helpers/debug_manager_state_restore.h" +#include "shared/test/unit_test/mocks/mock_device.h" +#include "shared/test/unit_test/mocks/ult_device_factory.h" #include "shared/test/unit_test/page_fault_manager/mock_cpu_page_fault_manager.h" #include "opencl/source/api/api.h" @@ -15,6 +17,7 @@ #include "opencl/test/unit_test/mocks/mock_command_queue.h" #include "opencl/test/unit_test/mocks/mock_context.h" #include "opencl/test/unit_test/mocks/mock_execution_environment.h" +#include "opencl/test/unit_test/mocks/mock_graphics_allocation.h" #include "opencl/test/unit_test/mocks/mock_memory_manager.h" #include "opencl/test/unit_test/mocks/mock_platform.h" #include "opencl/test/unit_test/mocks/mock_svm_manager.h" @@ -65,7 +68,7 @@ TEST_F(SVMMemoryAllocatorTest, whenRequestSVMAllocsThenReturnNonNullptr) { } TEST_F(SVMMemoryAllocatorTest, whenSVMAllocationIsFreedThenCannotBeGotAgain) { - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(mockRootDeviceIndex, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_NE(nullptr, ptr); auto svmData = svmManager->getSVMAlloc(ptr); ASSERT_NE(nullptr, svmData); @@ -111,7 +114,7 @@ TEST_F(SVMMemoryAllocatorTest, givenSvmManagerWhenOperatedOnThenCorrectAllocatio } TEST_F(SVMMemoryAllocatorTest, whenGetSVMAllocationFromReturnedPointerAreaThenReturnSameAllocation) { - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(mockRootDeviceIndex, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_NE(ptr, nullptr); auto svmData = svmManager->getSVMAlloc(ptr); ASSERT_NE(nullptr, svmData); @@ -130,7 +133,7 @@ TEST_F(SVMMemoryAllocatorTest, whenGetSVMAllocationFromReturnedPointerAreaThenRe } TEST_F(SVMMemoryAllocatorTest, whenGetSVMAllocationFromOutsideOfReturnedPointerAreaThenDontReturnThisAllocation) { - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(mockRootDeviceIndex, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_NE(ptr, nullptr); auto svmData = svmManager->getSVMAlloc(ptr); ASSERT_NE(nullptr, svmData); @@ -151,7 +154,7 @@ TEST_F(SVMMemoryAllocatorTest, whenGetSVMAllocationFromOutsideOfReturnedPointerA TEST_F(SVMMemoryAllocatorTest, whenCouldNotAllocateInMemoryManagerThenReturnsNullAndDoesNotChangeAllocsMap) { FailMemoryManager failMemoryManager(executionEnvironment); svmManager->memoryManager = &failMemoryManager; - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(mockRootDeviceIndex, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_EQ(nullptr, ptr); EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs()); svmManager->freeSVMAlloc(ptr); @@ -163,6 +166,7 @@ TEST_F(SVMMemoryAllocatorTest, whenCouldNotAllocateInMemoryManagerThenCreateUnif SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::DEVICE_UNIFIED_MEMORY; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; auto ptr = svmManager->createUnifiedMemoryAllocation(0, 4096u, unifiedMemoryProperties); EXPECT_EQ(nullptr, ptr); EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs()); @@ -172,7 +176,7 @@ TEST_F(SVMMemoryAllocatorTest, whenCouldNotAllocateInMemoryManagerThenCreateUnif TEST_F(SVMMemoryAllocatorTest, given64kbAllowedWhenAllocatingSvmMemoryThenDontPreferRenderCompression) { MockMemoryManager memoryManager64Kb(true, false, executionEnvironment); svmManager->memoryManager = &memoryManager64Kb; - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_FALSE(memoryManager64Kb.preferRenderCompressedFlagPassed); svmManager->freeSVMAlloc(ptr); } @@ -180,13 +184,13 @@ TEST_F(SVMMemoryAllocatorTest, given64kbAllowedWhenAllocatingSvmMemoryThenDontPr TEST_F(SVMMemoryAllocatorTest, given64kbAllowedwhenAllocatingSvmMemoryThenAllocationIsIn64kbPagePool) { MockMemoryManager memoryManager64Kb(true, false, executionEnvironment); svmManager->memoryManager = &memoryManager64Kb; - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_EQ(MemoryPool::System64KBPages, svmManager->getSVMAlloc(ptr)->gpuAllocation->getMemoryPool()); svmManager->freeSVMAlloc(ptr); } TEST_F(SVMMemoryAllocatorTest, given64kbDisallowedWhenAllocatingSvmMemoryThenAllocationIsIn4kbPagePool) { - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_EQ(MemoryPool::System4KBPages, svmManager->getSVMAlloc(ptr)->gpuAllocation->getMemoryPool()); svmManager->freeSVMAlloc(ptr); } @@ -194,7 +198,7 @@ TEST_F(SVMMemoryAllocatorTest, given64kbDisallowedWhenAllocatingSvmMemoryThenAll TEST_F(SVMMemoryAllocatorTest, whenCoherentFlagIsPassedThenAllocationIsCoherent) { SVMAllocsManager::SvmAllocationProperties svmProperties; svmProperties.coherent = true; - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, svmProperties, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, svmProperties, mockDeviceBitfield); EXPECT_TRUE(svmManager->getSVMAlloc(ptr)->gpuAllocation->isCoherent()); svmManager->freeSVMAlloc(ptr); } @@ -203,6 +207,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenDeviceAllocationIsCreatedThenItIsStoredW SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::DEVICE_UNIFIED_MEMORY; unifiedMemoryProperties.allocationFlags.allocFlags.allocWriteCombined = true; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; auto allocationSize = 4000u; auto ptr = svmManager->createUnifiedMemoryAllocation(0, 4000u, unifiedMemoryProperties); EXPECT_NE(nullptr, ptr); @@ -226,8 +231,9 @@ TEST_F(SVMMemoryAllocatorTest, givenNoWriteCombinedFlagwhenDeviceAllocationIsCre SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::DEVICE_UNIFIED_MEMORY; unifiedMemoryProperties.allocationFlags.allocFlags.allocWriteCombined = false; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; auto allocationSize = 4096u; - auto ptr = svmManager->createUnifiedMemoryAllocation(0, 4096u, unifiedMemoryProperties); + auto ptr = svmManager->createUnifiedMemoryAllocation(mockRootDeviceIndex, 4096u, unifiedMemoryProperties); EXPECT_NE(nullptr, ptr); auto allocation = svmManager->getSVMAlloc(ptr); EXPECT_EQ(nullptr, allocation->cpuAllocation); @@ -244,6 +250,7 @@ TEST_F(SVMMemoryAllocatorTest, givenNoWriteCombinedFlagwhenDeviceAllocationIsCre TEST_F(SVMMemoryAllocatorTest, whenHostAllocationIsCreatedThenItIsStoredWithProperTypeInAllocationMap) { SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::HOST_UNIFIED_MEMORY; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; auto allocationSize = 4096u; auto ptr = svmManager->createUnifiedMemoryAllocation(0, 4096u, unifiedMemoryProperties); EXPECT_NE(nullptr, ptr); @@ -269,6 +276,7 @@ TEST_F(SVMMemoryAllocatorTest, whenCouldNotAllocateInMemoryManagerThenCreateShar SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::SHARED_UNIFIED_MEMORY; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; auto ptr = svmManager->createSharedUnifiedMemoryAllocation(0, 4096u, unifiedMemoryProperties, &cmdQ); EXPECT_EQ(nullptr, ptr); EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs()); @@ -278,6 +286,7 @@ TEST_F(SVMMemoryAllocatorTest, whenCouldNotAllocateInMemoryManagerThenCreateShar TEST_F(SVMMemoryAllocatorTest, whenSharedAllocationIsCreatedThenItIsStoredWithProperTypeInAllocationMap) { MockCommandQueue cmdQ; SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; unifiedMemoryProperties.memoryType = InternalMemoryType::SHARED_UNIFIED_MEMORY; auto allocationSize = 4096u; @@ -305,6 +314,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenSharedAllocationIsCreatedWithDebugFlagSe SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::SHARED_UNIFIED_MEMORY; unifiedMemoryProperties.device = mockContext.getDevice(0u); + unifiedMemoryProperties.subdeviceBitfield = mockContext.getDevice(0)->getDeviceBitfield(); auto allocationSize = 4096u; auto ptr = svmManager->createSharedUnifiedMemoryAllocation(0, 4096u, unifiedMemoryProperties, &cmdQ); EXPECT_NE(nullptr, ptr); @@ -335,6 +345,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenSharedAllocationIsCreatedWithLocalMemory SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::SHARED_UNIFIED_MEMORY; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; auto allocationSize = 4096u; auto ptr = svmManager->createSharedUnifiedMemoryAllocation(0, 4096u, unifiedMemoryProperties, &cmdQ); EXPECT_NE(nullptr, ptr); @@ -363,6 +374,7 @@ TEST_F(SVMMemoryAllocatorTest, givenSharedAllocationsDebugFlagWhenDeviceMemoryIs SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::DEVICE_UNIFIED_MEMORY; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; auto allocationSize = 4096u; auto ptr = svmManager->createUnifiedMemoryAllocation(0, 4096u, unifiedMemoryProperties); EXPECT_NE(nullptr, ptr); @@ -418,7 +430,7 @@ TEST(SvmAllocationPropertiesTests, givenDifferentMemFlagsWhenGettingSvmAllocatio TEST_F(SVMMemoryAllocatorTest, whenReadOnlySvmAllocationCreatedThenGraphicsAllocationHasWriteableFlagFalse) { SVMAllocsManager::SvmAllocationProperties svmProperties; svmProperties.readOnly = true; - void *svm = svmManager->createSVMAlloc(0, 4096, svmProperties, {}); + void *svm = svmManager->createSVMAlloc(0, 4096, svmProperties, mockDeviceBitfield); EXPECT_NE(nullptr, svm); auto svmData = svmManager->getSVMAlloc(svm); @@ -431,7 +443,7 @@ TEST_F(SVMMemoryAllocatorTest, whenReadOnlySvmAllocationCreatedThenGraphicsAlloc } TEST_F(SVMLocalMemoryAllocatorTest, whenAllocatingSvmThenExpectCpuAllocationWithPointerAndGpuAllocationWithSameGpuAddress) { - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_NE(ptr, nullptr); auto svmData = svmManager->getSVMAlloc(ptr); ASSERT_NE(nullptr, svmData); @@ -447,7 +459,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenAllocatingSvmThenExpectCpuAllocationWith } TEST_F(SVMLocalMemoryAllocatorTest, whenGetSVMAllocationFromOutsideOfReturnedPointerAreaThenDontReturnThisAllocation) { - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_NE(ptr, nullptr); auto svmData = svmManager->getSVMAlloc(ptr); ASSERT_NE(nullptr, svmData); @@ -468,7 +480,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenGetSVMAllocationFromOutsideOfReturnedPoi TEST_F(SVMLocalMemoryAllocatorTest, whenCouldNotAllocateCpuAllocationInMemoryManagerThenReturnsNullAndDoesNotChangeAllocsMap) { FailMemoryManager failMemoryManager(false, true, executionEnvironment); svmManager->memoryManager = &failMemoryManager; - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_EQ(nullptr, ptr); EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs()); svmManager->freeSVMAlloc(ptr); @@ -477,7 +489,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenCouldNotAllocateCpuAllocationInMemoryMan TEST_F(SVMLocalMemoryAllocatorTest, whenCouldNotAllocateGpuAllocationInMemoryManagerThenReturnsNullAndDoesNotChangeAllocsMap) { FailMemoryManager failMemoryManager(1, executionEnvironment, true); svmManager->memoryManager = &failMemoryManager; - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_EQ(nullptr, ptr); EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs()); svmManager->freeSVMAlloc(ptr); @@ -485,7 +497,7 @@ TEST_F(SVMLocalMemoryAllocatorTest, whenCouldNotAllocateGpuAllocationInMemoryMan TEST_F(SVMLocalMemoryAllocatorTest, whenCouldNotReserveCpuAddressRangeInMemoryManagerThenReturnsNullAndDoesNotChangeAllocsMap) { memoryManager->failReserveAddress = true; - auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, {}); + auto ptr = svmManager->createSVMAlloc(0, MemoryConstants::pageSize, {}, mockDeviceBitfield); EXPECT_EQ(nullptr, ptr); EXPECT_EQ(0u, svmManager->SVMAllocs.getNumAllocs()); } @@ -527,8 +539,14 @@ struct UnifiedMemoryManagerPropertiesTest : public ::testing::Test { std::unique_ptr svmManager; }; -TEST_F(UnifiedMemoryManagerPropertiesTest, givenDeviceBitfieldWithMultipleBitsSetWhenSharedUnifiedMemoryAllocationIsCreatedThenProperPropertiesArePassedToMemoryManager) { +TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenSharedUnifiedMemoryAllocationIsCreatedThenProperPropertiesArePassedToMemoryManager) { MockCommandQueue cmdQ; + DebugManagerStateRestore restorer; + DebugManager.flags.CreateMultipleSubDevices.set(4); + MockExecutionEnvironment executionEnvironment; + auto memoryManager = std::make_unique(false, true, executionEnvironment); + auto svmManager = std::make_unique(memoryManager.get()); + memoryManager->pageFaultManager.reset(new MockPageFaultManager); SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::SHARED_UNIFIED_MEMORY; @@ -559,7 +577,12 @@ TEST_F(UnifiedMemoryManagerPropertiesTest, givenDeviceBitfieldWithSingleBitSetWh svmManager->freeSVMAlloc(ptr); } -TEST_F(UnifiedMemoryManagerPropertiesTest, givenDeviceBitfieldWithMultipleBitsSetWhenDeviceUnifiedMemoryAllocationIsCreatedThenProperPropertiesArePassedToMemoryManager) { +TEST(UnifiedMemoryTest, givenDeviceBitfieldWithMultipleBitsSetWhenDeviceUnifiedMemoryAllocationIsCreatedThenProperPropertiesArePassedToMemoryManager) { + DebugManagerStateRestore restorer; + DebugManager.flags.CreateMultipleSubDevices.set(4); + MockExecutionEnvironment executionEnvironment; + auto memoryManager = std::make_unique(false, true, executionEnvironment); + auto svmManager = std::make_unique(memoryManager.get()); SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::SHARED_UNIFIED_MEMORY; unifiedMemoryProperties.subdeviceBitfield = DeviceBitfield(0xf); @@ -607,6 +630,7 @@ struct ShareableUnifiedMemoryManagerPropertiesTest : public ::testing::Test { TEST_F(ShareableUnifiedMemoryManagerPropertiesTest, givenShareableUnifiedPropertyFlagThenShareableAllocationPropertyFlagIsSet) { SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties; unifiedMemoryProperties.memoryType = InternalMemoryType::DEVICE_UNIFIED_MEMORY; + unifiedMemoryProperties.subdeviceBitfield = mockDeviceBitfield; unifiedMemoryProperties.allocationFlags.flags.shareable = 1; auto ptr = svmManager->createUnifiedMemoryAllocation(0, 4096u, unifiedMemoryProperties); diff --git a/opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp b/opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp index 00a9e40d5b..e6a495fad7 100644 --- a/opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp +++ b/opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp @@ -1846,7 +1846,7 @@ TEST_F(DrmMemoryManagerTest, givenOsHandleWithNonTiledObjectWhenCreateFromShared imgInfo.surfaceFormat = &gmmSurfaceFormat->surfaceFormat; imgInfo.plane = GMM_PLANE_Y; - AllocationProperties properties(rootDeviceIndex, false, imgInfo, GraphicsAllocation::AllocationType::SHARED_IMAGE, {}); + AllocationProperties properties(rootDeviceIndex, false, imgInfo, GraphicsAllocation::AllocationType::SHARED_IMAGE, context.getDevice(0)->getDeviceBitfield()); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, false); ASSERT_NE(nullptr, graphicsAllocation); @@ -1888,7 +1888,7 @@ TEST_F(DrmMemoryManagerTest, givenOsHandleWithTileYObjectWhenCreateFromSharedHan imgInfo.surfaceFormat = &gmmSurfaceFormat->surfaceFormat; imgInfo.plane = GMM_PLANE_Y; - AllocationProperties properties(rootDeviceIndex, false, imgInfo, GraphicsAllocation::AllocationType::SHARED_IMAGE, {}); + AllocationProperties properties(rootDeviceIndex, false, imgInfo, GraphicsAllocation::AllocationType::SHARED_IMAGE, context.getDevice(0)->getDeviceBitfield()); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, false); ASSERT_NE(nullptr, graphicsAllocation); @@ -1930,7 +1930,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenCreateFromSharedHandleFail imgInfo.surfaceFormat = &gmmSurfaceFormat->surfaceFormat; imgInfo.plane = GMM_PLANE_Y; - AllocationProperties properties(rootDeviceIndex, false, imgInfo, GraphicsAllocation::AllocationType::SHARED_IMAGE, {}); + AllocationProperties properties(rootDeviceIndex, false, imgInfo, GraphicsAllocation::AllocationType::SHARED_IMAGE, context.getDevice(0)->getDeviceBitfield()); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, false); ASSERT_NE(nullptr, graphicsAllocation); @@ -1948,7 +1948,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerAndOsHandleWhenAllocationFails osHandle handle = 1u; InjectedFunction method = [this, &handle](size_t failureIndex) { - AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, false); if (MemoryManagement::nonfailingAllocation == failureIndex) { @@ -1982,7 +1982,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerAndThreeOsHandlesWhenReuseCrea if (i == 2) this->mock->outputHandle = 3u; - AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); graphicsAllocations[i] = memoryManager->createGraphicsAllocationFromSharedHandle(handles[i], properties, false); //Clang-tidy false positive WA @@ -2023,7 +2023,7 @@ TEST_F(DrmMemoryManagerTest, given32BitAddressingWhenBufferFromSharedHandleAndBi osHandle handle = 1u; this->mock->outputHandle = 2u; - AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, true); auto drmAllocation = static_cast(graphicsAllocation); @@ -2041,7 +2041,7 @@ TEST_F(DrmMemoryManagerTest, given32BitAddressingWhenBufferFromSharedHandleIsCre memoryManager->setForce32BitAllocations(true); osHandle handle = 1u; this->mock->outputHandle = 2u; - AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, false); auto drmAllocation = static_cast(graphicsAllocation); @@ -2061,7 +2061,7 @@ TEST_F(DrmMemoryManagerTest, givenLimitedRangeAllocatorWhenBufferFromSharedHandl memoryManager->forceLimitedRangeAllocator(0xFFFFFFFFF); osHandle handle = 1u; this->mock->outputHandle = 2u; - AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, false); EXPECT_FALSE(graphicsAllocation->is32BitAllocation()); auto drmAllocation = static_cast(graphicsAllocation); @@ -2079,7 +2079,7 @@ TEST_F(DrmMemoryManagerTest, givenNon32BitAddressingWhenBufferFromSharedHandleIs memoryManager->setForce32BitAllocations(false); osHandle handle = 1u; this->mock->outputHandle = 2u; - AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, true); auto drmAllocation = static_cast(graphicsAllocation); EXPECT_FALSE(graphicsAllocation->is32BitAllocation()); @@ -2095,7 +2095,7 @@ TEST_F(DrmMemoryManagerTest, givenSharedHandleWhenAllocationIsCreatedAndIoctlPri osHandle handle = 1u; this->mock->outputHandle = 2u; - AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(handle, properties, false); EXPECT_EQ(nullptr, graphicsAllocation); memoryManager->freeGraphicsMemory(graphicsAllocation); @@ -2108,7 +2108,7 @@ TEST_F(DrmMemoryManagerTest, givenTwoGraphicsAllocationsThatShareTheSameBufferOb mock->ioctl_expected.gemWait = 2; osHandle sharedHandle = 1u; - AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, {}); + AllocationProperties properties(rootDeviceIndex, false, MemoryConstants::pageSize, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, mockDeviceBitfield); auto graphicsAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(sharedHandle, properties, false); auto graphicsAllocation2 = memoryManager->createGraphicsAllocationFromSharedHandle(sharedHandle, properties, false); diff --git a/opencl/test/unit_test/os_interface/windows/device_command_stream_tests.cpp b/opencl/test/unit_test/os_interface/windows/device_command_stream_tests.cpp index 7af4ad7b45..fdef6c96fe 100644 --- a/opencl/test/unit_test/os_interface/windows/device_command_stream_tests.cpp +++ b/opencl/test/unit_test/os_interface/windows/device_command_stream_tests.cpp @@ -71,12 +71,12 @@ class WddmCommandStreamFixture { memoryManager = new MockWddmMemoryManager(*executionEnvironment); executionEnvironment->memoryManager.reset(memoryManager); wddm = static_cast(executionEnvironment->rootDeviceEnvironments[0]->osInterface->get()->getWddm()); + device.reset(MockDevice::create(executionEnvironment, 0u)); osContext.reset(OsContext::create(executionEnvironment->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, false, false)); osContext->setDefaultContext(true); csr = new WddmCommandStreamReceiver(*executionEnvironment, 0); - device.reset(MockDevice::create(executionEnvironment, 0u)); device->resetCommandStreamReceiver(csr); ASSERT_NE(nullptr, device); @@ -252,7 +252,7 @@ TEST_F(WddmCommandStreamTest, givenGraphicsAllocationWithDifferentGpuAddressThen } TEST_F(WddmCommandStreamTest, FlushWithOffset) { auto offset = 128u; - GraphicsAllocation *commandBuffer = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize}); + GraphicsAllocation *commandBuffer = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{csr->getRootDeviceIndex(), MemoryConstants::pageSize, mockDeviceBitfield}); ASSERT_NE(nullptr, commandBuffer); LinearStream cs(commandBuffer); @@ -1032,7 +1032,7 @@ TEST_F(WddmCommandStreamTest, whenDirectSubmissionEnabledOnBcsThenExpectFeatureA DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_BCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_BCS, PreemptionMode::ThreadGroup, false, false, false)); osContext->setDefaultContext(true); @@ -1049,7 +1049,7 @@ TEST_F(WddmCommandStreamTest, givenDirectSubmissionEnabledWhenPlatformNotSupport DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_BCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_BCS, PreemptionMode::ThreadGroup, false, false, false)); osContext->setDefaultContext(true); @@ -1066,7 +1066,7 @@ TEST_F(WddmCommandStreamTest, givenLowPriorityContextWhenDirectSubmissionDisable DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, true, false, false)); osContext->setDefaultContext(true); @@ -1083,7 +1083,7 @@ TEST_F(WddmCommandStreamTest, givenLowPriorityContextWhenDirectSubmissionEnabled DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, true, false, false)); auto hwInfo = device->getRootDeviceEnvironment().getMutableHardwareInfo(); @@ -1098,7 +1098,7 @@ TEST_F(WddmCommandStreamTest, givenInternalContextWhenDirectSubmissionDisabledOn DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, true, false)); osContext->setDefaultContext(true); @@ -1115,7 +1115,7 @@ TEST_F(WddmCommandStreamTest, givenInternalContextWhenDirectSubmissionEnabledOnI DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, true, false)); auto hwInfo = device->getRootDeviceEnvironment().getMutableHardwareInfo(); @@ -1131,7 +1131,7 @@ TEST_F(WddmCommandStreamTest, givenRootDeviceContextWhenDirectSubmissionDisabled DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, false, true)); osContext->setDefaultContext(true); @@ -1148,7 +1148,7 @@ TEST_F(WddmCommandStreamTest, givenRootDeviceContextWhenDirectSubmissionEnabledO DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, false, true)); auto hwInfo = device->getRootDeviceEnvironment().getMutableHardwareInfo(); @@ -1164,7 +1164,7 @@ TEST_F(WddmCommandStreamTest, givenNonDefaultContextWhenDirectSubmissionDisabled DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, false, false)); osContext->setDefaultContext(false); @@ -1181,7 +1181,7 @@ TEST_F(WddmCommandStreamTest, givenNonDefaultContextContextWhenDirectSubmissionE DebugManager.flags.EnableDirectSubmission.set(1); osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, false, false)); osContext->setDefaultContext(false); @@ -1206,7 +1206,7 @@ TEST_F(WddmCommandStreamMockGdiTest, givenDirectSubmissionEnabledOnRcsWhenFlushi std::unique_ptr osContext; osContext.reset(OsContext::create(device->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.get(), - 0, 0, aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, + 0, device->getDeviceBitfield(), aub_stream::ENGINE_RCS, PreemptionMode::ThreadGroup, false, false, false)); osContext->setDefaultContext(true); csr->callParentInitDirectSubmission = false; diff --git a/opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp b/opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp index 1ee7e88bfb..e7512e704a 100644 --- a/opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp +++ b/opencl/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp @@ -484,7 +484,7 @@ TEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenCreateFromSharedHandleIs std::unique_ptr gmm(new Gmm(rootDeviceEnvironment->getGmmClientContext(), pSysMem, 4096u, false)); setSizesFcn(gmm->gmmResourceInfo.get(), 1u, 1024u, 1u); - AllocationProperties properties(0, false, 4096u, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, false, 0); + AllocationProperties properties(0, false, 4096u, GraphicsAllocation::AllocationType::SHARED_BUFFER, false, false, mockDeviceBitfield); auto *gpuAllocation = memoryManager->createGraphicsAllocationFromSharedHandle(osHandle, properties, false); auto wddmAlloc = static_cast(gpuAllocation); @@ -1141,7 +1141,7 @@ TEST_F(BufferWithWddmMemory, NullOsHandleStorageAskedForPopulationReturnsFilledP TEST_F(BufferWithWddmMemory, GivenMisalignedHostPtrAndMultiplePagesSizeWhenAskedForGraphicsAllocationThenItContainsAllFragmentsWithProperGpuAdrresses) { auto ptr = reinterpret_cast(wddm->virtualAllocAddress + 0x1001); auto size = MemoryConstants::pageSize * 10; - auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{context.getDevice(0)->getRootDeviceIndex(), false, size}, ptr); + auto graphicsAllocation = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{context.getDevice(0)->getRootDeviceIndex(), false, size, context.getDevice(0)->getDeviceBitfield()}, ptr); auto hostPtrManager = static_cast(memoryManager->getHostPtrManager()); @@ -1310,7 +1310,7 @@ TEST_F(WddmMemoryManagerWithAsyncDeleterTest, givenMemoryManagerWithAsyncDeleter EXPECT_EQ(0, deleter->drainCalled); EXPECT_EQ(0u, wddm->createAllocationResult.called); deleter->expectDrainBlockingValue(true); - AllocationProperties allocProperties = MemObjHelper::getAllocationPropertiesWithImageInfo(0, imgInfo, true, {}, *hwInfo, {}); + AllocationProperties allocProperties = MemObjHelper::getAllocationPropertiesWithImageInfo(0, imgInfo, true, {}, *hwInfo, mockDeviceBitfield); memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, nullptr); EXPECT_EQ(1, deleter->drainCalled); @@ -1329,7 +1329,7 @@ TEST_F(WddmMemoryManagerWithAsyncDeleterTest, givenMemoryManagerWithAsyncDeleter EXPECT_EQ(0u, wddm->createAllocationResult.called); EXPECT_EQ(0u, wddm->mapGpuVirtualAddressResult.called); - AllocationProperties allocProperties = MemObjHelper::getAllocationPropertiesWithImageInfo(0, imgInfo, true, {}, *hwInfo, {}); + AllocationProperties allocProperties = MemObjHelper::getAllocationPropertiesWithImageInfo(0, imgInfo, true, {}, *hwInfo, mockDeviceBitfield); auto allocation = memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, nullptr); EXPECT_EQ(0, deleter->drainCalled); @@ -1347,7 +1347,7 @@ TEST_F(WddmMemoryManagerWithAsyncDeleterTest, givenMemoryManagerWithoutAsyncDele wddm->createAllocationStatus = STATUS_GRAPHICS_NO_VIDEO_MEMORY; EXPECT_EQ(0u, wddm->createAllocationResult.called); - AllocationProperties allocProperties = MemObjHelper::getAllocationPropertiesWithImageInfo(0, imgInfo, true, {}, *hwInfo, {}); + AllocationProperties allocProperties = MemObjHelper::getAllocationPropertiesWithImageInfo(0, imgInfo, true, {}, *hwInfo, mockDeviceBitfield); memoryManager->allocateGraphicsMemoryInPreferredPool(allocProperties, nullptr); EXPECT_EQ(1u, wddm->createAllocationResult.called); @@ -1860,7 +1860,7 @@ TEST_F(WddmMemoryManagerSimpleTest, givenAllocationWithReservedGpuVirtualAddress TEST_F(WddmMemoryManagerSimpleTest, givenSvmCpuAllocationWhenSizeAndAlignmentProvidedThenAllocateMemoryReserveGpuVa) { size_t size = 2 * MemoryConstants::megaByte; - MockAllocationProperties properties{csr->getRootDeviceIndex(), true, size, GraphicsAllocation::AllocationType::SVM_CPU}; + MockAllocationProperties properties{csr->getRootDeviceIndex(), true, size, GraphicsAllocation::AllocationType::SVM_CPU, mockDeviceBitfield}; properties.alignment = size; auto allocation = static_cast(memoryManager->allocateGraphicsMemoryWithProperties(properties)); ASSERT_NE(nullptr, allocation); diff --git a/shared/source/memory_manager/allocation_properties.h b/shared/source/memory_manager/allocation_properties.h index 605e0bba27..dcf7077856 100644 --- a/shared/source/memory_manager/allocation_properties.h +++ b/shared/source/memory_manager/allocation_properties.h @@ -38,7 +38,11 @@ struct AllocationProperties { AllocationProperties(uint32_t rootDeviceIndex, size_t size, GraphicsAllocation::AllocationType allocationType) - : AllocationProperties(rootDeviceIndex, true, size, allocationType, false, {}) {} + : AllocationProperties(rootDeviceIndex, size, allocationType, 0b1) {} + + AllocationProperties(uint32_t rootDeviceIndex, size_t size, + GraphicsAllocation::AllocationType allocationType, DeviceBitfield subDevicesBitfieldParam) + : AllocationProperties(rootDeviceIndex, true, size, allocationType, false, subDevicesBitfieldParam) {} AllocationProperties(uint32_t rootDeviceIndex, bool allocateMemory, ImageInfo &imgInfo,