From ceb9d81f8753da1e92de4f3d41d7f525adc2167c Mon Sep 17 00:00:00 2001 From: Zbigniew Zdanowicz Date: Thu, 11 Aug 2022 13:36:02 +0000 Subject: [PATCH] Add struct argument for input/output in StateBaseAddressHelper This refactor makes future interface changes easier Related-To: NEO-5019 Signed-off-by: Zbigniew Zdanowicz --- .../core/source/cmdqueue/cmdqueue_hw_base.inl | 38 +-- .../cmdqueue_xe_hp_core_and_later.inl | 38 +-- ...and_stream_receiver_flush_task_2_tests.cpp | 149 ++++----- ...ceiver_flush_task_tests_xehp_and_later.cpp | 37 +-- .../helpers/test_preamble_xehp_and_later.cpp | 45 ++- .../test_cmds_programming_xe_hpc_core.cpp | 52 +++- .../dg2/test_cmds_programming_dg2.cpp | 52 +++- .../test_cmds_programming_xe_hpg_core.cpp | 52 +++- .../command_encoder_bdw_and_later.inl | 47 +-- .../command_encoder_xehp_and_later.inl | 51 ++-- .../command_stream_receiver_hw_base.inl | 40 +-- .../source/gen8/state_base_address_gen8.cpp | 77 ++--- shared/source/helpers/state_base_address.h | 61 ++-- .../helpers/state_base_address_base.inl | 91 +++--- .../source/helpers/state_base_address_bdw.inl | 12 +- .../state_base_address_bdw_and_later.inl | 22 +- .../state_base_address_icllp_and_later.inl | 30 +- .../source/helpers/state_base_address_skl.inl | 22 +- .../state_base_address_xehp_and_later.inl | 66 ++-- .../gen8/state_base_address_tests_gen8.cpp | 32 +- .../helpers/state_base_address_tests.cpp | 287 +++++++++++------- 21 files changed, 734 insertions(+), 567 deletions(-) diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl b/level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl index d1342ba0a6..2bd9fd671b 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl +++ b/level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl @@ -52,23 +52,27 @@ void CommandQueueHw::programStateBaseAddress(uint64_t gsba, bool auto indirectObjectHeapBaseAddress = neoDevice->getMemoryManager()->getInternalHeapBaseAddress(device->getRootDeviceIndex(), useLocalMemoryForIndirectHeap); auto instructionHeapBaseAddress = neoDevice->getMemoryManager()->getInternalHeapBaseAddress(device->getRootDeviceIndex(), neoDevice->getMemoryManager()->isLocalMemoryUsedForIsa(neoDevice->getRootDeviceIndex())); - NEO::StateBaseAddressHelper::programStateBaseAddress(&sbaCmd, - nullptr, - nullptr, - nullptr, - gsba, - true, - (device->getMOCS(cachedMOCSAllowed, false) >> 1), - indirectObjectHeapBaseAddress, - instructionHeapBaseAddress, - globalHeapsBase, - true, - useGlobalSshAndDsh, - neoDevice->getGmmHelper(), - false, - NEO::MemoryCompressionState::NotApplicable, - false, - 1u); + NEO::StateBaseAddressHelperArgs args = { + gsba, // generalStateBase + indirectObjectHeapBaseAddress, // indirectObjectHeapBaseAddress + instructionHeapBaseAddress, // instructionHeapBaseAddress + globalHeapsBase, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + nullptr, // ssh + neoDevice->getGmmHelper(), // gmmHelper + (device->getMOCS(cachedMOCSAllowed, false) >> 1), // statelessMocsIndex + NEO::MemoryCompressionState::NotApplicable, // memoryCompressionState + true, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + useGlobalSshAndDsh, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + NEO::StateBaseAddressHelper::programStateBaseAddress(args); *sbaCmdBuf = sbaCmd; csr->setGSBAStateDirty(false); diff --git a/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl b/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl index 9b502742bf..d55acb406f 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl +++ b/level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl @@ -43,23 +43,27 @@ void CommandQueueHw::programStateBaseAddress(uint64_t gsba, bool auto sbaCmdBuf = static_cast(NEO::StateBaseAddressHelper::getSpaceForSbaCmd(commandStream)); STATE_BASE_ADDRESS sbaCmd; - NEO::StateBaseAddressHelper::programStateBaseAddress(&sbaCmd, - nullptr, - nullptr, - nullptr, - 0, - true, - (device->getMOCS(cachedMOCSAllowed, false) >> 1), - indirectObjectStateBaseAddress, - instructionStateBaseAddress, - globalHeapsBase, - true, - true, - neoDevice->getGmmHelper(), - multiOsContextCapable, - NEO::MemoryCompressionState::NotApplicable, - false, - 1u); + NEO::StateBaseAddressHelperArgs args = { + 0, // generalStateBase + indirectObjectStateBaseAddress, // indirectObjectHeapBaseAddress + instructionStateBaseAddress, // instructionHeapBaseAddress + globalHeapsBase, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + nullptr, // ssh + neoDevice->getGmmHelper(), // gmmHelper + (device->getMOCS(cachedMOCSAllowed, false) >> 1), // statelessMocsIndex + NEO::MemoryCompressionState::NotApplicable, // memoryCompressionState + true, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + true, // useGlobalHeapsBaseAddress + multiOsContextCapable, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + NEO::StateBaseAddressHelper::programStateBaseAddress(args); *sbaCmdBuf = sbaCmd; auto &hwInfoConfig = *NEO::HwInfoConfig::get(hwInfo.platform.eProductFamily); diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_2_tests.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_2_tests.cpp index 3619769813..eef568a36d 100644 --- a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_2_tests.cpp +++ b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_2_tests.cpp @@ -1213,23 +1213,26 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrWhenGen auto gmmHelper = pDevice->getGmmHelper(); typename FamilyType::STATE_BASE_ADDRESS sbaCmd; - StateBaseAddressHelper::programStateBaseAddress(&sbaCmd, - &dsh, - &ioh, - &ssh, - generalStateBaseAddress, - true, - 0, - 0, - generalStateBaseAddress, - 0, - true, - false, - gmmHelper, - false, - MemoryCompressionState::NotApplicable, - false, - 1u); + StateBaseAddressHelperArgs args = { + generalStateBaseAddress, // generalStateBase + 0, // indirectObjectHeapBaseAddress + generalStateBaseAddress, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + &dsh, // dsh + &ioh, // ioh + &ssh, // ssh + gmmHelper, // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + true, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_NE(generalStateBaseAddress, sbaCmd.getGeneralStateBaseAddress()); EXPECT_EQ(gmmHelper->decanonize(generalStateBaseAddress), sbaCmd.getGeneralStateBaseAddress()); @@ -1239,23 +1242,26 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNonZeroGeneralStateBaseAddres uint64_t generalStateBaseAddress = 0x80010000ull; typename FamilyType::STATE_BASE_ADDRESS sbaCmd; - StateBaseAddressHelper::programStateBaseAddress(&sbaCmd, - &dsh, - &ioh, - &ssh, - generalStateBaseAddress, - false, - 0, - 0, - generalStateBaseAddress, - 0, - true, - false, - pDevice->getGmmHelper(), - false, - MemoryCompressionState::NotApplicable, - false, - 1u); + StateBaseAddressHelperArgs args = { + generalStateBaseAddress, // generalStateBase + 0, // indirectObjectHeapBaseAddress + generalStateBaseAddress, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + &dsh, // dsh + &ioh, // ioh + &ssh, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + true, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_EQ(0ull, sbaCmd.getGeneralStateBaseAddress()); EXPECT_EQ(0u, sbaCmd.getGeneralStateBufferSize()); @@ -1267,23 +1273,26 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNonZeroInternalHeapBaseAddres uint64_t internalHeapBaseAddress = 0x80010000ull; typename FamilyType::STATE_BASE_ADDRESS sbaCmd; - StateBaseAddressHelper::programStateBaseAddress(&sbaCmd, - &dsh, - &ioh, - &ssh, - internalHeapBaseAddress, - true, - 0, - internalHeapBaseAddress, - 0, - 0, - false, - false, - pDevice->getGmmHelper(), - false, - MemoryCompressionState::NotApplicable, - false, - 1u); + StateBaseAddressHelperArgs args = { + internalHeapBaseAddress, // generalStateBase + internalHeapBaseAddress, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + &dsh, // dsh + &ioh, // ioh + &ssh, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_FALSE(sbaCmd.getInstructionBaseAddressModifyEnable()); EXPECT_EQ(0ull, sbaCmd.getInstructionBaseAddress()); @@ -1299,24 +1308,26 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenSbaProgram uint64_t instructionHeapBase = 0x10000; uint64_t generalStateBase = 0x30000; typename FamilyType::STATE_BASE_ADDRESS sbaCmd; - - StateBaseAddressHelper::programStateBaseAddress(&sbaCmd, - nullptr, - nullptr, - nullptr, - generalStateBase, - true, - 0, - internalHeapBase, - instructionHeapBase, - 0, - true, - false, - pDevice->getGmmHelper(), - false, - MemoryCompressionState::NotApplicable, - false, - 1u); + StateBaseAddressHelperArgs args = { + generalStateBase, // generalStateBase + internalHeapBase, // indirectObjectHeapBaseAddress + instructionHeapBase, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + nullptr, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + true, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_FALSE(sbaCmd.getDynamicStateBaseAddressModifyEnable()); EXPECT_FALSE(sbaCmd.getDynamicStateBufferSizeModifyEnable()); diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp index e8f2dfcafe..1b25ed2f3c 100644 --- a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp +++ b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp @@ -325,23 +325,26 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, gi uint64_t internalHeapBase = 0x10000; uint64_t generalStateBase = 0x30000; STATE_BASE_ADDRESS sbaCmd; - StateBaseAddressHelper::programStateBaseAddress(&sbaCmd, - nullptr, - nullptr, - nullptr, - generalStateBase, - true, - 0, - internalHeapBase, - instructionHeapBase, - 0, - true, - false, - pDevice->getGmmHelper(), - false, - MemoryCompressionState::NotApplicable, - false, - 1u); + StateBaseAddressHelperArgs args = { + generalStateBase, // generalStateBase + internalHeapBase, // indirectObjectHeapBaseAddress + instructionHeapBase, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + nullptr, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + true, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_FALSE(sbaCmd.getDynamicStateBaseAddressModifyEnable()); EXPECT_FALSE(sbaCmd.getDynamicStateBufferSizeModifyEnable()); diff --git a/opencl/test/unit_test/helpers/test_preamble_xehp_and_later.cpp b/opencl/test/unit_test/helpers/test_preamble_xehp_and_later.cpp index 5eeb44043f..5d0bb5feda 100644 --- a/opencl/test/unit_test/helpers/test_preamble_xehp_and_later.cpp +++ b/opencl/test/unit_test/helpers/test_preamble_xehp_and_later.cpp @@ -462,8 +462,26 @@ HWTEST2_F(StateBaseAddressXeHPAndLaterTests, givenMemoryCompressionEnabledWhenAp for (auto memoryCompressionState : {MemoryCompressionState::NotApplicable, MemoryCompressionState::Disabled, MemoryCompressionState::Enabled}) { auto sbaCmd = FamilyType::cmdInitStateBaseAddress; - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, memoryCompressionState, true, false, 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + memoryCompressionState, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); if (memoryCompressionState == MemoryCompressionState::Enabled) { EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES_ENABLED, sbaCmd.getEnableMemoryCompressionForAllStatelessAccesses()); } else { @@ -482,9 +500,26 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, StateBaseAddressXeHPAndLaterTests, givenNonZeroInte IndirectHeap indirectHeap(allocation, 1); auto sbaCmd = FamilyType::cmdInitStateBaseAddress; uint64_t ihba = 0x80010000ull; - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, false, ihba, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + ihba, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(0ull, sbaCmd.getGeneralStateBaseAddress()); memoryManager->freeGraphicsMemory(allocation); } diff --git a/opencl/test/unit_test/xe_hpc_core/test_cmds_programming_xe_hpc_core.cpp b/opencl/test/unit_test/xe_hpc_core/test_cmds_programming_xe_hpc_core.cpp index 975a4f4eaf..4bec09c956 100644 --- a/opencl/test/unit_test/xe_hpc_core/test_cmds_programming_xe_hpc_core.cpp +++ b/opencl/test/unit_test/xe_hpc_core/test_cmds_programming_xe_hpc_core.cpp @@ -51,10 +51,26 @@ XE_HPC_CORETEST_F(CmdsProgrammingTestsXeHpcCore, givenSpecificProductFamilyWhenA IndirectHeap indirectHeap(allocation, 1); DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags(); auto sbaCmd = FamilyType::cmdInitStateBaseAddress; - - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, sbaCmd.getL1CachePolicyL1CacheControl()); @@ -71,18 +87,32 @@ XE_HPC_CORETEST_F(CmdsProgrammingTestsXeHpcCore, givenL1CachingOverrideWhenState IndirectHeap indirectHeap(allocation, 1); DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags(); auto sbaCmd = FamilyType::cmdInitStateBaseAddress; - - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl()); DebugManager.flags.ForceStatelessL1CachingPolicy.set(1u); - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl()); diff --git a/opencl/test/unit_test/xe_hpg_core/dg2/test_cmds_programming_dg2.cpp b/opencl/test/unit_test/xe_hpg_core/dg2/test_cmds_programming_dg2.cpp index 396875670b..8f8c7baff9 100644 --- a/opencl/test/unit_test/xe_hpg_core/dg2/test_cmds_programming_dg2.cpp +++ b/opencl/test/unit_test/xe_hpg_core/dg2/test_cmds_programming_dg2.cpp @@ -51,10 +51,26 @@ DG2TEST_F(CmdsProgrammingTestsDg2, givenSpecificProductFamilyWhenAppendingSbaThe IndirectHeap indirectHeap(allocation, 1); DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags(); auto sbaCmd = FamilyType::cmdInitStateBaseAddress; - - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, sbaCmd.getL1CachePolicyL1CacheControl()); @@ -71,18 +87,32 @@ DG2TEST_F(CmdsProgrammingTestsDg2, givenL1CachingOverrideWhenStateBaseAddressIsP IndirectHeap indirectHeap(allocation, 1); DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags(); auto sbaCmd = FamilyType::cmdInitStateBaseAddress; - - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl()); DebugManager.flags.ForceStatelessL1CachingPolicy.set(1u); - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl()); diff --git a/opencl/test/unit_test/xe_hpg_core/test_cmds_programming_xe_hpg_core.cpp b/opencl/test/unit_test/xe_hpg_core/test_cmds_programming_xe_hpg_core.cpp index eced76acac..05576d36e6 100644 --- a/opencl/test/unit_test/xe_hpg_core/test_cmds_programming_xe_hpg_core.cpp +++ b/opencl/test/unit_test/xe_hpg_core/test_cmds_programming_xe_hpg_core.cpp @@ -51,10 +51,26 @@ XE_HPG_CORETEST_F(CmdsProgrammingTestsXeHpgCore, givenSpecificProductFamilyWhenA IndirectHeap indirectHeap(allocation, 1); DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags(); auto sbaCmd = FamilyType::cmdInitStateBaseAddress; - - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WBP, sbaCmd.getL1CachePolicyL1CacheControl()); @@ -71,18 +87,32 @@ XE_HPG_CORETEST_F(CmdsProgrammingTestsXeHpgCore, givenL1CachingOverrideWhenState IndirectHeap indirectHeap(allocation, 1); DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags(); auto sbaCmd = FamilyType::cmdInitStateBaseAddress; - - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl()); DebugManager.flags.ForceStatelessL1CachingPolicy.set(1u); - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl()); diff --git a/shared/source/command_container/command_encoder_bdw_and_later.inl b/shared/source/command_container/command_encoder_bdw_and_later.inl index d6132c034d..ce96a5b543 100644 --- a/shared/source/command_container/command_encoder_bdw_and_later.inl +++ b/shared/source/command_container/command_encoder_bdw_and_later.inl @@ -367,27 +367,34 @@ void EncodeStateBaseAddress::encode(CommandContainer &container, STATE_B auto gmmHelper = device.getGmmHelper(); - StateBaseAddressHelper::programStateBaseAddress( - &sbaCmd, - container.isHeapDirty(HeapType::DYNAMIC_STATE) ? container.getIndirectHeap(HeapType::DYNAMIC_STATE) : nullptr, - container.isHeapDirty(HeapType::INDIRECT_OBJECT) ? container.getIndirectHeap(HeapType::INDIRECT_OBJECT) : nullptr, - container.isHeapDirty(HeapType::SURFACE_STATE) ? container.getIndirectHeap(HeapType::SURFACE_STATE) : nullptr, - 0, - false, - statelessMocsIndex, - container.getIndirectObjectHeapBaseAddress(), - container.getInstructionHeapBaseAddress(), - 0, - false, - false, - gmmHelper, - false, - MemoryCompressionState::NotApplicable, - useGlobalAtomics, - 1u); + auto dsh = container.isHeapDirty(HeapType::DYNAMIC_STATE) ? container.getIndirectHeap(HeapType::DYNAMIC_STATE) : nullptr; + auto ioh = container.isHeapDirty(HeapType::INDIRECT_OBJECT) ? container.getIndirectHeap(HeapType::INDIRECT_OBJECT) : nullptr; + auto ssh = container.isHeapDirty(HeapType::SURFACE_STATE) ? container.getIndirectHeap(HeapType::SURFACE_STATE) : nullptr; - auto pCmd = reinterpret_cast(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS))); - *pCmd = sbaCmd; + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + container.getIndirectObjectHeapBaseAddress(), // indirectObjectHeapBaseAddress + container.getInstructionHeapBaseAddress(), // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + dsh, // dsh + ioh, // ioh + ssh, // ssh + gmmHelper, // gmmHelper + statelessMocsIndex, // statelessMocsIndex + NEO::MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + useGlobalAtomics, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::programStateBaseAddress(args); + + auto cmdSpace = reinterpret_cast(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS))); + *cmdSpace = sbaCmd; EncodeWA::encodeAdditionalPipelineSelect(*container.getCommandStream(), {}, false, hwInfo, isRcs); } diff --git a/shared/source/command_container/command_encoder_xehp_and_later.inl b/shared/source/command_container/command_encoder_xehp_and_later.inl index 27b95f157e..e649685f7d 100644 --- a/shared/source/command_container/command_encoder_xehp_and_later.inl +++ b/shared/source/command_container/command_encoder_xehp_and_later.inl @@ -474,33 +474,40 @@ template void EncodeStateBaseAddress::encode(CommandContainer &container, STATE_BASE_ADDRESS &sbaCmd, uint32_t statelessMocsIndex, bool useGlobalAtomics, bool multiOsContextCapable) { auto gmmHelper = container.getDevice()->getRootDeviceEnvironment().getGmmHelper(); - StateBaseAddressHelper::programStateBaseAddress( - &sbaCmd, - container.isHeapDirty(HeapType::DYNAMIC_STATE) ? container.getIndirectHeap(HeapType::DYNAMIC_STATE) : nullptr, - container.isHeapDirty(HeapType::INDIRECT_OBJECT) ? container.getIndirectHeap(HeapType::INDIRECT_OBJECT) : nullptr, - container.isHeapDirty(HeapType::SURFACE_STATE) ? container.getIndirectHeap(HeapType::SURFACE_STATE) : nullptr, - 0, - true, - statelessMocsIndex, - container.getIndirectObjectHeapBaseAddress(), - container.getInstructionHeapBaseAddress(), - 0, - true, - false, - gmmHelper, - multiOsContextCapable, - MemoryCompressionState::NotApplicable, - useGlobalAtomics, - 1u); + auto dsh = container.isHeapDirty(HeapType::DYNAMIC_STATE) ? container.getIndirectHeap(HeapType::DYNAMIC_STATE) : nullptr; + auto ioh = container.isHeapDirty(HeapType::INDIRECT_OBJECT) ? container.getIndirectHeap(HeapType::INDIRECT_OBJECT) : nullptr; + auto ssh = container.isHeapDirty(HeapType::SURFACE_STATE) ? container.getIndirectHeap(HeapType::SURFACE_STATE) : nullptr; - auto pCmd = reinterpret_cast(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS))); - *pCmd = sbaCmd; + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + container.getIndirectObjectHeapBaseAddress(), // indirectObjectHeapBaseAddress + container.getInstructionHeapBaseAddress(), // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + dsh, // dsh + ioh, // ioh + ssh, // ssh + gmmHelper, // gmmHelper + statelessMocsIndex, // statelessMocsIndex + NEO::MemoryCompressionState::NotApplicable, // memoryCompressionState + true, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + multiOsContextCapable, // isMultiOsContextCapable + useGlobalAtomics, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::programStateBaseAddress(args); + + auto cmdSpace = reinterpret_cast(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS))); + *cmdSpace = sbaCmd; auto &hwInfo = container.getDevice()->getHardwareInfo(); auto &hwInfoConfig = *HwInfoConfig::get(hwInfo.platform.eProductFamily); if (hwInfoConfig.isAdditionalStateBaseAddressWARequired(hwInfo)) { - pCmd = reinterpret_cast(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS))); - *pCmd = sbaCmd; + cmdSpace = reinterpret_cast(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS))); + *cmdSpace = sbaCmd; } if (container.isHeapDirty(HeapType::SURFACE_STATE)) { diff --git a/shared/source/command_stream/command_stream_receiver_hw_base.inl b/shared/source/command_stream/command_stream_receiver_hw_base.inl index ac707fbd42..06ad7fd608 100644 --- a/shared/source/command_stream/command_stream_receiver_hw_base.inl +++ b/shared/source/command_stream/command_stream_receiver_hw_base.inl @@ -408,24 +408,28 @@ CompletionStamp CommandStreamReceiverHw::flushTask( uint64_t indirectObjectStateBaseAddress = getMemoryManager()->getInternalHeapBaseAddress(rootDeviceIndex, ioh->getGraphicsAllocation()->isAllocatedInLocalMemoryPool()); STATE_BASE_ADDRESS stateBaseAddressCmd; - StateBaseAddressHelper::programStateBaseAddress( - &stateBaseAddressCmd, - dsh, - ioh, - ssh, - newGSHbase, - true, - mocsIndex, - indirectObjectStateBaseAddress, - instructionHeapBaseAddress, - 0, - true, - false, - device.getGmmHelper(), - isMultiOsContextCapable(), - memoryCompressionState, - dispatchFlags.useGlobalAtomics, - dispatchFlags.areMultipleSubDevicesInContext); + + StateBaseAddressHelperArgs args = { + newGSHbase, // generalStateBase + indirectObjectStateBaseAddress, // indirectObjectHeapBaseAddress + instructionHeapBaseAddress, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &stateBaseAddressCmd, // stateBaseAddressCmd + dsh, // dsh + ioh, // ioh + ssh, // ssh + device.getGmmHelper(), // gmmHelper + mocsIndex, // statelessMocsIndex + memoryCompressionState, // memoryCompressionState + true, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + isMultiOsContextCapable(), // isMultiOsContextCapable + dispatchFlags.useGlobalAtomics, // useGlobalAtomics + dispatchFlags.areMultipleSubDevicesInContext // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::programStateBaseAddress(args); if (stateBaseAddressCmdBuffer) { *stateBaseAddressCmdBuffer = stateBaseAddressCmd; diff --git a/shared/source/gen8/state_base_address_gen8.cpp b/shared/source/gen8/state_base_address_gen8.cpp index 5071026fdc..7e9de5a948 100644 --- a/shared/source/gen8/state_base_address_gen8.cpp +++ b/shared/source/gen8/state_base_address_gen8.cpp @@ -14,71 +14,54 @@ namespace NEO { template <> void StateBaseAddressHelper::programStateBaseAddress( - STATE_BASE_ADDRESS *stateBaseAddress, - const IndirectHeap *dsh, - const IndirectHeap *ioh, - const IndirectHeap *ssh, - uint64_t generalStateBase, - bool setGeneralStateBaseAddress, - uint32_t statelessMocsIndex, - uint64_t indirectObjectHeapBaseAddress, - uint64_t instructionHeapBaseAddress, - uint64_t globalHeapsBaseAddress, - bool setInstructionStateBaseAddress, - bool useGlobalHeapsBaseAddress, - GmmHelper *gmmHelper, - bool isMultiOsContextCapable, - MemoryCompressionState memoryCompressionState, - bool useGlobalAtomics, - bool areMultipleSubDevicesInContext) { + StateBaseAddressHelperArgs &args) { - *stateBaseAddress = Gen8Family::cmdInitStateBaseAddress; + *args.stateBaseAddressCmd = Gen8Family::cmdInitStateBaseAddress; - if (dsh) { - stateBaseAddress->setDynamicStateBaseAddressModifyEnable(true); - stateBaseAddress->setDynamicStateBufferSizeModifyEnable(true); - stateBaseAddress->setDynamicStateBaseAddress(dsh->getHeapGpuBase()); - stateBaseAddress->setDynamicStateBufferSize(dsh->getHeapSizeInPages()); + if (args.dsh) { + args.stateBaseAddressCmd->setDynamicStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setDynamicStateBufferSizeModifyEnable(true); + args.stateBaseAddressCmd->setDynamicStateBaseAddress(args.dsh->getHeapGpuBase()); + args.stateBaseAddressCmd->setDynamicStateBufferSize(args.dsh->getHeapSizeInPages()); } - if (ioh) { - stateBaseAddress->setIndirectObjectBaseAddressModifyEnable(true); - stateBaseAddress->setIndirectObjectBufferSizeModifyEnable(true); - stateBaseAddress->setIndirectObjectBaseAddress(ioh->getHeapGpuBase()); - stateBaseAddress->setIndirectObjectBufferSize(ioh->getHeapSizeInPages()); + if (args.ioh) { + args.stateBaseAddressCmd->setIndirectObjectBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setIndirectObjectBufferSizeModifyEnable(true); + args.stateBaseAddressCmd->setIndirectObjectBaseAddress(args.ioh->getHeapGpuBase()); + args.stateBaseAddressCmd->setIndirectObjectBufferSize(args.ioh->getHeapSizeInPages()); } - if (ssh) { - stateBaseAddress->setSurfaceStateBaseAddressModifyEnable(true); - stateBaseAddress->setSurfaceStateBaseAddress(ssh->getHeapGpuBase()); + if (args.ssh) { + args.stateBaseAddressCmd->setSurfaceStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setSurfaceStateBaseAddress(args.ssh->getHeapGpuBase()); } - if (setInstructionStateBaseAddress) { - stateBaseAddress->setInstructionBaseAddressModifyEnable(true); - stateBaseAddress->setInstructionBaseAddress(instructionHeapBaseAddress); - stateBaseAddress->setInstructionBufferSizeModifyEnable(true); - stateBaseAddress->setInstructionBufferSize(MemoryConstants::sizeOf4GBinPageEntities); - stateBaseAddress->setInstructionMemoryObjectControlState(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_STATE_HEAP_BUFFER)); + if (args.setInstructionStateBaseAddress) { + args.stateBaseAddressCmd->setInstructionBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setInstructionBaseAddress(args.instructionHeapBaseAddress); + args.stateBaseAddressCmd->setInstructionBufferSizeModifyEnable(true); + args.stateBaseAddressCmd->setInstructionBufferSize(MemoryConstants::sizeOf4GBinPageEntities); + args.stateBaseAddressCmd->setInstructionMemoryObjectControlState(args.gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_STATE_HEAP_BUFFER)); } - if (setGeneralStateBaseAddress) { - stateBaseAddress->setGeneralStateBaseAddressModifyEnable(true); - stateBaseAddress->setGeneralStateBufferSizeModifyEnable(true); + if (args.setGeneralStateBaseAddress) { + args.stateBaseAddressCmd->setGeneralStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setGeneralStateBufferSizeModifyEnable(true); // GSH must be set to 0 for stateless - stateBaseAddress->setGeneralStateBaseAddress(gmmHelper->decanonize(generalStateBase)); - stateBaseAddress->setGeneralStateBufferSize(0xfffff); + args.stateBaseAddressCmd->setGeneralStateBaseAddress(args.gmmHelper->decanonize(args.generalStateBase)); + args.stateBaseAddressCmd->setGeneralStateBufferSize(0xfffff); } if (DebugManager.flags.OverrideStatelessMocsIndex.get() != -1) { - statelessMocsIndex = DebugManager.flags.OverrideStatelessMocsIndex.get(); + args.statelessMocsIndex = DebugManager.flags.OverrideStatelessMocsIndex.get(); } - statelessMocsIndex = statelessMocsIndex << 1; + args.statelessMocsIndex = args.statelessMocsIndex << 1; - stateBaseAddress->setStatelessDataPortAccessMemoryObjectControlState(statelessMocsIndex); + args.stateBaseAddressCmd->setStatelessDataPortAccessMemoryObjectControlState(args.statelessMocsIndex); - appendStateBaseAddressParameters(stateBaseAddress, ssh, setGeneralStateBaseAddress, indirectObjectHeapBaseAddress, - gmmHelper, isMultiOsContextCapable, memoryCompressionState, true, useGlobalAtomics, areMultipleSubDevicesInContext); + appendStateBaseAddressParameters(args, true); } template struct StateBaseAddressHelper; } // namespace NEO diff --git a/shared/source/helpers/state_base_address.h b/shared/source/helpers/state_base_address.h index 68d328f49c..228221bf20 100644 --- a/shared/source/helpers/state_base_address.h +++ b/shared/source/helpers/state_base_address.h @@ -18,44 +18,45 @@ class LinearStream; struct DispatchFlags; struct HardwareInfo; +template +struct StateBaseAddressHelperArgs { + using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS; + + uint64_t generalStateBase = 0; + uint64_t indirectObjectHeapBaseAddress = 0; + uint64_t instructionHeapBaseAddress = 0; + uint64_t globalHeapsBaseAddress = 0; + + STATE_BASE_ADDRESS *stateBaseAddressCmd = nullptr; + + const IndirectHeap *dsh = nullptr; + const IndirectHeap *ioh = nullptr; + const IndirectHeap *ssh = nullptr; + GmmHelper *gmmHelper = nullptr; + + uint32_t statelessMocsIndex = 0; + MemoryCompressionState memoryCompressionState; + + bool setInstructionStateBaseAddress = false; + bool setGeneralStateBaseAddress = false; + bool useGlobalHeapsBaseAddress = false; + bool isMultiOsContextCapable = false; + bool useGlobalAtomics = false; + bool areMultipleSubDevicesInContext = false; +}; + template struct StateBaseAddressHelper { using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS; static void *getSpaceForSbaCmd(LinearStream &cmdStream); - static void programStateBaseAddress( - STATE_BASE_ADDRESS *stateBaseAddress, - const IndirectHeap *dsh, - const IndirectHeap *ioh, - const IndirectHeap *ssh, - uint64_t generalStateBase, - bool setGeneralStateBaseAddress, - uint32_t statelessMocsIndex, - uint64_t indirectObjectHeapBaseAddress, - uint64_t instructionHeapBaseAddress, - uint64_t globalHeapsBaseAddress, - bool setInstructionStateBaseAddress, - bool useGlobalHeapsBaseAddress, - GmmHelper *gmmHelper, - bool isMultiOsContextCapable, - MemoryCompressionState memoryCompressionState, - bool useGlobalAtomics, - bool areMultipleSubDevicesInContext); + static void programStateBaseAddress(StateBaseAddressHelperArgs &args); - static void appendIohParameters(STATE_BASE_ADDRESS *stateBaseAddress, const IndirectHeap *ioh, bool useGlobalHeapsBaseAddress, uint64_t indirectObjectHeapBaseAddress); + static void appendIohParameters(StateBaseAddressHelperArgs &args); - static void appendStateBaseAddressParameters( - STATE_BASE_ADDRESS *stateBaseAddress, - const IndirectHeap *ssh, - bool setGeneralStateBaseAddress, - uint64_t indirectObjectHeapBaseAddress, - GmmHelper *gmmHelper, - bool isMultiOsContextCapable, - MemoryCompressionState memoryCompressionState, - bool overrideBindlessSurfaceStateBase, - bool useGlobalAtomics, - bool areMultipleSubDevicesInContext); + static void appendStateBaseAddressParameters(StateBaseAddressHelperArgs &args, + bool overrideBindlessSurfaceStateBase); static void appendExtraCacheSettings(STATE_BASE_ADDRESS *stateBaseAddress, const HardwareInfo *hwInfo); diff --git a/shared/source/helpers/state_base_address_base.inl b/shared/source/helpers/state_base_address_base.inl index 7f9cd51cfc..65b39ef192 100644 --- a/shared/source/helpers/state_base_address_base.inl +++ b/shared/source/helpers/state_base_address_base.inl @@ -17,88 +17,71 @@ namespace NEO { template void StateBaseAddressHelper::programStateBaseAddress( - STATE_BASE_ADDRESS *stateBaseAddress, - const IndirectHeap *dsh, - const IndirectHeap *ioh, - const IndirectHeap *ssh, - uint64_t generalStateBase, - bool setGeneralStateBaseAddress, - uint32_t statelessMocsIndex, - uint64_t indirectObjectHeapBaseAddress, - uint64_t instructionHeapBaseAddress, - uint64_t globalHeapsBaseAddress, - bool setInstructionStateBaseAddress, - bool useGlobalHeapsBaseAddress, - GmmHelper *gmmHelper, - bool isMultiOsContextCapable, - MemoryCompressionState memoryCompressionState, - bool useGlobalAtomics, - bool areMultipleSubDevicesInContext) { + StateBaseAddressHelperArgs &args) { - *stateBaseAddress = GfxFamily::cmdInitStateBaseAddress; + *args.stateBaseAddressCmd = GfxFamily::cmdInitStateBaseAddress; bool overrideBindlessSurfaceStateBase = true; const auto surfaceStateCount = getMaxBindlessSurfaceStates(); - stateBaseAddress->setBindlessSurfaceStateSize(surfaceStateCount); + args.stateBaseAddressCmd->setBindlessSurfaceStateSize(surfaceStateCount); - if (useGlobalHeapsBaseAddress) { - stateBaseAddress->setDynamicStateBaseAddressModifyEnable(true); - stateBaseAddress->setDynamicStateBufferSizeModifyEnable(true); - stateBaseAddress->setDynamicStateBaseAddress(globalHeapsBaseAddress); - stateBaseAddress->setDynamicStateBufferSize(MemoryConstants::pageSize64k); + if (args.useGlobalHeapsBaseAddress) { + args.stateBaseAddressCmd->setDynamicStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setDynamicStateBufferSizeModifyEnable(true); + args.stateBaseAddressCmd->setDynamicStateBaseAddress(args.globalHeapsBaseAddress); + args.stateBaseAddressCmd->setDynamicStateBufferSize(MemoryConstants::pageSize64k); - stateBaseAddress->setSurfaceStateBaseAddressModifyEnable(true); - stateBaseAddress->setSurfaceStateBaseAddress(globalHeapsBaseAddress); + args.stateBaseAddressCmd->setSurfaceStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setSurfaceStateBaseAddress(args.globalHeapsBaseAddress); - stateBaseAddress->setBindlessSurfaceStateBaseAddressModifyEnable(true); - stateBaseAddress->setBindlessSurfaceStateBaseAddress(globalHeapsBaseAddress); + args.stateBaseAddressCmd->setBindlessSurfaceStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setBindlessSurfaceStateBaseAddress(args.globalHeapsBaseAddress); overrideBindlessSurfaceStateBase = false; } else { - if (dsh) { - stateBaseAddress->setDynamicStateBaseAddressModifyEnable(true); - stateBaseAddress->setDynamicStateBufferSizeModifyEnable(true); - stateBaseAddress->setDynamicStateBaseAddress(dsh->getHeapGpuBase()); - stateBaseAddress->setDynamicStateBufferSize(dsh->getHeapSizeInPages()); + if (args.dsh) { + args.stateBaseAddressCmd->setDynamicStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setDynamicStateBufferSizeModifyEnable(true); + args.stateBaseAddressCmd->setDynamicStateBaseAddress(args.dsh->getHeapGpuBase()); + args.stateBaseAddressCmd->setDynamicStateBufferSize(args.dsh->getHeapSizeInPages()); } - if (ssh) { - stateBaseAddress->setSurfaceStateBaseAddressModifyEnable(true); - stateBaseAddress->setSurfaceStateBaseAddress(ssh->getHeapGpuBase()); + if (args.ssh) { + args.stateBaseAddressCmd->setSurfaceStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setSurfaceStateBaseAddress(args.ssh->getHeapGpuBase()); } } - appendIohParameters(stateBaseAddress, ioh, useGlobalHeapsBaseAddress, indirectObjectHeapBaseAddress); + appendIohParameters(args); - if (setInstructionStateBaseAddress) { - stateBaseAddress->setInstructionBaseAddressModifyEnable(true); - stateBaseAddress->setInstructionBaseAddress(instructionHeapBaseAddress); - stateBaseAddress->setInstructionBufferSizeModifyEnable(true); - stateBaseAddress->setInstructionBufferSize(MemoryConstants::sizeOf4GBinPageEntities); + if (args.setInstructionStateBaseAddress) { + args.stateBaseAddressCmd->setInstructionBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setInstructionBaseAddress(args.instructionHeapBaseAddress); + args.stateBaseAddressCmd->setInstructionBufferSizeModifyEnable(true); + args.stateBaseAddressCmd->setInstructionBufferSize(MemoryConstants::sizeOf4GBinPageEntities); - auto resourceUsage = CacheSettingsHelper::getGmmUsageType(AllocationType::INTERNAL_HEAP, DebugManager.flags.DisableCachingForHeaps.get(), *gmmHelper->getHardwareInfo()); + auto resourceUsage = CacheSettingsHelper::getGmmUsageType(AllocationType::INTERNAL_HEAP, DebugManager.flags.DisableCachingForHeaps.get(), *args.gmmHelper->getHardwareInfo()); - stateBaseAddress->setInstructionMemoryObjectControlState(gmmHelper->getMOCS(resourceUsage)); + args.stateBaseAddressCmd->setInstructionMemoryObjectControlState(args.gmmHelper->getMOCS(resourceUsage)); } - if (setGeneralStateBaseAddress) { - stateBaseAddress->setGeneralStateBaseAddressModifyEnable(true); - stateBaseAddress->setGeneralStateBufferSizeModifyEnable(true); + if (args.setGeneralStateBaseAddress) { + args.stateBaseAddressCmd->setGeneralStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setGeneralStateBufferSizeModifyEnable(true); // GSH must be set to 0 for stateless - stateBaseAddress->setGeneralStateBaseAddress(gmmHelper->decanonize(generalStateBase)); - stateBaseAddress->setGeneralStateBufferSize(0xfffff); + args.stateBaseAddressCmd->setGeneralStateBaseAddress(args.gmmHelper->decanonize(args.generalStateBase)); + args.stateBaseAddressCmd->setGeneralStateBufferSize(0xfffff); } if (DebugManager.flags.OverrideStatelessMocsIndex.get() != -1) { - statelessMocsIndex = DebugManager.flags.OverrideStatelessMocsIndex.get(); + args.statelessMocsIndex = DebugManager.flags.OverrideStatelessMocsIndex.get(); } - statelessMocsIndex = statelessMocsIndex << 1; + args.statelessMocsIndex = args.statelessMocsIndex << 1; - stateBaseAddress->setStatelessDataPortAccessMemoryObjectControlState(statelessMocsIndex); + args.stateBaseAddressCmd->setStatelessDataPortAccessMemoryObjectControlState(args.statelessMocsIndex); - appendStateBaseAddressParameters(stateBaseAddress, ssh, setGeneralStateBaseAddress, indirectObjectHeapBaseAddress, gmmHelper, - isMultiOsContextCapable, memoryCompressionState, overrideBindlessSurfaceStateBase, useGlobalAtomics, areMultipleSubDevicesInContext); + appendStateBaseAddressParameters(args, overrideBindlessSurfaceStateBase); } template diff --git a/shared/source/helpers/state_base_address_bdw.inl b/shared/source/helpers/state_base_address_bdw.inl index eb075edb4b..9431ab7f61 100644 --- a/shared/source/helpers/state_base_address_bdw.inl +++ b/shared/source/helpers/state_base_address_bdw.inl @@ -11,16 +11,8 @@ namespace NEO { template void StateBaseAddressHelper::appendStateBaseAddressParameters( - STATE_BASE_ADDRESS *stateBaseAddress, - const IndirectHeap *ssh, - bool setGeneralStateBaseAddress, - uint64_t indirectObjectHeapBaseAddress, - GmmHelper *gmmHelper, - bool isMultiOsContextCapable, - MemoryCompressionState memoryCompressionState, - bool overrideBindlessSurfaceStateBase, - bool useGlobalAtomics, - bool areMultipleSubDevicesInContext) { + StateBaseAddressHelperArgs &args, + bool overrideBindlessSurfaceStateBase) { } template diff --git a/shared/source/helpers/state_base_address_bdw_and_later.inl b/shared/source/helpers/state_base_address_bdw_and_later.inl index 0854c95044..154e801120 100644 --- a/shared/source/helpers/state_base_address_bdw_and_later.inl +++ b/shared/source/helpers/state_base_address_bdw_and_later.inl @@ -14,17 +14,17 @@ void StateBaseAddressHelper::programBindingTableBaseAddress(LinearStr } template -void StateBaseAddressHelper::appendIohParameters(typename GfxFamily::STATE_BASE_ADDRESS *stateBaseAddress, const IndirectHeap *ioh, bool useGlobalHeapsBaseAddress, uint64_t indirectObjectHeapBaseAddress) { - if (useGlobalHeapsBaseAddress) { - stateBaseAddress->setIndirectObjectBaseAddressModifyEnable(true); - stateBaseAddress->setIndirectObjectBufferSizeModifyEnable(true); - stateBaseAddress->setIndirectObjectBaseAddress(indirectObjectHeapBaseAddress); - stateBaseAddress->setIndirectObjectBufferSize(MemoryConstants::sizeOf4GBinPageEntities); - } else if (ioh) { - stateBaseAddress->setIndirectObjectBaseAddressModifyEnable(true); - stateBaseAddress->setIndirectObjectBufferSizeModifyEnable(true); - stateBaseAddress->setIndirectObjectBaseAddress(ioh->getHeapGpuBase()); - stateBaseAddress->setIndirectObjectBufferSize(ioh->getHeapSizeInPages()); +void StateBaseAddressHelper::appendIohParameters(StateBaseAddressHelperArgs &args) { + if (args.useGlobalHeapsBaseAddress) { + args.stateBaseAddressCmd->setIndirectObjectBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setIndirectObjectBufferSizeModifyEnable(true); + args.stateBaseAddressCmd->setIndirectObjectBaseAddress(args.indirectObjectHeapBaseAddress); + args.stateBaseAddressCmd->setIndirectObjectBufferSize(MemoryConstants::sizeOf4GBinPageEntities); + } else if (args.ioh) { + args.stateBaseAddressCmd->setIndirectObjectBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setIndirectObjectBufferSizeModifyEnable(true); + args.stateBaseAddressCmd->setIndirectObjectBaseAddress(args.ioh->getHeapGpuBase()); + args.stateBaseAddressCmd->setIndirectObjectBufferSize(args.ioh->getHeapSizeInPages()); } } diff --git a/shared/source/helpers/state_base_address_icllp_and_later.inl b/shared/source/helpers/state_base_address_icllp_and_later.inl index e806180bab..291e8cb98b 100644 --- a/shared/source/helpers/state_base_address_icllp_and_later.inl +++ b/shared/source/helpers/state_base_address_icllp_and_later.inl @@ -11,31 +11,23 @@ namespace NEO { template void StateBaseAddressHelper::appendStateBaseAddressParameters( - STATE_BASE_ADDRESS *stateBaseAddress, - const IndirectHeap *ssh, - bool setGeneralStateBaseAddress, - uint64_t indirectObjectHeapBaseAddress, - GmmHelper *gmmHelper, - bool isMultiOsContextCapable, - MemoryCompressionState memoryCompressionState, - bool overrideBindlessSurfaceStateBase, - bool useGlobalAtomics, - bool areMultipleSubDevicesInContext) { + StateBaseAddressHelperArgs &args, + bool overrideBindlessSurfaceStateBase) { - if (overrideBindlessSurfaceStateBase && ssh) { - stateBaseAddress->setBindlessSurfaceStateBaseAddressModifyEnable(true); - stateBaseAddress->setBindlessSurfaceStateBaseAddress(ssh->getHeapGpuBase()); - uint32_t size = uint32_t(ssh->getMaxAvailableSpace() / 64) - 1; - stateBaseAddress->setBindlessSurfaceStateSize(size); + if (overrideBindlessSurfaceStateBase && args.ssh) { + args.stateBaseAddressCmd->setBindlessSurfaceStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setBindlessSurfaceStateBaseAddress(args.ssh->getHeapGpuBase()); + uint32_t size = uint32_t(args.ssh->getMaxAvailableSpace() / 64) - 1; + args.stateBaseAddressCmd->setBindlessSurfaceStateSize(size); } - stateBaseAddress->setBindlessSamplerStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setBindlessSamplerStateBaseAddressModifyEnable(true); auto l3CacheOnPolicy = GMM_RESOURCE_USAGE_OCL_STATE_HEAP_BUFFER; - if (gmmHelper != nullptr) { - stateBaseAddress->setBindlessSurfaceStateMemoryObjectControlState(gmmHelper->getMOCS(l3CacheOnPolicy)); - stateBaseAddress->setBindlessSamplerStateMemoryObjectControlState(gmmHelper->getMOCS(l3CacheOnPolicy)); + if (args.gmmHelper != nullptr) { + args.stateBaseAddressCmd->setBindlessSurfaceStateMemoryObjectControlState(args.gmmHelper->getMOCS(l3CacheOnPolicy)); + args.stateBaseAddressCmd->setBindlessSamplerStateMemoryObjectControlState(args.gmmHelper->getMOCS(l3CacheOnPolicy)); } } diff --git a/shared/source/helpers/state_base_address_skl.inl b/shared/source/helpers/state_base_address_skl.inl index ef2f58d2f0..7d4a77f79b 100644 --- a/shared/source/helpers/state_base_address_skl.inl +++ b/shared/source/helpers/state_base_address_skl.inl @@ -11,22 +11,14 @@ namespace NEO { template void StateBaseAddressHelper::appendStateBaseAddressParameters( - STATE_BASE_ADDRESS *stateBaseAddress, - const IndirectHeap *ssh, - bool setGeneralStateBaseAddress, - uint64_t indirectObjectHeapBaseAddress, - GmmHelper *gmmHelper, - bool isMultiOsContextCapable, - MemoryCompressionState memoryCompressionState, - bool overrideBindlessSurfaceStateBase, - bool useGlobalAtomics, - bool areMultipleSubDevicesInContext) { + StateBaseAddressHelperArgs &args, + bool overrideBindlessSurfaceStateBase) { - if (overrideBindlessSurfaceStateBase && ssh) { - stateBaseAddress->setBindlessSurfaceStateBaseAddressModifyEnable(true); - stateBaseAddress->setBindlessSurfaceStateBaseAddress(ssh->getHeapGpuBase()); - uint32_t size = uint32_t(ssh->getMaxAvailableSpace() / 64) - 1; - stateBaseAddress->setBindlessSurfaceStateSize(size); + if (overrideBindlessSurfaceStateBase && args.ssh) { + args.stateBaseAddressCmd->setBindlessSurfaceStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setBindlessSurfaceStateBaseAddress(args.ssh->getHeapGpuBase()); + uint32_t size = uint32_t(args.ssh->getMaxAvailableSpace() / 64) - 1; + args.stateBaseAddressCmd->setBindlessSurfaceStateSize(size); } } diff --git a/shared/source/helpers/state_base_address_xehp_and_later.inl b/shared/source/helpers/state_base_address_xehp_and_later.inl index b9e90b6915..c17656a0fc 100644 --- a/shared/source/helpers/state_base_address_xehp_and_later.inl +++ b/shared/source/helpers/state_base_address_xehp_and_later.inl @@ -27,66 +27,58 @@ void setSbaStatelessCompressionParams(typename GfxFamily::STATE_BASE_ADDRESS *st template void StateBaseAddressHelper::appendStateBaseAddressParameters( - STATE_BASE_ADDRESS *stateBaseAddress, - const IndirectHeap *ssh, - bool setGeneralStateBaseAddress, - uint64_t internalHeapBase, - GmmHelper *gmmHelper, - bool isMultiOsContextCapable, - MemoryCompressionState memoryCompressionState, - bool overrideBindlessSurfaceStateBase, - bool useGlobalAtomics, - bool areMultipleSubDevicesInContext) { + StateBaseAddressHelperArgs &args, + bool overrideBindlessSurfaceStateBase) { using RENDER_SURFACE_STATE = typename GfxFamily::RENDER_SURFACE_STATE; using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS; - if (setGeneralStateBaseAddress && is64bit) { - stateBaseAddress->setGeneralStateBaseAddress(gmmHelper->decanonize(internalHeapBase)); + if (args.setGeneralStateBaseAddress && is64bit) { + args.stateBaseAddressCmd->setGeneralStateBaseAddress(args.gmmHelper->decanonize(args.indirectObjectHeapBaseAddress)); } - if (overrideBindlessSurfaceStateBase && ssh) { - stateBaseAddress->setBindlessSurfaceStateBaseAddress(ssh->getHeapGpuBase()); - stateBaseAddress->setBindlessSurfaceStateBaseAddressModifyEnable(true); - const auto surfaceStateCount = ssh->getMaxAvailableSpace() / sizeof(RENDER_SURFACE_STATE); - stateBaseAddress->setBindlessSurfaceStateSize(static_cast(surfaceStateCount - 1)); + if (overrideBindlessSurfaceStateBase && args.ssh) { + args.stateBaseAddressCmd->setBindlessSurfaceStateBaseAddress(args.ssh->getHeapGpuBase()); + args.stateBaseAddressCmd->setBindlessSurfaceStateBaseAddressModifyEnable(true); + const auto surfaceStateCount = args.ssh->getMaxAvailableSpace() / sizeof(RENDER_SURFACE_STATE); + args.stateBaseAddressCmd->setBindlessSurfaceStateSize(static_cast(surfaceStateCount - 1)); } - stateBaseAddress->setBindlessSamplerStateBaseAddressModifyEnable(true); + args.stateBaseAddressCmd->setBindlessSamplerStateBaseAddressModifyEnable(true); - auto heapResourceUsage = CacheSettingsHelper::getGmmUsageType(AllocationType::INTERNAL_HEAP, DebugManager.flags.DisableCachingForHeaps.get(), *gmmHelper->getHardwareInfo()); - auto heapMocsValue = gmmHelper->getMOCS(heapResourceUsage); + auto heapResourceUsage = CacheSettingsHelper::getGmmUsageType(AllocationType::INTERNAL_HEAP, DebugManager.flags.DisableCachingForHeaps.get(), *args.gmmHelper->getHardwareInfo()); + auto heapMocsValue = args.gmmHelper->getMOCS(heapResourceUsage); - stateBaseAddress->setSurfaceStateMemoryObjectControlState(heapMocsValue); - stateBaseAddress->setDynamicStateMemoryObjectControlState(heapMocsValue); - stateBaseAddress->setGeneralStateMemoryObjectControlState(heapMocsValue); - stateBaseAddress->setBindlessSurfaceStateMemoryObjectControlState(heapMocsValue); - stateBaseAddress->setBindlessSamplerStateMemoryObjectControlState(heapMocsValue); + args.stateBaseAddressCmd->setSurfaceStateMemoryObjectControlState(heapMocsValue); + args.stateBaseAddressCmd->setDynamicStateMemoryObjectControlState(heapMocsValue); + args.stateBaseAddressCmd->setGeneralStateMemoryObjectControlState(heapMocsValue); + args.stateBaseAddressCmd->setBindlessSurfaceStateMemoryObjectControlState(heapMocsValue); + args.stateBaseAddressCmd->setBindlessSamplerStateMemoryObjectControlState(heapMocsValue); - bool enableMultiGpuAtomics = isMultiOsContextCapable; + bool enableMultiGpuAtomics = args.isMultiOsContextCapable; if (DebugManager.flags.EnableMultiGpuAtomicsOptimization.get()) { - enableMultiGpuAtomics = useGlobalAtomics && (isMultiOsContextCapable || areMultipleSubDevicesInContext); + enableMultiGpuAtomics = args.useGlobalAtomics && (args.isMultiOsContextCapable || args.areMultipleSubDevicesInContext); } - stateBaseAddress->setDisableSupportForMultiGpuAtomicsForStatelessAccesses(!enableMultiGpuAtomics); + args.stateBaseAddressCmd->setDisableSupportForMultiGpuAtomicsForStatelessAccesses(!enableMultiGpuAtomics); - stateBaseAddress->setDisableSupportForMultiGpuPartialWritesForStatelessMessages(!isMultiOsContextCapable); + args.stateBaseAddressCmd->setDisableSupportForMultiGpuPartialWritesForStatelessMessages(!args.isMultiOsContextCapable); if (DebugManager.flags.ForceMultiGpuAtomics.get() != -1) { - stateBaseAddress->setDisableSupportForMultiGpuAtomicsForStatelessAccesses(!!DebugManager.flags.ForceMultiGpuAtomics.get()); + args.stateBaseAddressCmd->setDisableSupportForMultiGpuAtomicsForStatelessAccesses(!!DebugManager.flags.ForceMultiGpuAtomics.get()); } if (DebugManager.flags.ForceMultiGpuPartialWrites.get() != -1) { - stateBaseAddress->setDisableSupportForMultiGpuPartialWritesForStatelessMessages(!!DebugManager.flags.ForceMultiGpuPartialWrites.get()); + args.stateBaseAddressCmd->setDisableSupportForMultiGpuPartialWritesForStatelessMessages(!!DebugManager.flags.ForceMultiGpuPartialWrites.get()); } - if (memoryCompressionState != MemoryCompressionState::NotApplicable) { - setSbaStatelessCompressionParams(stateBaseAddress, memoryCompressionState); + if (args.memoryCompressionState != MemoryCompressionState::NotApplicable) { + setSbaStatelessCompressionParams(args.stateBaseAddressCmd, args.memoryCompressionState); } - if (stateBaseAddress->getStatelessDataPortAccessMemoryObjectControlState() == gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) && DebugManager.flags.ForceL1Caching.get() != 0) { - stateBaseAddress->setStatelessDataPortAccessMemoryObjectControlState(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST)); + if (args.stateBaseAddressCmd->getStatelessDataPortAccessMemoryObjectControlState() == args.gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER) && DebugManager.flags.ForceL1Caching.get() != 0) { + args.stateBaseAddressCmd->setStatelessDataPortAccessMemoryObjectControlState(args.gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST)); } - appendExtraCacheSettings(stateBaseAddress, gmmHelper->getHardwareInfo()); + appendExtraCacheSettings(args.stateBaseAddressCmd, args.gmmHelper->getHardwareInfo()); } template @@ -106,7 +98,7 @@ void StateBaseAddressHelper::programBindingTableBaseAddress(LinearStr } template -void StateBaseAddressHelper::appendIohParameters(STATE_BASE_ADDRESS *stateBaseAddress, const IndirectHeap *ioh, bool useGlobalHeapsBaseAddress, uint64_t indirectObjectHeapBaseAddress) { +void StateBaseAddressHelper::appendIohParameters(StateBaseAddressHelperArgs &args) { } template diff --git a/shared/test/unit_test/gen8/state_base_address_tests_gen8.cpp b/shared/test/unit_test/gen8/state_base_address_tests_gen8.cpp index fb4a3ddbe1..1fd3beb90b 100644 --- a/shared/test/unit_test/gen8/state_base_address_tests_gen8.cpp +++ b/shared/test/unit_test/gen8/state_base_address_tests_gen8.cpp @@ -18,17 +18,27 @@ BDWTEST_F(SBATest, givenUsedBindlessBuffersWhenAppendStateBaseAddressParametersI STATE_BASE_ADDRESS stateBaseAddress = {}; STATE_BASE_ADDRESS stateBaseAddressReference = {}; - StateBaseAddressHelper::appendStateBaseAddressParameters( - &stateBaseAddress, - &ssh, - false, - 0, - nullptr, - false, - MemoryCompressionState::NotApplicable, - true, - false, - 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &stateBaseAddress, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &ssh, // ssh + nullptr, // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(0u, ssh.getUsed()); EXPECT_EQ(0, memcmp(&stateBaseAddressReference, &stateBaseAddress, sizeof(STATE_BASE_ADDRESS))); diff --git a/shared/test/unit_test/helpers/state_base_address_tests.cpp b/shared/test/unit_test/helpers/state_base_address_tests.cpp index c3e173afba..47a4cd6adb 100644 --- a/shared/test/unit_test/helpers/state_base_address_tests.cpp +++ b/shared/test/unit_test/helpers/state_base_address_tests.cpp @@ -22,17 +22,27 @@ HWTEST2_F(SBATest, WhenAppendStateBaseAddressParametersIsCalledThenSBACmdHasBind stateBaseAddress.setBindlessSurfaceStateBaseAddress(0); stateBaseAddress.setBindlessSurfaceStateBaseAddressModifyEnable(false); - StateBaseAddressHelper::appendStateBaseAddressParameters( - &stateBaseAddress, - &ssh, - false, - 0, - nullptr, - false, - MemoryCompressionState::NotApplicable, - true, - false, - 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &stateBaseAddress, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &ssh, // ssh + nullptr, // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(ssh.getMaxAvailableSpace() / 64 - 1, stateBaseAddress.getBindlessSurfaceStateSize()); EXPECT_EQ(ssh.getHeapGpuBase(), stateBaseAddress.getBindlessSurfaceStateBaseAddress()); @@ -52,24 +62,27 @@ HWTEST2_F(SBATest, WhenProgramStateBaseAddressParametersIsCalledThenSBACmdHasBin STATE_BASE_ADDRESS *cmd = reinterpret_cast(commandStream.getSpace(0)); *cmd = stateBaseAddress; - StateBaseAddressHelper::programStateBaseAddress( - cmd, - nullptr, - nullptr, - &ssh, - 0, - false, - 0, - 0, - 0, - 0, - false, - false, - pDevice->getGmmHelper(), - true, - MemoryCompressionState::NotApplicable, - false, - 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + cmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &ssh, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_EQ(ssh.getMaxAvailableSpace() / 64 - 1, cmd->getBindlessSurfaceStateSize()); EXPECT_EQ(ssh.getHeapGpuBase(), cmd->getBindlessSurfaceStateBaseAddress()); @@ -89,24 +102,28 @@ HWTEST2_F(SbaForBindlessTests, givenGlobalBindlessBaseAddressWhenProgramStateBas NEO::LinearStream cmdStream(buffer.begin(), buffer.size()); STATE_BASE_ADDRESS *cmd = reinterpret_cast(cmdStream.getSpace(0)); - StateBaseAddressHelper::programStateBaseAddress( - cmd, - nullptr, - nullptr, - nullptr, - 0, - false, - 0, - 0, - 0, - globalBindlessHeapsBaseAddress, - false, - true, - pDevice->getGmmHelper(), - true, - MemoryCompressionState::NotApplicable, - false, - 1u); + + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + globalBindlessHeapsBaseAddress, // globalHeapsBaseAddress + cmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + nullptr, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + true, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_TRUE(cmd->getBindlessSurfaceStateBaseAddressModifyEnable()); EXPECT_EQ(cmd->getBindlessSurfaceStateBaseAddress(), globalBindlessHeapsBaseAddress); @@ -129,24 +146,28 @@ HWTEST2_F(SbaForBindlessTests, givenGlobalBindlessBaseAddressWhenPassingIndirect NEO::LinearStream cmdStream(buffer.begin(), buffer.size()); STATE_BASE_ADDRESS *cmd = reinterpret_cast(cmdStream.getSpace(0)); - StateBaseAddressHelper::programStateBaseAddress( - cmd, - nullptr, - nullptr, - nullptr, - 0, - false, - 0, - indirectObjectBaseAddress, - 0, - globalBindlessHeapsBaseAddress, - false, - true, - pDevice->getGmmHelper(), - true, - MemoryCompressionState::NotApplicable, - false, - 1u); + + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + indirectObjectBaseAddress, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + globalBindlessHeapsBaseAddress, // globalHeapsBaseAddress + cmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + nullptr, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + true, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_EQ(cmd->getIndirectObjectBaseAddress(), indirectObjectBaseAddress); } @@ -161,17 +182,27 @@ HWTEST2_F(SBATest, givenSbaWhenOverrideBindlessSurfaceBaseIsFalseThenBindlessSur stateBaseAddress.setBindlessSurfaceStateBaseAddress(0); stateBaseAddress.setBindlessSurfaceStateBaseAddressModifyEnable(false); - StateBaseAddressHelper::appendStateBaseAddressParameters( - &stateBaseAddress, - &ssh, - false, - 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), - false, - MemoryCompressionState::NotApplicable, - false, - false, - 1u); + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &stateBaseAddress, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + nullptr, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + true, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::appendStateBaseAddressParameters(args, false); EXPECT_EQ(0u, stateBaseAddress.getBindlessSurfaceStateBaseAddress()); } @@ -187,24 +218,28 @@ HWTEST2_F(SBATest, givenGlobalBindlessBaseAddressWhenSshIsPassedThenBindlessSurf NEO::LinearStream cmdStream(buffer.begin(), buffer.size()); STATE_BASE_ADDRESS *cmd = reinterpret_cast(cmdStream.getSpace(0)); - StateBaseAddressHelper::programStateBaseAddress( - cmd, - nullptr, - nullptr, - &ssh, - 0, - false, - 0, - 0, - 0, - globalBindlessHeapsBaseAddress, - false, - true, - pDevice->getGmmHelper(), - true, - MemoryCompressionState::NotApplicable, - false, - 1u); + + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + globalBindlessHeapsBaseAddress, // globalHeapsBaseAddress + cmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &ssh, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + true, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_EQ(cmd->getBindlessSurfaceStateBaseAddress(), globalBindlessHeapsBaseAddress); } @@ -219,24 +254,28 @@ HWTEST2_F(SBATest, givenSurfaceStateHeapWhenNotUsingGlobalHeapBaseThenBindlessSu NEO::LinearStream cmdStream(buffer.begin(), buffer.size()); STATE_BASE_ADDRESS *cmd = reinterpret_cast(cmdStream.getSpace(0)); - StateBaseAddressHelper::programStateBaseAddress( - cmd, - nullptr, - nullptr, - &ssh, - 0, - false, - 0, - 0, - 0, - globalBindlessHeapsBaseAddress, - false, - false, - pDevice->getGmmHelper(), - true, - MemoryCompressionState::NotApplicable, - false, - 1u); + + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + globalBindlessHeapsBaseAddress, // globalHeapsBaseAddress + cmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &ssh, // ssh + pDevice->getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + false, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + + StateBaseAddressHelper::programStateBaseAddress(args); EXPECT_EQ(ssh.getHeapGpuBase(), cmd->getBindlessSurfaceStateBaseAddress()); } @@ -271,11 +310,29 @@ HWTEST2_F(SBATest, givenDebugFlagSetWhenAppendingSbaThenProgramCorrectL1CachePol {3, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WT}, {4, FamilyType::STATE_BASE_ADDRESS::L1_CACHE_POLICY_WS}}; + StateBaseAddressHelperArgs args = { + 0, // generalStateBase + 0, // indirectObjectHeapBaseAddress + 0, // instructionHeapBaseAddress + 0, // globalHeapsBaseAddress + &sbaCmd, // stateBaseAddressCmd + nullptr, // dsh + nullptr, // ioh + &indirectHeap, // ssh + pDevice->getRootDeviceEnvironment().getGmmHelper(), // gmmHelper + 0, // statelessMocsIndex + MemoryCompressionState::NotApplicable, // memoryCompressionState + false, // setInstructionStateBaseAddress + true, // setGeneralStateBaseAddress + false, // useGlobalHeapsBaseAddress + false, // isMultiOsContextCapable + false, // useGlobalAtomics + false // areMultipleSubDevicesInContext + }; + for (const auto &input : testInputs) { DebugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(input.option); - StateBaseAddressHelper::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0, - pDevice->getRootDeviceEnvironment().getGmmHelper(), false, - MemoryCompressionState::NotApplicable, true, false, 1u); + StateBaseAddressHelper::appendStateBaseAddressParameters(args, true); EXPECT_EQ(input.cachePolicy, sbaCmd.getL1CachePolicyL1CacheControl()); }