From 5f37aa4ba47ab2507386e0e714114c668c28c2bd Mon Sep 17 00:00:00 2001 From: Bartosz Dunajski Date: Wed, 13 Apr 2022 13:47:52 +0000 Subject: [PATCH] Pass cache settings to aub_stream Signed-off-by: Bartosz Dunajski --- .../unit_test/gmm_helper/gmm_helper_tests.cpp | 19 +++++ .../command_stream_receiver_simulated_hw.h | 8 ++- .../source/gmm_helper/cache_settings_helper.h | 6 ++ .../aub_memory_operations_handler.cpp | 8 ++- ...ommand_stream_receiver_simulated_tests.cpp | 72 +++++++++++++++++++ .../aub_memory_operations_handler_tests.cpp | 24 ++++++- 6 files changed, 133 insertions(+), 4 deletions(-) diff --git a/opencl/test/unit_test/gmm_helper/gmm_helper_tests.cpp b/opencl/test/unit_test/gmm_helper/gmm_helper_tests.cpp index 606192fff4..9e97aed43b 100644 --- a/opencl/test/unit_test/gmm_helper/gmm_helper_tests.cpp +++ b/opencl/test/unit_test/gmm_helper/gmm_helper_tests.cpp @@ -894,6 +894,25 @@ TEST(GmmTest, givenForceAllResourcesUncachedFlagSetWhenGettingUsageTypeThenRetur } } +TEST(GmmTest, givenUsageTypeWhenAskingIfUncachableThenReturnCorrectValue) { + for (GMM_RESOURCE_USAGE_TYPE_ENUM usage : {GMM_RESOURCE_USAGE_OCL_IMAGE, + GMM_RESOURCE_USAGE_OCL_STATE_HEAP_BUFFER, + GMM_RESOURCE_USAGE_OCL_BUFFER_CONST, + GMM_RESOURCE_USAGE_OCL_BUFFER, + GMM_RESOURCE_USAGE_OCL_BUFFER_CSR_UC, + GMM_RESOURCE_USAGE_OCL_SYSTEM_MEMORY_BUFFER_CACHELINE_MISALIGNED, + GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED}) { + + if (usage == GMM_RESOURCE_USAGE_OCL_BUFFER_CSR_UC || + usage == GMM_RESOURCE_USAGE_OCL_SYSTEM_MEMORY_BUFFER_CACHELINE_MISALIGNED || + usage == GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) { + EXPECT_TRUE(CacheSettingsHelper::isUncachedType(usage)); + } else { + EXPECT_FALSE(CacheSettingsHelper::isUncachedType(usage)); + } + } +} + TEST(GmmTest, givenInternalHeapOrLinearStreamWhenDebugFlagIsSetThenReturnUncachedType) { DebugManagerStateRestore restore; DebugManager.flags.DisableCachingForHeaps.set(true); diff --git a/shared/source/command_stream/command_stream_receiver_simulated_hw.h b/shared/source/command_stream/command_stream_receiver_simulated_hw.h index 2fed6d39e9..09433475cc 100644 --- a/shared/source/command_stream/command_stream_receiver_simulated_hw.h +++ b/shared/source/command_stream/command_stream_receiver_simulated_hw.h @@ -9,6 +9,7 @@ #include "shared/source/aub/aub_helper.h" #include "shared/source/aub_mem_dump/aub_mem_dump.h" #include "shared/source/command_stream/command_stream_receiver_simulated_common_hw.h" +#include "shared/source/gmm_helper/cache_settings_helper.h" #include "shared/source/helpers/debug_helpers.h" #include "shared/source/helpers/hardware_context_controller.h" #include "shared/source/helpers/hw_helper.h" @@ -107,7 +108,12 @@ class CommandStreamReceiverSimulatedHw : public CommandStreamReceiverSimulatedCo aub_stream::AllocationParams allocationParams(gpuAddress, cpuAddress, size, this->getMemoryBank(&graphicsAllocation), hint, graphicsAllocation.getUsedPageSize()); - allocationParams.additionalParams.compressionEnabled = graphicsAllocation.isCompressionEnabled(); + auto gmm = graphicsAllocation.getDefaultGmm(); + + if (gmm) { + allocationParams.additionalParams.compressionEnabled = gmm->isCompressionEnabled; + allocationParams.additionalParams.uncached = CacheSettingsHelper::isUncachedType(gmm->resourceParams.Usage); + } if (graphicsAllocation.storageInfo.cloningOfPageTables || !graphicsAllocation.isAllocatedInLocalMemoryPool()) { aubManager->writeMemory2(allocationParams); diff --git a/shared/source/gmm_helper/cache_settings_helper.h b/shared/source/gmm_helper/cache_settings_helper.h index 55213a3843..d9e51a4b96 100644 --- a/shared/source/gmm_helper/cache_settings_helper.h +++ b/shared/source/gmm_helper/cache_settings_helper.h @@ -15,6 +15,12 @@ struct HardwareInfo; struct CacheSettingsHelper { static GMM_RESOURCE_USAGE_TYPE_ENUM getGmmUsageType(AllocationType allocationType, bool forceUncached, const HardwareInfo &hwInfo); + static constexpr bool isUncachedType(GMM_RESOURCE_USAGE_TYPE_ENUM gmmResourceUsageType) { + return ((gmmResourceUsageType == GMM_RESOURCE_USAGE_OCL_BUFFER_CSR_UC) || + (gmmResourceUsageType == GMM_RESOURCE_USAGE_OCL_SYSTEM_MEMORY_BUFFER_CACHELINE_MISALIGNED) || + (gmmResourceUsageType == GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED)); + } + protected: static GMM_RESOURCE_USAGE_TYPE_ENUM getDefaultUsageTypeWithCachingEnabled(AllocationType allocationType, const HardwareInfo &hwInfo); static GMM_RESOURCE_USAGE_TYPE_ENUM getDefaultUsageTypeWithCachingDisabled(AllocationType allocationType); diff --git a/shared/source/os_interface/aub_memory_operations_handler.cpp b/shared/source/os_interface/aub_memory_operations_handler.cpp index ec69109d63..582d105c70 100644 --- a/shared/source/os_interface/aub_memory_operations_handler.cpp +++ b/shared/source/os_interface/aub_memory_operations_handler.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2019-2021 Intel Corporation + * Copyright (C) 2019-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -8,6 +8,7 @@ #include "shared/source/os_interface/aub_memory_operations_handler.h" #include "shared/source/aub_mem_dump/aub_mem_dump.h" +#include "shared/source/gmm_helper/cache_settings_helper.h" #include "shared/source/gmm_helper/gmm.h" #include "shared/source/memory_manager/graphics_allocation.h" @@ -37,7 +38,10 @@ MemoryOperationsStatus AubMemoryOperationsHandler::makeResident(Device *device, auto gmm = allocation->getDefaultGmm(); - params.additionalParams.compressionEnabled = gmm ? gmm->isCompressionEnabled : false; + if (gmm) { + params.additionalParams.compressionEnabled = gmm->isCompressionEnabled; + params.additionalParams.uncached = CacheSettingsHelper::isUncachedType(gmm->resourceParams.Usage); + } aubManager->writeMemory2(params); residentAllocations.push_back(allocation); diff --git a/shared/test/unit_test/command_stream/command_stream_receiver_simulated_tests.cpp b/shared/test/unit_test/command_stream/command_stream_receiver_simulated_tests.cpp index 7203bede2c..4094a1f25f 100644 --- a/shared/test/unit_test/command_stream/command_stream_receiver_simulated_tests.cpp +++ b/shared/test/unit_test/command_stream/command_stream_receiver_simulated_tests.cpp @@ -344,6 +344,37 @@ HWTEST_F(CommandStreamSimulatedTests, givenCompressedAllocationWhenCloningPageTa EXPECT_EQ(1u, mockManager->storedAllocationParams.size()); EXPECT_TRUE(mockManager->storedAllocationParams[0].additionalParams.compressionEnabled); + EXPECT_FALSE(mockManager->storedAllocationParams[0].additionalParams.uncached); +} + +HWTEST_F(CommandStreamSimulatedTests, givenUncachedAllocationWhenCloningPageTableIsRequiredThenAubManagerIsUsedForWriteMemory) { + auto mockManager = std::make_unique(); + mockManager->storeAllocationParams = true; + + auto csr = std::make_unique>(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield()); + csr->aubManager = mockManager.get(); + MockOsContext osContext(0, EngineDescriptorHelper::getDefaultDescriptor()); + csr->setupContext(osContext); + auto mockHardwareContext = static_cast(csr->hardwareContextController->hardwareContexts[0].get()); + + MockGmm gmm(pDevice->executionEnvironment->rootDeviceEnvironments[0]->getGmmClientContext(), nullptr, 1, 0, GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED, false, {}, true); + gmm.isCompressionEnabled = false; + + int dummy = 1; + GraphicsAllocation graphicsAllocation{0, AllocationType::UNKNOWN, + &dummy, 0, 0, sizeof(dummy), MemoryPool::MemoryNull, MemoryManager::maxOsContextCount}; + graphicsAllocation.storageInfo.cloningOfPageTables = true; + + graphicsAllocation.setDefaultGmm(&gmm); + + csr->writeMemoryWithAubManager(graphicsAllocation); + + EXPECT_FALSE(mockHardwareContext->writeMemory2Called); + EXPECT_TRUE(mockManager->writeMemory2Called); + + EXPECT_EQ(1u, mockManager->storedAllocationParams.size()); + EXPECT_FALSE(mockManager->storedAllocationParams[0].additionalParams.compressionEnabled); + EXPECT_TRUE(mockManager->storedAllocationParams[0].additionalParams.uncached); } HWTEST_F(CommandStreamSimulatedTests, givenTileInstancedAllocationWhenWriteMemoryWithAubManagerThenEachHardwareContextGetsDifferentMemoryBank) { @@ -403,10 +434,51 @@ HWTEST_F(CommandStreamSimulatedTests, givenCompressedTileInstancedAllocationWhen EXPECT_TRUE(firstMockHardwareContext->writeMemory2Called); EXPECT_EQ(1u, firstMockHardwareContext->storedAllocationParams.size()); EXPECT_TRUE(firstMockHardwareContext->storedAllocationParams[0].additionalParams.compressionEnabled); + EXPECT_FALSE(firstMockHardwareContext->storedAllocationParams[0].additionalParams.uncached); EXPECT_TRUE(secondMockHardwareContext->writeMemory2Called); EXPECT_EQ(1u, secondMockHardwareContext->storedAllocationParams.size()); EXPECT_TRUE(secondMockHardwareContext->storedAllocationParams[0].additionalParams.compressionEnabled); + EXPECT_FALSE(secondMockHardwareContext->storedAllocationParams[0].additionalParams.uncached); +} + +HWTEST_F(CommandStreamSimulatedTests, givenUncachedTileInstancedAllocationWhenWriteMemoryWithAubManagerThenEachHardwareContextGetsCompressionInfo) { + auto mockManager = std::make_unique(); + + auto csr = std::make_unique>(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield()); + csr->aubManager = mockManager.get(); + MockOsContext osContext(0, EngineDescriptorHelper::getDefaultDescriptor(0b11)); + csr->hardwareContextController = std::make_unique(*mockManager, osContext, 0); + auto firstMockHardwareContext = static_cast(csr->hardwareContextController->hardwareContexts[0].get()); + firstMockHardwareContext->storeAllocationParams = true; + auto secondMockHardwareContext = static_cast(csr->hardwareContextController->hardwareContexts[1].get()); + secondMockHardwareContext->storeAllocationParams = true; + + csr->multiOsContextCapable = true; + + MockGmm gmm(pDevice->executionEnvironment->rootDeviceEnvironments[0]->getGmmClientContext(), nullptr, 1, 0, GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED, false, {}, true); + gmm.isCompressionEnabled = false; + + int dummy = 1; + GraphicsAllocation graphicsAllocation{0, AllocationType::UNKNOWN, + &dummy, 0, 0, sizeof(dummy), MemoryPool::LocalMemory, MemoryManager::maxOsContextCount}; + graphicsAllocation.storageInfo.cloningOfPageTables = false; + graphicsAllocation.storageInfo.tileInstanced = true; + graphicsAllocation.storageInfo.memoryBanks = 0b11u; + + graphicsAllocation.setDefaultGmm(&gmm); + + csr->writeMemoryWithAubManager(graphicsAllocation); + + EXPECT_TRUE(firstMockHardwareContext->writeMemory2Called); + EXPECT_EQ(1u, firstMockHardwareContext->storedAllocationParams.size()); + EXPECT_FALSE(firstMockHardwareContext->storedAllocationParams[0].additionalParams.compressionEnabled); + EXPECT_TRUE(firstMockHardwareContext->storedAllocationParams[0].additionalParams.uncached); + + EXPECT_TRUE(secondMockHardwareContext->writeMemory2Called); + EXPECT_EQ(1u, secondMockHardwareContext->storedAllocationParams.size()); + EXPECT_FALSE(secondMockHardwareContext->storedAllocationParams[0].additionalParams.compressionEnabled); + EXPECT_TRUE(secondMockHardwareContext->storedAllocationParams[0].additionalParams.uncached); } HWTEST_F(CommandStreamSimulatedTests, givenTileInstancedAllocationWithMissingMemoryBankWhenWriteMemoryWithAubManagerThenAbortIsCalled) { diff --git a/shared/test/unit_test/os_interface/aub_memory_operations_handler_tests.cpp b/shared/test/unit_test/os_interface/aub_memory_operations_handler_tests.cpp index b582ad963a..c258e2fdfe 100644 --- a/shared/test/unit_test/os_interface/aub_memory_operations_handler_tests.cpp +++ b/shared/test/unit_test/os_interface/aub_memory_operations_handler_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2019-2021 Intel Corporation + * Copyright (C) 2019-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -45,6 +45,28 @@ TEST_F(AubMemoryOperationsHandlerTests, givenAubManagerWhenMakeResidentCalledOnC EXPECT_TRUE(aubManager.writeMemory2Called); EXPECT_EQ(1u, aubManager.storedAllocationParams.size()); EXPECT_TRUE(aubManager.storedAllocationParams[0].additionalParams.compressionEnabled); + EXPECT_FALSE(aubManager.storedAllocationParams[0].additionalParams.uncached); +} + +TEST_F(AubMemoryOperationsHandlerTests, givenAubManagerWhenMakeResidentCalledOnUncachedAllocationThenPassCorrectParams) { + MockAubManager aubManager; + aubManager.storeAllocationParams = true; + + getMemoryOperationsHandler()->setAubManager(&aubManager); + auto memoryOperationsInterface = getMemoryOperationsHandler(); + auto executionEnvironment = std::unique_ptr(MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), 0u)); + executionEnvironment->rootDeviceEnvironments[0]->initGmm(); + MockGmm gmm(executionEnvironment->rootDeviceEnvironments[0]->getGmmClientContext(), nullptr, 1, 0, GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED, false, {}, true); + gmm.isCompressionEnabled = false; + allocPtr->setDefaultGmm(&gmm); + + auto result = memoryOperationsInterface->makeResident(nullptr, ArrayRef(&allocPtr, 1)); + EXPECT_EQ(result, MemoryOperationsStatus::SUCCESS); + + EXPECT_TRUE(aubManager.writeMemory2Called); + EXPECT_EQ(1u, aubManager.storedAllocationParams.size()); + EXPECT_FALSE(aubManager.storedAllocationParams[0].additionalParams.compressionEnabled); + EXPECT_TRUE(aubManager.storedAllocationParams[0].additionalParams.uncached); } TEST_F(AubMemoryOperationsHandlerTests, givenAllocationWhenMakeResidentCalledThenTraceNotypeHintReturned) {