Skip to content

Commit cd95572

Browse files
fhazubski-IntelCompute-Runtime-Automation
fhazubski-Intel
authored and
Compute-Runtime-Automation
committed
Reuse common logic of programming SCM fields for gen 9 and gen 11
Logic related to programming non coherent and thread arbitration policy for gens 9 and 11 has been moved to EncodeComputeMode object, where similar logic for gens gen12lp and newer is located. Functions PreambleHelper::programThreadArbitration and PreambleHelper::getThreadArbitrationCommandsSize have been removed. Redundant setForceNonCoherent call has been removed from XE HPG Related-To: NEO-6728 Signed-off-by: Filip Hazubski <[email protected]>
1 parent 5d90e2a commit cd95572

31 files changed

+190
-273
lines changed

‎level_zero/core/source/cmdlist/cmdlist_hw.inl‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -78,7 +78,10 @@ void CommandListCoreFamily<gfxCoreFamily>::programThreadArbitrationPolicy(Device
7878
if (NEO::DebugManager.flags.OverrideThreadArbitrationPolicy.get() != -1) {
7979
threadArbitrationPolicy = static_cast<uint32_t>(NEO::DebugManager.flags.OverrideThreadArbitrationPolicy.get());
8080
}
81-
NEO::PreambleHelper<GfxFamily>::programThreadArbitration(commandContainer.getCommandStream(), threadArbitrationPolicy);
81+
NEO::StreamProperties streamProperties{};
82+
streamProperties.stateComputeMode.threadArbitrationPolicy.set(threadArbitrationPolicy);
83+
NEO::EncodeComputeMode<GfxFamily>::programComputeModeCommand(*commandContainer.getCommandStream(), streamProperties.stateComputeMode,
84+
this->device->getHwInfo());
8285
}
8386

8487
template <GFXCORE_FAMILY gfxCoreFamily>

‎level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp‎

Lines changed: 19 additions & 116 deletions
Original file line numberDiff line numberDiff line change
@@ -283,29 +283,8 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyRegionHavingHostMemor
283283
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
284284
cmdList, ptrOffset(commandContainer.getCommandStream()->getCpuBase(), 0), commandContainer.getCommandStream()->getUsed()));
285285

286-
auto itor = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
287-
EXPECT_NE(cmdList.end(), itor);
288-
itor++;
289-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
290-
EXPECT_NE(cmdList.end(), itor);
291-
itor++;
292-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
293-
EXPECT_NE(cmdList.end(), itor);
294-
itor++;
295-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
296-
EXPECT_NE(cmdList.end(), itor);
297-
itor++;
298-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
299-
EXPECT_NE(cmdList.end(), itor);
300-
itor++;
301-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
302-
EXPECT_NE(cmdList.end(), itor);
303-
itor++;
304-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
305-
EXPECT_NE(cmdList.end(), itor);
306-
itor++;
307-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
308-
EXPECT_EQ(cmdList.end(), itor);
286+
auto allPcCommands = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
287+
EXPECT_EQ(8u, allPcCommands.size());
309288
}
310289

311290
HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyRegionHavingDeviceMemoryWithSignalAndWaitEventsUsingRenderEngineThenPipeControlIsNotFound, PlatformSupport) {
@@ -351,26 +330,8 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryCopyRegionHavingDeviceMem
351330
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
352331
cmdList, ptrOffset(commandContainer.getCommandStream()->getCpuBase(), 0), commandContainer.getCommandStream()->getUsed()));
353332

354-
auto itor = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
355-
EXPECT_NE(cmdList.end(), itor);
356-
itor++;
357-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
358-
EXPECT_NE(cmdList.end(), itor);
359-
itor++;
360-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
361-
EXPECT_NE(cmdList.end(), itor);
362-
itor++;
363-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
364-
EXPECT_NE(cmdList.end(), itor);
365-
itor++;
366-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
367-
EXPECT_NE(cmdList.end(), itor);
368-
itor++;
369-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
370-
EXPECT_NE(cmdList.end(), itor);
371-
itor++;
372-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
373-
EXPECT_EQ(cmdList.end(), itor);
333+
auto allPcCommands = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
334+
EXPECT_EQ(7u, allPcCommands.size());
374335

