From f06bb256c7848f9a8553605fbf8a7d50e5d6ecff Mon Sep 17 00:00:00 2001 From: Jack Myers Date: Tue, 9 Sep 2025 22:16:35 +0000 Subject: [PATCH] refactor: sba type helper Signed-off-by: Jack Myers --- .../unit_tests/fixtures/cmdlist_fixture.inl | 222 ++++++------- .../sources/cmdlist/test_cmdlist_1.cpp | 18 +- .../sources/cmdlist/test_cmdlist_2.cpp | 41 ++- .../sources/cmdlist/test_cmdlist_4.cpp | 2 +- .../test_cmdlist_append_launch_kernel_1.cpp | 16 +- .../cmdlist/test_cmdlist_xehp_and_later.cpp | 52 ++-- .../cmdqueue/test_cmdqueue_debugger.cpp | 6 +- .../sources/debugger/test_l0_debugger_2.cpp | 12 +- .../test_l0_debugger_sba_tracking.cpp | 25 +- ...and_stream_receiver_flush_task_1_tests.cpp | 11 +- ...stream_receiver_flush_task_gmock_tests.cpp | 3 +- ...ceiver_flush_task_tests_xehp_and_later.cpp | 136 ++++---- .../command_container/command_encoder.h | 5 +- .../command_encoder_xehp_and_later.inl | 72 ++--- .../command_stream_receiver_hw.h | 3 +- .../command_stream_receiver_hw_gen12lp.cpp | 9 +- .../cache_policy_from_xe_hpg_to_xe3.inl | 5 +- shared/source/helpers/state_base_address.h | 6 +- .../helpers/state_base_address_base.inl | 4 +- .../helpers/state_base_address_helper.h | 20 +- .../test/common/cmd_parse/cmd_parse_base.inl | 45 ++- .../header/heapful_test_definitions.h | 18 ++ .../test_macros/header/heapless_matchers.h | 24 ++ .../command_encoder_tests_xehp_and_later.cpp | 16 +- .../encoders/test_encode_dispatch_kernel.cpp | 11 +- .../unit_test/encoders/test_encode_states.cpp | 5 +- .../unit_test/helpers/cache_policy_tests.cpp | 20 +- .../helpers/cmd_buffer_validator_tests.cpp | 292 ++++++++++-------- .../helpers/state_base_address_tests.cpp | 55 ++-- .../os_interface/product_helper_tests.cpp | 45 ++- .../pvc/compiler_product_helper_tests_pvc.cpp | 2 +- .../dg2/excludes_xe_hpg_core_dg2.cpp | 4 +- 32 files changed, 699 insertions(+), 506 deletions(-) create mode 100644 shared/test/common/test_macros/header/heapful_test_definitions.h diff --git a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl index 09e2e5b956..6cacfb4c0c 100644 --- a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl +++ b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl @@ -1573,137 +1573,139 @@ void ImmediateCmdListSharedHeapsFlushTaskFixtureInit::testBody(NonKernelOperatio template void CommandListScratchPatchFixtureInit::testScratchInline(bool useImmediate, bool patchPreamble) { - auto csr = device->getNEODevice()->getDefaultEngine().commandStreamReceiver; - auto scratchController = csr->getScratchSpaceController(); + if constexpr (GfxFamilyWithSBA) { + auto csr = device->getNEODevice()->getDefaultEngine().commandStreamReceiver; + auto scratchController = csr->getScratchSpaceController(); - auto ultCsr = static_cast *>(commandQueue->csr); - ultCsr->storeMakeResidentAllocations = true; + auto ultCsr = static_cast *>(commandQueue->csr); + ultCsr->storeMakeResidentAllocations = true; - NEO::EncodeDispatchKernelArgs dispatchKernelArgs = {}; - dispatchKernelArgs.isHeaplessModeEnabled = true; + NEO::EncodeDispatchKernelArgs dispatchKernelArgs = {}; + dispatchKernelArgs.isHeaplessModeEnabled = true; - size_t inlineOffset = NEO::EncodeDispatchKernel::getInlineDataOffset(dispatchKernelArgs); + size_t inlineOffset = NEO::EncodeDispatchKernel::getInlineDataOffset(dispatchKernelArgs); - auto scratchCmdList = static_cast(commandList.get()); - auto cmdListStream = commandList->commandContainer.getCommandStream(); - if (useImmediate) { - scratchCmdList = static_cast(commandListImmediate.get()); - cmdListStream = commandListImmediate->commandContainer.getCommandStream(); - } + auto scratchCmdList = static_cast(commandList.get()); + auto cmdListStream = commandList->commandContainer.getCommandStream(); + if (useImmediate) { + scratchCmdList = static_cast(commandListImmediate.get()); + cmdListStream = commandListImmediate->commandContainer.getCommandStream(); + } - const ze_group_count_t groupCount{1, 1, 1}; - CmdListKernelLaunchParams launchParams = {}; + const ze_group_count_t groupCount{1, 1, 1}; + CmdListKernelLaunchParams launchParams = {}; - auto cmdListGpuBase = cmdListStream->getGpuBase(); - auto cmdListCpuBase = cmdListStream->getCpuBase(); + auto cmdListGpuBase = cmdListStream->getGpuBase(); + auto cmdListCpuBase = cmdListStream->getCpuBase(); - auto result = ZE_RESULT_SUCCESS; - size_t usedBefore = cmdListStream->getUsed(); - result = scratchCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams); - size_t usedAfter = cmdListStream->getUsed(); - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - - uint64_t surfaceHeapGpuBase = getSurfStateGpuBase(useImmediate); - - GenCmdList cmdList; - ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( - cmdList, - ptrOffset(cmdListStream->getCpuBase(), usedBefore), - usedAfter - usedBefore)); - - auto walkerIterator = NEO::UnitTestHelper::findWalkerTypeCmd(cmdList.begin(), cmdList.end()); - ASSERT_NE(cmdList.end(), walkerIterator); - void *walkerPtrWithScratch = *walkerIterator; - auto walkerOffset = ptrDiff(walkerPtrWithScratch, cmdListCpuBase); - - mockKernelImmData->kernelDescriptor->kernelAttributes.perThreadScratchSize[0] = 0x0; - - usedBefore = cmdListStream->getUsed(); - result = scratchCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams); - usedAfter = cmdListStream->getUsed(); - EXPECT_EQ(ZE_RESULT_SUCCESS, result); - - cmdList.clear(); - ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( - cmdList, - ptrOffset(cmdListStream->getCpuBase(), usedBefore), - usedAfter - usedBefore)); - - walkerIterator = NEO::UnitTestHelper::findWalkerTypeCmd(cmdList.begin(), cmdList.end()); - ASSERT_NE(cmdList.end(), walkerIterator); - void *walkerPtrWithoutScratch = *walkerIterator; - - if (!useImmediate) { - result = commandList->close(); + auto result = ZE_RESULT_SUCCESS; + size_t usedBefore = cmdListStream->getUsed(); + result = scratchCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams); + size_t usedAfter = cmdListStream->getUsed(); EXPECT_EQ(ZE_RESULT_SUCCESS, result); - EXPECT_EQ(1u, commandList->getActiveScratchPatchElements()); - auto commandListHandle = commandList->toHandle(); + uint64_t surfaceHeapGpuBase = getSurfStateGpuBase(useImmediate); - void *queueCpuBase = commandQueue->commandStream.getCpuBase(); - auto usedSpaceBefore = commandQueue->commandStream.getUsed(); - commandQueue->setPatchingPreamble(patchPreamble, false); - result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr); + GenCmdList cmdList; + ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( + cmdList, + ptrOffset(cmdListStream->getCpuBase(), usedBefore), + usedAfter - usedBefore)); + + auto walkerIterator = NEO::UnitTestHelper::findWalkerTypeCmd(cmdList.begin(), cmdList.end()); + ASSERT_NE(cmdList.end(), walkerIterator); + void *walkerPtrWithScratch = *walkerIterator; + auto walkerOffset = ptrDiff(walkerPtrWithScratch, cmdListCpuBase); + + mockKernelImmData->kernelDescriptor->kernelAttributes.perThreadScratchSize[0] = 0x0; + + usedBefore = cmdListStream->getUsed(); + result = scratchCmdList->appendLaunchKernel(kernel->toHandle(), groupCount, nullptr, 0, nullptr, launchParams); + usedAfter = cmdListStream->getUsed(); EXPECT_EQ(ZE_RESULT_SUCCESS, result); - auto usedSpaceAfter = commandQueue->commandStream.getUsed(); - ASSERT_GT(usedSpaceAfter, usedSpaceBefore); + + cmdList.clear(); + ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( + cmdList, + ptrOffset(cmdListStream->getCpuBase(), usedBefore), + usedAfter - usedBefore)); + + walkerIterator = NEO::UnitTestHelper::findWalkerTypeCmd(cmdList.begin(), cmdList.end()); + ASSERT_NE(cmdList.end(), walkerIterator); + void *walkerPtrWithoutScratch = *walkerIterator; + + if (!useImmediate) { + result = commandList->close(); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + EXPECT_EQ(1u, commandList->getActiveScratchPatchElements()); + + auto commandListHandle = commandList->toHandle(); + + void *queueCpuBase = commandQueue->commandStream.getCpuBase(); + auto usedSpaceBefore = commandQueue->commandStream.getUsed(); + commandQueue->setPatchingPreamble(patchPreamble, false); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false, nullptr, nullptr); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + auto usedSpaceAfter = commandQueue->commandStream.getUsed(); + ASSERT_GT(usedSpaceAfter, usedSpaceBefore); + + if (patchPreamble) { + cmdList.clear(); + ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( + cmdList, + ptrOffset(queueCpuBase, usedSpaceBefore), + usedSpaceAfter - usedSpaceBefore)); + } + } + + auto scratchAddress = scratchController->getScratchPatchAddress(); + auto fullScratchAddress = surfaceHeapGpuBase + scratchAddress; + + uint64_t scratchInlineValue = 0; if (patchPreamble) { - cmdList.clear(); - ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( - cmdList, - ptrOffset(queueCpuBase, usedSpaceBefore), - usedSpaceAfter - usedSpaceBefore)); - } - } + using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM; - auto scratchAddress = scratchController->getScratchPatchAddress(); - auto fullScratchAddress = surfaceHeapGpuBase + scratchAddress; + auto sdiCmds = findAll(cmdList.begin(), cmdList.end()); + ASSERT_LT(2u, sdiCmds.size()); // last two SDI encodes returning BB_START - uint64_t scratchInlineValue = 0; + uint64_t walkerScratchInlineGpuVa = cmdListGpuBase + walkerOffset + (inlineOffset + scratchInlineOffset); - if (patchPreamble) { - using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM; + uint32_t scratchLowerDword = static_cast(fullScratchAddress & std::numeric_limits::max()); + uint32_t scratchUpperDword = static_cast(fullScratchAddress >> 32); - auto sdiCmds = findAll(cmdList.begin(), cmdList.end()); - ASSERT_LT(2u, sdiCmds.size()); // last two SDI encodes returning BB_START - - uint64_t walkerScratchInlineGpuVa = cmdListGpuBase + walkerOffset + (inlineOffset + scratchInlineOffset); - - uint32_t scratchLowerDword = static_cast(fullScratchAddress & std::numeric_limits::max()); - uint32_t scratchUpperDword = static_cast(fullScratchAddress >> 32); - - size_t sdiMax = sdiCmds.size() - 2; - for (size_t i = 0; i < sdiMax; i++) { - auto sdiCmd = reinterpret_cast(*sdiCmds[i]); - EXPECT_EQ(walkerScratchInlineGpuVa, sdiCmd->getAddress()); - if (i == 0) { - EXPECT_EQ(scratchLowerDword, sdiCmd->getDataDword0()); - } else { - EXPECT_EQ(scratchUpperDword, sdiCmd->getDataDword0()); - } - if (sdiCmd->getStoreQword() == false) { - walkerScratchInlineGpuVa += sizeof(uint32_t); - } else { - EXPECT_EQ(scratchUpperDword, sdiCmd->getDataDword1()); + size_t sdiMax = sdiCmds.size() - 2; + for (size_t i = 0; i < sdiMax; i++) { + auto sdiCmd = reinterpret_cast(*sdiCmds[i]); + EXPECT_EQ(walkerScratchInlineGpuVa, sdiCmd->getAddress()); + if (i == 0) { + EXPECT_EQ(scratchLowerDword, sdiCmd->getDataDword0()); + } else { + EXPECT_EQ(scratchUpperDword, sdiCmd->getDataDword0()); + } + if (sdiCmd->getStoreQword() == false) { + walkerScratchInlineGpuVa += sizeof(uint32_t); + } else { + EXPECT_EQ(scratchUpperDword, sdiCmd->getDataDword1()); + } } + } else { + void *scratchInlinePtr = ptrOffset(walkerPtrWithScratch, (inlineOffset + scratchInlineOffset)); + std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); + EXPECT_EQ(fullScratchAddress, scratchInlineValue); + + scratchInlinePtr = ptrOffset(walkerPtrWithoutScratch, (inlineOffset + scratchInlineOffset)); + std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); + EXPECT_EQ(0u, scratchInlineValue); } - } else { - void *scratchInlinePtr = ptrOffset(walkerPtrWithScratch, (inlineOffset + scratchInlineOffset)); - std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); - EXPECT_EQ(fullScratchAddress, scratchInlineValue); - scratchInlinePtr = ptrOffset(walkerPtrWithoutScratch, (inlineOffset + scratchInlineOffset)); - std::memcpy(&scratchInlineValue, scratchInlinePtr, sizeof(scratchInlineValue)); - EXPECT_EQ(0u, scratchInlineValue); + auto scratch0Allocation = scratchController->getScratchSpaceSlot0Allocation(); + bool scratchInResidency = ultCsr->isMadeResident(scratch0Allocation); + EXPECT_TRUE(scratchInResidency); + + commandList->reset(); + EXPECT_EQ(0u, commandList->getActiveScratchPatchElements()); } - - auto scratch0Allocation = scratchController->getScratchSpaceSlot0Allocation(); - bool scratchInResidency = ultCsr->isMadeResident(scratch0Allocation); - EXPECT_TRUE(scratchInResidency); - - commandList->reset(); - EXPECT_EQ(0u, commandList->getActiveScratchPatchElements()); } template diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp index ee80fb2ab2..9d6626679c 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp @@ -39,6 +39,10 @@ #include "level_zero/core/test/unit_tests/mocks/mock_module.h" #include "level_zero/core/test/unit_tests/sources/helper/ze_object_utils.h" +using namespace NEO; +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" +#include "shared/test/common/test_macros/header/heapless_matchers.h" + namespace L0 { namespace ult { @@ -3133,7 +3137,7 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, CommandListCreateTests, whenCommandListIsCreatedT EXPECT_EQ(gmmHelper->getL3EnabledMOCS(), cmdSba->getStatelessDataPortAccessMemoryObjectControlState()); } -HWTEST_F(CommandListCreateTests, givenCommandListWithCopyOnlyWhenCreatedThenStateBaseAddressCmdIsNotProgrammedAndHeapIsNotAllocated) { +SBA_HWTEST_F(CommandListCreateTests, givenCommandListWithCopyOnlyWhenCreatedThenStateBaseAddressCmdIsNotProgrammedAndHeapIsNotAllocated) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; ze_result_t returnValue; @@ -3205,15 +3209,7 @@ HWTEST_F(CommandListCreateTests, whenCommandListIsResetThenContainsStatelessUnca EXPECT_FALSE(commandList->getContainsStatelessUncachedResource()); } -HWTEST_F(CommandListCreateTests, givenBindlessModeDisabledWhenCommandListsResetThenSbaReloaded) { - - auto &compilerProductHelper = device->getCompilerProductHelper(); - auto heaplessEnabled = compilerProductHelper.isHeaplessModeEnabled(*defaultHwInfo); - - if (compilerProductHelper.isHeaplessStateInitEnabled(heaplessEnabled)) { - GTEST_SKIP(); - } - +HEAPFUL_HWTEST_F(CommandListCreateTests, givenBindlessModeDisabledWhenCommandListsResetThenSbaReloaded) { DebugManagerStateRestore dbgRestorer; debugManager.flags.UseBindlessMode.set(0); debugManager.flags.EnableStateBaseAddressTracking.set(0); @@ -3236,7 +3232,7 @@ HWTEST_F(CommandListCreateTests, givenBindlessModeDisabledWhenCommandListsResetT ASSERT_NE(cmdList.end(), itor); } -HWTEST_F(CommandListCreateTests, givenCommandListWithCopyOnlyWhenResetThenStateBaseAddressNotProgrammed) { +SBA_HWTEST_F(CommandListCreateTests, givenCommandListWithCopyOnlyWhenResetThenStateBaseAddressNotProgrammed) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; ze_result_t returnValue; diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp index 42051d8dc4..8853e6e8b4 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_2.cpp @@ -26,6 +26,10 @@ #include "test_traits_common.h" +using namespace NEO; +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" +#include "shared/test/common/test_macros/header/heapless_matchers.h" + namespace L0 { namespace ult { @@ -2538,7 +2542,6 @@ using PrimaryBatchBufferPreamblelessCmdListTest = TestgetProductHelper().isNewCoherencyModelSupported()) { GTEST_SKIP(); @@ -2590,12 +2593,15 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest, ptrOffset(cmdQueueStream.getCpuBase(), queueSizeUsed), cmdQueueStream.getUsed() - queueSizeUsed)); - auto cmdQueueSbaDirtyCmds = findAll(cmdList.begin(), cmdList.end()); - ASSERT_TRUE(cmdQueueSbaDirtyCmds.size() >= 1u); - auto sbaCmd = reinterpret_cast(*cmdQueueSbaDirtyCmds[0]); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto cmdQueueSbaDirtyCmds = findAll(cmdList.begin(), cmdList.end()); + ASSERT_TRUE(cmdQueueSbaDirtyCmds.size() >= 1u); + auto sbaCmd = reinterpret_cast(*cmdQueueSbaDirtyCmds[0]); - auto uncachedMocs = device->getMOCS(false, false) >> 1; - EXPECT_EQ((uncachedMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState()); + auto uncachedMocs = device->getMOCS(false, false) >> 1; + EXPECT_EQ((uncachedMocs << 1), sbaCmd->getStatelessDataPortAccessMemoryObjectControlState()); + } } HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest, @@ -2725,7 +2731,6 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest, givenPrimaryBatchBufferWhenExecutingMultipleCommandListsAndSecondWithPreambleThenUseCommandListBufferAsStartingBufferAndChainFirstListToQueuePreambleAndAfterToSecondList, IsAtLeastXeCore) { using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START; - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; if (device->getProductHelper().isNewCoherencyModelSupported()) { GTEST_SKIP(); @@ -2788,8 +2793,11 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest, cmdList, ptrOffset(cmdQueueStream.getCpuBase(), queueUsedSize), cmdQueueStream.getUsed() - queueUsedSize)); - auto cmdQueueSbaDirtyCmds = findAll(cmdList.begin(), cmdList.end()); - ASSERT_TRUE(cmdQueueSbaDirtyCmds.size() >= 1u); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto cmdQueueSbaDirtyCmds = findAll(cmdList.begin(), cmdList.end()); + ASSERT_TRUE(cmdQueueSbaDirtyCmds.size() >= 1u); + } auto cmdQueueBbStartCmds = findAll(cmdList.begin(), cmdList.end()); ASSERT_EQ(1u, cmdQueueBbStartCmds.size()); @@ -2810,13 +2818,16 @@ HWTEST2_F(PrimaryBatchBufferPreamblelessCmdListTest, bbStartCmd = genCmdCast(cmdContainer3rdCmdList.getEndCmdPtr()); ASSERT_NE(nullptr, bbStartCmd); - size_t sbaSize = sizeof(STATE_BASE_ADDRESS) + NEO::MemorySynchronizationCommands::getSizeForSingleBarrier(); - if (commandQueue->doubleSbaWa) { - sbaSize += sizeof(STATE_BASE_ADDRESS); - } + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + size_t sbaSize = sizeof(STATE_BASE_ADDRESS) + NEO::MemorySynchronizationCommands::getSizeForSingleBarrier(); + if (commandQueue->doubleSbaWa) { + sbaSize += sizeof(STATE_BASE_ADDRESS); + } - gpuReturnAddress += sizeof(MI_BATCH_BUFFER_START) + sbaSize; - EXPECT_EQ(gpuReturnAddress, bbStartCmd->getBatchBufferStartAddress()); + gpuReturnAddress += sizeof(MI_BATCH_BUFFER_START) + sbaSize; + EXPECT_EQ(gpuReturnAddress, bbStartCmd->getBatchBufferStartAddress()); + } } HWTEST_F(CommandListAppend, givenCopyCommandListWhenImageCopyFromFromMemoryExtThenNotAlignedSrcPtrPassedToBltDispatch) { diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp index 667c0a5bc7..50c5fa7351 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_4.cpp @@ -1124,7 +1124,7 @@ HWTEST_F(ImmediateCmdListSharedHeapsImmediateFlushTaskTest, givenMultipleCommand HWTEST2_F(ImmediateCmdListSharedHeapsImmediateFlushTaskTest, givenImmediateCommandListWhenFirstAppendIsNonKernelAppendAndSecondAppendIsKernelAppendThenExpectAllBaseAddressSbaCommandBeforeSecondAppend, - IsAtLeastXeCore) { + IsSbaRequiredAndAtLeastXeCore) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; auto &ultCsr = neoDevice->getUltCommandStreamReceiver(); diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp index 8239eab8f4..723cf8c050 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp @@ -1087,7 +1087,6 @@ HWTEST_F(CommandListAppendLaunchKernel, givenCommandListWhenResetCalledThenState auto bindlessHeapsHelper = neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->bindlessHeapsHelper.get(); - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; createKernel(); ze_result_t returnValue; @@ -1150,13 +1149,16 @@ HWTEST_F(CommandListAppendLaunchKernel, givenCommandListWhenResetCalledThenState auto heaplessEnabled = compilerProductHelper.isHeaplessModeEnabled(*defaultHwInfo); auto heaplessStateInitEnabled = compilerProductHelper.isHeaplessStateInitEnabled(heaplessEnabled); - if (!heaplessStateInitEnabled) { - GenCmdList cmdList; - ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( - cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), commandList->getCmdContainer().getCommandStream()->getUsed())); + if constexpr (FamilyType::isHeaplessRequired() == false) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + if (!heaplessStateInitEnabled) { + GenCmdList cmdList; + ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( + cmdList, ptrOffset(commandList->getCmdContainer().getCommandStream()->getCpuBase(), 0), commandList->getCmdContainer().getCommandStream()->getUsed())); - auto itor = find(cmdList.begin(), cmdList.end()); - EXPECT_NE(cmdList.end(), itor); + auto itor = find(cmdList.begin(), cmdList.end()); + EXPECT_NE(cmdList.end(), itor); + } } } diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_xehp_and_later.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_xehp_and_later.cpp index fe9be9ad1d..99ff92703a 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_xehp_and_later.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_xehp_and_later.cpp @@ -35,17 +35,16 @@ #include "test_traits_common.h" using namespace NEO; +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" #include "shared/test/common/test_macros/header/heapless_matchers.h" namespace L0 { namespace ult { using CommandListTests = Test; -HWCMDTEST_F(IGFX_XE_HP_CORE, CommandListTests, whenCommandListIsCreatedThenPCAndStateBaseAddressCmdsAreAddedAndCorrectlyProgrammed) { - - auto &compilerProductHelper = device->getNEODevice()->getCompilerProductHelper(); - auto isHeaplessEnabled = compilerProductHelper.isHeaplessModeEnabled(*defaultHwInfo); - if (isHeaplessEnabled) { +HEAPFUL_HWTEST_F(CommandListTests, whenCommandListIsCreatedThenPCAndStateBaseAddressCmdsAreAddedAndCorrectlyProgrammed) { + auto shouldBeTested = FamilyType::supportsCmdSet(IGFX_XE_HP_CORE); + if (shouldBeTested == false) { GTEST_SKIP(); } @@ -118,7 +117,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandListTests, whenCommandListIsCreatedThenPCAnd EXPECT_EQ(gmmHelper->getL1EnabledMOCS(), cmdSba->getStatelessDataPortAccessMemoryObjectControlState()); } -HWTEST2_F(CommandListTests, whenCommandListIsCreatedAndProgramExtendedPipeControlPriorToNonPipelinedStateCommandIsEnabledThenPCAndStateBaseAddressCmdsAreAddedAndCorrectlyProgrammed, IsAtLeastXeCore) { +HWTEST2_F(CommandListTests, whenCommandListIsCreatedAndProgramExtendedPipeControlPriorToNonPipelinedStateCommandIsEnabledThenPCAndStateBaseAddressCmdsAreAddedAndCorrectlyProgrammed, IsSbaRequiredAndAtLeastXeCore) { auto &compilerProductHelper = device->getNEODevice()->getCompilerProductHelper(); auto isHeaplessEnabled = compilerProductHelper.isHeaplessModeEnabled(*defaultHwInfo); @@ -1906,7 +1905,6 @@ using ImmediateFlushTaskGlobalStatelessCmdListTest = TestgetUltCommandStreamReceiver(); csrImmediate.storeMakeResidentAllocations = true; @@ -1934,14 +1932,16 @@ HWTEST2_F(ImmediateFlushTaskGlobalStatelessCmdListTest, cmdList, ptrOffset(csrStream.getCpuBase(), csrUsedBefore), csrUsedAfter - csrUsedBefore)); - auto sbaCmds = findAll(cmdList.begin(), cmdList.end()); - ASSERT_EQ(expectedSbaCmds, sbaCmds.size()); - auto sbaCmd = reinterpret_cast(*sbaCmds[0]); + if constexpr (FamilyType::isHeaplessRequired() == false) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto sbaCmds = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(expectedSbaCmds, sbaCmds.size()); + auto sbaCmd = reinterpret_cast(*sbaCmds[0]); - EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable()); - EXPECT_EQ(ssBaseAddress, sbaCmd->getSurfaceStateBaseAddress()); - - EXPECT_EQ(ioBaseAddress, sbaCmd->getGeneralStateBaseAddress()); + EXPECT_TRUE(sbaCmd->getSurfaceStateBaseAddressModifyEnable()); + EXPECT_EQ(ssBaseAddress, sbaCmd->getSurfaceStateBaseAddress()); + EXPECT_EQ(ioBaseAddress, sbaCmd->getGeneralStateBaseAddress()); + } EXPECT_TRUE(csrImmediate.isMadeResident(ioHeap->getGraphicsAllocation())); EXPECT_TRUE(csrImmediate.isMadeResident(globalSurfaceHeap->getGraphicsAllocation())); @@ -1956,13 +1956,16 @@ HWTEST2_F(ImmediateFlushTaskGlobalStatelessCmdListTest, cmdList, ptrOffset(csrStream.getCpuBase(), csrUsedBefore), csrUsedAfter - csrUsedBefore)); - sbaCmds = findAll(cmdList.begin(), cmdList.end()); - EXPECT_EQ(0u, sbaCmds.size()); + if constexpr (FamilyType::isHeaplessRequired() == false) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto sbaCmds = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, sbaCmds.size()); + } } HWTEST2_F(ImmediateFlushTaskGlobalStatelessCmdListTest, givenImmediateFlushOnGlobalStatelessWhenAppendingSecondKernelWithChangedMocsThenExpectStateBaseAddressCommandDispatchedTwiceWithChangedMocs, - IsAtLeastXeCore) { + IsSbaRequiredAndAtLeastXeCore) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; if (neoDevice->getProductHelper().isNewCoherencyModelSupported()) { @@ -2022,15 +2025,12 @@ using ImmediateFlushTaskCsrSharedHeapCmdListTest = TestgetExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->bindlessHeapsHelper.get(); auto &csrImmediate = neoDevice->getUltCommandStreamReceiver(); csrImmediate.storeMakeResidentAllocations = true; - if (csrImmediate.heaplessModeEnabled) { - GTEST_SKIP(); - } auto &csrStream = csrImmediate.commandStream; ze_group_count_t groupCount{1, 1, 1}; @@ -2097,7 +2097,7 @@ HWTEST2_F(ImmediateFlushTaskCsrSharedHeapCmdListTest, HWTEST2_F(ImmediateFlushTaskCsrSharedHeapCmdListTest, givenImmediateFlushOnCsrSharedHeapsWhenAppendingSecondKernelWithChangedMocsThenExpectStateBaseAddressCommandDispatchedTwiceWithChangedMocs, - IsAtLeastXeCore) { + IsHeapfulRequiredAndAtLeastXeCore) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; if (neoDevice->getProductHelper().isNewCoherencyModelSupported()) { @@ -2233,7 +2233,7 @@ HWTEST2_F(ImmediateFlushTaskCsrSharedHeapCmdListTest, HWTEST2_F(ImmediateFlushTaskCsrSharedHeapCmdListTest, givenImmediateFlushOnCsrSharedHeapsWhenAppendingBarrierThenNoSurfaceHeapAllocated, - IsAtLeastXeCore) { + IsHeapfulRequiredAndAtLeastXeCore) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; auto &csrImmediate = neoDevice->getUltCommandStreamReceiver(); @@ -2264,7 +2264,7 @@ HWTEST2_F(ImmediateFlushTaskCsrSharedHeapCmdListTest, HWTEST2_F(ImmediateFlushTaskCsrSharedHeapCmdListTest, givenImmediateFlushOnCsrSharedHeapsFirstWhenExecuteRegularCommandListSecondAndImmediateThirdThenExpectSharedHeapBaseAddressRestored, - IsAtLeastXeCore) { + IsHeapfulRequiredAndAtLeastXeCore) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; auto bindlessHeapsHelper = neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->bindlessHeapsHelper.get(); @@ -2361,7 +2361,7 @@ using ImmediateFlushTaskPrivateHeapCmdListTest = TestgetExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()]->bindlessHeapsHelper.get(); @@ -2438,7 +2438,7 @@ HWTEST2_F(ImmediateFlushTaskPrivateHeapCmdListTest, } using CommandListCreate = Test; -HWTEST2_F(CommandListCreate, givenPlatformSupportsHdcUntypedCacheFlushWhenAppendWriteGlobalTimestampThenExpectNoCacheFlushInPostSyncCommand, IsAtLeastXeCore) { +HWTEST2_F(CommandListCreate, givenPlatformSupportsHdcUntypedCacheFlushWhenAppendWriteGlobalTimestampThenExpectNoCacheFlushInPostSyncCommand, IsSbaRequiredAndAtLeastXeCore) { using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; using POST_SYNC_OPERATION = typename PIPE_CONTROL::POST_SYNC_OPERATION; ze_result_t returnValue; diff --git a/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_debugger.cpp b/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_debugger.cpp index caece0f9d4..35a5850344 100644 --- a/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_debugger.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_debugger.cpp @@ -21,6 +21,10 @@ #include "level_zero/core/test/unit_tests/mocks/mock_module.h" #include "level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h" +using namespace NEO; +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" +#include "shared/test/common/test_macros/header/heapless_matchers.h" + namespace L0 { template struct CommandQueueHw; @@ -28,7 +32,7 @@ struct CommandQueueHw; namespace ult { using L0CmdQueueDebuggerTest = Test; -HWTEST_F(L0CmdQueueDebuggerTest, givenDebuggingEnabledWhenCmdListRequiringSbaProgrammingExecutedThenProgramSbaWritesToSbaTrackingBufferForNonInternalQueues) { +SBA_HWTEST_F(L0CmdQueueDebuggerTest, givenDebuggingEnabledWhenCmdListRequiringSbaProgrammingExecutedThenProgramSbaWritesToSbaTrackingBufferForNonInternalQueues) { DebugManagerStateRestore restorer; debugManager.flags.EnableStateBaseAddressTracking.set(1); diff --git a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp index 4144bff2fc..307d5b5f7e 100644 --- a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp +++ b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_2.cpp @@ -24,6 +24,10 @@ #include "level_zero/core/test/unit_tests/mocks/mock_module.h" #include "level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h" +using namespace NEO; +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" +#include "shared/test/common/test_macros/header/heapless_matchers.h" + namespace L0 { namespace ult { @@ -36,15 +40,9 @@ struct L0DebuggerWithBlitterTest : public L0DebuggerHwParameterizedFixture { CmdListMemoryCopyParams copyParams = {}; }; -HWTEST_P(L0DebuggerWithBlitterTest, givenFlushTaskSubmissionEnabledWhenCommandListIsInititalizedOrResetThenCaptureSbaIsNotCalled) { +HEAPFUL_HWTEST_P(L0DebuggerWithBlitterTest, givenFlushTaskSubmissionEnabledWhenCommandListIsInititalizedOrResetThenCaptureSbaIsNotCalled) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; - auto &compilerProductHelper = neoDevice->getCompilerProductHelper(); - auto heaplessEnabled = compilerProductHelper.isHeaplessModeEnabled(*defaultHwInfo); - if (compilerProductHelper.isHeaplessStateInitEnabled(heaplessEnabled)) { - GTEST_SKIP(); - } - DebugManagerStateRestore restorer; debugManager.flags.EnableStateBaseAddressTracking.set(0); diff --git a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_sba_tracking.cpp b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_sba_tracking.cpp index 8033ec0be8..34563e7837 100644 --- a/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_sba_tracking.cpp +++ b/level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_sba_tracking.cpp @@ -23,6 +23,10 @@ #include "level_zero/core/test/unit_tests/mocks/mock_module.h" #include "level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h" +using namespace NEO; +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" +#include "shared/test/common/test_macros/header/heapless_matchers.h" + namespace L0 { namespace ult { @@ -122,7 +126,7 @@ HWTEST_P(L0DebuggerParameterizedTests, givenL0DebuggerWhenCreatedThenPerContextS using Gen12Plus = IsAtLeastGfxCore; -HWTEST_F(L0DebuggerPerContextAddressSpaceTest, givenDebuggingEnabledAndRequiredGsbaWhenCommandListIsExecutedThenProgramGsbaWritesToSbaTrackingBuffer) { +SBA_HWTEST_F(L0DebuggerPerContextAddressSpaceTest, givenDebuggingEnabledAndRequiredGsbaWhenCommandListIsExecutedThenProgramGsbaWritesToSbaTrackingBuffer) { using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM; using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; @@ -384,7 +388,6 @@ HWTEST2_F(L0DebuggerTest, givenDebuggingEnabledWhenNonCopyCommandListIsInititali GTEST_SKIP(); } - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START; DebugManagerStateRestore dbgRestorer; @@ -406,14 +409,16 @@ HWTEST2_F(L0DebuggerTest, givenDebuggingEnabledWhenNonCopyCommandListIsInititali ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer( cmdList, commandList->getCmdContainer().getCommandStream()->getCpuBase(), usedSpaceAfter)); - auto sbaItor = find(cmdList.begin(), cmdList.end()); - ASSERT_NE(cmdList.end(), sbaItor); - auto cmdSba = genCmdCast(*sbaItor); - - uint64_t sshGpuVa = cmdSba->getSurfaceStateBaseAddress(); - auto expectedGpuVa = commandList->getCmdContainer().getIndirectHeap(NEO::HeapType::surfaceState)->getHeapGpuBase(); - EXPECT_EQ(expectedGpuVa, sshGpuVa); - EXPECT_EQ(1u, getMockDebuggerL0Hw()->captureStateBaseAddressCount); + if constexpr (FamilyType::isHeaplessRequired() == false) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto sbaItor = find(cmdList.begin(), cmdList.end()); + ASSERT_NE(cmdList.end(), sbaItor); + auto cmdSba = genCmdCast(*sbaItor); + uint64_t sshGpuVa = cmdSba->getSurfaceStateBaseAddress(); + auto expectedGpuVa = commandList->getCmdContainer().getIndirectHeap(NEO::HeapType::surfaceState)->getHeapGpuBase(); + EXPECT_EQ(expectedGpuVa, sshGpuVa); + EXPECT_EQ(1u, getMockDebuggerL0Hw()->captureStateBaseAddressCount); + } auto bbStartList = findAll(cmdList.begin(), cmdList.end()); for (const auto &bbStartIt : bbStartList) { diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_1_tests.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_1_tests.cpp index a78d1d0a42..3a99846384 100644 --- a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_1_tests.cpp +++ b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_1_tests.cpp @@ -29,6 +29,7 @@ using namespace NEO; +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" #include "shared/test/common/test_macros/header/heapless_matchers.h" typedef UltCommandStreamReceiverTest CommandStreamReceiverFlushTaskTests; @@ -588,7 +589,7 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, CommandStreamReceiverFlushTaskTests, WhenFlushing EXPECT_EQ(stateHeapMocs, cmd.getInstructionMemoryObjectControlState()); } -HWTEST_F(CommandStreamReceiverFlushTaskTests, givenDebugVariableSetWhenProgrammingSbaThenSetStatelessMocsEncryptionBit) { +SBA_HWTEST_F(CommandStreamReceiverFlushTaskTests, givenDebugVariableSetWhenProgrammingSbaThenSetStatelessMocsEncryptionBit) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; DebugManagerStateRestore restorer; @@ -611,7 +612,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenDebugVariableSetWhenProgrammi EXPECT_EQ(1u, cmd->getStatelessDataPortAccessMemoryObjectControlState() & 1); } -HWTEST_F(CommandStreamReceiverFlushTaskTests, givenStateBaseAddressWhenItIsRequiredThenThereIsPipeControlPriorToItWithTextureCacheFlush) { +SBA_HWTEST_F(CommandStreamReceiverFlushTaskTests, givenStateBaseAddressWhenItIsRequiredThenThereIsPipeControlPriorToItWithTextureCacheFlush) { auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); if (commandStreamReceiver.heaplessStateInitialized) { GTEST_SKIP(); @@ -631,7 +632,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenStateBaseAddressWhenItIsRequi EXPECT_EQ(MemorySynchronizationCommands::getDcFlushEnable(true, pDevice->getRootDeviceEnvironment()), pipeControlCmd->getDcFlushEnable()); } -HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNotApplicableL3ConfigWhenFlushingTaskThenDontReloadSba) { +SBA_HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNotApplicableL3ConfigWhenFlushingTaskThenDontReloadSba) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); @@ -657,7 +658,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNotApplicableL3ConfigWhenFlus } } -HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNotApplicableGrfConfigWhenFlushingTaskThenDontReloadSba) { +SBA_HWTEST_F(CommandStreamReceiverFlushTaskTests, givenNotApplicableGrfConfigWhenFlushingTaskThenDontReloadSba) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); @@ -918,7 +919,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, GivenEnoughMemoryOnlyForPreambleWh EXPECT_GE(sizeNeeded, csrCS.getUsed()); } -HWTEST_F(CommandStreamReceiverFlushTaskTests, GivenEnoughMemoryOnlyForPreambleAndSbaWhenFlushingTaskThenOnlyAvailableMemoryIsUsed) { +SBA_HWTEST_F(CommandStreamReceiverFlushTaskTests, GivenEnoughMemoryOnlyForPreambleAndSbaWhenFlushingTaskThenOnlyAvailableMemoryIsUsed) { typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL; typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS; typedef typename FamilyType::MI_BATCH_BUFFER_START MI_BATCH_BUFFER_START; diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_gmock_tests.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_gmock_tests.cpp index ea8fa6e33f..ed38099361 100644 --- a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_gmock_tests.cpp +++ b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_gmock_tests.cpp @@ -47,6 +47,7 @@ #include "test_traits_common.h" using namespace NEO; +#include "shared/test/common/test_macros/header/heapless_matchers.h" using CommandStreamReceiverFlushTaskGmockTests = UltCommandStreamReceiverTest; using CommandStreamReceiverFlushTaskGmockTestsWithMockCsrHw2 = UltCommandStreamReceiverTestWithCsrT; @@ -213,7 +214,7 @@ HWTEST2_TEMPLATED_F(CommandStreamReceiverFlushTaskGmockTestsWithMockCsrHw2, give EXPECT_EQ(expectedCallsCount, mockHelper->setPatchInfoDataCalled); } -HWTEST2_F(CommandStreamReceiverFlushTaskGmockTests, givenMockCsrWhenCollectStateBaseAddresPatchInfoIsCalledThenAppropriateAddressesAreTaken, MatchAny) { +HWTEST2_F(CommandStreamReceiverFlushTaskGmockTests, givenMockCsrWhenCollectStateBaseAddresPatchInfoIsCalledThenAppropriateAddressesAreTaken, IsHeapfulRequired) { typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS; std::unique_ptr> mockCsr(new MockCsrHw2(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield())); diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp index c3689793df..bfdf82375f 100644 --- a/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp +++ b/opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp @@ -27,6 +27,8 @@ #include "test_traits_common.h" using namespace NEO; +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" +#include "shared/test/common/test_macros/header/heapless_matchers.h" typedef UltCommandStreamReceiverTest CommandStreamReceiverFlushTaskXeHPAndLaterTests; using CommandStreamReceiverFlushTaskXeHPAndLaterTestsWithMockCsrHw = UltCommandStreamReceiverTestWithCsrT; @@ -108,54 +110,58 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, wh } HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, givenStateBaseAddressWhenItIsRequiredThenThereIsPipeControlPriorToItWithTextureCacheFlushAndHdc) { - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; - auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); - if (commandStreamReceiver.heaplessStateInitialized) { - GTEST_SKIP(); + if constexpr (FamilyType::isHeaplessRequired() == false) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); + if (commandStreamReceiver.heaplessStateInitialized) { + GTEST_SKIP(); + } + + configureCSRtoNonDirtyState(false); + ioh.replaceBuffer(ptrOffset(ioh.getCpuBase(), +1u), ioh.getMaxAvailableSpace() + MemoryConstants::pageSize * 3); + flushTask(commandStreamReceiver); + parseCommands(commandStreamReceiver.getCS(0)); + + auto stateBaseAddressItor = find(cmdList.begin(), cmdList.end()); + auto pipeControlItor = find(cmdList.begin(), stateBaseAddressItor); + EXPECT_NE(stateBaseAddressItor, pipeControlItor); + auto pipeControlCmd = reinterpret_cast(*pipeControlItor); + EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable()); + EXPECT_EQ(MemorySynchronizationCommands::getDcFlushEnable(true, pDevice->getRootDeviceEnvironment()), pipeControlCmd->getDcFlushEnable()); + EXPECT_TRUE(UnitTestHelper::getPipeControlHdcPipelineFlush(*pipeControlCmd)); } - - configureCSRtoNonDirtyState(false); - ioh.replaceBuffer(ptrOffset(ioh.getCpuBase(), +1u), ioh.getMaxAvailableSpace() + MemoryConstants::pageSize * 3); - flushTask(commandStreamReceiver); - parseCommands(commandStreamReceiver.getCS(0)); - - auto stateBaseAddressItor = find(cmdList.begin(), cmdList.end()); - auto pipeControlItor = find(cmdList.begin(), stateBaseAddressItor); - EXPECT_NE(stateBaseAddressItor, pipeControlItor); - auto pipeControlCmd = reinterpret_cast(*pipeControlItor); - EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable()); - EXPECT_EQ(MemorySynchronizationCommands::getDcFlushEnable(true, pDevice->getRootDeviceEnvironment()), pipeControlCmd->getDcFlushEnable()); - EXPECT_TRUE(UnitTestHelper::getPipeControlHdcPipelineFlush(*pipeControlCmd)); } HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, givenProgramExtendedPipeControlPriorToNonPipelinedStateCommandEnabledAndStateBaseAddressWhenItIsRequiredThenThereIsPipeControlPriorToIt) { - DebugManagerStateRestore dbgRestorer; - debugManager.flags.ProgramExtendedPipeControlPriorToNonPipelinedStateCommand.set(true); + if constexpr (FamilyType::isHeaplessRequired() == false) { + DebugManagerStateRestore dbgRestorer; + debugManager.flags.ProgramExtendedPipeControlPriorToNonPipelinedStateCommand.set(true); - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; - auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); - if (commandStreamReceiver.heaplessStateInitialized) { - GTEST_SKIP(); + if (commandStreamReceiver.heaplessStateInitialized) { + GTEST_SKIP(); + } + + configureCSRtoNonDirtyState(false); + ioh.replaceBuffer(ptrOffset(ioh.getCpuBase(), +1u), ioh.getMaxAvailableSpace() + MemoryConstants::pageSize * 3); + flushTask(commandStreamReceiver); + parseCommands(commandStreamReceiver.getCS(0)); + + auto stateBaseAddressItor = find(cmdList.begin(), cmdList.end()); + auto pipeControlItor = find(cmdList.begin(), stateBaseAddressItor); + EXPECT_NE(stateBaseAddressItor, pipeControlItor); + auto pipeControlCmd = reinterpret_cast(*pipeControlItor); + EXPECT_TRUE(UnitTestHelper::getPipeControlHdcPipelineFlush(*pipeControlCmd)); + EXPECT_TRUE(pipeControlCmd->getAmfsFlushEnable()); + EXPECT_TRUE(pipeControlCmd->getCommandStreamerStallEnable()); + EXPECT_TRUE(pipeControlCmd->getInstructionCacheInvalidateEnable()); + EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable()); + EXPECT_TRUE(pipeControlCmd->getConstantCacheInvalidationEnable()); + EXPECT_TRUE(pipeControlCmd->getStateCacheInvalidationEnable()); + EXPECT_TRUE(UnitTestHelper::getPipeControlHdcPipelineFlush(*pipeControlCmd)); } - - configureCSRtoNonDirtyState(false); - ioh.replaceBuffer(ptrOffset(ioh.getCpuBase(), +1u), ioh.getMaxAvailableSpace() + MemoryConstants::pageSize * 3); - flushTask(commandStreamReceiver); - parseCommands(commandStreamReceiver.getCS(0)); - - auto stateBaseAddressItor = find(cmdList.begin(), cmdList.end()); - auto pipeControlItor = find(cmdList.begin(), stateBaseAddressItor); - EXPECT_NE(stateBaseAddressItor, pipeControlItor); - auto pipeControlCmd = reinterpret_cast(*pipeControlItor); - EXPECT_TRUE(UnitTestHelper::getPipeControlHdcPipelineFlush(*pipeControlCmd)); - EXPECT_TRUE(pipeControlCmd->getAmfsFlushEnable()); - EXPECT_TRUE(pipeControlCmd->getCommandStreamerStallEnable()); - EXPECT_TRUE(pipeControlCmd->getInstructionCacheInvalidateEnable()); - EXPECT_TRUE(pipeControlCmd->getTextureCacheInvalidationEnable()); - EXPECT_TRUE(pipeControlCmd->getConstantCacheInvalidationEnable()); - EXPECT_TRUE(pipeControlCmd->getStateCacheInvalidationEnable()); - EXPECT_TRUE(UnitTestHelper::getPipeControlHdcPipelineFlush(*pipeControlCmd)); } HWTEST2_F(CommandStreamReceiverFlushTaskXeHPAndLaterTests, givenSBACommandToProgramOnSingleCCSSetupThenThereIsPipeControlPriorToIt, IsXeCore) { @@ -457,31 +463,33 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, wh } HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, WhenFlushingTaskThenStateBaseAddressProgrammingShouldMatchTracking) { - typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS; - auto gmmHelper = pDevice->getGmmHelper(); - auto stateHeapMocs = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_STATE_HEAP_BUFFER); - auto l1CacheOnMocs = gmmHelper->getL1EnabledMOCS(); - auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); + if constexpr (FamilyType::isHeaplessRequired() == false) { + typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS; + auto gmmHelper = pDevice->getGmmHelper(); + auto stateHeapMocs = gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_STATE_HEAP_BUFFER); + auto l1CacheOnMocs = gmmHelper->getL1EnabledMOCS(); + auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); - if (commandStreamReceiver.heaplessStateInitialized) { - GTEST_SKIP(); + if (commandStreamReceiver.heaplessStateInitialized) { + GTEST_SKIP(); + } + + flushTask(commandStreamReceiver); + + auto &commandStreamCSR = commandStreamReceiver.commandStream; + parseCommands(commandStreamCSR, 0); + HardwareParse::findHardwareCommands(); + + ASSERT_NE(nullptr, cmdStateBaseAddress); + auto &cmd = *reinterpret_cast(cmdStateBaseAddress); + + EXPECT_EQ(dsh.getCpuBase(), reinterpret_cast(cmd.getDynamicStateBaseAddress())); + EXPECT_EQ(commandStreamReceiver.getMemoryManager()->getInternalHeapBaseAddress(commandStreamReceiver.rootDeviceIndex, ioh.getGraphicsAllocation()->isAllocatedInLocalMemoryPool()), cmd.getInstructionBaseAddress()); + EXPECT_EQ(ssh.getCpuBase(), reinterpret_cast(cmd.getSurfaceStateBaseAddress())); + + EXPECT_EQ(l1CacheOnMocs, cmd.getStatelessDataPortAccessMemoryObjectControlState()); + EXPECT_EQ(stateHeapMocs, cmd.getInstructionMemoryObjectControlState()); } - - flushTask(commandStreamReceiver); - - auto &commandStreamCSR = commandStreamReceiver.commandStream; - parseCommands(commandStreamCSR, 0); - HardwareParse::findHardwareCommands(); - - ASSERT_NE(nullptr, cmdStateBaseAddress); - auto &cmd = *reinterpret_cast(cmdStateBaseAddress); - - EXPECT_EQ(dsh.getCpuBase(), reinterpret_cast(cmd.getDynamicStateBaseAddress())); - EXPECT_EQ(commandStreamReceiver.getMemoryManager()->getInternalHeapBaseAddress(commandStreamReceiver.rootDeviceIndex, ioh.getGraphicsAllocation()->isAllocatedInLocalMemoryPool()), cmd.getInstructionBaseAddress()); - EXPECT_EQ(ssh.getCpuBase(), reinterpret_cast(cmd.getSurfaceStateBaseAddress())); - - EXPECT_EQ(l1CacheOnMocs, cmd.getStatelessDataPortAccessMemoryObjectControlState()); - EXPECT_EQ(stateHeapMocs, cmd.getInstructionMemoryObjectControlState()); } HWCMDTEST_TEMPLATED_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTestsWithMockCsrHw, GivenBlockingWhenFlushingTaskThenPipeControlProgrammedCorrectly) { diff --git a/shared/source/command_container/command_encoder.h b/shared/source/command_container/command_encoder.h index 859d75f429..4bf106838d 100644 --- a/shared/source/command_container/command_encoder.h +++ b/shared/source/command_container/command_encoder.h @@ -16,6 +16,7 @@ #include "shared/source/helpers/definitions/command_encoder_args.h" #include "shared/source/helpers/hw_info.h" #include "shared/source/helpers/register_offsets.h" +#include "shared/source/helpers/state_base_address_helper.h" #include "shared/source/kernel/kernel_arg_descriptor.h" #include "shared/source/kernel/kernel_execution_type.h" @@ -497,7 +498,7 @@ struct EncodeMediaInterfaceDescriptorLoad { template struct EncodeStateBaseAddressArgs { - using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS; + using STATE_BASE_ADDRESS = typename StateBaseAddressTypeHelper::type; CommandContainer *container = nullptr; STATE_BASE_ADDRESS &sbaCmd; @@ -515,7 +516,7 @@ struct EncodeStateBaseAddressArgs { template struct EncodeStateBaseAddress { - using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS; + using STATE_BASE_ADDRESS = StateBaseAddressTypeHelper::type; static void encode(EncodeStateBaseAddressArgs &args); static size_t getRequiredSizeForStateBaseAddress(Device &device, CommandContainer &container, bool isRcs); static void setSbaTrackingForL0DebuggerIfEnabled(bool trackingEnabled, diff --git a/shared/source/command_container/command_encoder_xehp_and_later.inl b/shared/source/command_container/command_encoder_xehp_and_later.inl index 39e335e0d8..d50af20ac9 100644 --- a/shared/source/command_container/command_encoder_xehp_and_later.inl +++ b/shared/source/command_container/command_encoder_xehp_and_later.inl @@ -50,7 +50,6 @@ namespace NEO { template template void EncodeDispatchKernel::encode(CommandContainer &container, EncodeDispatchKernelArgs &args) { - using STATE_BASE_ADDRESS = typename Family::STATE_BASE_ADDRESS; UNRECOVERABLE_IF(args.makeCommandView && (args.cpuWalkerBuffer == nullptr || args.cpuPayloadBuffer == nullptr)); @@ -296,40 +295,43 @@ void EncodeDispatchKernel::encode(CommandContainer &container, EncodeDis } } - if (args.isHeaplessStateInitEnabled == false && !args.makeCommandView) { - if (container.isAnyHeapDirty() || - args.requiresUncachedMocs) { + if constexpr (NEO::GfxFamilyWithSBA) { + if (args.isHeaplessStateInitEnabled == false && !args.makeCommandView) { + if (container.isAnyHeapDirty() || + args.requiresUncachedMocs) { - PipeControlArgs syncArgs; - syncArgs.dcFlushEnable = args.postSyncArgs.dcFlushEnable; - MemorySynchronizationCommands::addSingleBarrier(*container.getCommandStream(), syncArgs); - STATE_BASE_ADDRESS sbaCmd; - auto gmmHelper = container.getDevice()->getGmmHelper(); - uint32_t statelessMocsIndex = - args.requiresUncachedMocs ? (gmmHelper->getUncachedMOCS() >> 1) : (gmmHelper->getL3EnabledMOCS() >> 1); - auto l1CachePolicy = container.l1CachePolicyDataRef()->getL1CacheValue(false); - auto l1CachePolicyDebuggerActive = container.l1CachePolicyDataRef()->getL1CacheValue(true); + PipeControlArgs syncArgs; + syncArgs.dcFlushEnable = args.postSyncArgs.dcFlushEnable; + MemorySynchronizationCommands::addSingleBarrier(*container.getCommandStream(), syncArgs); + using STATE_BASE_ADDRESS = typename Family::STATE_BASE_ADDRESS; + STATE_BASE_ADDRESS sbaCmd; + auto gmmHelper = container.getDevice()->getGmmHelper(); + uint32_t statelessMocsIndex = + args.requiresUncachedMocs ? (gmmHelper->getUncachedMOCS() >> 1) : (gmmHelper->getL3EnabledMOCS() >> 1); + auto l1CachePolicy = container.l1CachePolicyDataRef()->getL1CacheValue(false); + auto l1CachePolicyDebuggerActive = container.l1CachePolicyDataRef()->getL1CacheValue(true); - EncodeStateBaseAddressArgs encodeStateBaseAddressArgs = { - &container, // container - sbaCmd, // sbaCmd - nullptr, // sbaProperties - statelessMocsIndex, // statelessMocsIndex - l1CachePolicy, // l1CachePolicy - l1CachePolicyDebuggerActive, // l1CachePolicyDebuggerActive - args.partitionCount > 1, // multiOsContextCapable - args.isRcs, // isRcs - container.doubleSbaWaRef(), // doubleSbaWa - heaplessModeEnabled // heaplessModeEnabled - }; - EncodeStateBaseAddress::encode(encodeStateBaseAddressArgs); - container.setDirtyStateForAllHeaps(false); + EncodeStateBaseAddressArgs encodeStateBaseAddressArgs = { + &container, // container + sbaCmd, // sbaCmd + nullptr, // sbaProperties + statelessMocsIndex, // statelessMocsIndex + l1CachePolicy, // l1CachePolicy + l1CachePolicyDebuggerActive, // l1CachePolicyDebuggerActive + args.partitionCount > 1, // multiOsContextCapable + args.isRcs, // isRcs + container.doubleSbaWaRef(), // doubleSbaWa + heaplessModeEnabled // heaplessModeEnabled + }; + EncodeStateBaseAddress::encode(encodeStateBaseAddressArgs); + container.setDirtyStateForAllHeaps(false); - bool sbaTrackingEnabled = NEO::Debugger::isDebugEnabled(args.isInternal) && args.device->getL0Debugger(); - NEO::EncodeStateBaseAddress::setSbaTrackingForL0DebuggerIfEnabled(sbaTrackingEnabled, - *args.device, - *container.getCommandStream(), - sbaCmd, container.isUsingPrimaryBuffer()); + bool sbaTrackingEnabled = NEO::Debugger::isDebugEnabled(args.isInternal) && args.device->getL0Debugger(); + NEO::EncodeStateBaseAddress::setSbaTrackingForL0DebuggerIfEnabled(sbaTrackingEnabled, + *args.device, + *container.getCommandStream(), + sbaCmd, container.isUsingPrimaryBuffer()); + } } } @@ -765,13 +767,13 @@ void EncodeStateBaseAddress::encode(EncodeStateBaseAddressArgs & template size_t EncodeStateBaseAddress::getRequiredSizeForStateBaseAddress(Device &device, CommandContainer &container, bool isRcs) { - if constexpr (!Family::isHeaplessRequired()) { + if constexpr (Family::isHeaplessRequired() == false) { auto &hwInfo = device.getHardwareInfo(); auto &productHelper = device.getProductHelper(); - size_t size = sizeof(typename Family::STATE_BASE_ADDRESS); + size_t size = sizeof(STATE_BASE_ADDRESS); if (productHelper.isAdditionalStateBaseAddressWARequired(hwInfo)) { - size += sizeof(typename Family::STATE_BASE_ADDRESS); + size += sizeof(STATE_BASE_ADDRESS); } if (container.isHeapDirty(HeapType::surfaceState)) { size += sizeof(typename Family::_3DSTATE_BINDING_TABLE_POOL_ALLOC); diff --git a/shared/source/command_stream/command_stream_receiver_hw.h b/shared/source/command_stream/command_stream_receiver_hw.h index 5d2e66f012..fbb857def9 100644 --- a/shared/source/command_stream/command_stream_receiver_hw.h +++ b/shared/source/command_stream/command_stream_receiver_hw.h @@ -14,6 +14,7 @@ #include "shared/source/direct_submission/dispatchers/render_dispatcher.h" #include "shared/source/helpers/dirty_state_helpers.h" #include "shared/source/helpers/pipeline_select_args.h" +#include "shared/source/helpers/state_base_address_helper.h" namespace NEO { class TagNodeBase; @@ -25,7 +26,7 @@ template class CommandStreamReceiverHw : public CommandStreamReceiver { using MI_BATCH_BUFFER_START = typename GfxFamily::MI_BATCH_BUFFER_START; using PIPE_CONTROL = typename GfxFamily::PIPE_CONTROL; - using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS; + using STATE_BASE_ADDRESS = typename StateBaseAddressTypeHelper::type; struct ImmediateFlushData { PipelineSelectArgs pipelineSelectArgs{}; diff --git a/shared/source/gen12lp/command_stream_receiver_hw_gen12lp.cpp b/shared/source/gen12lp/command_stream_receiver_hw_gen12lp.cpp index 6cd416c09b..b4a9f2960a 100644 --- a/shared/source/gen12lp/command_stream_receiver_hw_gen12lp.cpp +++ b/shared/source/gen12lp/command_stream_receiver_hw_gen12lp.cpp @@ -6,6 +6,7 @@ */ #include "shared/source/gen12lp/hw_cmds.h" +#include "shared/source/gen12lp/hw_cmds_base.h" #include "shared/source/gmm_helper/resource_info.h" using Family = NEO::Gen12LpFamily; @@ -25,14 +26,14 @@ static auto gfxCore = IGFX_GEN12LP_CORE; template bool CommandStreamReceiverHw::are4GbHeapsAvailable() const { return true; } -template -size_t CommandStreamReceiverHw::getRequiredStateBaseAddressSize(const Device &device) const { +template <> +size_t CommandStreamReceiverHw::getRequiredStateBaseAddressSize(const Device &device) const { size_t size = 0; const auto &productHelper = getProductHelper(); if (productHelper.is3DPipelineSelectWARequired()) { - size += (2 * PreambleHelper::getCmdSizeForPipelineSelect(peekRootDeviceEnvironment())); + size += (2 * PreambleHelper::getCmdSizeForPipelineSelect(peekRootDeviceEnvironment())); } - size += sizeof(typename GfxFamily::STATE_BASE_ADDRESS) + sizeof(PIPE_CONTROL); + size += sizeof(typename Gen12LpFamily::STATE_BASE_ADDRESS) + sizeof(PIPE_CONTROL); return size; } diff --git a/shared/source/helpers/cache_policy_from_xe_hpg_to_xe3.inl b/shared/source/helpers/cache_policy_from_xe_hpg_to_xe3.inl index d7038ab900..d3bc58057e 100644 --- a/shared/source/helpers/cache_policy_from_xe_hpg_to_xe3.inl +++ b/shared/source/helpers/cache_policy_from_xe_hpg_to_xe3.inl @@ -14,12 +14,11 @@ namespace NEO { template const char *L1CachePolicyHelper::getCachingPolicyOptions(bool isDebuggerActive) { using GfxFamily = typename HwMapper::GfxFamily; - static constexpr const char *writeBackCachingPolicy = "-cl-store-cache-default=7 -cl-load-cache-default=4"; static constexpr const char *writeByPassCachingPolicy = "-cl-store-cache-default=2 -cl-load-cache-default=4"; static constexpr const char *uncachedCachingPolicy = "-cl-store-cache-default=2 -cl-load-cache-default=2"; - - switch (L1CachePolicyHelper::getL1CachePolicy(isDebuggerActive)) { + auto policy = L1CachePolicyHelper::getL1CachePolicy(isDebuggerActive); + switch (policy) { case GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP: return writeByPassCachingPolicy; case GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB: diff --git a/shared/source/helpers/state_base_address.h b/shared/source/helpers/state_base_address.h index 13bd0c6614..8eb50ce689 100644 --- a/shared/source/helpers/state_base_address.h +++ b/shared/source/helpers/state_base_address.h @@ -7,6 +7,8 @@ #pragma once +#include "shared/source/helpers/state_base_address_helper.h" + #include #include @@ -23,7 +25,7 @@ struct StateBaseAddressProperties; template struct StateBaseAddressHelperArgs { - using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS; + using STATE_BASE_ADDRESS = typename StateBaseAddressTypeHelper::type; uint64_t generalStateBaseAddress = 0; uint64_t indirectObjectHeapBaseAddress = 0; @@ -59,7 +61,7 @@ struct StateBaseAddressHelperArgs { template struct StateBaseAddressHelper { - using STATE_BASE_ADDRESS = typename GfxFamily::STATE_BASE_ADDRESS; + using STATE_BASE_ADDRESS = typename StateBaseAddressTypeHelper::type; static STATE_BASE_ADDRESS *getSpaceForSbaCmd(LinearStream &cmdStream); diff --git a/shared/source/helpers/state_base_address_base.inl b/shared/source/helpers/state_base_address_base.inl index b12716f1ed..0b4745f4ba 100644 --- a/shared/source/helpers/state_base_address_base.inl +++ b/shared/source/helpers/state_base_address_base.inl @@ -128,8 +128,8 @@ void StateBaseAddressHelper::programStateBaseAddress( } template -typename GfxFamily::STATE_BASE_ADDRESS *StateBaseAddressHelper::getSpaceForSbaCmd(LinearStream &cmdStream) { - return cmdStream.getSpaceForCmd(); +typename StateBaseAddressTypeHelper::type *StateBaseAddressHelper::getSpaceForSbaCmd(LinearStream &cmdStream) { + return cmdStream.getSpaceForCmd::type>(); } template diff --git a/shared/source/helpers/state_base_address_helper.h b/shared/source/helpers/state_base_address_helper.h index 15d900ea51..bdff65f087 100644 --- a/shared/source/helpers/state_base_address_helper.h +++ b/shared/source/helpers/state_base_address_helper.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2024 Intel Corporation + * Copyright (C) 2024-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -11,6 +11,24 @@ namespace NEO { +struct SBAPlaceholder {}; +template +concept GfxFamilyWithSBA = requires() { + typename GfxFamily::STATE_BASE_ADDRESS; + }; +template +struct StateBaseAddressTypeHelper; + +template +struct StateBaseAddressTypeHelper { + using type = SBAPlaceholder; +}; + +template +struct StateBaseAddressTypeHelper { + using type = typename Family::STATE_BASE_ADDRESS; +}; + inline uint64_t getStateBaseAddress(const IndirectHeap &heap, const bool useGlobalHeaps) { if (useGlobalHeaps) { return heap.getGraphicsAllocation()->getGpuBaseAddress(); diff --git a/shared/test/common/cmd_parse/cmd_parse_base.inl b/shared/test/common/cmd_parse/cmd_parse_base.inl index cbd94df598..9e0d89bbeb 100644 --- a/shared/test/common/cmd_parse/cmd_parse_base.inl +++ b/shared/test/common/cmd_parse/cmd_parse_base.inl @@ -5,6 +5,7 @@ * */ +#include "shared/source/helpers/state_base_address_helper.h" #include "shared/test/common/cmd_parse/gen_cmd_parse.h" // clang-format off @@ -19,7 +20,7 @@ using MI_STORE_REGISTER_MEM = GenStruct::MI_STORE_REGISTER_MEM; using MI_NOOP = GenStruct::MI_NOOP; using PIPE_CONTROL = GenStruct::PIPE_CONTROL; using PIPELINE_SELECT = GenStruct::PIPELINE_SELECT; -using STATE_BASE_ADDRESS = GenStruct::STATE_BASE_ADDRESS; +using STATE_BASE_ADDRESS = typename StateBaseAddressTypeHelper::type; using MI_REPORT_PERF_COUNT = GenStruct::MI_REPORT_PERF_COUNT; using MI_MATH = GenStruct::MI_MATH; using MI_LOAD_REGISTER_REG = GenStruct::MI_LOAD_REGISTER_REG; @@ -32,16 +33,38 @@ using XY_BLOCK_COPY_BLT = GenGfxFamily::XY_BLOCK_COPY_BLT; using XY_COLOR_BLT = GenGfxFamily::XY_COLOR_BLT; // clang-format on +template +SBAType *genSBACast(void *buffer) { + if constexpr (std::is_same_v) { + return nullptr; + } else { + auto pCmd = reinterpret_cast(buffer); + + return SBAType::COMMAND_TYPE_GFXPIPE == pCmd->TheStructure.Common.CommandType && + SBAType::COMMAND_SUBTYPE_GFXPIPE_COMMON == pCmd->TheStructure.Common.CommandSubtype && + SBAType::_3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED == pCmd->TheStructure.Common._3DCommandOpcode && + SBAType::_3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS == pCmd->TheStructure.Common._3DCommandSubOpcode + ? pCmd + : nullptr; + } +} + template <> STATE_BASE_ADDRESS *genCmdCast(void *buffer) { - auto pCmd = reinterpret_cast(buffer); + return genSBACast(buffer); +} - return STATE_BASE_ADDRESS::COMMAND_TYPE_GFXPIPE == pCmd->TheStructure.Common.CommandType && - STATE_BASE_ADDRESS::COMMAND_SUBTYPE_GFXPIPE_COMMON == pCmd->TheStructure.Common.CommandSubtype && - STATE_BASE_ADDRESS::_3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED == pCmd->TheStructure.Common._3DCommandOpcode && - STATE_BASE_ADDRESS::_3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS == pCmd->TheStructure.Common._3DCommandSubOpcode - ? pCmd - : nullptr; +template +size_t getSBALength(void *cmd) { + if constexpr (std::is_same_v) { + return 0u; + } else { + auto pCmd = genCmdCast(cmd); + if (pCmd) { + return pCmd->TheStructure.Common.DwordLength + 2; + } + return 0u; + } } template <> @@ -241,9 +264,9 @@ MI_ARB_CHECK *genCmdCast(void *buffer) { template size_t CmdParse::getCommandLength(void *cmd) { { - auto pCmd = genCmdCast(cmd); - if (pCmd) { - return pCmd->TheStructure.Common.DwordLength + 2; + auto sbaLength = getSBALength(cmd); + if (sbaLength != 0) { + return sbaLength; } } { diff --git a/shared/test/common/test_macros/header/heapful_test_definitions.h b/shared/test/common/test_macros/header/heapful_test_definitions.h new file mode 100644 index 0000000000..a934eaa217 --- /dev/null +++ b/shared/test/common/test_macros/header/heapful_test_definitions.h @@ -0,0 +1,18 @@ +/* + * Copyright (C) 2025 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#define HEAPFUL_HWTEST_F(test_fixture, test_name) \ + HWTEST2_F(test_fixture, test_name, IsHeapfulRequired) + +#define HEAPFUL_HWTEST_P(test_fixture, test_name) \ + HWTEST2_P(test_fixture, test_name, IsHeapfulRequired) + +#define SBA_HWTEST_F(test_fixture, test_name) \ + HWTEST2_F(test_fixture, test_name, IsSbaRequired) + +#define SBA_HWTEST_P(test_fixture, test_name) \ + HWTEST2_P(test_fixture, test_name, IsSbaRequired) diff --git a/shared/test/common/test_macros/header/heapless_matchers.h b/shared/test/common/test_macros/header/heapless_matchers.h index ffaa5bd689..db98a4390e 100644 --- a/shared/test/common/test_macros/header/heapless_matchers.h +++ b/shared/test/common/test_macros/header/heapless_matchers.h @@ -5,6 +5,8 @@ * */ +#include "shared/source/helpers/state_base_address_helper.h" + #include "test_traits_common.h" struct IsHeapfulRequired { @@ -29,7 +31,29 @@ struct IsHeapfulRequiredAnd { } }; +struct IsSbaRequired { + template + static constexpr bool isMatched() { + [[maybe_unused]] const GFXCORE_FAMILY gfxCoreFamily = NEO::ToGfxCoreFamily::get(); + using FamilyType = typename NEO::GfxFamilyMapper::GfxFamily; + if constexpr (NEO::GfxFamilyWithSBA) { + return true; + } + + return false; + } +}; + +template +struct IsSbaRequiredAnd { + template + static constexpr bool isMatched() { + return IsSbaRequired::template isMatched() && DependentMatcher::template isMatched(); + } +}; + using IsHeapfulRequiredAndAtLeastXeCore = IsHeapfulRequiredAnd; +using IsSbaRequiredAndAtLeastXeCore = IsSbaRequiredAnd; using IsHeapfulRequiredAndAtLeastXeHpcCore = IsHeapfulRequiredAnd; using IsHeapfulRequiredAndAtLeastXe2HpgCore = IsHeapfulRequiredAnd; using IsHeapfulRequiredAndAtLeastXe3Core = IsHeapfulRequiredAnd; diff --git a/shared/test/unit_test/encoders/command_encoder_tests_xehp_and_later.cpp b/shared/test/unit_test/encoders/command_encoder_tests_xehp_and_later.cpp index a90c45cae1..189cbb161b 100644 --- a/shared/test/unit_test/encoders/command_encoder_tests_xehp_and_later.cpp +++ b/shared/test/unit_test/encoders/command_encoder_tests_xehp_and_later.cpp @@ -227,14 +227,18 @@ HWTEST2_F(XeHpAndLaterSbaTest, givenMemoryCompressionEnabledWhenAppendingSbaThen } HWCMDTEST_F(IGFX_XE_HP_CORE, XeHpAndLaterSbaTest, givenNonZeroInternalHeapBaseAddressWhenSettingIsDisabledThenExpectCommandValueZero) { - constexpr uint64_t ihba = 0x80010000ull; + if constexpr (FamilyType::isHeaplessRequired()) { + GTEST_SKIP(); + } else { + constexpr uint64_t ihba = 0x80010000ull; - auto sbaCmd = FamilyType::cmdInitStateBaseAddress; - StateBaseAddressHelperArgs args = createSbaHelperArgs(&sbaCmd, pDevice->getRootDeviceEnvironment().getGmmHelper(), &ssh, nullptr, nullptr); - args.indirectObjectHeapBaseAddress = ihba; + auto sbaCmd = FamilyType::cmdInitStateBaseAddress; + StateBaseAddressHelperArgs args = createSbaHelperArgs(&sbaCmd, pDevice->getRootDeviceEnvironment().getGmmHelper(), &ssh, nullptr, nullptr); + args.indirectObjectHeapBaseAddress = ihba; - StateBaseAddressHelper::appendStateBaseAddressParameters(args); - EXPECT_EQ(0ull, sbaCmd.getGeneralStateBaseAddress()); + StateBaseAddressHelper::appendStateBaseAddressParameters(args); + EXPECT_EQ(0ull, sbaCmd.getGeneralStateBaseAddress()); + } } HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterCommandEncoderTest, givenEncodeDataInMemoryWhenProgrammingFeCmdThenExpectFeCmdDataInDispatchedCommand) { diff --git a/shared/test/unit_test/encoders/test_encode_dispatch_kernel.cpp b/shared/test/unit_test/encoders/test_encode_dispatch_kernel.cpp index 5956501013..c7131dab12 100644 --- a/shared/test/unit_test/encoders/test_encode_dispatch_kernel.cpp +++ b/shared/test/unit_test/encoders/test_encode_dispatch_kernel.cpp @@ -22,6 +22,7 @@ #include "shared/test/common/helpers/unit_test_helper.h" #include "shared/test/common/mocks/mock_device.h" #include "shared/test/common/mocks/mock_l0_debugger.h" +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" #include "shared/test/common/test_macros/hw_test.h" #include "shared/test/common/test_macros/test.h" #include "shared/test/unit_test/fixtures/command_container_fixture.h" @@ -92,7 +93,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandEncodeStatesTest, givenDebugFlagSetWhenProgr using CommandEncodeStatesUncachedMocsTests = Test; -HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithUncachedMocsAndDirtyHeapsThenCorrectMocsIsSet) { +HEAPFUL_HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithUncachedMocsAndDirtyHeapsThenCorrectMocsIsSet) { using DefaultWalkerType = typename FamilyType::DefaultWalkerType; DebugManagerStateRestore restore; debugManager.flags.ForceL1Caching.set(0u); @@ -120,7 +121,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithUnc (gmmHelper->getUncachedMOCS())); } -HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithUncachedMocsAndNonDirtyHeapsThenCorrectMocsIsSet) { +HEAPFUL_HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithUncachedMocsAndNonDirtyHeapsThenCorrectMocsIsSet) { using DefaultWalkerType = typename FamilyType::DefaultWalkerType; DebugManagerStateRestore restore; debugManager.flags.ForceL1Caching.set(0u); @@ -148,7 +149,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithUnc (gmmHelper->getUncachedMOCS())); } -HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNonUncachedMocsAndDirtyHeapsThenSbaIsNotProgrammed) { +HEAPFUL_HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNonUncachedMocsAndDirtyHeapsThenSbaIsNotProgrammed) { using DefaultWalkerType = typename FamilyType::DefaultWalkerType; DebugManagerStateRestore restore; debugManager.flags.ForceL1Caching.set(0u); @@ -177,7 +178,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNon (gmmHelper->getL3EnabledMOCS())); } -HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNonUncachedMocsAndNonDirtyHeapsThenSbaIsNotProgrammed) { +HEAPFUL_HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNonUncachedMocsAndNonDirtyHeapsThenSbaIsNotProgrammed) { using DefaultWalkerType = typename FamilyType::DefaultWalkerType; DebugManagerStateRestore restore; debugManager.flags.ForceL1Caching.set(0u); @@ -201,7 +202,7 @@ HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNon ASSERT_EQ(commands.end(), itor); } -HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNonUncachedMocsAndNonDirtyHeapsAndSlmSizeThenSbaIsNotProgrammed) { +HEAPFUL_HWTEST_F(CommandEncodeStatesUncachedMocsTests, whenEncodingDispatchKernelWithNonUncachedMocsAndNonDirtyHeapsAndSlmSizeThenSbaIsNotProgrammed) { using DefaultWalkerType = typename FamilyType::DefaultWalkerType; DebugManagerStateRestore restore; debugManager.flags.ForceL1Caching.set(0u); diff --git a/shared/test/unit_test/encoders/test_encode_states.cpp b/shared/test/unit_test/encoders/test_encode_states.cpp index 164f9e7ed8..507c4136aa 100644 --- a/shared/test/unit_test/encoders/test_encode_states.cpp +++ b/shared/test/unit_test/encoders/test_encode_states.cpp @@ -20,6 +20,7 @@ #include "shared/test/common/mocks/mock_bindless_heaps_helper.h" #include "shared/test/common/mocks/mock_device.h" #include "shared/test/common/mocks/ult_device_factory.h" +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" #include "shared/test/common/test_macros/hw_test.h" #include "shared/test/unit_test/fixtures/command_container_fixture.h" #include "shared/test/unit_test/fixtures/front_window_fixture.h" @@ -453,7 +454,7 @@ HWTEST2_F(CommandEncodeStatesTest, givenCommandContainerWithDirtyHeapsWhenSetSta } } -HWTEST_F(CommandEncodeStatesTest, givenCommandContainerWhenSetStateBaseAddressCalledThenStateBaseAddressIsSetCorrectly) { +SBA_HWTEST_F(CommandEncodeStatesTest, givenCommandContainerWhenSetStateBaseAddressCalledThenStateBaseAddressIsSetCorrectly) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; cmdContainer->dirtyHeaps = 0; @@ -581,7 +582,7 @@ HWTEST2_F(CommandEncodeStatesTest, givenSbaPropertiesWhenBindingBaseAddressSetTh EXPECT_EQ(bindingTablePoolSize, bindTablePoolCmd->getBindingTablePoolBufferSize()); } -HWTEST2_F(CommandEncodeStatesTest, givenSbaPropertiesWhenGeneralBaseAddressSetThenExpectAddressFromPropertiesUsedNotFromContainer, IsAtLeastXeCore) { +HWTEST2_F(CommandEncodeStatesTest, givenSbaPropertiesWhenGeneralBaseAddressSetThenExpectAddressFromPropertiesUsedNotFromContainer, IsSbaRequiredAndAtLeastXeCore) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; auto indirectHeapBaseAddress = cmdContainer->getIndirectObjectHeapBaseAddress(); diff --git a/shared/test/unit_test/helpers/cache_policy_tests.cpp b/shared/test/unit_test/helpers/cache_policy_tests.cpp index 8f27072f0b..b4b202c5e1 100644 --- a/shared/test/unit_test/helpers/cache_policy_tests.cpp +++ b/shared/test/unit_test/helpers/cache_policy_tests.cpp @@ -25,13 +25,27 @@ HWTEST2_F(ProductHelperTest, givenL1CachePolicyHelperWhenUnsupportedL1PoliciesAn HWTEST2_F(ProductHelperTest, givenAtLeastXeHpgCoreWhenGetL1CachePolicyThenReturnCorrectValue, IsAtLeastXeCore) { using GfxFamily = typename HwMapper::GfxFamily; - EXPECT_EQ(L1CachePolicyHelper::getL1CachePolicy(false), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP); - EXPECT_EQ(L1CachePolicyHelper::getL1CachePolicy(true), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP); + auto policy = [&]() -> uint32_t { + if constexpr (GfxFamily::isHeaplessRequired()) { + return GfxFamily::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_WBP; + } else { + return GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP; + } + }(); + EXPECT_EQ(L1CachePolicyHelper::getL1CachePolicy(false), policy); + EXPECT_EQ(L1CachePolicyHelper::getL1CachePolicy(true), policy); } HWTEST2_F(ProductHelperTest, givenAtLeastXeHpgCoreWhenGetUncached1CachePolicyThenReturnCorrectValue, IsAtLeastXeCore) { using GfxFamily = typename HwMapper::GfxFamily; - EXPECT_EQ(L1CachePolicyHelper::getUncachedL1CachePolicy(), GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC); + auto policy = [&]() -> uint32_t { + if constexpr (GfxFamily::isHeaplessRequired()) { + return GfxFamily::RENDER_SURFACE_STATE::L1_CACHE_CONTROL_UC; + } else { + return GfxFamily::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC; + } + }(); + EXPECT_EQ(L1CachePolicyHelper::getUncachedL1CachePolicy(), policy); } HWTEST2_F(ProductHelperTest, givenAtLeastXeHpgCoreAndWriteBackPolicyWhenGetL1CachePolicyThenReturnCorrectValue, IsAtLeastXeCore) { diff --git a/shared/test/unit_test/helpers/cmd_buffer_validator_tests.cpp b/shared/test/unit_test/helpers/cmd_buffer_validator_tests.cpp index 7a0111249d..588d4d77e5 100644 --- a/shared/test/unit_test/helpers/cmd_buffer_validator_tests.cpp +++ b/shared/test/unit_test/helpers/cmd_buffer_validator_tests.cpp @@ -1,10 +1,11 @@ /* - * Copyright (C) 2019-2023 Intel Corporation + * Copyright (C) 2019-2025 Intel Corporation * * SPDX-License-Identifier: MIT * */ +#include "shared/source/helpers/state_base_address_helper.h" #include "shared/test/common/cmd_parse/hw_parse.h" #include "shared/test/common/helpers/cmd_buffer_validator.h" #include "shared/test/common/test_macros/hw_test.h" @@ -53,19 +54,21 @@ HWTEST_F(HwParseTest, WhenEmptyBufferThenDontExpectCommands) { HWTEST_F(HwParseTest, WhenExpectingAnyCommandThenAllCommandsAreValidAsLongAsTheCountMatches) { using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; bool cmdBuffOk = false; char buffer[8192]; LinearStream stream{alignUp(buffer, 4096), 4096}; + std::vector expectedCmdBuf; *stream.getSpaceForCmd() = FamilyType::cmdInitPipeControl; - *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchAnyCmd(1)); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchAnyCmd(1)); + } *stream.getSpaceForCmd() = FamilyType::cmdInitPipeControl; + expectedCmdBuf.push_back(new MatchAnyCmd(1)); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchAnyCmd(1), - new MatchAnyCmd(1), - new MatchAnyCmd(1)}); + cmdBuffOk = expectCmdBuff(stream, 0, std::move(expectedCmdBuf)); EXPECT_TRUE(cmdBuffOk); cmdBuffOk = expectCmdBuff(stream, 0, @@ -96,19 +99,23 @@ HWTEST_F(HwParseTest, WhenExpectingAnyCommandThenAllCommandsAreValidAsLongAsTheC new MatchAnyCmd(atLeastOne)}); EXPECT_FALSE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchAnyCmd(1), - new MatchAnyCmd(1), - new MatchAnyCmd(1), - new MatchAnyCmd(anyNumber)}); - EXPECT_TRUE(cmdBuffOk); + if constexpr (GfxFamilyWithSBA) { + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchAnyCmd(1), + new MatchAnyCmd(1), + new MatchAnyCmd(1), + new MatchAnyCmd(anyNumber)}); + EXPECT_TRUE(cmdBuffOk); + } - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchAnyCmd(atLeastOne), - new MatchAnyCmd(1)}); - EXPECT_FALSE(cmdBuffOk); + if constexpr (GfxFamilyWithSBA) { + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchAnyCmd(atLeastOne), + new MatchAnyCmd(1)}); + EXPECT_FALSE(cmdBuffOk); + } cmdBuffOk = expectCmdBuff(stream, 0, std::vector{ @@ -116,12 +123,14 @@ HWTEST_F(HwParseTest, WhenExpectingAnyCommandThenAllCommandsAreValidAsLongAsTheC new MatchAnyCmd(1)}); EXPECT_FALSE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchAnyCmd(1), - new MatchAnyCmd(1), - }); - EXPECT_FALSE(cmdBuffOk); + if constexpr (GfxFamilyWithSBA) { + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchAnyCmd(1), + new MatchAnyCmd(1), + }); + EXPECT_FALSE(cmdBuffOk); + } cmdBuffOk = expectCmdBuff(stream, 0, std::vector{ @@ -131,153 +140,168 @@ HWTEST_F(HwParseTest, WhenExpectingAnyCommandThenAllCommandsAreValidAsLongAsTheC HWTEST_F(HwParseTest, WhenExpectingSpecificSetOfCommandsThenNoOtherCommandBufferIsValid) { using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; bool cmdBuffOk = false; char buffer[8192]; LinearStream stream{alignUp(buffer, 4096), 4096}; + std::vector expectedCmdBuf; *stream.getSpaceForCmd() = FamilyType::cmdInitPipeControl; - *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchHwCmd(1)); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchHwCmd(1)); + } *stream.getSpaceForCmd() = FamilyType::cmdInitPipeControl; + expectedCmdBuf.push_back(new MatchHwCmd(1)); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1)}); + cmdBuffOk = expectCmdBuff(stream, 0, std::move(expectedCmdBuf)); EXPECT_TRUE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1)}); - EXPECT_FALSE(cmdBuffOk); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(1), + new MatchHwCmd(1), + new MatchHwCmd(1), + new MatchHwCmd(1)}); + EXPECT_FALSE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(1), - }); - EXPECT_FALSE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(1), + new MatchHwCmd(1), + }); + EXPECT_FALSE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1)}); - EXPECT_FALSE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(1), + new MatchHwCmd(1), + new MatchHwCmd(1), + new MatchHwCmd(1)}); + EXPECT_FALSE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1)}); - EXPECT_FALSE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(1), + new MatchHwCmd(1), + new MatchHwCmd(1)}); + EXPECT_FALSE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1)}); - EXPECT_FALSE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(1), + new MatchHwCmd(1), + new MatchHwCmd(1)}); + EXPECT_FALSE(cmdBuffOk); + } } HWTEST_F(HwParseTest, WhenExpectingAnyNumberOfCommandsThenOnlyTypeOfCommandMatters) { using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; bool cmdBuffOk = false; char buffer[8192]; LinearStream stream{alignUp(buffer, 4096), 4096}; + std::vector expectedCmdBuf; *stream.getSpaceForCmd() = FamilyType::cmdInitPipeControl; - *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; - *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; - *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; - *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchHwCmd(1)); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchHwCmd(1)); + *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchHwCmd(1)); + *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchHwCmd(1)); + *stream.getSpaceForCmd() = FamilyType::cmdInitStateBaseAddress; + expectedCmdBuf.push_back(new MatchHwCmd(1)); + } *stream.getSpaceForCmd() = FamilyType::cmdInitPipeControl; + expectedCmdBuf.push_back(new MatchHwCmd(1)); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1)}); + cmdBuffOk = expectCmdBuff(stream, 0, std::move(expectedCmdBuf)); EXPECT_TRUE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(1), - new MatchHwCmd(1)}); - EXPECT_FALSE(cmdBuffOk); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(1), + new MatchHwCmd(1), + new MatchHwCmd(1)}); + EXPECT_FALSE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(1), - new MatchHwCmd(anyNumber), - new MatchHwCmd(1)}); - EXPECT_TRUE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(1), + new MatchHwCmd(anyNumber), + new MatchHwCmd(1)}); + EXPECT_TRUE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(anyNumber), - new MatchHwCmd(anyNumber), - new MatchHwCmd(anyNumber)}); - EXPECT_TRUE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(anyNumber), + new MatchHwCmd(anyNumber), + new MatchHwCmd(anyNumber)}); + EXPECT_TRUE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(atLeastOne), - new MatchHwCmd(atLeastOne), - new MatchHwCmd(atLeastOne)}); - EXPECT_TRUE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(atLeastOne), + new MatchHwCmd(atLeastOne), + new MatchHwCmd(atLeastOne)}); + EXPECT_TRUE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(atLeastOne), - new MatchHwCmd(atLeastOne), - new MatchHwCmd(atLeastOne), - new MatchHwCmd(atLeastOne), - new MatchHwCmd(atLeastOne), - }); - EXPECT_FALSE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(atLeastOne), + new MatchHwCmd(atLeastOne), + new MatchHwCmd(atLeastOne), + new MatchHwCmd(atLeastOne), + new MatchHwCmd(atLeastOne), + }); + EXPECT_FALSE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(anyNumber), - new MatchHwCmd(0), - new MatchHwCmd(anyNumber), - new MatchHwCmd(anyNumber), - new MatchHwCmd(0)}); - EXPECT_TRUE(cmdBuffOk); + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(anyNumber), + new MatchHwCmd(0), + new MatchHwCmd(anyNumber), + new MatchHwCmd(anyNumber), + new MatchHwCmd(0)}); + EXPECT_TRUE(cmdBuffOk); + } } HWTEST_F(HwParseTest, WhenCommandMemberValidatorFailsThenCommandBufferValidationFails) { using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; - using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; bool cmdBuffOk = false; char buffer[8192]; LinearStream stream{alignUp(buffer, 4096), 4096}; + std::vector expectedCmdBuf; *stream.getSpaceForCmd() = FamilyType::cmdInitPipeControl; - auto sba = stream.getSpaceForCmd(); - *sba = FamilyType::cmdInitStateBaseAddress; - sba->setGeneralStateBaseAddressModifyEnable(true); + expectedCmdBuf.push_back(new MatchHwCmd(1)); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto sba = stream.getSpaceForCmd(); + *sba = FamilyType::cmdInitStateBaseAddress; + sba->setGeneralStateBaseAddressModifyEnable(true); + expectedCmdBuf.push_back(new MatchHwCmd(1, Expects{EXPECT_MEMBER(STATE_BASE_ADDRESS, getGeneralStateBaseAddressModifyEnable, true)})); + } *stream.getSpaceForCmd() = FamilyType::cmdInitPipeControl; + expectedCmdBuf.push_back(new MatchHwCmd(1)); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(anyNumber), - new MatchHwCmd(anyNumber, Expects{EXPECT_MEMBER(STATE_BASE_ADDRESS, getGeneralStateBaseAddressModifyEnable, true)}), - new MatchHwCmd(anyNumber)}); + cmdBuffOk = expectCmdBuff(stream, 0, std::move(expectedCmdBuf)); EXPECT_TRUE(cmdBuffOk); - cmdBuffOk = expectCmdBuff(stream, 0, - std::vector{ - new MatchHwCmd(anyNumber), - new MatchHwCmd(anyNumber, Expects{EXPECT_MEMBER(STATE_BASE_ADDRESS, getGeneralStateBaseAddressModifyEnable, false)}), - new MatchHwCmd(anyNumber)}); - EXPECT_FALSE(cmdBuffOk); + if constexpr (GfxFamilyWithSBA) { + using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + cmdBuffOk = expectCmdBuff(stream, 0, + std::vector{ + new MatchHwCmd(anyNumber), + new MatchHwCmd(anyNumber, Expects{EXPECT_MEMBER(STATE_BASE_ADDRESS, getGeneralStateBaseAddressModifyEnable, false)}), + new MatchHwCmd(anyNumber)}); + EXPECT_FALSE(cmdBuffOk); + } } diff --git a/shared/test/unit_test/helpers/state_base_address_tests.cpp b/shared/test/unit_test/helpers/state_base_address_tests.cpp index d815a522c5..ed1026bca4 100644 --- a/shared/test/unit_test/helpers/state_base_address_tests.cpp +++ b/shared/test/unit_test/helpers/state_base_address_tests.cpp @@ -18,6 +18,11 @@ #include "encode_surface_state_args.h" +using namespace NEO; + +#include "shared/test/common/test_macros/header/heapful_test_definitions.h" +#include "shared/test/common/test_macros/header/heapless_matchers.h" + HWTEST2_F(SbaTest, WhenAppendStateBaseAddressParametersIsCalledThenSBACmdHasBindingSurfaceStateProgrammed, IsGen12LP) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; @@ -35,7 +40,7 @@ HWTEST2_F(SbaTest, WhenAppendStateBaseAddressParametersIsCalledThenSBACmdHasBind EXPECT_TRUE(stateBaseAddress.getBindlessSurfaceStateBaseAddressModifyEnable()); } -HWTEST2_F(SbaTest, WhenProgramStateBaseAddressParametersIsCalledThenSBACmdHasBindingSurfaceStateProgrammed, MatchAny) { +HWTEST2_F(SbaTest, WhenProgramStateBaseAddressParametersIsCalledThenSBACmdHasBindingSurfaceStateProgrammed, IsSbaRequired) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; STATE_BASE_ADDRESS stateBaseAddress; @@ -59,7 +64,7 @@ HWTEST2_F(SbaTest, WhenProgramStateBaseAddressParametersIsCalledThenSBACmdHasBin } HWTEST2_F(SbaTest, - givenProgramSurfaceStateBaseAddressUsingHeapBaseWhenOverrideSurfaceStateBaseAddressUsedThenSbaDispatchedWithOverrideValue, MatchAny) { + givenProgramSurfaceStateBaseAddressUsingHeapBaseWhenOverrideSurfaceStateBaseAddressUsedThenSbaDispatchedWithOverrideValue, IsSbaRequired) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; constexpr uint64_t surfaceStateBaseAddress = 0xBADA550000; @@ -78,7 +83,7 @@ HWTEST2_F(SbaTest, using SbaForBindlessTests = SbaTest; -HWTEST2_F(SbaForBindlessTests, givenGlobalBindlessBaseAddressWhenProgramStateBaseAddressThenSbaProgrammedCorrectly, MatchAny) { +HWTEST2_F(SbaForBindlessTests, givenGlobalBindlessBaseAddressWhenProgramStateBaseAddressThenSbaProgrammedCorrectly, IsSbaRequired) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; constexpr uint64_t globalBindlessHeapsBaseAddress = 0x12340000; @@ -113,7 +118,7 @@ HWTEST2_F(SbaForBindlessTests, givenGlobalBindlessBaseAddressWhenProgramStateBas } HWTEST2_F(SbaForBindlessTests, - givenGlobalBindlessBaseAddressOverriddenSurfaceStateBaseAddressWhenProgramStateBaseAddressThenSbaProgrammedCorrectly, MatchAny) { + givenGlobalBindlessBaseAddressOverridenSurfaceStateBaseAddressWhenProgramStateBaseAddressThenSbaProgrammedCorrectly, IsSbaRequired) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; constexpr uint64_t globalBindlessHeapsBaseAddress = 0x12340000; @@ -170,7 +175,7 @@ HWTEST2_F(SbaForBindlessTests, givenGlobalBindlessBaseAddressWhenPassingIndirect EXPECT_EQ(cmd->getIndirectObjectBaseAddress(), indirectObjectBaseAddress); } -HWTEST2_F(SbaTest, givenSbaWhenOverrideBindlessSurfaceBaseIsFalseThenBindlessSurfaceBaseIsNotSet, MatchAny) { +HWTEST2_F(SbaTest, givenSbaWhenOverrideBindlessSurfaceBaseIsFalseThenBindlessSurfaceBaseIsNotSet, IsSbaRequired) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; STATE_BASE_ADDRESS stateBaseAddress; @@ -186,7 +191,7 @@ HWTEST2_F(SbaTest, givenSbaWhenOverrideBindlessSurfaceBaseIsFalseThenBindlessSur EXPECT_EQ(0u, stateBaseAddress.getBindlessSurfaceStateBaseAddress()); } -HWTEST2_F(SbaTest, givenGlobalBindlessBaseAddressWhenSshIsPassedThenBindlessSurfaceBaseIsGlobalHeapBase, MatchAny) { +HWTEST2_F(SbaTest, givenGlobalBindlessBaseAddressWhenSshIsPassedThenBindlessSurfaceBaseIsGlobalHeapBase, IsSbaRequired) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; constexpr uint64_t globalBindlessHeapsBaseAddress = 0x12340000; @@ -203,7 +208,7 @@ HWTEST2_F(SbaTest, givenGlobalBindlessBaseAddressWhenSshIsPassedThenBindlessSurf EXPECT_EQ(cmd->getBindlessSurfaceStateBaseAddress(), globalBindlessHeapsBaseAddress); } -HWTEST2_F(SbaTest, givenSurfaceStateHeapWhenNotUsingGlobalHeapBaseThenBindlessSurfaceBaseIsSshBase, MatchAny) { +HWTEST2_F(SbaTest, givenSurfaceStateHeapWhenNotUsingGlobalHeapBaseThenBindlessSurfaceBaseIsSshBase, IsSbaRequired) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; constexpr uint64_t globalBindlessHeapsBaseAddress = 0x12340000; @@ -220,7 +225,7 @@ HWTEST2_F(SbaTest, givenSurfaceStateHeapWhenNotUsingGlobalHeapBaseThenBindlessSu EXPECT_EQ(ssh.getHeapGpuBase(), cmd->getBindlessSurfaceStateBaseAddress()); } -HWTEST2_F(SbaTest, givenNotUsedGlobalHeapBaseAndSshPassedWhenBindlessSurfStateBaseIsPassedThenBindlessSurfaceBaseIsSetToPassedValue, MatchAny) { +HWTEST2_F(SbaTest, givenNotUsedGlobalHeapBaseAndSshPassedWhenBindlessSurfStateBaseIsPassedThenBindlessSurfaceBaseIsSetToPassedValue, IsSbaRequired) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; constexpr uint64_t globalBindlessHeapsBaseAddress = 0x12340000; @@ -259,7 +264,7 @@ HWTEST2_F(SbaTest, givenStateBaseAddressAndDebugFlagSetWhenAppendExtraCacheSetti EXPECT_EQ(0, memcmp(&stateBaseAddress, &expectedStateBaseAddress, sizeof(STATE_BASE_ADDRESS))); } -HWTEST2_F(SbaTest, givenStateBaseAddressAndDebugFlagSetWhenAppendExtraCacheSettingsThenProgramCorrectL1CachePolicy, IsAtLeastXeCore) { +HWTEST2_F(SbaTest, givenStateBaseAddressAndDebugFlagSetWhenAppendExtraCacheSettingsThenProgramCorrectL1CachePolicy, IsSbaRequiredAndAtLeastXeCore) { auto stateBaseAddress = FamilyType::cmdInitStateBaseAddress; StateBaseAddressHelperArgs args = createSbaHelperArgs(&stateBaseAddress, pDevice->getGmmHelper(), &ssh, nullptr, nullptr); @@ -329,7 +334,7 @@ HWTEST2_F(SbaTest, givenStateBaseAddressAndDebugFlagSetWhenAppendExtraCacheSetti } } -HWTEST2_F(SbaTest, givenDebugFlagSetWhenAppendingSbaThenProgramCorrectL1CachePolicy, IsAtLeastXeCore) { +HWTEST2_F(SbaTest, givenDebugFlagSetWhenAppendingSbaThenProgramCorrectL1CachePolicy, IsSbaRequiredAndAtLeastXeCore) { auto sbaCmd = FamilyType::cmdInitStateBaseAddress; struct { @@ -363,7 +368,7 @@ HWTEST2_F(SbaTest, givenDebugFlagSetWhenAppendingSbaThenProgramCorrectL1CachePol } } -HWTEST2_F(SbaTest, givenDebugFlagSetWhenAppendingRssThenProgramCorrectL1CachePolicy, IsAtLeastXeCore) { +HWTEST2_F(SbaTest, givenDebugFlagSetWhenAppendingRssThenProgramCorrectL1CachePolicy, IsSbaRequiredAndAtLeastXeCore) { auto memoryManager = pDevice->getExecutionEnvironment()->memoryManager.get(); size_t allocationSize = MemoryConstants::pageSize; AllocationProperties properties(pDevice->getRootDeviceIndex(), allocationSize, AllocationType::buffer, pDevice->getDeviceBitfield()); @@ -420,7 +425,7 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, SbaTest, whenGeneralStateBaseAddressIsProgrammedT EXPECT_EQ(gmmHelper->decanonize(generalStateBaseAddress), sbaCmd.getGeneralStateBaseAddress()); } -HWTEST_F(SbaTest, givenNonZeroGeneralStateBaseAddressWhenProgrammingIsDisabledThenExpectCommandValueZero) { +SBA_HWTEST_F(SbaTest, givenNonZeroGeneralStateBaseAddressWhenProgrammingIsDisabledThenExpectCommandValueZero) { constexpr uint64_t generalStateBaseAddress = 0x80010000ull; typename FamilyType::STATE_BASE_ADDRESS sbaCmd; @@ -437,7 +442,7 @@ HWTEST_F(SbaTest, givenNonZeroGeneralStateBaseAddressWhenProgrammingIsDisabledTh EXPECT_FALSE(sbaCmd.getGeneralStateBufferSizeModifyEnable()); } -HWTEST_F(SbaTest, givenNonZeroInternalHeapBaseAddressWhenProgrammingIsDisabledThenExpectCommandValueZero) { +SBA_HWTEST_F(SbaTest, givenNonZeroInternalHeapBaseAddressWhenProgrammingIsDisabledThenExpectCommandValueZero) { constexpr uint64_t internalHeapBaseAddress = 0x80010000ull; typename FamilyType::STATE_BASE_ADDRESS sbaCmd; @@ -497,9 +502,13 @@ HWCMDTEST_F(IGFX_GEN12LP_CORE, SbaTest, givenSbaProgrammingWhenHeapsAreNotProvid EXPECT_EQ(0xfffffu, sbaCmd.getGeneralStateBufferSize()); } -HWCMDTEST_F(IGFX_XE_HP_CORE, SbaTest, - givenNoHeapsProvidedWhenSBAIsProgrammedThenBaseAddressesAreNotSetAndBindlessSurfaceStateSizeSetToMax) { +HEAPFUL_HWTEST_F(SbaTest, + givenNoHeapsProvidedWhenSBAIsProgrammedThenBaseAddressesAreNotSetAndBindlessSurfaceStateSizeSetToMax) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto shouldBeTested = FamilyType::supportsCmdSet(IGFX_XE_HP_CORE); + if (shouldBeTested == false) { + GTEST_SKIP(); + } auto gmmHelper = pDevice->getGmmHelper(); @@ -545,9 +554,13 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, SbaTest, EXPECT_EQ(defaultBindlessSurfaceStateSize, sbaCmd.getBindlessSurfaceStateSize()); } -HWCMDTEST_F(IGFX_XE_HP_CORE, SbaTest, - givenNoHeapsProvidedAndBindlessBaseSetWhenSBAIsProgrammedThenBindlessSurfaceStateSizeSetToZeroAndBaseAddressSetToPassedValue) { +HEAPFUL_HWTEST_F(SbaTest, + givenNoHeapsProvidedAndBindlessBaseSetWhenSBAIsProgrammedThenBindlessSurfaceStateSizeSetToZeroAndBaseAddressSetToPassedValue) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; + auto shouldBeTested = FamilyType::supportsCmdSet(IGFX_XE_HP_CORE); + if (shouldBeTested == false) { + GTEST_SKIP(); + } auto gmmHelper = pDevice->getGmmHelper(); @@ -594,12 +607,12 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, SbaTest, EXPECT_EQ(surfaceStateCount, sbaCmd.getBindlessSurfaceStateSize()); } -HWTEST2_F(SbaTest, GivenPlatformNotSupportingIndirectHeapBaseWhenProgramIndirectHeapThenNothingHappens, IsAtLeastXeCore) { +HWTEST2_F(SbaTest, GivenPlatformNotSupportingIndirectHeapBaseWhenProgramIndirectHeapThenNothingHappens, IsSbaRequiredAndAtLeastXeCore) { StateBaseAddressHelperArgs args = createSbaHelperArgs(nullptr, nullptr); StateBaseAddressHelper::appendIohParameters(args); } -HWTEST_F(SbaTest, givenStateBaseAddressPropertiesWhenSettingDynamicStateSurfaceStateMocsPropertiesThenCommandDispatchedCorrectly) { +SBA_HWTEST_F(SbaTest, givenStateBaseAddressPropertiesWhenSettingDynamicStateSurfaceStateMocsPropertiesThenCommandDispatchedCorrectly) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; DebugManagerStateRestore restore; @@ -682,9 +695,9 @@ HWTEST2_F(SbaTest, givenStateBaseAddressPropertiesWhenSettingIndirectStateProper EXPECT_EQ(indirectHeapSize, sbaCmd.getIndirectObjectBufferSize()); } -using GlobalBaseAddressPlatforms = IsAtLeastXeCore; +using GlobalBaseAddressPlatforms = IsSbaRequiredAndAtLeastXeCore; -using BindlessSurfaceAddressPlatforms = MatchAny; +using BindlessSurfaceAddressPlatforms = IsSbaRequired; HWTEST2_F(SbaTest, givenStateBaseAddressPropertiesWhenSettingBindlessSurfaceStatePropertyThenCommandDispatchedCorrectlyBindlessBaseAddress, BindlessSurfaceAddressPlatforms) { using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS; diff --git a/shared/test/unit_test/os_interface/product_helper_tests.cpp b/shared/test/unit_test/os_interface/product_helper_tests.cpp index cd33da614d..1c0ac2359c 100644 --- a/shared/test/unit_test/os_interface/product_helper_tests.cpp +++ b/shared/test/unit_test/os_interface/product_helper_tests.cpp @@ -43,6 +43,7 @@ extern ApiSpecificConfig::ApiType apiTypeForUlts; } using namespace NEO; +#include "shared/test/common/test_macros/header/heapless_matchers.h" ProductHelperTest::ProductHelperTest() { executionEnvironment = std::make_unique(); @@ -709,33 +710,51 @@ HWTEST2_F(ProductHelperTest, givenProductHelperWhenIsImplicitScalingSupportedThe EXPECT_FALSE(productHelper->isImplicitScalingSupported(*defaultHwInfo)); } +template +struct CacheControlStructHelper; + +template + requires GfxFamilyWithSBA +struct CacheControlStructHelper { + using type = typename GfxFamily::STATE_BASE_ADDRESS; +}; + +template + requires(!GfxFamilyWithSBA) +struct CacheControlStructHelper { + using type = typename GfxFamily::RENDER_SURFACE_STATE; +}; + HWTEST2_F(ProductHelperTest, givenProductHelperAndDebugFlagWhenGetL1CachePolicyThenReturnCorrectPolicy, IsAtLeastXeCore) { DebugManagerStateRestore restorer; + using CacheControlType = typename CacheControlStructHelper::type; + debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(0); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(false)); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(true)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(false)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(true)); debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(2); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB, productHelper->getL1CachePolicy(false)); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WB, productHelper->getL1CachePolicy(true)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WB, productHelper->getL1CachePolicy(false)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WB, productHelper->getL1CachePolicy(true)); debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(3); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WT, productHelper->getL1CachePolicy(false)); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WT, productHelper->getL1CachePolicy(true)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WT, productHelper->getL1CachePolicy(false)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WT, productHelper->getL1CachePolicy(true)); debugManager.flags.OverrideL1CachePolicyInSurfaceStateAndStateless.set(4); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WS, productHelper->getL1CachePolicy(false)); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WS, productHelper->getL1CachePolicy(true)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WS, productHelper->getL1CachePolicy(false)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WS, productHelper->getL1CachePolicy(true)); debugManager.flags.ForceAllResourcesUncached.set(true); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC, productHelper->getL1CachePolicy(false)); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_UC, productHelper->getL1CachePolicy(true)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_UC, productHelper->getL1CachePolicy(false)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_UC, productHelper->getL1CachePolicy(true)); } -HWTEST2_F(ProductHelperTest, givenProductHelperWhenGetL1CachePolicyThenReturnWriteByPass, IsAtLeastXeCore) { - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(false)); - EXPECT_EQ(FamilyType::STATE_BASE_ADDRESS::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(true)); +HWTEST2_F(ProductHelperTest, givenProductHelperWhenGetL1CachePolicyThenReturnWriteByPass, IsSbaRequiredAndAtLeastXeCore) { + using CacheControlType = typename CacheControlStructHelper::type; + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(false)); + EXPECT_EQ(CacheControlType::L1_CACHE_CONTROL_WBP, productHelper->getL1CachePolicy(true)); } HWTEST2_F(ProductHelperTest, givenPlatformWithUnsupportedL1CachePoliciesWhenGetL1CachePolicyThenReturnZero, IsGen12LP) { diff --git a/shared/test/unit_test/xe_hpc_core/pvc/compiler_product_helper_tests_pvc.cpp b/shared/test/unit_test/xe_hpc_core/pvc/compiler_product_helper_tests_pvc.cpp index 5a950c4ecb..8a7f11b306 100644 --- a/shared/test/unit_test/xe_hpc_core/pvc/compiler_product_helper_tests_pvc.cpp +++ b/shared/test/unit_test/xe_hpc_core/pvc/compiler_product_helper_tests_pvc.cpp @@ -80,4 +80,4 @@ PVCTEST_F(CompilerProductHelperPvcTest, givenPvcB0AndLaterThenMatrixMultiplyAccu hwInfo.platform.usRevId = productHelper.getHwRevIdFromStepping(REVISION_C, hwInfo); EXPECT_FALSE(compilerProductHelper.isMatrixMultiplyAccumulateTF32Supported(hwInfo)); } -} +} \ No newline at end of file diff --git a/shared/test/unit_test/xe_hpg_core/dg2/excludes_xe_hpg_core_dg2.cpp b/shared/test/unit_test/xe_hpg_core/dg2/excludes_xe_hpg_core_dg2.cpp index e23fcd5622..ba25c4e5bd 100644 --- a/shared/test/unit_test/xe_hpg_core/dg2/excludes_xe_hpg_core_dg2.cpp +++ b/shared/test/unit_test/xe_hpg_core/dg2/excludes_xe_hpg_core_dg2.cpp @@ -13,12 +13,12 @@ HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenAskedForDefaultE HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenAskedIfTile64With3DSurfaceOnBCSIsSupportedThenTrueIsReturned, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenAskedIfStorageInfoAdjustmentIsRequiredThenFalseIsReturned, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(CompilerProductHelperFixture, givenAtLeastXeHpgCoreWhenGetCachingPolicyOptionsThenReturnWriteByPassPolicyOption_IsAtLeastXeCore, IGFX_DG2); -HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenGetL1CachePolicyThenReturnWriteByPass_IsAtLeastXeCore, IGFX_DG2); +HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenGetL1CachePolicyThenReturnWriteByPass_IsSbaRequiredAndAtLeastXeCore, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenAtLeastXeHpgCoreWhenGetL1CachePolicyThenReturnCorrectValue_IsAtLeastXeCore, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(CommandEncodeStatesTest, givenSlmTotalSizeEqualZeroWhenDispatchingKernelThenSharedMemorySizeIsSetCorrectly, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(MemoryManagerTests, givenEnabledLocalMemoryWhenLinearStreamIsAllocatedInDevicePoolThenLocalMemoryPoolIsUsed, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(MemoryManagerTests, givenEnabledLocalMemoryWhenAllocateKernelIsaInDevicePoolThenLocalMemoryPoolIsUsed, IGFX_DG2); -HWTEST_EXCLUDE_PRODUCT(SbaTest, givenStateBaseAddressAndDebugFlagSetWhenAppendExtraCacheSettingsThenProgramCorrectL1CachePolicy_IsAtLeastXeCore, IGFX_DG2); +HWTEST_EXCLUDE_PRODUCT(SbaTest, givenStateBaseAddressAndDebugFlagSetWhenAppendExtraCacheSettingsThenProgramCorrectL1CachePolicy_IsSbaRequiredAndAtLeastXeCore, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(XeHpgSbaTest, givenSpecificProductFamilyWhenAppendingSbaThenProgramWBPL1CachePolicy, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(GfxCoreHelperTest, GivenZeroSlmSizeWhenComputeSlmSizeIsCalledThenCorrectValueIsReturned_IsHeapfulRequired, IGFX_DG2); HWTEST_EXCLUDE_PRODUCT(ProductHelperCommonTest, givenHwHelperWhenIsFusedEuDisabledForDpasCalledThenFalseReturned, IGFX_DG2);