Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add struct argument for input/output in StateBaseAddressHelper

Browse Source 
This refactor makes future interface changes easier

Related-To: NEO-5019

Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
This commit is contained in:
Zbigniew Zdanowicz
2022-08-11 13:36:02 +00:00
committed by Compute-Runtime-Automation
parent 9b1afe4067
commit ceb9d81f87
21 changed files with 734 additions and 567 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
level_zero/core/source/cmdqueue/cmdqueue_hw_base.inl
View File

@ -52,23 +52,27 @@ void CommandQueueHw<gfxCoreFamily>::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<GfxFamily>::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<GfxFamily> 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<GfxFamily>::programStateBaseAddress(args);
*sbaCmdBuf = sbaCmd;
csr->setGSBAStateDirty(false);

38
level_zero/core/source/cmdqueue/cmdqueue_xe_hp_core_and_later.inl
View File

@ -43,23 +43,27 @@ void CommandQueueHw<gfxCoreFamily>::programStateBaseAddress(uint64_t gsba, bool
auto sbaCmdBuf = static_cast<STATE_BASE_ADDRESS *>(NEO::StateBaseAddressHelper<GfxFamily>::getSpaceForSbaCmd(commandStream));
STATE_BASE_ADDRESS sbaCmd;
NEO::StateBaseAddressHelper<GfxFamily>::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<GfxFamily> 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<GfxFamily>::programStateBaseAddress(args);
*sbaCmdBuf = sbaCmd;
auto &hwInfoConfig = *NEO::HwInfoConfig::get(hwInfo.platform.eProductFamily);

149
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_2_tests.cpp
View File

@ -1213,23 +1213,26 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrWhenGen
auto gmmHelper = pDevice->getGmmHelper();
typename FamilyType::STATE_BASE_ADDRESS sbaCmd;
StateBaseAddressHelper<FamilyType>::programStateBaseAddress(&sbaCmd,
&dsh,
&ioh,
&ssh,
generalStateBaseAddress,
true,
0,
0,
generalStateBaseAddress,
0,
true,
false,
gmmHelper,
false,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<FamilyType>::programStateBaseAddress(&sbaCmd,
&dsh,
&ioh,
&ssh,
generalStateBaseAddress,
false,
0,
0,
generalStateBaseAddress,
0,
true,
false,
pDevice->getGmmHelper(),
false,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<FamilyType>::programStateBaseAddress(&sbaCmd,
&dsh,
&ioh,
&ssh,
internalHeapBaseAddress,
true,
0,
internalHeapBaseAddress,
0,
0,
false,
false,
pDevice->getGmmHelper(),
false,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<FamilyType>::programStateBaseAddress(&sbaCmd,
nullptr,
nullptr,
nullptr,
generalStateBase,
true,
0,
internalHeapBase,
instructionHeapBase,
0,
true,
false,
pDevice->getGmmHelper(),
false,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::programStateBaseAddress(args);
EXPECT_FALSE(sbaCmd.getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd.getDynamicStateBufferSizeModifyEnable());

37
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp
View File

@ -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<FamilyType>::programStateBaseAddress(&sbaCmd,
nullptr,
nullptr,
nullptr,
generalStateBase,
true,
0,
internalHeapBase,
instructionHeapBase,
0,
true,
false,
pDevice->getGmmHelper(),
false,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::programStateBaseAddress(args);
EXPECT_FALSE(sbaCmd.getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd.getDynamicStateBufferSizeModifyEnable());

45
opencl/test/unit_test/helpers/test_preamble_xehp_and_later.cpp
View File

@ -462,8 +462,26 @@ HWTEST2_F(StateBaseAddressXeHPAndLaterTests, givenMemoryCompressionEnabledWhenAp
for (auto memoryCompressionState : {MemoryCompressionState::NotApplicable, MemoryCompressionState::Disabled, MemoryCompressionState::Enabled}) {
auto sbaCmd = FamilyType::cmdInitStateBaseAddress;
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false, memoryCompressionState, true, false, 1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, false, ihba,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(0ull, sbaCmd.getGeneralStateBaseAddress());
memoryManager->freeGraphicsMemory(allocation);
}

52
opencl/test/unit_test/xe_hpc_core/test_cmds_programming_xe_hpc_core.cpp
View File

@ -51,10 +51,26 @@ XE_HPC_CORETEST_F(CmdsProgrammingTestsXeHpcCore, givenSpecificProductFamilyWhenA
IndirectHeap indirectHeap(allocation, 1);
DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
auto sbaCmd = FamilyType::cmdInitStateBaseAddress;
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl());
DebugManager.flags.ForceStatelessL1CachingPolicy.set(1u);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl());

52
opencl/test/unit_test/xe_hpg_core/dg2/test_cmds_programming_dg2.cpp
View File

@ -51,10 +51,26 @@ DG2TEST_F(CmdsProgrammingTestsDg2, givenSpecificProductFamilyWhenAppendingSbaThe
IndirectHeap indirectHeap(allocation, 1);
DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
auto sbaCmd = FamilyType::cmdInitStateBaseAddress;
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl());
DebugManager.flags.ForceStatelessL1CachingPolicy.set(1u);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl());

52
opencl/test/unit_test/xe_hpg_core/test_cmds_programming_xe_hpg_core.cpp
View File

@ -51,10 +51,26 @@ XE_HPG_CORETEST_F(CmdsProgrammingTestsXeHpgCore, givenSpecificProductFamilyWhenA
IndirectHeap indirectHeap(allocation, 1);
DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
auto sbaCmd = FamilyType::cmdInitStateBaseAddress;
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(0u, sbaCmd.getL1CachePolicyL1CacheControl());
DebugManager.flags.ForceStatelessL1CachingPolicy.set(1u);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(1u, sbaCmd.getL1CachePolicyL1CacheControl());

47
shared/source/command_container/command_encoder_bdw_and_later.inl
View File

@ -367,27 +367,34 @@ void EncodeStateBaseAddress<Family>::encode(CommandContainer &container, STATE_B
auto gmmHelper = device.getGmmHelper();
StateBaseAddressHelper<Family>::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<STATE_BASE_ADDRESS *>(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS)));
*pCmd = sbaCmd;
StateBaseAddressHelperArgs<Family> 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<Family>::programStateBaseAddress(args);
auto cmdSpace = reinterpret_cast<STATE_BASE_ADDRESS *>(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS)));
*cmdSpace = sbaCmd;
EncodeWA<Family>::encodeAdditionalPipelineSelect(*container.getCommandStream(), {}, false, hwInfo, isRcs);
}

51
shared/source/command_container/command_encoder_xehp_and_later.inl
View File

@ -474,33 +474,40 @@ template <typename Family>
void EncodeStateBaseAddress<Family>::encode(CommandContainer &container, STATE_BASE_ADDRESS &sbaCmd, uint32_t statelessMocsIndex, bool useGlobalAtomics, bool multiOsContextCapable) {
auto gmmHelper = container.getDevice()->getRootDeviceEnvironment().getGmmHelper();
StateBaseAddressHelper<Family>::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<STATE_BASE_ADDRESS *>(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS)));
*pCmd = sbaCmd;
StateBaseAddressHelperArgs<Family> 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<Family>::programStateBaseAddress(args);
auto cmdSpace = reinterpret_cast<STATE_BASE_ADDRESS *>(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<STATE_BASE_ADDRESS *>(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS)));
*pCmd = sbaCmd;
cmdSpace = reinterpret_cast<STATE_BASE_ADDRESS *>(container.getCommandStream()->getSpace(sizeof(STATE_BASE_ADDRESS)));
*cmdSpace = sbaCmd;
}
if (container.isHeapDirty(HeapType::SURFACE_STATE)) {

40
shared/source/command_stream/command_stream_receiver_hw_base.inl
View File

@ -408,24 +408,28 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
uint64_t indirectObjectStateBaseAddress = getMemoryManager()->getInternalHeapBaseAddress(rootDeviceIndex, ioh->getGraphicsAllocation()->isAllocatedInLocalMemoryPool());
STATE_BASE_ADDRESS stateBaseAddressCmd;
StateBaseAddressHelper<GfxFamily>::programStateBaseAddress(
&stateBaseAddressCmd,
dsh,
ioh,
ssh,
newGSHbase,
true,
mocsIndex,
indirectObjectStateBaseAddress,
instructionHeapBaseAddress,
0,
true,
false,
device.getGmmHelper(),
isMultiOsContextCapable(),
memoryCompressionState,
dispatchFlags.useGlobalAtomics,
dispatchFlags.areMultipleSubDevicesInContext);
StateBaseAddressHelperArgs<GfxFamily> 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<GfxFamily>::programStateBaseAddress(args);
if (stateBaseAddressCmdBuffer) {
*stateBaseAddressCmdBuffer = stateBaseAddressCmd;

77
shared/source/gen8/state_base_address_gen8.cpp
View File

@ -14,71 +14,54 @@ namespace NEO {
template <>
void StateBaseAddressHelper<Gen8Family>::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<Gen8Family> &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<Gen8Family>;
} // namespace NEO

61
shared/source/helpers/state_base_address.h
View File

@ -18,44 +18,45 @@ class LinearStream;
struct DispatchFlags;
struct HardwareInfo;
template <typename GfxFamily>
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 <typename GfxFamily>
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<GfxFamily> &args);
static void appendIohParameters(STATE_BASE_ADDRESS *stateBaseAddress, const IndirectHeap *ioh, bool useGlobalHeapsBaseAddress, uint64_t indirectObjectHeapBaseAddress);
static void appendIohParameters(StateBaseAddressHelperArgs<GfxFamily> &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<GfxFamily> &args,
bool overrideBindlessSurfaceStateBase);
static void appendExtraCacheSettings(STATE_BASE_ADDRESS *stateBaseAddress, const HardwareInfo *hwInfo);

91
shared/source/helpers/state_base_address_base.inl
View File

@ -17,88 +17,71 @@
namespace NEO {
template <typename GfxFamily>
void StateBaseAddressHelper<GfxFamily>::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<GfxFamily> &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 <typename GfxFamily>

12
shared/source/helpers/state_base_address_bdw.inl
View File

@ -11,16 +11,8 @@ namespace NEO {
template <typename GfxFamily>
void StateBaseAddressHelper<GfxFamily>::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<GfxFamily> &args,
bool overrideBindlessSurfaceStateBase) {
}
template <typename GfxFamily>

22
shared/source/helpers/state_base_address_bdw_and_later.inl
View File

@ -14,17 +14,17 @@ void StateBaseAddressHelper<GfxFamily>::programBindingTableBaseAddress(LinearStr
}
template <typename GfxFamily>
void StateBaseAddressHelper<GfxFamily>::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<GfxFamily>::appendIohParameters(StateBaseAddressHelperArgs<GfxFamily> &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());
}
}

