From 57d35c89321cd87e2f992bd0b0d42120f1fc1333 Mon Sep 17 00:00:00 2001 From: Zbigniew Zdanowicz Date: Tue, 20 Sep 2022 16:46:15 +0000 Subject: [PATCH] Add state compute mode tracking Related-To: NEO-5019 Signed-off-by: Zbigniew Zdanowicz --- level_zero/core/source/cmdlist/cmdlist.h | 1 + level_zero/core/source/cmdlist/cmdlist_hw.inl | 9 +- .../core/source/cmdlist/cmdlist_imp.cpp | 1 + level_zero/core/source/cmdqueue/cmdqueue.cpp | 1 + level_zero/core/source/cmdqueue/cmdqueue.h | 1 + level_zero/core/source/cmdqueue/cmdqueue_hw.h | 9 + .../core/source/cmdqueue/cmdqueue_hw.inl | 53 +- .../core/source/hw_helpers/l0_hw_helper.cpp | 8 + .../core/source/hw_helpers/l0_hw_helper.h | 1 + .../unit_tests/fixtures/cmdlist_fixture.cpp | 5 + .../unit_tests/fixtures/cmdlist_fixture.h | 16 + .../unit_tests/fixtures/cmdlist_fixture.inl | 527 ++++++++++++++++++ .../core/test/unit_tests/mocks/mock_cmdlist.h | 3 + .../test/unit_tests/mocks/mock_cmdqueue.h | 2 + .../test_cmdqueue_enqueue_cmdlist_2.cpp | 16 + .../debug_settings/debug_variables_base.inl | 2 +- shared/test/common/test_files/igdrcl.config | 1 + 17 files changed, 652 insertions(+), 4 deletions(-) diff --git a/level_zero/core/source/cmdlist/cmdlist.h b/level_zero/core/source/cmdlist/cmdlist.h index 3eacaf7f9a..4db49bed2f 100644 --- a/level_zero/core/source/cmdlist/cmdlist.h +++ b/level_zero/core/source/cmdlist/cmdlist.h @@ -323,6 +323,7 @@ struct CommandList : _ze_command_list_handle_t { bool multiReturnPointCommandList = false; bool systolicModeSupport = false; bool pipelineSelectStateTracking = false; + bool stateComputeModeTracking = false; std::atomic barrierCounter{0u}; uint32_t latestFlushedBarrierCounter = 0u; diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.inl b/level_zero/core/source/cmdlist/cmdlist_hw.inl index a634618f0c..2e94d369dc 100644 --- a/level_zero/core/source/cmdlist/cmdlist_hw.inl +++ b/level_zero/core/source/cmdlist/cmdlist_hw.inl @@ -2320,8 +2320,13 @@ void CommandListCoreFamily::updateStreamProperties(Kernel &kernel if (!containsAnyKernel) { requiredStreamState.frontEndState.setProperties(isCooperative, kernelAttributes.flags.requiresDisabledEUFusion, true, -1, hwInfo); requiredStreamState.pipelineSelect.setProperties(true, false, kernelAttributes.flags.usesSystolicPipelineSelectMode, hwInfo); - finalStreamState = requiredStreamState; - requiredStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernelAttributes.threadArbitrationPolicy, device->getDevicePreemptionMode(), hwInfo); + if (this->stateComputeModeTracking) { + requiredStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernelAttributes.threadArbitrationPolicy, device->getDevicePreemptionMode(), hwInfo); + finalStreamState = requiredStreamState; + } else { + finalStreamState = requiredStreamState; + requiredStreamState.stateComputeMode.setProperties(false, kernelAttributes.numGrfRequired, kernelAttributes.threadArbitrationPolicy, device->getDevicePreemptionMode(), hwInfo); + } containsAnyKernel = true; } diff --git a/level_zero/core/source/cmdlist/cmdlist_imp.cpp b/level_zero/core/source/cmdlist/cmdlist_imp.cpp index 656a843687..02fe1dd806 100644 --- a/level_zero/core/source/cmdlist/cmdlist_imp.cpp +++ b/level_zero/core/source/cmdlist/cmdlist_imp.cpp @@ -29,6 +29,7 @@ namespace L0 { CommandList::CommandList(uint32_t numIddsPerBlock) : commandContainer(numIddsPerBlock) { multiReturnPointCommandList = L0HwHelper::enableMultiReturnPointCommandList(); pipelineSelectStateTracking = L0HwHelper::enablePipelineSelectStateTracking(); + stateComputeModeTracking = L0HwHelper::enableStateComputeModeTracking(); } CommandListAllocatorFn commandListFactory[IGFX_MAX_PRODUCT] = {}; diff --git a/level_zero/core/source/cmdqueue/cmdqueue.cpp b/level_zero/core/source/cmdqueue/cmdqueue.cpp index 8cb9bbfe0c..59203918b6 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue.cpp +++ b/level_zero/core/source/cmdqueue/cmdqueue.cpp @@ -46,6 +46,7 @@ CommandQueueImp::CommandQueueImp(Device *device, NEO::CommandStreamReceiver *csr multiReturnPointCommandList = L0HwHelper::enableMultiReturnPointCommandList(); pipelineSelectStateTracking = L0HwHelper::enablePipelineSelectStateTracking(); + stateComputeModeTracking = L0HwHelper::enableStateComputeModeTracking(); } ze_result_t CommandQueueImp::destroy() { diff --git a/level_zero/core/source/cmdqueue/cmdqueue.h b/level_zero/core/source/cmdqueue/cmdqueue.h index 78c89c7ce8..a898682ea4 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue.h +++ b/level_zero/core/source/cmdqueue/cmdqueue.h @@ -69,6 +69,7 @@ struct CommandQueue : _ze_command_queue_handle_t { bool internalUsage = false; bool multiReturnPointCommandList = false; bool pipelineSelectStateTracking = false; + bool stateComputeModeTracking = false; }; using CommandQueueAllocatorFn = CommandQueue *(*)(Device *device, NEO::CommandStreamReceiver *csr, diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw.h b/level_zero/core/source/cmdqueue/cmdqueue_hw.h index 1c3649c3c0..f041fd438f 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_hw.h +++ b/level_zero/core/source/cmdqueue/cmdqueue_hw.h @@ -181,6 +181,15 @@ struct CommandQueueHw : public CommandQueueImp { const NEO::StreamProperties &cmdListRequired, const NEO::StreamProperties &cmdListFinal); + inline size_t estimateScmCmdSizeForMultipleCommandLists(NEO::StreamProperties &csrStateCopy, + const NEO::StreamProperties &cmdListRequired, + const NEO::StreamProperties &cmdListFinal); + inline void programRequiredStateComputeModeForCommandList(CommandList *commandList, + NEO::LinearStream &commandStream, + NEO::StreamProperties &csrState, + const NEO::StreamProperties &cmdListRequired, + const NEO::StreamProperties &cmdListFinal); + size_t alignedChildStreamPadding{}; }; diff --git a/level_zero/core/source/cmdqueue/cmdqueue_hw.inl b/level_zero/core/source/cmdqueue/cmdqueue_hw.inl index c0549b01ff..b26537c273 100644 --- a/level_zero/core/source/cmdqueue/cmdqueue_hw.inl +++ b/level_zero/core/source/cmdqueue/cmdqueue_hw.inl @@ -182,8 +182,10 @@ ze_result_t CommandQueueHw::executeCommandListsRegular( auto &finalStreamState = commandList->getFinalStreamState(); this->updateOneCmdListPreemptionModeAndCtxStatePreemption(ctx, commandList->getCommandListPreemptionMode(), child); + this->programOneCmdListPipelineSelect(commandList, child, csrStateProperties, requiredStreamState, finalStreamState); this->programOneCmdListFrontEndIfDirty(ctx, child, csrStateProperties, requiredStreamState, finalStreamState); + this->programRequiredStateComputeModeForCommandList(commandList, child, csrStateProperties, requiredStreamState, finalStreamState); this->patchCommands(*commandList, this->csr->getScratchSpaceController()->getScratchPatchAddress()); this->programOneCmdListBatchBufferStart(commandList, child, ctx); @@ -655,7 +657,7 @@ size_t CommandQueueHw::estimateLinearStreamSizeComplementary( linearStreamSizeEstimate += estimateFrontEndCmdSize(ctx.frontEndStateDirty); linearStreamSizeEstimate += estimatePipelineSelectCmdSize(); - if (this->pipelineSelectStateTracking || frontEndTrackingEnabled()) { + if (this->stateComputeModeTracking || this->pipelineSelectStateTracking || frontEndTrackingEnabled()) { bool frontEndStateDirtyCopy = ctx.frontEndStateDirty; auto streamPropertiesCopy = csr->getStreamProperties(); bool gpgpuEnabledCopy = csr->getPreambleSetFlag(); @@ -667,6 +669,7 @@ size_t CommandQueueHw::estimateLinearStreamSizeComplementary( linearStreamSizeEstimate += estimateFrontEndCmdSizeForMultipleCommandLists(frontEndStateDirtyCopy, ctx.engineInstanced, cmdList, streamPropertiesCopy, requiredStreamState, finalStreamState); linearStreamSizeEstimate += estimatePipelineSelectCmdSizeForMultipleCommandLists(streamPropertiesCopy, requiredStreamState, finalStreamState, gpgpuEnabledCopy); + linearStreamSizeEstimate += estimateScmCmdSizeForMultipleCommandLists(streamPropertiesCopy, requiredStreamState, finalStreamState); } } @@ -1174,6 +1177,54 @@ void CommandQueueHw::programOneCmdListPipelineSelect(CommandList csrState.pipelineSelect.setProperties(cmdListFinal.pipelineSelect); } +template +size_t CommandQueueHw::estimateScmCmdSizeForMultipleCommandLists(NEO::StreamProperties &csrStateCopy, + const NEO::StreamProperties &cmdListRequired, + const NEO::StreamProperties &cmdListFinal) { + if (!this->stateComputeModeTracking) { + return 0; + } + + size_t estimatedSize = 0; + + bool isRcs = this->getCsr()->isRcs(); + size_t singleScmCmdSize = NEO::EncodeComputeMode::getCmdSizeForComputeMode(device->getHwInfo(), false, isRcs); + + csrStateCopy.stateComputeMode.setProperties(cmdListRequired.stateComputeMode); + if (csrStateCopy.stateComputeMode.isDirty()) { + estimatedSize += singleScmCmdSize; + } + csrStateCopy.stateComputeMode.setProperties(cmdListFinal.stateComputeMode); + + return estimatedSize; +} + +template +void CommandQueueHw::programRequiredStateComputeModeForCommandList(CommandList *commandList, + NEO::LinearStream &commandStream, + NEO::StreamProperties &csrState, + const NEO::StreamProperties &cmdListRequired, + const NEO::StreamProperties &cmdListFinal) { + if (!this->stateComputeModeTracking) { + return; + } + + csrState.stateComputeMode.setProperties(cmdListRequired.stateComputeMode); + + if (csrState.stateComputeMode.isDirty()) { + NEO::PipelineSelectArgs pipelineSelectArgs = { + !!csrState.pipelineSelect.systolicMode.value, + false, + false, + commandList->getSystolicModeSupport()}; + + bool isRcs = this->getCsr()->isRcs(); + NEO::EncodeComputeMode::programComputeModeCommandWithSynchronization(commandStream, csrState.stateComputeMode, pipelineSelectArgs, + false, device->getHwInfo(), isRcs, nullptr); + } + csrState.stateComputeMode.setProperties(cmdListFinal.stateComputeMode); +} + template bool CommandQueueHw::isCleanLeftoverMemoryRequired() { return false; diff --git a/level_zero/core/source/hw_helpers/l0_hw_helper.cpp b/level_zero/core/source/hw_helpers/l0_hw_helper.cpp index 8ad2c929e8..e6dae60098 100644 --- a/level_zero/core/source/hw_helpers/l0_hw_helper.cpp +++ b/level_zero/core/source/hw_helpers/l0_hw_helper.cpp @@ -31,4 +31,12 @@ bool L0HwHelper::enablePipelineSelectStateTracking() { return defaultValue; } +bool L0HwHelper::enableStateComputeModeTracking() { + constexpr bool defaultValue = false; + if (NEO::DebugManager.flags.EnableStateComputeModeTracking.get() != -1) { + return !!NEO::DebugManager.flags.EnableStateComputeModeTracking.get(); + } + return defaultValue; +} + } // namespace L0 diff --git a/level_zero/core/source/hw_helpers/l0_hw_helper.h b/level_zero/core/source/hw_helpers/l0_hw_helper.h index 76aaec6f2e..db7ab8de22 100644 --- a/level_zero/core/source/hw_helpers/l0_hw_helper.h +++ b/level_zero/core/source/hw_helpers/l0_hw_helper.h @@ -32,6 +32,7 @@ class L0HwHelper { static L0HwHelper &get(GFXCORE_FAMILY gfxCore); static bool enableMultiReturnPointCommandList(); static bool enablePipelineSelectStateTracking(); + static bool enableStateComputeModeTracking(); virtual void setAdditionalGroupProperty(ze_command_queue_group_properties_t &groupProperty, NEO::EngineGroupT &group) const = 0; virtual L0::Event *createEvent(L0::EventPool *eventPool, const ze_event_desc_t *desc, L0::Device *device) const = 0; diff --git a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp index 3d9881c42c..f666c5879e 100644 --- a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp +++ b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.cpp @@ -126,5 +126,10 @@ void CmdListPipelineSelectStateFixture::setUp() { ModuleMutableCommandListFixture::setUp(); } +void CmdListStateComputeModeStateFixture::setUp() { + DebugManager.flags.EnableStateComputeModeTracking.set(1); + ModuleMutableCommandListFixture::setUp(); +} + } // namespace ult } // namespace L0 diff --git a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h index 3e66cef892..c5a23a913b 100644 --- a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h +++ b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.h @@ -101,5 +101,21 @@ struct CmdListPipelineSelectStateFixture : public ModuleMutableCommandListFixtur DebugManagerStateRestore restorer; }; +struct CmdListStateComputeModeStateFixture : public ModuleMutableCommandListFixture { + void setUp(); + + DebugManagerStateRestore restorer; +}; + +struct CmdListThreadArbitrationFixture : public CmdListStateComputeModeStateFixture { + template + void testBody(); +}; + +struct CmdListLargeGrfFixture : public CmdListStateComputeModeStateFixture { + template + void testBody(); +}; + } // namespace ult } // namespace L0 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 214f2c3dbc..0213a13ff1 100644 --- a/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl +++ b/level_zero/core/test/unit_tests/fixtures/cmdlist_fixture.inl @@ -5,6 +5,8 @@ * */ +#include "shared/source/command_stream/thread_arbitration_policy.h" +#include "shared/source/kernel/grf_config.h" #include "shared/test/common/helpers/unit_test_helper.h" #include "shared/test/common/libult/ult_command_stream_receiver.h" @@ -576,5 +578,530 @@ void CmdListPipelineSelectStateFixture::testBodyShareStateImmediateRegular() { EXPECT_EQ(0u, pipelineSelectList.size()); } +template +void CmdListThreadArbitrationFixture::testBody() { + using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE; + using EU_THREAD_SCHEDULING_MODE_OVERRIDE = typename STATE_COMPUTE_MODE::EU_THREAD_SCHEDULING_MODE_OVERRIDE; + + const ze_group_count_t groupCount{1, 1, 1}; + CmdListKernelLaunchParams launchParams = {}; + + void *currentBuffer = nullptr; + + auto &cmdlistRequiredState = commandList->getRequiredStreamState(); + auto &cmdListFinalState = commandList->getFinalStreamState(); + auto &csrState = commandQueue->csr->getStreamProperties(); + + auto commandListHandle = commandList->toHandle(); + + auto &commandListStream = *commandList->commandContainer.getCommandStream(); + auto &cmdQueueStream = commandQueue->commandStream; + + GenCmdList cmdList; + std::vector stateComputeModeList; + size_t sizeBefore = 0; + size_t sizeAfter = 0; + auto result = ZE_RESULT_SUCCESS; + + { + mockKernelImmData->kernelDescriptor->kernelAttributes.threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::AgeBased; + + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::AgeBased, cmdlistRequiredState.stateComputeMode.threadArbitrationPolicy.value); + EXPECT_EQ(NEO::ThreadArbitrationPolicy::AgeBased, cmdListFinalState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->close(); + + sizeBefore = cmdQueueStream.getUsed(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = cmdQueueStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::AgeBased, csrState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(cmdQueueStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + auto stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_EQ(EU_THREAD_SCHEDULING_MODE_OVERRIDE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST, stateComputeModeCmd->getEuThreadSchedulingModeOverride()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->reset(); + } + + { + mockKernelImmData->kernelDescriptor->kernelAttributes.threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::RoundRobin; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobin, cmdlistRequiredState.stateComputeMode.threadArbitrationPolicy.value); + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobin, cmdListFinalState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + + cmdList.clear(); + stateComputeModeList.clear(); + + mockKernelImmData->kernelDescriptor->kernelAttributes.threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::AgeBased; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobin, cmdlistRequiredState.stateComputeMode.threadArbitrationPolicy.value); + EXPECT_EQ(NEO::ThreadArbitrationPolicy::AgeBased, cmdListFinalState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + auto stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_EQ(EU_THREAD_SCHEDULING_MODE_OVERRIDE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST, stateComputeModeCmd->getEuThreadSchedulingModeOverride()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->close(); + + sizeBefore = cmdQueueStream.getUsed(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = cmdQueueStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::AgeBased, csrState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(cmdQueueStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_EQ(EU_THREAD_SCHEDULING_MODE_OVERRIDE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_ROUND_ROBIN, stateComputeModeCmd->getEuThreadSchedulingModeOverride()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->reset(); + } + + { + mockKernelImmData->kernelDescriptor->kernelAttributes.threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::RoundRobin; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobin, cmdlistRequiredState.stateComputeMode.threadArbitrationPolicy.value); + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobin, cmdListFinalState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + + cmdList.clear(); + stateComputeModeList.clear(); + + mockKernelImmData->kernelDescriptor->kernelAttributes.threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::AgeBased; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobin, cmdlistRequiredState.stateComputeMode.threadArbitrationPolicy.value); + EXPECT_EQ(NEO::ThreadArbitrationPolicy::AgeBased, cmdListFinalState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + auto stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_EQ(EU_THREAD_SCHEDULING_MODE_OVERRIDE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_OLDEST_FIRST, stateComputeModeCmd->getEuThreadSchedulingModeOverride()); + + cmdList.clear(); + stateComputeModeList.clear(); + + mockKernelImmData->kernelDescriptor->kernelAttributes.threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobin, cmdlistRequiredState.stateComputeMode.threadArbitrationPolicy.value); + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency, cmdListFinalState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_EQ(EU_THREAD_SCHEDULING_MODE_OVERRIDE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_STALL_BASED_ROUND_ROBIN, stateComputeModeCmd->getEuThreadSchedulingModeOverride()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->close(); + + sizeBefore = cmdQueueStream.getUsed(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = cmdQueueStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency, csrState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(cmdQueueStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_EQ(EU_THREAD_SCHEDULING_MODE_OVERRIDE::EU_THREAD_SCHEDULING_MODE_OVERRIDE_ROUND_ROBIN, stateComputeModeCmd->getEuThreadSchedulingModeOverride()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->reset(); + } + { + mockKernelImmData->kernelDescriptor->kernelAttributes.threadArbitrationPolicy = NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency, cmdlistRequiredState.stateComputeMode.threadArbitrationPolicy.value); + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency, cmdListFinalState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->close(); + + sizeBefore = cmdQueueStream.getUsed(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = cmdQueueStream.getUsed(); + + EXPECT_EQ(NEO::ThreadArbitrationPolicy::RoundRobinAfterDependency, csrState.stateComputeMode.threadArbitrationPolicy.value); + + currentBuffer = ptrOffset(cmdQueueStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + } +} + +template +void CmdListLargeGrfFixture::testBody() { + using STATE_COMPUTE_MODE = typename FamilyType::STATE_COMPUTE_MODE; + + const ze_group_count_t groupCount{1, 1, 1}; + CmdListKernelLaunchParams launchParams = {}; + + void *currentBuffer = nullptr; + + auto &cmdlistRequiredState = commandList->getRequiredStreamState(); + auto &cmdListFinalState = commandList->getFinalStreamState(); + auto &csrState = commandQueue->csr->getStreamProperties(); + + auto commandListHandle = commandList->toHandle(); + + auto &commandListStream = *commandList->commandContainer.getCommandStream(); + auto &cmdQueueStream = commandQueue->commandStream; + + GenCmdList cmdList; + std::vector stateComputeModeList; + size_t sizeBefore = 0; + size_t sizeAfter = 0; + auto result = ZE_RESULT_SUCCESS; + + { + mockKernelImmData->kernelDescriptor->kernelAttributes.numGrfRequired = GrfConfig::DefaultGrfNumber; + + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(0, cmdlistRequiredState.stateComputeMode.largeGrfMode.value); + EXPECT_EQ(0, cmdListFinalState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->close(); + + sizeBefore = cmdQueueStream.getUsed(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = cmdQueueStream.getUsed(); + + EXPECT_EQ(0, csrState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(cmdQueueStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + auto stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_FALSE(stateComputeModeCmd->getLargeGrfMode()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->reset(); + } + + { + mockKernelImmData->kernelDescriptor->kernelAttributes.numGrfRequired = GrfConfig::LargeGrfNumber; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(1, cmdlistRequiredState.stateComputeMode.largeGrfMode.value); + EXPECT_EQ(1, cmdListFinalState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + + cmdList.clear(); + stateComputeModeList.clear(); + + mockKernelImmData->kernelDescriptor->kernelAttributes.numGrfRequired = GrfConfig::DefaultGrfNumber; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(1, cmdlistRequiredState.stateComputeMode.largeGrfMode.value); + EXPECT_EQ(0, cmdListFinalState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + auto stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_FALSE(stateComputeModeCmd->getLargeGrfMode()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->close(); + + sizeBefore = cmdQueueStream.getUsed(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = cmdQueueStream.getUsed(); + + EXPECT_EQ(0, csrState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(cmdQueueStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_TRUE(stateComputeModeCmd->getLargeGrfMode()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->reset(); + } + + { + mockKernelImmData->kernelDescriptor->kernelAttributes.numGrfRequired = GrfConfig::LargeGrfNumber; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(1, cmdlistRequiredState.stateComputeMode.largeGrfMode.value); + EXPECT_EQ(1, cmdListFinalState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + + cmdList.clear(); + stateComputeModeList.clear(); + + mockKernelImmData->kernelDescriptor->kernelAttributes.numGrfRequired = GrfConfig::DefaultGrfNumber; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(1, cmdlistRequiredState.stateComputeMode.largeGrfMode.value); + EXPECT_EQ(0, cmdListFinalState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + auto stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_FALSE(stateComputeModeCmd->getLargeGrfMode()); + + cmdList.clear(); + stateComputeModeList.clear(); + + mockKernelImmData->kernelDescriptor->kernelAttributes.numGrfRequired = GrfConfig::LargeGrfNumber; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(1, cmdlistRequiredState.stateComputeMode.largeGrfMode.value); + EXPECT_EQ(1, cmdListFinalState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_TRUE(stateComputeModeCmd->getLargeGrfMode()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->close(); + + sizeBefore = cmdQueueStream.getUsed(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = cmdQueueStream.getUsed(); + + EXPECT_EQ(1, csrState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(cmdQueueStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + ASSERT_EQ(1u, stateComputeModeList.size()); + + stateComputeModeCmd = genCmdCast(*stateComputeModeList[0]); + EXPECT_TRUE(stateComputeModeCmd->getLargeGrfMode()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->reset(); + } + { + mockKernelImmData->kernelDescriptor->kernelAttributes.numGrfRequired = GrfConfig::LargeGrfNumber; + sizeBefore = commandListStream.getUsed(); + result = commandList->appendLaunchKernel(kernel->toHandle(), &groupCount, nullptr, 0, nullptr, launchParams); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = commandListStream.getUsed(); + + EXPECT_EQ(1, cmdlistRequiredState.stateComputeMode.largeGrfMode.value); + EXPECT_EQ(1, cmdListFinalState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(commandListStream.getCpuBase(), sizeBefore); + + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + + cmdList.clear(); + stateComputeModeList.clear(); + commandList->close(); + + sizeBefore = cmdQueueStream.getUsed(); + result = commandQueue->executeCommandLists(1, &commandListHandle, nullptr, false); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + sizeAfter = cmdQueueStream.getUsed(); + + EXPECT_EQ(1, csrState.stateComputeMode.largeGrfMode.value); + + currentBuffer = ptrOffset(cmdQueueStream.getCpuBase(), sizeBefore); + ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, + currentBuffer, + (sizeAfter - sizeBefore))); + stateComputeModeList = findAll(cmdList.begin(), cmdList.end()); + EXPECT_EQ(0u, stateComputeModeList.size()); + } +} + } // namespace ult } // namespace L0 diff --git a/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h b/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h index 52159996df..6b281829e6 100644 --- a/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h +++ b/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h @@ -65,6 +65,7 @@ struct WhiteBox<::L0::CommandListCoreFamily> using BaseClass::patternAllocations; using BaseClass::pipelineSelectStateTracking; using BaseClass::requiredStreamState; + using BaseClass::stateComputeModeTracking; using BaseClass::unifiedMemoryControls; using BaseClass::updateStreamProperties; @@ -126,6 +127,7 @@ struct WhiteBox> using BaseClass::partitionCount; using BaseClass::pipelineSelectStateTracking; using BaseClass::requiredStreamState; + using BaseClass::stateComputeModeTracking; WhiteBox() : BaseClass(BaseClass::defaultNumIddsPerBlock) {} }; @@ -151,6 +153,7 @@ struct WhiteBox<::L0::CommandList> : public ::L0::CommandListImp { using BaseClass::nonImmediateLogicalStateHelper; using BaseClass::partitionCount; using BaseClass::pipelineSelectStateTracking; + using BaseClass::stateComputeModeTracking; WhiteBox(Device *device); ~WhiteBox() override; diff --git a/level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h b/level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h index 24b6749865..8a90790bb7 100644 --- a/level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h +++ b/level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h @@ -37,6 +37,7 @@ struct WhiteBox<::L0::CommandQueue> : public ::L0::CommandQueueImp { using CommandQueue::multiReturnPointCommandList; using CommandQueue::partitionCount; using CommandQueue::pipelineSelectStateTracking; + using CommandQueue::stateComputeModeTracking; WhiteBox(Device *device, NEO::CommandStreamReceiver *csr, const ze_command_queue_desc_t *desc); @@ -70,6 +71,7 @@ struct MockCommandQueueHw : public L0::CommandQueueHw { using L0::CommandQueue::partitionCount; using L0::CommandQueue::pipelineSelectStateTracking; using L0::CommandQueue::preemptionCmdSyncProgramming; + using L0::CommandQueue::stateComputeModeTracking; using L0::CommandQueueImp::csr; using typename BaseClass::CommandListExecutionContext; diff --git a/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_enqueue_cmdlist_2.cpp b/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_enqueue_cmdlist_2.cpp index ff0c191f6e..f068ad8d4f 100644 --- a/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_enqueue_cmdlist_2.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_enqueue_cmdlist_2.cpp @@ -552,5 +552,21 @@ HWTEST2_F(CmdListPipelineSelectStateTest, testBodyShareStateImmediateRegular(); } +using CmdListThreadArbitrationTest = Test; + +using ThreadArbitrationSupport = IsProduct; +HWTEST2_F(CmdListThreadArbitrationTest, + givenAppendThreadArbitrationKernelToCommandListWhenExecutingCommandListThenStateComputeModeStateIsTrackedCorrectly, ThreadArbitrationSupport) { + testBody(); +} + +using CmdListLargeGrfTest = Test; + +using LargeGrfSupport = IsAnyProducts; +HWTEST2_F(CmdListLargeGrfTest, + givenAppendLargeGrfKernelToCommandListWhenExecutingCommandListThenStateComputeModeStateIsTrackedCorrectly, LargeGrfSupport) { + testBody(); +} + } // namespace ult } // namespace L0 diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl index bf1600f636..7106ddd225 100644 --- a/shared/source/debug_settings/debug_variables_base.inl +++ b/shared/source/debug_settings/debug_variables_base.inl @@ -479,6 +479,6 @@ DECLARE_DEBUG_VARIABLE(int32_t, ProgramExtendedPipeControlPriorToNonPipelinedSta DECLARE_DEBUG_VARIABLE(int32_t, OverrideDrmRegion, -1, "-1: disable, 0+: override to given memory region for all allocations") DECLARE_DEBUG_VARIABLE(int32_t, MultiReturnPointCommandList, -1, "-1: default: disabled, 0: disabled, 1: enabled. This flag creates multiple return point from List to Queue for Front End reconfiguration on Queue buffer for single List") DECLARE_DEBUG_VARIABLE(int32_t, EnablePipelineSelectTracking, -1, "-1: default: disabled, 0: disabled, 1: enabled. This flag enables optimization that limits number of pipeline select dispatched by command lists") - +DECLARE_DEBUG_VARIABLE(int32_t, EnableStateComputeModeTracking, -1, "-1: default: disabled, 0: disabled, 1: enabled. This flag enables tracking state compute mode changes in command lists") /* Binary Cache */ DECLARE_DEBUG_VARIABLE(bool, BinaryCacheTrace, false, "enable cl_cache to produce .trace files with information about hash computation") diff --git a/shared/test/common/test_files/igdrcl.config b/shared/test/common/test_files/igdrcl.config index 905af3748f..7fde1d9067 100644 --- a/shared/test/common/test_files/igdrcl.config +++ b/shared/test/common/test_files/igdrcl.config @@ -168,6 +168,7 @@ CsrDispatchMode = 0 OverrideDefaultFP64Settings = -1 RenderCompressedImagesEnabled = -1 RenderCompressedBuffersEnabled = -1 +EnableStateComputeModeTracking = -1 EnableUsmConcurrentAccessSupport = 0 EnableSharedSystemUsmSupport = -1 EnablePassInlineData = -1