375336
context->freeMem(srcBuffer);
376337
context->freeMem(dstBuffer);
@@ -412,26 +373,8 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingDeviceMemoryWit
412373
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
413374
cmdList, ptrOffset(commandContainer.getCommandStream()->getCpuBase(), 0), commandContainer.getCommandStream()->getUsed()));
414375

415-
auto itor = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
416-
EXPECT_NE(cmdList.end(), itor);
417-
itor++;
418-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
419-
EXPECT_NE(cmdList.end(), itor);
420-
itor++;
421-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
422-
EXPECT_NE(cmdList.end(), itor);
423-
itor++;
424-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
425-
EXPECT_NE(cmdList.end(), itor);
426-
itor++;
427-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
428-
EXPECT_NE(cmdList.end(), itor);
429-
itor++;
430-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
431-
EXPECT_NE(cmdList.end(), itor);
432-
itor++;
433-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
434-
EXPECT_EQ(cmdList.end(), itor);
376+
auto allPcCommands = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
377+
EXPECT_EQ(7u, allPcCommands.size());
435378

436379
context->freeMem(dstBuffer);
437380
}
@@ -473,29 +416,8 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingSharedMemoryWit
473416
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
474417
cmdList, ptrOffset(commandContainer.getCommandStream()->getCpuBase(), 0), commandContainer.getCommandStream()->getUsed()));
475418

476-
auto itor = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
477-
EXPECT_NE(cmdList.end(), itor);
478-
itor++;
479-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
480-
EXPECT_NE(cmdList.end(), itor);
481-
itor++;
482-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
483-
EXPECT_NE(cmdList.end(), itor);
484-
itor++;
485-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
486-
EXPECT_NE(cmdList.end(), itor);
487-
itor++;
488-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
489-
EXPECT_NE(cmdList.end(), itor);
490-
itor++;
491-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
492-
EXPECT_NE(cmdList.end(), itor);
493-
itor++;
494-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
495-
EXPECT_NE(cmdList.end(), itor);
496-
itor++;
497-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
498-
EXPECT_EQ(cmdList.end(), itor);
419+
auto allPcCommands = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
420+
EXPECT_EQ(8u, allPcCommands.size());
499421

500422
context->freeMem(dstBuffer);
501423
}
@@ -537,26 +459,8 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingHostMemoryWithS
537459
ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
538460
cmdList, ptrOffset(commandContainer.getCommandStream()->getCpuBase(), 0), commandContainer.getCommandStream()->getUsed()));
539461

540-
auto itor = find<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
541-
EXPECT_NE(cmdList.end(), itor);
542-
itor++;
543-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
544-
EXPECT_NE(cmdList.end(), itor);
545-
itor++;
546-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
547-
EXPECT_NE(cmdList.end(), itor);
548-
itor++;
549-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
550-
EXPECT_NE(cmdList.end(), itor);
551-
itor++;
552-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
553-
EXPECT_NE(cmdList.end(), itor);
554-
itor++;
555-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
556-
EXPECT_NE(cmdList.end(), itor);
557-
itor++;
558-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
559-
EXPECT_EQ(cmdList.end(), itor);
462+
auto allPcCommands = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
463+
EXPECT_EQ(7u, allPcCommands.size());
560464

561465
context->freeMem(dstBuffer);
562466
}
@@ -601,16 +505,9 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingEventsWithDevic
601505

602506
auto itor = find<SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
603507
EXPECT_NE(cmdList.end(), itor);
604-
itor++;
605-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
606-
EXPECT_NE(cmdList.end(), itor);
607-
itor++;
608-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
609-
EXPECT_NE(cmdList.end(), itor);
610-
itor++;
611-
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
612-
EXPECT_NE(cmdList.end(), itor);
613-
auto cmd = genCmdCast<PIPE_CONTROL *>(*itor);
508+
auto allPcCommands = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
509+
EXPECT_EQ(7u, allPcCommands.size());
510+
auto cmd = genCmdCast<PIPE_CONTROL *>(*allPcCommands.back());
614511
EXPECT_TRUE(cmd->getDcFlushEnable());
615512