30
shared/source/helpers/state_base_address_icllp_and_later.inl
View File

@ -11,31 +11,23 @@ namespace NEO {
template <typename GfxFamily>
void StateBaseAddressHelper<GfxFamily>::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<GfxFamily> &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));
}
}

22
shared/source/helpers/state_base_address_skl.inl
View File

@ -11,22 +11,14 @@ namespace NEO {
template <typename GfxFamily>
void StateBaseAddressHelper<GfxFamily>::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<GfxFamily> &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);
}
}

66
shared/source/helpers/state_base_address_xehp_and_later.inl
View File

@ -27,66 +27,58 @@ void setSbaStatelessCompressionParams(typename GfxFamily::STATE_BASE_ADDRESS *st
template <typename GfxFamily>
void StateBaseAddressHelper<GfxFamily>::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<GfxFamily> &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<uint32_t>(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<uint32_t>(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<GfxFamily>(stateBaseAddress, memoryCompressionState);
if (args.memoryCompressionState != MemoryCompressionState::NotApplicable) {
setSbaStatelessCompressionParams<GfxFamily>(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 <typename GfxFamily>
@ -106,7 +98,7 @@ void StateBaseAddressHelper<GfxFamily>::programBindingTableBaseAddress(LinearStr
}
template <typename GfxFamily>
void StateBaseAddressHelper<GfxFamily>::appendIohParameters(STATE_BASE_ADDRESS *stateBaseAddress, const IndirectHeap *ioh, bool useGlobalHeapsBaseAddress, uint64_t indirectObjectHeapBaseAddress) {
void StateBaseAddressHelper<GfxFamily>::appendIohParameters(StateBaseAddressHelperArgs<GfxFamily> &args) {
}
template <typename GfxFamily>

32
shared/test/unit_test/gen8/state_base_address_tests_gen8.cpp
View File

@ -18,17 +18,27 @@ BDWTEST_F(SBATest, givenUsedBindlessBuffersWhenAppendStateBaseAddressParametersI
STATE_BASE_ADDRESS stateBaseAddress = {};
STATE_BASE_ADDRESS stateBaseAddressReference = {};
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(
&stateBaseAddress,
&ssh,
false,
0,
nullptr,
false,
MemoryCompressionState::NotApplicable,
true,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(0u, ssh.getUsed());
EXPECT_EQ(0, memcmp(&stateBaseAddressReference, &stateBaseAddress, sizeof(STATE_BASE_ADDRESS)));

287
shared/test/unit_test/helpers/state_base_address_tests.cpp
View File

@ -22,17 +22,27 @@ HWTEST2_F(SBATest, WhenAppendStateBaseAddressParametersIsCalledThenSBACmdHasBind
stateBaseAddress.setBindlessSurfaceStateBaseAddress(0);
stateBaseAddress.setBindlessSurfaceStateBaseAddressModifyEnable(false);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(
&stateBaseAddress,
&ssh,
false,
0,
nullptr,
false,
MemoryCompressionState::NotApplicable,
true,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<STATE_BASE_ADDRESS *>(commandStream.getSpace(0));
*cmd = stateBaseAddress;
StateBaseAddressHelper<FamilyType>::programStateBaseAddress(
cmd,
nullptr,
nullptr,
&ssh,
0,
false,
0,
0,
0,
0,
false,
false,
pDevice->getGmmHelper(),
true,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<STATE_BASE_ADDRESS *>(cmdStream.getSpace(0));
StateBaseAddressHelper<FamilyType>::programStateBaseAddress(
cmd,
nullptr,
nullptr,
nullptr,
0,
false,
0,
0,
0,
globalBindlessHeapsBaseAddress,
false,
true,
pDevice->getGmmHelper(),
true,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<STATE_BASE_ADDRESS *>(cmdStream.getSpace(0));
StateBaseAddressHelper<FamilyType>::programStateBaseAddress(
cmd,
nullptr,
nullptr,
nullptr,
0,
false,
0,
indirectObjectBaseAddress,
0,
globalBindlessHeapsBaseAddress,
false,
true,
pDevice->getGmmHelper(),
true,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::programStateBaseAddress(args);
EXPECT_EQ(cmd->getIndirectObjectBaseAddress(), indirectObjectBaseAddress);
}
@ -161,17 +182,27 @@ HWTEST2_F(SBATest, givenSbaWhenOverrideBindlessSurfaceBaseIsFalseThenBindlessSur
stateBaseAddress.setBindlessSurfaceStateBaseAddress(0);
stateBaseAddress.setBindlessSurfaceStateBaseAddressModifyEnable(false);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(
&stateBaseAddress,
&ssh,
false,
0,
pDevice->getRootDeviceEnvironment().getGmmHelper(),
false,
MemoryCompressionState::NotApplicable,
false,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<STATE_BASE_ADDRESS *>(cmdStream.getSpace(0));
StateBaseAddressHelper<FamilyType>::programStateBaseAddress(
cmd,
nullptr,
nullptr,
&ssh,
0,
false,
0,
0,
0,
globalBindlessHeapsBaseAddress,
false,
true,
pDevice->getGmmHelper(),
true,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<STATE_BASE_ADDRESS *>(cmdStream.getSpace(0));
StateBaseAddressHelper<FamilyType>::programStateBaseAddress(
cmd,
nullptr,
nullptr,
&ssh,
0,
false,
0,
0,
0,
globalBindlessHeapsBaseAddress,
false,
false,
pDevice->getGmmHelper(),
true,
MemoryCompressionState::NotApplicable,
false,
1u);
StateBaseAddressHelperArgs<FamilyType> 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<FamilyType>::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<FamilyType> 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<FamilyType>::appendStateBaseAddressParameters(&sbaCmd, &indirectHeap, true, 0,
pDevice->getRootDeviceEnvironment().getGmmHelper(), false,
MemoryCompressionState::NotApplicable, true, false, 1u);
StateBaseAddressHelper<FamilyType>::appendStateBaseAddressParameters(args, true);
EXPECT_EQ(input.cachePolicy, sbaCmd.getL1CachePolicyL1CacheControl());
}