intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: use correct gpu address when bindless heaps helper is enabled

Browse Source 
Related-To: NEO-7063
Signed-off-by: Fabian Zwoliński <fabian.zwolinski@intel.com>
This commit is contained in:
Fabian Zwoliński
2024-08-05 14:02:25 +00:00
committed by Compute-Runtime-Automation
parent 619b47e3d5
commit 674c4a15ad
19 changed files with 510 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
level_zero/core/source/cmdlist/cmdlist.h
View File

@@ -384,6 +384,14 @@ struct CommandList : _ze_command_list_handle_t {
return statelessBuiltinsEnabled;
}
bool isLastAppendedKernelBindlessMode() const {
return lastAppendedKernelBindlessMode;
}
void setIsLastAppendedKernelBindlessMode(bool isBindlessKernel) {
lastAppendedKernelBindlessMode = isBindlessKernel;
}
void registerCsrDcFlushForDcMitigation(NEO::CommandStreamReceiver &csr);
protected:
@@ -476,6 +484,7 @@ struct CommandList : _ze_command_list_handle_t {
bool taskCountUpdateFenceRequired = false;
bool requiresDcFlushForDcMitigation = false;
bool statelessBuiltinsEnabled = false;
bool lastAppendedKernelBindlessMode = false;
};
using CommandListAllocatorFn = CommandList *(*)(uint32_t);