616513
context->freeMem(dstBuffer);
@@ -662,6 +559,12 @@ HWTEST2_F(CommandListCreate, givenCommandListWhenMemoryFillHavingEventsWithDevic
662559
itor++;
663560
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
664561
EXPECT_NE(cmdList.end(), itor);
562+
itor++;
563+
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
564+
EXPECT_NE(cmdList.end(), itor);
565+
itor++;
566+
itor = find<PIPE_CONTROL *>(itor, cmdList.end());
567+
EXPECT_NE(cmdList.end(), itor);
665568
auto cmd = genCmdCast<PIPE_CONTROL *>(*itor);
666569
EXPECT_FALSE(cmd->getDcFlushEnable());
667570

‎opencl/test/unit_test/command_stream/command_stream_receiver_hw_1_tests.cpp‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -154,8 +154,7 @@ HWTEST_F(UltCommandStreamReceiverTest, givenPreambleSentAndThreadArbitrationPoli
154154

155155
auto actualDifferenceForPreamble = policyChangedPreamble - policyNotChangedPreamble;
156156
auto actualDifferenceForFlush = policyChangedFlush - policyNotChangedFlush;
157-
auto expectedDifference = PreambleHelper<FamilyType>::getThreadArbitrationCommandsSize() +
158-
EncodeComputeMode<FamilyType>::getCmdSizeForComputeMode(*defaultHwInfo, false, commandStreamReceiver.isRcs());
157+
auto expectedDifference = EncodeComputeMode<FamilyType>::getCmdSizeForComputeMode(*defaultHwInfo, false, commandStreamReceiver.isRcs());
159158
EXPECT_EQ(0u, actualDifferenceForPreamble);
160159
EXPECT_EQ(expectedDifference, actualDifferenceForFlush);
161160
}

‎opencl/test/unit_test/gen11/coherency_tests_gen11.cpp‎

Lines changed: 2 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -44,22 +44,17 @@ struct Gen11CoherencyRequirements : public ::testing::Test {
4444
};
4545

4646
GEN11TEST_F(Gen11CoherencyRequirements, GivenSettingsWhenCoherencyRequestedThenProgrammingIsCorrect) {
47-
auto lriSize = sizeof(MI_LOAD_REGISTER_IMM);
4847
overrideCoherencyRequest(false, false);
4948
EXPECT_FALSE(csr->streamProperties.stateComputeMode.isDirty());
5049

5150
overrideCoherencyRequest(false, true);
5251
EXPECT_FALSE(csr->streamProperties.stateComputeMode.isDirty());
5352

5453
overrideCoherencyRequest(true, true);
55-
auto retSize = csr->getCmdSizeForComputeMode();
5654
EXPECT_TRUE(csr->streamProperties.stateComputeMode.isDirty());
57-
EXPECT_EQ(lriSize, retSize);
5855

5956
overrideCoherencyRequest(true, false);
60-
retSize = csr->getCmdSizeForComputeMode();
6157
EXPECT_TRUE(csr->streamProperties.stateComputeMode.isDirty());
62-
EXPECT_EQ(lriSize, retSize);
6358
}
6459

6560
GEN11TEST_F(Gen11CoherencyRequirements, GivenSettingsWhenCoherencyRequestedThenHdcModeCmdValuesAreCorrect) {
@@ -73,14 +68,14 @@ GEN11TEST_F(Gen11CoherencyRequirements, GivenSettingsWhenCoherencyRequestedThenH
7368

7469
overrideCoherencyRequest(true, false);
7570
csr->programComputeMode(stream, flags, *defaultHwInfo);
76-
EXPECT_EQ(csr->getCmdSizeForComputeMode(), stream.getUsed());
71+
EXPECT_EQ(lriSize, stream.getUsed());
7772

7873
auto cmd = reinterpret_cast<MI_LOAD_REGISTER_IMM *>(stream.getCpuBase());
7974
EXPECT_TRUE(memcmp(&expectedCmd, cmd, lriSize) == 0);
8075

8176
overrideCoherencyRequest(true, true);
8277
csr->programComputeMode(stream, flags, *defaultHwInfo);
83-
EXPECT_EQ(csr->getCmdSizeForComputeMode() * 2, stream.getUsed());
78+
EXPECT_EQ(lriSize * 2, stream.getUsed());
8479

8580
cmd = reinterpret_cast<MI_LOAD_REGISTER_IMM *>(ptrOffset(stream.getCpuBase(), lriSize));
8681
expectedCmd.setDataDword(DwordBuilder::build(gen11HdcModeRegister::forceNonCoherentEnableBit, true, false));

‎opencl/test/unit_test/gen9/coherency_tests_gen9.cpp‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -22,14 +22,10 @@ GEN9TEST_F(Gen9CoherencyRequirements, WhenMemoryManagerIsInitializedThenNoCohere
2222
DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
2323
auto &csr = deviceFactory.rootDevices[0]->getUltCommandStreamReceiver<FamilyType>();
2424

25-
auto retSize = csr.getCmdSizeForComputeMode();
26-
EXPECT_EQ(0u, retSize);
2725
csr.programComputeMode(stream, flags, *defaultHwInfo);
2826
EXPECT_EQ(0u, stream.getUsed());
2927

3028
flags.requiresCoherency = true;
31-
retSize = csr.getCmdSizeForComputeMode();
32-
EXPECT_EQ(0u, retSize);
3329
csr.programComputeMode(stream, flags, *defaultHwInfo);
3430
EXPECT_EQ(0u, stream.getUsed());
3531
}

‎opencl/test/unit_test/helpers/test_preamble_xehp_and_later.cpp‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -23,12 +23,8 @@
2323
using namespace NEO;
2424

2525
using ThreadArbitrationXeHPAndLater = PreambleFixture;
26-
HWCMDTEST_F(IGFX_XE_HP_CORE, ThreadArbitrationXeHPAndLater, givenPolicyWhenThreadArbitrationProgrammedThenDoNothing) {
27-
LinearStream &cs = linearStream;
28-
29-
PreambleHelper<FamilyType>::programThreadArbitration(&cs, ThreadArbitrationPolicy::RoundRobin);
30-
31-
EXPECT_EQ(0u, cs.getUsed());
26+
using Platforms = IsWithinGfxCore<IGFX_XE_HP_CORE, IGFX_XE_HPG_CORE>;
27+
HWTEST2_F(ThreadArbitrationXeHPAndLater, whenGetDefaultThreadArbitrationPolicyIsCalledThenCorrectPolicyIsReturned, Platforms) {
3228
EXPECT_EQ(ThreadArbitrationPolicy::AgeBased, HwHelperHw<FamilyType>::get().getDefaultThreadArbitrationPolicy());
3329
}
3430

‎opencl/test/unit_test/xe_hpc_core/excludes_ocl_xe_hpc_core.cpp‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,6 @@
1010
HWTEST_EXCLUDE_PRODUCT(BufferSetSurfaceTests, givenAlignedCacheableReadOnlyBufferThenChoseOclBufferPolicy, IGFX_XE_HPC_CORE);
1111
HWTEST_EXCLUDE_PRODUCT(BufferSetSurfaceTests, givenBufferSetSurfaceThatMemoryIsUnalignedToCachelineButReadOnlyThenL3CacheShouldBeStillOn, IGFX_XE_HPC_CORE);
1212
HWTEST_EXCLUDE_PRODUCT(HwHelperTestXeHPAndLater, givenVariousCachesRequestProperMOCSIndexesAreBeingReturned, IGFX_XE_HPC_CORE);
13-
HWTEST_EXCLUDE_PRODUCT(ThreadArbitrationXeHPAndLater, givenPolicyWhenThreadArbitrationProgrammedThenDoNothing, IGFX_XE_HPC_CORE);
1413
HWTEST_EXCLUDE_PRODUCT(PipeControlHelperTestsXeHPAndLater, WhenAddingPipeControlWAThenCorrectCommandsAreProgrammed, IGFX_XE_HPC_CORE);
1514
HWTEST_EXCLUDE_PRODUCT(QueueFamilyNameTest, givenRcsWhenGettingQueueFamilyNameThenReturnProperValue, IGFX_XE_HPC_CORE);
1615
HWTEST_EXCLUDE_PRODUCT(HwInfoConfigTest, givenVariousValuesWhenConvertingHwRevIdAndSteppingThenConversionIsCorrect, IGFX_XE_HPC_CORE);

‎shared/source/command_container/command_encoder_bdw_and_later.inl‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -333,10 +333,6 @@ inline void EncodeDispatchKernel<Family>::encodeAdditionalWalkerFields(const Har
333333
template <typename Family>
334334
void EncodeDispatchKernel<Family>::appendAdditionalIDDFields(INTERFACE_DESCRIPTOR_DATA *pInterfaceDescriptor, const HardwareInfo &hwInfo, const uint32_t threadsPerThreadGroup, uint32_t slmTotalSize, SlmPolicy slmPolicy) {}
335335

336-
template <typename Family>
337-
inline void EncodeComputeMode<Family>::programComputeModeCommand(LinearStream &csr, StateComputeModeProperties &properties, const HardwareInfo &hwInfo) {
338-
}
339-
340336
template <typename Family>
341337
inline void EncodeComputeMode<Family>::adjustPipelineSelect(CommandContainer &container, const NEO::KernelDescriptor &kernelDescriptor) {
342338
}

‎shared/source/command_container/encode_compute_mode_bdw_and_later.inl‎

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -11,15 +11,12 @@
1111

1212
namespace NEO {
1313

14-
template <typename Family>
15-
size_t EncodeComputeMode<Family>::getCmdSizeForComputeMode(const HardwareInfo &hwInfo, bool hasSharedHandles, bool isRcs) {
16-
return 0u;
17-
}
18-
1914
template <typename Family>
2015
inline void EncodeComputeMode<Family>::programComputeModeCommandWithSynchronization(
2116
LinearStream &csr, StateComputeModeProperties &properties, const PipelineSelectArgs &args,
2217
bool hasSharedHandles, const HardwareInfo &hwInfo, bool isRcs) {
18+
19+
EncodeComputeMode<Family>::programComputeModeCommand(csr, properties, hwInfo);
2320
}
2421

2522
template <typename Family>

‎shared/source/command_stream/command_stream_receiver_hw_base.inl‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -340,11 +340,6 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
340340
addPipeControlBefore3dState(commandStreamCSR, dispatchFlags);
341341
programPerDssBackedBuffer(commandStreamCSR, device, dispatchFlags);
342342

343-
if (this->streamProperties.stateComputeMode.threadArbitrationPolicy.isDirty) {
344-
auto threadArbitrationPolicy = this->streamProperties.stateComputeMode.threadArbitrationPolicy.value;
345-
PreambleHelper<GfxFamily>::programThreadArbitration(&commandStreamCSR, threadArbitrationPolicy);
346-
}
347-
348343
stateBaseAddressDirty |= ((GSBAFor32BitProgrammed ^ dispatchFlags.gsba32BitRequired) && force32BitAllocations);
349344

350345
programVFEState(commandStreamCSR, dispatchFlags, device.getDeviceInfo().maxFrontEndThreads);
@@ -654,6 +649,15 @@ void CommandStreamReceiverHw<GfxFamily>::forcePipeControl(NEO::LinearStream &com
654649
MemorySynchronizationCommands<GfxFamily>::addPipeControl(commandStreamCSR, args);
655650
}
656651

652+
template <typename GfxFamily>
653+
void CommandStreamReceiverHw<GfxFamily>::programComputeMode(LinearStream &stream, DispatchFlags &dispatchFlags, const HardwareInfo &hwInfo) {
654+
if (this->streamProperties.stateComputeMode.isDirty()) {
655+
EncodeComputeMode<GfxFamily>::programComputeModeCommandWithSynchronization(
656+
stream, this->streamProperties.stateComputeMode, dispatchFlags.pipelineSelectArgs,
657+
hasSharedHandles(), hwInfo, isRcs());
658+
}
659+
}
660+
657661
template <typename GfxFamily>
658662
inline void CommandStreamReceiverHw<GfxFamily>::programStallingCommandsForBarrier(LinearStream &cmdStream, DispatchFlags &dispatchFlags) {
659663
stallingCommandsOnNextFlushRequired = false;
@@ -829,10 +833,6 @@ size_t CommandStreamReceiverHw<GfxFamily>::getRequiredCmdStreamSize(const Dispat
829833
size += TimestampPacketHelper::getRequiredCmdStreamSize<GfxFamily>(dispatchFlags.csrDependencies);
830834
size += TimestampPacketHelper::getRequiredCmdStreamSizeForTaskCountContainer<GfxFamily>(dispatchFlags.csrDependencies);
831835

832-
if (this->streamProperties.stateComputeMode.threadArbitrationPolicy.isDirty) {
833-
size += PreambleHelper<GfxFamily>::getThreadArbitrationCommandsSize();
834-
}
835-
836836
if (stallingCommandsOnNextFlushRequired) {
837837
size += getCmdSizeForStallingCommands(dispatchFlags);
838838
}

0 commit comments

Comments
 (0)