16
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@@ -26,6 +26,7 @@
#include "shared/source/helpers/pipe_control_args.h"
#include "shared/source/helpers/preamble.h"
#include "shared/source/helpers/register_offsets.h"
#include "shared/source/helpers/state_base_address_helper.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/source/indirect_heap/indirect_heap.h"
#include "shared/source/memory_manager/allocation_properties.h"
@@ -152,6 +153,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::reset() {
latestOperationRequiredNonWalkerInOrderCmdsChaining = false;
taskCountUpdateFenceRequired = false;
lastAppendedKernelBindlessMode = false;
this->inOrderPatchCmds.clear();
@@ -3099,6 +3101,9 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::prepareIndirectParams(const ze
template <GFXCORE_FAMILY gfxCoreFamily>
void CommandListCoreFamily<gfxCoreFamily>::updateStreamProperties(Kernel &kernel, bool isCooperative, const ze_group_count_t &threadGroupDimensions, bool isIndirect) {
const bool isBindlessKernel = NEO::KernelDescriptor::isBindlessAddressingKernel(kernel.getKernelDescriptor());
setIsLastAppendedKernelBindlessMode(isBindlessKernel);
if (this->isFlushTaskSubmissionEnabled) {
updateStreamPropertiesForFlushTaskDispatchFlags(kernel, isCooperative, threadGroupDimensions, isIndirect);
} else {
@@ -3155,6 +3160,8 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamPropertiesForRegularComma
auto &rootDeviceEnvironment = device->getNEODevice()->getRootDeviceEnvironment();
auto &kernelAttributes = kernel.getKernelDescriptor().kernelAttributes;
const auto bindlessHeapsHelper = device->getNEODevice()->getBindlessHeapsHelper();
KernelImp &kernelImp = static_cast<KernelImp &>(kernel);
int32_t currentMocsState = static_cast<int32_t>(device->getMOCS(!kernelImp.getKernelRequiresUncachedMocs(), false) >> 1);
@@ -3166,8 +3173,8 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamPropertiesForRegularComma
if (currentSurfaceStateBaseAddress == NEO::StreamProperty64::initValue || commandContainer.isHeapDirty(NEO::IndirectHeap::Type::surfaceState)) {
auto ssh = commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::surfaceState);
if (ssh) {
currentSurfaceStateBaseAddress = ssh->getHeapGpuBase();
currentSurfaceStateSize = ssh->getHeapSizeInPages();
currentSurfaceStateBaseAddress = NEO::getStateBaseAddress(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode());
currentSurfaceStateSize = NEO::getStateSize(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode());
currentBindingTablePoolBaseAddress = currentSurfaceStateBaseAddress;
currentBindingTablePoolSize = currentSurfaceStateSize;
@@ -3179,8 +3186,9 @@ void CommandListCoreFamily<gfxCoreFamily>::updateStreamPropertiesForRegularComma
if (this->dynamicHeapRequired && (currentDynamicStateBaseAddress == NEO::StreamProperty64::initValue || commandContainer.isHeapDirty(NEO::IndirectHeap::Type::dynamicState))) {
auto dsh = commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::dynamicState);
currentDynamicStateBaseAddress = dsh->getHeapGpuBase();
currentDynamicStateSize = dsh->getHeapSizeInPages();
currentDynamicStateBaseAddress = NEO::getStateBaseAddress(*dsh, bindlessHeapsHelper);
currentDynamicStateSize = NEO::getStateSize(*dsh, bindlessHeapsHelper);
checkDsh = true;
}

32
level_zero/core/source/cmdlist/cmdlist_hw_immediate.inl
View File

@@ -21,6 +21,7 @@
#include "shared/source/helpers/blit_commands_helper.h"
#include "shared/source/helpers/completion_stamp.h"
#include "shared/source/helpers/in_order_cmd_helpers.h"
#include "shared/source/helpers/state_base_address_helper.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/source/memory_manager/internal_allocation_storage.h"
#include "shared/source/memory_manager/unified_memory_manager.h"
@@ -152,6 +153,9 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleHeapsAndResidencyForIm
NEO::IndirectHeap *ioh = this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::indirectObject);
NEO::IndirectHeap *ssh = nullptr;
const auto bindlessHeapsHelper = this->device->getNEODevice()->getBindlessHeapsHelper();
const bool isLastAppendedKernelBindlessMode = this->isLastAppendedKernelBindlessMode();
auto csr = getCsr(false);
csr->makeResident(*ioh->getGraphicsAllocation());
@@ -168,7 +172,8 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleHeapsAndResidencyForIm
if constexpr (streamStatesSupported) {
if (this->requiredStreamState.stateBaseAddress.surfaceStateBaseAddress.value == NEO::StreamProperty64::initValue) {
this->requiredStreamState.stateBaseAddress.setPropertiesSurfaceState(ssh->getHeapGpuBase(), ssh->getHeapSizeInPages());
this->requiredStreamState.stateBaseAddress.setPropertiesSurfaceState(NEO::getStateBaseAddress(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode),
NEO::getStateSize(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode));
}
}
} else if (this->immediateCmdListHeapSharing) {
@@ -177,8 +182,10 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleHeapsAndResidencyForIm
csr->makeResident(*ssh->getGraphicsAllocation());
if constexpr (streamStatesSupported) {
this->requiredStreamState.stateBaseAddress.setPropertiesBindingTableSurfaceState(ssh->getHeapGpuBase(), ssh->getHeapSizeInPages(),
ssh->getHeapGpuBase(), ssh->getHeapSizeInPages());
this->requiredStreamState.stateBaseAddress.setPropertiesBindingTableSurfaceState(NEO::getStateBaseAddress(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode),
NEO::getStateSize(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode),
NEO::getStateBaseAddress(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode),
NEO::getStateSize(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode));
}
}
if (this->dynamicHeapRequired) {
@@ -186,7 +193,8 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleHeapsAndResidencyForIm
if (dsh->getGraphicsAllocation()) {
csr->makeResident(*dsh->getGraphicsAllocation());
if constexpr (streamStatesSupported) {
this->requiredStreamState.stateBaseAddress.setPropertiesDynamicState(dsh->getHeapGpuBase(), dsh->getHeapSizeInPages());
this->requiredStreamState.stateBaseAddress.setPropertiesDynamicState(NEO::getStateBaseAddress(*dsh, bindlessHeapsHelper),
NEO::getStateSize(*dsh, bindlessHeapsHelper));
}
}
}
@@ -195,15 +203,18 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleHeapsAndResidencyForIm
dsh = this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::dynamicState);
csr->makeResident(*dsh->getGraphicsAllocation());
if constexpr (streamStatesSupported) {
this->requiredStreamState.stateBaseAddress.setPropertiesDynamicState(dsh->getHeapGpuBase(), dsh->getHeapSizeInPages());
this->requiredStreamState.stateBaseAddress.setPropertiesDynamicState(NEO::getStateBaseAddress(*dsh, bindlessHeapsHelper),
NEO::getStateSize(*dsh, bindlessHeapsHelper));
}
}
ssh = this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::surfaceState);
if (ssh) {
csr->makeResident(*ssh->getGraphicsAllocation());
if constexpr (streamStatesSupported) {
this->requiredStreamState.stateBaseAddress.setPropertiesBindingTableSurfaceState(ssh->getHeapGpuBase(), ssh->getHeapSizeInPages(),
ssh->getHeapGpuBase(), ssh->getHeapSizeInPages());
this->requiredStreamState.stateBaseAddress.setPropertiesBindingTableSurfaceState(NEO::getStateBaseAddress(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode),
NEO::getStateSize(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode),
NEO::getStateBaseAddress(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode),
NEO::getStateSize(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode));
}
}
}
@@ -211,8 +222,8 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleHeapsAndResidencyForIm
if (this->device->getL0Debugger()) {
csr->makeResident(*this->device->getL0Debugger()->getSbaTrackingBuffer(csr->getOsContext().getContextId()));
csr->makeResident(*this->device->getDebugSurface());
if (this->device->getNEODevice()->getBindlessHeapsHelper()) {
csr->makeResident(*this->device->getNEODevice()->getBindlessHeapsHelper()->getHeap(NEO::BindlessHeapsHelper::specialSsh)->getGraphicsAllocation());
if (bindlessHeapsHelper) {
csr->makeResident(*bindlessHeapsHelper->getHeap(NEO::BindlessHeapsHelper::specialSsh)->getGraphicsAllocation());
}
}
@@ -307,7 +318,8 @@ NEO::CompletionStamp CommandListCoreFamilyImmediate<gfxCoreFamily>::flushRegular
hasRelaxedOrderingDependencies, // hasRelaxedOrderingDependencies
false, // stateCacheInvalidation
false, // isStallingCommandsOnNextFlushRequired
false // isDcFlushRequiredOnStallingCommandsOnNextFlush
false, // isDcFlushRequiredOnStallingCommandsOnNextFlush
!this->isLastAppendedKernelBindlessMode() // disableGlobalSSH
);
auto ioh = (this->commandContainer.getIndirectHeap(NEO::IndirectHeap::Type::indirectObject));

22
level_zero/core/source/cmdqueue/cmdqueue_hw.inl
View File

@@ -29,6 +29,7 @@
#include "shared/source/helpers/pause_on_gpu_properties.h"
#include "shared/source/helpers/pipe_control_args.h"
#include "shared/source/helpers/preamble.h"
#include "shared/source/helpers/state_base_address_helper.h"
#include "shared/source/memory_manager/graphics_allocation.h"
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/source/memory_manager/residency_container.h"
@@ -1601,6 +1602,9 @@ void CommandQueueHw<gfxCoreFamily>::updateBaseAddressState(CommandList *lastComm
auto csrHw = static_cast<NEO::CommandStreamReceiverHw<GfxFamily> *>(csr);
auto &streamProperties = this->csr->getStreamProperties();
const auto bindlessHeapsHelper = device->getNEODevice()->getBindlessHeapsHelper();
const bool isLastAppendedKernelBindlessMode = lastCommandList->isLastAppendedKernelBindlessMode();
auto &commandContainer = lastCommandList->getCmdContainer();
if (lastCommandList->getCmdListHeapAddressModel() == NEO::HeapAddressModel::globalStateless) {
@@ -1610,15 +1614,23 @@ void CommandQueueHw<gfxCoreFamily>::updateBaseAddressState(CommandList *lastComm
} else {
auto dsh = commandContainer.getIndirectHeap(NEO::HeapType::dynamicState);
if (dsh != nullptr) {
csrHw->getDshState().updateAndCheck(dsh);
streamProperties.stateBaseAddress.setPropertiesDynamicState(dsh->getHeapGpuBase(), dsh->getHeapSizeInPages());
auto stateBaseAddress = NEO::getStateBaseAddress(*dsh, bindlessHeapsHelper);
auto stateSize = NEO::getStateSize(*dsh, bindlessHeapsHelper);
csrHw->getDshState().updateAndCheck(dsh, stateBaseAddress, stateSize);
streamProperties.stateBaseAddress.setPropertiesDynamicState(stateBaseAddress, stateSize);
}
auto ssh = commandContainer.getIndirectHeap(NEO::HeapType::surfaceState);
if (ssh != nullptr) {
csrHw->getSshState().updateAndCheck(ssh);
streamProperties.stateBaseAddress.setPropertiesBindingTableSurfaceState(ssh->getHeapGpuBase(), ssh->getHeapSizeInPages(),
ssh->getHeapGpuBase(), ssh->getHeapSizeInPages());
auto stateBaseAddress = NEO::getStateBaseAddress(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode);
auto stateSize = NEO::getStateSize(*ssh, bindlessHeapsHelper, isLastAppendedKernelBindlessMode);
csrHw->getSshState().updateAndCheck(ssh, stateBaseAddress, stateSize);
streamProperties.stateBaseAddress.setPropertiesBindingTableSurfaceState(stateBaseAddress,
stateSize,
stateBaseAddress,
stateSize);
}
}

13
level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp
View File

@@ -219,6 +219,19 @@ void CommandListPrivateHeapsFixture::setUp() {
mockKernelImmData->kernelDescriptor->payloadMappings.bindingTable.tableOffset = 64;
kernel->surfaceStateHeapDataSize = 128;
kernel->surfaceStateHeapData.reset(new uint8_t[256]);
bindlessHeapsHelper = device->getNEODevice()->getBindlessHeapsHelper();
}
void CommandListPrivateHeapsFixture::checkAndPrepareBindlessKernel() {
if (NEO::ApiSpecificConfig::getBindlessMode(device->getNEODevice()->getReleaseHelper())) {
const_cast<KernelDescriptor &>(kernel->getKernelDescriptor()).kernelAttributes.bufferAddressingMode = KernelDescriptor::Bindless;
isBindlessKernel = true;
}
if (commandList->commandContainer.getIndirectHeap(NEO::HeapType::surfaceState) == nullptr) {
commandList->commandContainer.prepareBindfulSsh();
}
}
void CommandListGlobalHeapsFixtureInit::setUp() {

4
level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h
View File

@@ -139,6 +139,10 @@ struct CommandListStateBaseAddressFixture : public ModuleMutableCommandListFixtu
struct CommandListPrivateHeapsFixture : public CommandListStateBaseAddressFixture {
void setUp();
void checkAndPrepareBindlessKernel();
bool isBindlessKernel = false;
NEO::BindlessHeapsHelper *bindlessHeapsHelper = nullptr;
};
struct CommandListGlobalHeapsFixtureInit : public CommandListStateBaseAddressFixture {

389
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_5.cpp
View File

@@ -7,6 +7,7 @@
#include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/source/helpers/state_base_address_helper.h"
#include "shared/source/indirect_heap/indirect_heap.h"
#include "shared/source/kernel/implicit_args_helper.h"
#include "shared/test/common/cmd_parse/gen_cmd_parse.h"
@@ -1097,6 +1098,16 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
IsAtLeastSkl) {
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
checkAndPrepareBindlessKernel();
StackVec<size_t, 4> sbaCmdsSizes = {};
if (bindlessHeapsHelper) {
sbaCmdsSizes = {1, 1, 0, 0};
} else {
sbaCmdsSizes = {0, expectedSbaCmds, 0, 0};
}
auto sbaCmdsSizesIter = sbaCmdsSizes.begin();
NEO::StateBaseAddressPropertiesSupport sbaPropertiesSupport = {};
auto &productHelper = device->getProductHelper();
productHelper.fillStateBaseAddressPropertiesSupportStructure(sbaPropertiesSupport);
@@ -1117,11 +1128,11 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
cmdListStream.getCpuBase(),
cmdListStream.getUsed()));
auto sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sshHeap = container.getIndirectHeap(NEO::HeapType::surfaceState);
auto ssBaseAddress = sshHeap->getHeapGpuBase();
auto ssSize = sshHeap->getHeapSizeInPages();
auto ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
auto ssSize = NEO::getStateSize(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
uint64_t dsBaseAddress = -1;
size_t dsSize = static_cast<size_t>(-1);
@@ -1132,9 +1143,10 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
} else {
EXPECT_NE(nullptr, dshHeap);
}
if (dshHeap) {
dsBaseAddress = dshHeap->getHeapGpuBase();
dsSize = dshHeap->getHeapSizeInPages();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsSize = NEO::getStateSize(*dshHeap, bindlessHeapsHelper);
}
auto ioBaseAddress = container.getIndirectHeap(NEO::HeapType::indirectObject)->getHeapGpuBase();
@@ -1193,7 +1205,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdQueueStream.getCpuBase(), queueBefore),
queueAfter - queueBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
@@ -1242,7 +1254,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdQueueStream.getCpuBase(), queueBefore),
queueAfter - queueBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
result = commandList->reset();
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@@ -1254,7 +1266,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
cmdListStream.getCpuBase(),
afterReset));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
}
HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
@@ -1262,6 +1274,16 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
IsAtLeastSkl) {
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
checkAndPrepareBindlessKernel();
StackVec<size_t, 4> sbaCmdsSizes = {};
if (bindlessHeapsHelper) {
sbaCmdsSizes = {1, 2, 1, 0};
} else {
sbaCmdsSizes = {0, expectedSbaCmds, expectedSbaCmds, expectedSbaCmds};
}
auto sbaCmdsSizesIter = sbaCmdsSizes.begin();
NEO::StateBaseAddressPropertiesSupport sbaPropertiesSupport = {};
auto &productHelper = device->getProductHelper();
productHelper.fillStateBaseAddressPropertiesSupportStructure(sbaPropertiesSupport);
@@ -1282,22 +1304,22 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
cmdListStream.getCpuBase(),
cmdListStream.getUsed()));
auto sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sshHeap = container.getIndirectHeap(NEO::HeapType::surfaceState);
uint64_t ssBaseAddress = sshHeap->getHeapGpuBase();
uint64_t ssSize = sshHeap->getHeapSizeInPages();
uint64_t ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
uint64_t ssSize = NEO::getStateSize(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
uint64_t dsBaseAddress = -1;
uint32_t dsBaseSize = 0;
uint32_t dsFirstBaseSize = 0;
size_t dsFirstBaseSize = 0;
size_t dsSize = static_cast<size_t>(-1);
auto dshHeap = container.getIndirectHeap(NEO::HeapType::dynamicState);
if (dshHeap) {
dsBaseAddress = dshHeap->getHeapGpuBase();
dsSize = dsFirstBaseSize = dshHeap->getHeapSizeInPages();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsSize = dsFirstBaseSize = NEO::getStateSize(*dshHeap, bindlessHeapsHelper);
}
auto statlessMocs = getMocs(true);
@@ -1329,14 +1351,17 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
result = commandList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams, false);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
ssBaseAddress = sshHeap->getGpuBase();
ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
if (dshHeap) {
dsBaseAddress = dshHeap->getGpuBase();
dsBaseSize = dshHeap->getHeapSizeInPages();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsBaseSize = static_cast<uint32_t>(NEO::getStateSize(*dshHeap, bindlessHeapsHelper));
}
EXPECT_NE(static_cast<int64_t>(ssBaseAddress), requiredState.surfaceStateBaseAddress.value);
if (dshHeap) {
if (!bindlessHeapsHelper) {
EXPECT_NE(static_cast<int64_t>(ssBaseAddress), requiredState.surfaceStateBaseAddress.value);
}
if (dshHeap && !bindlessHeapsHelper) {
EXPECT_NE(static_cast<int64_t>(dsBaseAddress), requiredState.dynamicStateBaseAddress.value);
} else {
EXPECT_EQ(static_cast<int64_t>(dsBaseAddress), requiredState.dynamicStateBaseAddress.value);
@@ -1351,9 +1376,9 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
cmdListStream.getCpuBase(),
cmdListStream.getUsed()));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds.back());
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
@@ -1368,7 +1393,8 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
}
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
EXPECT_EQ(sshHeap->getHeapGpuBase(), sbaCmd->getSurfaceStateBaseAddress());
EXPECT_EQ((statlessMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState());
result = commandList->close();
@@ -1396,9 +1422,9 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdQueueStream.getCpuBase(), queueBefore),
queueAfter - queueBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds.back());
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
@@ -1428,25 +1454,30 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdQueueStream.getCpuBase(), queueBefore),
queueAfter - queueBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_TRUE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(dsFirstBaseAddress, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(dsFirstBaseSize, sbaCmd->getDynamicStateBufferSize());
if (bindlessHeapsHelper) {
EXPECT_FALSE(finalState.isDirty());
ASSERT_EQ(0u, sbaCmds.size());
} else {
EXPECT_FALSE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBufferSize());
}
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds.back());
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssFirstBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
EXPECT_EQ((statlessMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState());
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_TRUE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(dsFirstBaseAddress, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(dsFirstBaseSize, sbaCmd->getDynamicStateBufferSize());
} else {
EXPECT_FALSE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBufferSize());
}
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssFirstBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
EXPECT_EQ((statlessMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState());
}
}
struct CommandListPrivateHeapsBindlessSshFixture : public CommandListPrivateHeapsFixture {
@@ -1800,6 +1831,16 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
IsAtLeastSkl) {
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
checkAndPrepareBindlessKernel();
StackVec<size_t, 3> sbaCmdsSizes = {};
if (bindlessHeapsHelper) {
sbaCmdsSizes = {1, 2, 0};
} else {
sbaCmdsSizes = {0, expectedSbaCmds, 0};
}
auto sbaCmdsSizesIter = sbaCmdsSizes.begin();
EXPECT_TRUE(commandList->stateBaseAddressTracking);
auto &container = commandList->getCmdContainer();
@@ -1816,11 +1857,11 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
cmdListStream.getCpuBase(),
cmdListStream.getUsed()));
auto sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sshHeap = container.getIndirectHeap(NEO::HeapType::surfaceState);
uint64_t ssBaseAddress = sshHeap->getHeapGpuBase();
uint64_t ssSize = sshHeap->getHeapSizeInPages();
uint64_t ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
uint64_t ssSize = NEO::getStateSize(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
uint64_t dsBaseAddress = -1;
uint32_t dsBaseSize = 0;
@@ -1830,8 +1871,8 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
auto dshHeap = container.getIndirectHeap(NEO::HeapType::dynamicState);
if (dshHeap) {
dsBaseAddress = dshHeap->getHeapGpuBase();
dsSize = dsFirstBaseSize = dshHeap->getHeapSizeInPages();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsSize = dsFirstBaseSize = static_cast<uint32_t>(NEO::getStateSize(*dshHeap, bindlessHeapsHelper));
}
auto statlessMocs = getMocs(true);
@@ -1860,14 +1901,17 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
result = commandList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams, false);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
ssBaseAddress = sshHeap->getGpuBase();
ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, true);
if (dshHeap) {
dsBaseAddress = dshHeap->getGpuBase();
dsBaseSize = dshHeap->getHeapSizeInPages();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsBaseSize = static_cast<uint32_t>(NEO::getStateSize(*dshHeap, bindlessHeapsHelper));
}
EXPECT_NE(static_cast<int64_t>(ssBaseAddress), requiredState.surfaceStateBaseAddress.value);
if (dshHeap) {
if (!bindlessHeapsHelper) {
EXPECT_NE(static_cast<int64_t>(ssBaseAddress), requiredState.surfaceStateBaseAddress.value);
}
if (dshHeap && !bindlessHeapsHelper) {
EXPECT_NE(static_cast<int64_t>(dsBaseAddress), requiredState.dynamicStateBaseAddress.value);
} else {
EXPECT_EQ(static_cast<int64_t>(dsBaseAddress), requiredState.dynamicStateBaseAddress.value);
@@ -1882,9 +1926,9 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
cmdListStream.getCpuBase(),
cmdListStream.getUsed()));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds.back());
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
@@ -1899,7 +1943,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
}
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
EXPECT_EQ(sshHeap->getHeapGpuBase(), sbaCmd->getSurfaceStateBaseAddress());
EXPECT_EQ((statlessMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState());
size_t sizeBefore = cmdListStream.getUsed();
@@ -1912,14 +1956,24 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdListStream.getCpuBase(), sizeBefore),
cmdListStream.getUsed() - sizeBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
}
HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
givenStateBaseAddressTrackingWhenImmediateCmdListAppendKernelChangesHeapsAndExecuteThenFinalBaseAddressStateIsStoredInCsr,
IsAtLeastSkl) {
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
checkAndPrepareBindlessKernel();
StackVec<size_t, 3> sbaCmdsSizes = {};
if (bindlessHeapsHelper) {
sbaCmdsSizes = {0, 1, 0};
} else {
sbaCmdsSizes = {0, expectedSbaCmds, expectedSbaCmds};
}
auto sbaCmdsSizesIter = sbaCmdsSizes.begin();
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
NEO::StateBaseAddressPropertiesSupport sbaPropertiesSupport = {};
auto &productHelper = device->getProductHelper();
productHelper.fillStateBaseAddressPropertiesSupportStructure(sbaPropertiesSupport);
@@ -1949,11 +2003,11 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdListImmediateStream.getCpuBase(), cmdListUsedBefore),
cmdListUsedAfter - cmdListUsedBefore));
auto sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sshHeap = container.getIndirectHeap(NEO::HeapType::surfaceState);
auto ssBaseAddress = sshHeap->getHeapGpuBase();
auto ssSize = sshHeap->getHeapSizeInPages();
auto ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
auto ssSize = NEO::getStateSize(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
uint64_t dsBaseAddress = -1;
size_t dsSize = static_cast<size_t>(-1);
@@ -1964,9 +2018,10 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
} else {
EXPECT_NE(nullptr, dshHeap);
}
if (dshHeap) {
dsBaseAddress = dshHeap->getHeapGpuBase();
dsSize = dshHeap->getHeapSizeInPages();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsSize = NEO::getStateSize(*dshHeap, bindlessHeapsHelper);
}
cmdList.clear();
@@ -1975,7 +2030,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(csrStream.getCpuBase(), csrUsedBefore),
csrUsedAfter - csrUsedBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
@@ -2037,9 +2092,9 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
csrUsedAfter = csrStream.getUsed();
ssBaseAddress = sshHeap->getGpuBase();
ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
if (dshHeap) {
dsBaseAddress = dshHeap->getGpuBase();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsSize = dshHeap->getHeapSizeInPages();
}
@@ -2052,29 +2107,45 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(csrStream.getCpuBase(), csrUsedBefore),
csrUsedAfter - csrUsedBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_TRUE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(dsBaseAddress, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(dsSize, sbaCmd->getDynamicStateBufferSize());
if (bindlessHeapsHelper) {
EXPECT_FALSE(csrState.isDirty());
EXPECT_EQ(0u, sbaCmds.size());
} else {
EXPECT_FALSE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBufferSize());
}
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_TRUE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(dsBaseAddress, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(dsSize, sbaCmd->getDynamicStateBufferSize());
} else {
EXPECT_FALSE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBufferSize());
}
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
}
}
HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
givenStateBaseAddressTrackingWhenRegularCmdListAppendKernelAndExecuteAndImmediateCmdListAppendKernelSharingCsrThenBaseAddressStateIsUpdatedInCsr,
IsAtLeastSkl) {
checkAndPrepareBindlessKernel();
StackVec<size_t, 3> sbaCmdsSizes = {};
if (bindlessHeapsHelper) {
sbaCmdsSizes = {1, 1, 1};
} else {
sbaCmdsSizes = {0, expectedSbaCmds, expectedSbaCmds};
}
auto sbaCmdsSizesIter = sbaCmdsSizes.begin();
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
ASSERT_EQ(commandListImmediate->getCsr(false), commandQueue->getCsr());
@@ -2099,19 +2170,19 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
cmdListStream.getCpuBase(),
cmdListStream.getUsed()));
auto sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sshHeap = container.getIndirectHeap(NEO::HeapType::surfaceState);
auto ssBaseAddress = sshHeap->getHeapGpuBase();
auto ssSize = sshHeap->getHeapSizeInPages();
auto ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
auto ssSize = NEO::getStateSize(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
uint64_t dsBaseAddress = -1;
size_t dsSize = static_cast<size_t>(-1);
uint32_t dsBaseSize = 0;
auto dshHeap = container.getIndirectHeap(NEO::HeapType::dynamicState);
if (dshHeap) {
dsBaseAddress = dshHeap->getHeapGpuBase();
dsSize = dsBaseSize = dshHeap->getHeapSizeInPages();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsSize = dsBaseSize = static_cast<uint32_t>(NEO::getStateSize(*dshHeap, bindlessHeapsHelper));
}
auto ioBaseAddress = container.getIndirectHeap(NEO::HeapType::indirectObject)->getHeapGpuBase();
@@ -2186,7 +2257,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdQueueStream.getCpuBase(), queueBefore),
queueAfter - queueBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
@@ -2221,16 +2292,16 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t csrUsedAfter = csrStream.getUsed();
auto sshHeapImmediate = containerImmediate.getIndirectHeap(NEO::HeapType::surfaceState);
auto ssBaseAddressImmediate = sshHeapImmediate->getHeapGpuBase();
auto ssSizeImmediate = sshHeapImmediate->getHeapSizeInPages();
auto ssBaseAddressImmediate = NEO::getStateBaseAddress(*sshHeapImmediate, bindlessHeapsHelper, isBindlessKernel);
auto ssSizeImmediate = NEO::getStateSize(*sshHeapImmediate, bindlessHeapsHelper, isBindlessKernel);
uint64_t dsBaseAddressImmediate = -1;
size_t dsSizeImmediate = static_cast<size_t>(-1);
auto dshHeapImmediate = containerImmediate.getIndirectHeap(NEO::HeapType::dynamicState);
if (dshHeapImmediate) {
dsBaseAddressImmediate = dshHeapImmediate->getHeapGpuBase();
dsSizeImmediate = dshHeapImmediate->getHeapSizeInPages();
dsBaseAddressImmediate = NEO::getStateBaseAddress(*dshHeapImmediate, bindlessHeapsHelper);
dsSizeImmediate = NEO::getStateSize(*dshHeapImmediate, bindlessHeapsHelper);
}
auto ioBaseAddressImmediate = containerImmediate.getIndirectHeap(NEO::HeapType::indirectObject)->getHeapGpuBase();
@@ -2256,34 +2327,50 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
}
cmdList.clear();
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(
cmdList,
ptrOffset(csrStream.getCpuBase(), csrUsedBefore),
csrUsedAfter - csrUsedBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_TRUE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(dsBaseAddressImmediate, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(dsSizeImmediate, sbaCmd->getDynamicStateBufferSize());
if (bindlessHeapsHelper) {
EXPECT_FALSE(csrState.isDirty());
} else {
EXPECT_FALSE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBufferSize());
}
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(
cmdList,
ptrOffset(csrStream.getCpuBase(), csrUsedBefore),
csrUsedAfter - csrUsedBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssBaseAddressImmediate, sbaCmd->getSurfaceStateBaseAddress());
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_TRUE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(dsBaseAddressImmediate, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(dsSizeImmediate, sbaCmd->getDynamicStateBufferSize());
} else {
EXPECT_FALSE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBufferSize());
}
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssBaseAddressImmediate, sbaCmd->getSurfaceStateBaseAddress());
}
}
HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
givenStateBaseAddressTrackingWhenImmediateCmdListAppendKernelAndRegularCmdListAppendKernelAndExecuteSharingCsrThenBaseAddressStateIsUpdatedInCsr,
IsAtLeastSkl) {
checkAndPrepareBindlessKernel();
StackVec<size_t, 2> sbaCmdsSizes = {};
if (bindlessHeapsHelper) {
sbaCmdsSizes = {1, 0};
} else {
sbaCmdsSizes = {expectedSbaCmds, expectedSbaCmds};
}
auto sbaCmdsSizesIter = sbaCmdsSizes.begin();
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
ASSERT_EQ(commandListImmediate->getCsr(false), commandQueue->getCsr());
@@ -2309,16 +2396,16 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
size_t csrUsedAfter = csrStream.getUsed();
auto sshHeapImmediate = containerImmediate.getIndirectHeap(NEO::HeapType::surfaceState);
auto ssBaseAddressImmediate = sshHeapImmediate->getHeapGpuBase();
auto ssSizeImmediate = sshHeapImmediate->getHeapSizeInPages();
auto ssBaseAddressImmediate = NEO::getStateBaseAddress(*sshHeapImmediate, bindlessHeapsHelper, isBindlessKernel);
auto ssSizeImmediate = NEO::getStateSize(*sshHeapImmediate, bindlessHeapsHelper, isBindlessKernel);
uint64_t dsBaseAddressImmediate = -1;
size_t dsSizeImmediate = static_cast<size_t>(-1);
auto dshHeapImmediate = containerImmediate.getIndirectHeap(NEO::HeapType::dynamicState);
if (dshHeapImmediate) {
dsBaseAddressImmediate = dshHeapImmediate->getHeapGpuBase();
dsSizeImmediate = dshHeapImmediate->getHeapSizeInPages();
dsBaseAddressImmediate = NEO::getStateBaseAddress(*dshHeapImmediate, bindlessHeapsHelper);
dsSizeImmediate = NEO::getStateSize(*dshHeapImmediate, bindlessHeapsHelper);
}
auto ioBaseAddressImmediate = containerImmediate.getIndirectHeap(NEO::HeapType::indirectObject)->getHeapGpuBase();
@@ -2349,7 +2436,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(csrStream.getCpuBase(), csrUsedBefore),
csrUsedAfter - csrUsedBefore));
auto sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
@@ -2374,16 +2461,16 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
auto sshHeap = container.getIndirectHeap(NEO::HeapType::surfaceState);
auto ssBaseAddress = sshHeap->getHeapGpuBase();
auto ssSize = sshHeap->getHeapSizeInPages();
auto ssBaseAddress = NEO::getStateBaseAddress(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
auto ssSize = NEO::getStateSize(*sshHeap, bindlessHeapsHelper, isBindlessKernel);
uint64_t dsBaseAddress = -1;
size_t dsSize = static_cast<size_t>(-1);
uint32_t dsBaseSize = 0;
auto dshHeap = container.getIndirectHeap(NEO::HeapType::dynamicState);
if (dshHeap) {
dsBaseAddress = dshHeap->getHeapGpuBase();
dsSize = dsBaseSize = dshHeap->getHeapSizeInPages();
dsBaseAddress = NEO::getStateBaseAddress(*dshHeap, bindlessHeapsHelper);
dsSize = dsBaseSize = static_cast<uint32_t>(NEO::getStateSize(*dshHeap, bindlessHeapsHelper));
}
auto ioBaseAddress = container.getIndirectHeap(NEO::HeapType::indirectObject)->getHeapGpuBase();
@@ -2456,30 +2543,46 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdQueueStream.getCpuBase(), queueBefore),
queueAfter - queueBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_TRUE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(dsBaseAddress, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(dsBaseSize, sbaCmd->getDynamicStateBufferSize());
if (bindlessHeapsHelper) {
EXPECT_FALSE(finalState.isDirty());
EXPECT_EQ(0u, sbaCmds.size());
} else {
EXPECT_FALSE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBufferSize());
}
sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
EXPECT_EQ((statlessMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState());
if (this->dshRequired) {
EXPECT_TRUE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_TRUE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(dsBaseAddress, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(dsBaseSize, sbaCmd->getDynamicStateBufferSize());
} else {
EXPECT_FALSE(sbaCmd->getDynamicStateBaseAddressModifyEnable());
EXPECT_FALSE(sbaCmd->getDynamicStateBufferSizeModifyEnable());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBaseAddress());
EXPECT_EQ(0u, sbaCmd->getDynamicStateBufferSize());
}
EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable());
EXPECT_EQ(ssBaseAddress, sbaCmd->getSurfaceStateBaseAddress());
EXPECT_EQ((statlessMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState());
}
}
HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
givenStateBaseAddressTrackingWhenRegularCmdListAppendUncachedKernelFirstAndExecuteAndImmediateCmdListAppendUncachedKerneThenMocsStateIsUpdatedInCsr,
IsAtLeastSkl) {
checkAndPrepareBindlessKernel();
StackVec<size_t, 3> sbaCmdsSizes = {};
if (bindlessHeapsHelper) {
sbaCmdsSizes = {1, 1, 1};
} else {
sbaCmdsSizes = {0, expectedSbaCmds, 0};
}
auto sbaCmdsSizesIter = sbaCmdsSizes.begin();
using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
EXPECT_TRUE(commandList->stateBaseAddressTracking);
@@ -2503,7 +2606,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
usedAfter - usedBefore));
auto sbaList = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaList.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaList.size());
uint32_t uncachedStatlessMocs = getMocs(false);
@@ -2533,7 +2636,7 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
ptrOffset(cmdQueueStream.getCpuBase(), queueBefore),
queueAfter - queueBefore));
auto sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(expectedSbaCmds, sbaCmds.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaCmds.size());
auto sbaCmd = reinterpret_cast<STATE_BASE_ADDRESS *>(*sbaCmds[0]);
EXPECT_EQ((uncachedStatlessMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState());
@@ -2549,13 +2652,20 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
EXPECT_EQ(static_cast<int32_t>(uncachedStatlessMocs), csrState.statelessMocs.value);
cmdList.clear();
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(
cmdList,
ptrOffset(csrStream.getCpuBase(), csrBefore),
csrAfter - csrBefore));
sbaCmds = findAll<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
ASSERT_EQ(0u, sbaList.size());
ASSERT_EQ(*(sbaCmdsSizesIter++), sbaList.size());
if (bindlessHeapsHelper) {
EXPECT_FALSE(csrState.isDirty());
EXPECT_EQ(0u, sbaCmds.size());
} else {
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(
cmdList,
ptrOffset(csrStream.getCpuBase(), csrBefore),
csrAfter - csrBefore));
}
}
HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
@@ -2849,7 +2959,8 @@ HWTEST2_F(CommandListStateBaseAddressPrivateHeapTest,
auto surfaceBaseAddress = container.getIndirectHeap(NEO::HeapType::surfaceState)->getHeapGpuBase();
auto dynamicBaseAddress = static_cast<uint64_t>(NEO::StreamProperty64::initValue);
if (dshRequired) {
dynamicBaseAddress = container.getIndirectHeap(NEO::HeapType::dynamicState)->getHeapGpuBase();
auto dsh = container.getIndirectHeap(NEO::HeapType::dynamicState);
dynamicBaseAddress = NEO::getStateBaseAddress(*dsh, device->getNEODevice()->getBindlessHeapsHelper());
}
EXPECT_EQ(static_cast<int64_t>(indirectBaseAddress), commandList->currentIndirectObjectBaseAddress);

5
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_xehp_and_later.cpp
View File

@@ -14,6 +14,7 @@
#include "shared/source/helpers/definitions/command_encoder_args.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/source/helpers/preamble.h"
#include "shared/source/helpers/state_base_address_helper.h"
#include "shared/source/indirect_heap/indirect_heap.h"
#include "shared/source/os_interface/product_helper.h"
#include "shared/test/common/cmd_parse/gen_cmd_parse.h"
@@ -2363,7 +2364,7 @@ HWTEST2_F(ImmediateFlushTaskCsrSharedHeapCmdListTest,
uint64_t dsRegularBaseAddress = static_cast<uint64_t>(-1);
if (this->dshRequired) {
auto dshRegularHeap = container.getIndirectHeap(NEO::HeapType::dynamicState);
dsRegularBaseAddress = dshRegularHeap->getHeapGpuBase();
dsRegularBaseAddress = NEO::getStateBaseAddress(*dshRegularHeap, bindlessHeapsHelper);
}
ze_command_list_handle_t cmdListHandle = commandList->toHandle();
@@ -2408,6 +2409,8 @@ HWTEST2_F(ImmediateFlushTaskPrivateHeapCmdListTest,
csrImmediate.storeMakeResidentAllocations = true;
auto &csrStream = csrImmediate.commandStream;
commandListImmediate->getCmdContainer().prepareBindfulSsh();
ze_group_count_t groupCount{1, 1, 1};
CmdListKernelLaunchParams launchParams = {};
size_t csrUsedBefore = csrStream.getUsed();