Skip to content

Commit 56bef79

Browse files
zzdanowiczCompute-Runtime-Automation
zzdanowicz
authored and
Compute-Runtime-Automation
committed
Add multi tile support for OCL post sync barrier
Related-To: NEO-6262 Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
1 parent 4b589bf commit 56bef79

7 files changed

+274
-12
lines changed

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

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1424,3 +1424,47 @@ HWCMDTEST_F(IGFX_GEN8_CORE, UltCommandStreamReceiverTest, WhenProgrammingActiveP
14241424
size_t usedAfter = commandStreamReceiver.commandStream.getUsed();
14251425
EXPECT_EQ(usedBefore, usedAfter);
14261426
}
1427+
1428+
HWCMDTEST_F(IGFX_GEN8_CORE, UltCommandStreamReceiverTest, givenBarrierNodeSetWhenProgrammingBarrierCommandThenExpectPostSyncPipeControl) {
1429+
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
1430+
1431+
auto &hwInfo = pDevice->getHardwareInfo();
1432+
auto commandStreamReceiver = &pDevice->getUltCommandStreamReceiver<FamilyType>();
1433+
1434+
auto &commandStreamCSR = commandStreamReceiver->getCS();
1435+
1436+
TagNodeBase *tagNode = commandStreamReceiver->getTimestampPacketAllocator()->getTag();
1437+
uint64_t gpuAddress = TimestampPacketHelper::getContextEndGpuAddress(*tagNode);
1438+
1439+
TimestampPacketDependencies timestampPacketDependencies;
1440+
timestampPacketDependencies.barrierNodes.add(tagNode);
1441+
1442+
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
1443+
dispatchFlags.barrierTimestampPacketNodes = &timestampPacketDependencies.barrierNodes;
1444+
1445+
size_t expectedCmdSize = MemorySynchronizationCommands<FamilyType>::getSizeForPipeControlWithPostSyncOperation(hwInfo);
1446+
size_t estimatedCmdSize = commandStreamReceiver->getCmdSizeForStallingCommands(dispatchFlags);
1447+
EXPECT_EQ(expectedCmdSize, estimatedCmdSize);
1448+
1449+
commandStreamReceiver->programStallingCommandsForBarrier(commandStreamCSR, dispatchFlags);
1450+
EXPECT_EQ(estimatedCmdSize, commandStreamCSR.getUsed());
1451+
1452+
parseCommands<FamilyType>(commandStreamCSR, 0);
1453+
findHardwareCommands<FamilyType>();
1454+
auto cmdItor = cmdList.begin();
1455+
1456+
if (MemorySynchronizationCommands<FamilyType>::isPipeControlWArequired(hwInfo)) {
1457+
PIPE_CONTROL *pipeControl = genCmdCast<PIPE_CONTROL *>(*cmdItor);
1458+
ASSERT_NE(nullptr, pipeControl);
1459+
cmdItor++;
1460+
if (MemorySynchronizationCommands<FamilyType>::getSizeForSingleAdditionalSynchronization(hwInfo) > 0) {
1461+
cmdItor++;
1462+
}
1463+
}
1464+
PIPE_CONTROL *pipeControl = genCmdCast<PIPE_CONTROL *>(*cmdItor);
1465+
ASSERT_NE(nullptr, pipeControl);
1466+
EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation());
1467+
EXPECT_TRUE(pipeControl->getCommandStreamerStallEnable());
1468+
EXPECT_EQ(0u, pipeControl->getImmediateData());
1469+
EXPECT_EQ(gpuAddress, UnitTestHelper<FamilyType>::getPipeControlPostSyncAddress(*pipeControl));
1470+
}

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

Lines changed: 168 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -950,3 +950,171 @@ HWTEST2_F(CommandStreamReceiverHwTestXeHPAndLater, givenStaticPartitionEnabledWh
950950

951951
EXPECT_EQ(estimatedCmdSize, offset);
952952
}
953+
954+
HWTEST2_F(CommandStreamReceiverHwTestXeHPAndLater, givenStaticPartitionEnabledWhenSinglePartitionUsedForPostSyncBarrierThenExpectOnlyPostSyncCommands, IsAtLeastXeHpCore) {
955+
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
956+
957+
auto &hwInfo = pDevice->getHardwareInfo();
958+
959+
auto commandStreamReceiver = new MockCsrHw<FamilyType>(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield());
960+
pDevice->resetCommandStreamReceiver(commandStreamReceiver);
961+
auto &commandStreamCSR = commandStreamReceiver->getCS();
962+
963+
TagNodeBase *tagNode = commandStreamReceiver->getTimestampPacketAllocator()->getTag();
964+
uint64_t gpuAddress = TimestampPacketHelper::getContextEndGpuAddress(*tagNode);
965+
966+
TimestampPacketDependencies timestampPacketDependencies;
967+
timestampPacketDependencies.barrierNodes.add(tagNode);
968+
969+
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
970+
dispatchFlags.barrierTimestampPacketNodes = &timestampPacketDependencies.barrierNodes;
971+
972+
commandStreamReceiver->staticWorkPartitioningEnabled = true;
973+
commandStreamReceiver->activePartitions = 1;
974+
975+
size_t expectedCmdSize = MemorySynchronizationCommands<FamilyType>::getSizeForPipeControlWithPostSyncOperation(hwInfo);
976+
size_t estimatedCmdSize = commandStreamReceiver->getCmdSizeForStallingCommands(dispatchFlags);
977+
EXPECT_EQ(expectedCmdSize, estimatedCmdSize);
978+
979+
commandStreamReceiver->programStallingCommandsForBarrier(commandStreamCSR, dispatchFlags);
980+
EXPECT_EQ(estimatedCmdSize, commandStreamCSR.getUsed());
981+
982+
parseCommands<FamilyType>(commandStreamCSR, 0);
983+
findHardwareCommands<FamilyType>();
984+
auto cmdItor = cmdList.begin();
985+
986+
if (MemorySynchronizationCommands<FamilyType>::isPipeControlWArequired(hwInfo)) {
987+
PIPE_CONTROL *pipeControl = genCmdCast<PIPE_CONTROL *>(*cmdItor);
988+
ASSERT_NE(nullptr, pipeControl);
989+
cmdItor++;
990+
if (MemorySynchronizationCommands<FamilyType>::getSizeForSingleAdditionalSynchronization(hwInfo) > 0) {
991+
cmdItor++;
992+
}
993+
}
994+
PIPE_CONTROL *pipeControl = genCmdCast<PIPE_CONTROL *>(*cmdItor);
995+
ASSERT_NE(nullptr, pipeControl);
996+
EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation());
997+
EXPECT_TRUE(pipeControl->getCommandStreamerStallEnable());
998+
EXPECT_EQ(0u, pipeControl->getImmediateData());
999+
EXPECT_EQ(gpuAddress, UnitTestHelper<FamilyType>::getPipeControlPostSyncAddress(*pipeControl));
1000+
}
1001+
1002+
HWTEST2_F(CommandStreamReceiverHwTestXeHPAndLater, givenStaticPartitionDisabledWhenMultiplePartitionsUsedForPostSyncBarrierThenExpectOnlyPostSyncCommands, IsAtLeastXeHpCore) {
1003+
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
1004+
1005+
auto &hwInfo = pDevice->getHardwareInfo();
1006+
1007+
auto commandStreamReceiver = new MockCsrHw<FamilyType>(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield());
1008+
pDevice->resetCommandStreamReceiver(commandStreamReceiver);
1009+
auto &commandStreamCSR = commandStreamReceiver->getCS();
1010+
1011+
TagNodeBase *tagNode = commandStreamReceiver->getTimestampPacketAllocator()->getTag();
1012+
uint64_t gpuAddress = TimestampPacketHelper::getContextEndGpuAddress(*tagNode);
1013+
1014+
TimestampPacketDependencies timestampPacketDependencies;
1015+
timestampPacketDependencies.barrierNodes.add(tagNode);
1016+
1017+
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
1018+
dispatchFlags.barrierTimestampPacketNodes = &timestampPacketDependencies.barrierNodes;
1019+
1020+
commandStreamReceiver->staticWorkPartitioningEnabled = false;
1021+
commandStreamReceiver->activePartitions = 2;
1022+
1023+
size_t expectedCmdSize = MemorySynchronizationCommands<FamilyType>::getSizeForPipeControlWithPostSyncOperation(hwInfo);
1024+
size_t estimatedCmdSize = commandStreamReceiver->getCmdSizeForStallingCommands(dispatchFlags);
1025+
EXPECT_EQ(expectedCmdSize, estimatedCmdSize);
1026+
1027+
commandStreamReceiver->programStallingCommandsForBarrier(commandStreamCSR, dispatchFlags);
1028+
EXPECT_EQ(estimatedCmdSize, commandStreamCSR.getUsed());
1029+
1030+
parseCommands<FamilyType>(commandStreamCSR, 0);
1031+
findHardwareCommands<FamilyType>();
1032+
auto cmdItor = cmdList.begin();
1033+
1034+
if (MemorySynchronizationCommands<FamilyType>::isPipeControlWArequired(hwInfo)) {
1035+
PIPE_CONTROL *pipeControl = genCmdCast<PIPE_CONTROL *>(*cmdItor);
1036+
ASSERT_NE(nullptr, pipeControl);
1037+
cmdItor++;
1038+
if (MemorySynchronizationCommands<FamilyType>::getSizeForSingleAdditionalSynchronization(hwInfo) > 0) {
1039+
cmdItor++;
1040+
}
1041+
}
1042+
PIPE_CONTROL *pipeControl = genCmdCast<PIPE_CONTROL *>(*cmdItor);
1043+
ASSERT_NE(nullptr, pipeControl);
1044+
EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation());
1045+
EXPECT_TRUE(pipeControl->getCommandStreamerStallEnable());
1046+
EXPECT_EQ(0u, pipeControl->getImmediateData());
1047+
EXPECT_EQ(gpuAddress, UnitTestHelper<FamilyType>::getPipeControlPostSyncAddress(*pipeControl));
1048+
}
1049+
1050+
HWTEST2_F(CommandStreamReceiverHwTestXeHPAndLater, givenStaticPartitionEnabledWhenMultiplePartitionsUsedThenExpectImplicitScalingPostSyncBarrierWithoutSelfCleanup, IsAtLeastXeHpCore) {
1051+
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
1052+
using MI_BATCH_BUFFER_START = typename FamilyType::MI_BATCH_BUFFER_START;
1053+
using MI_ATOMIC = typename FamilyType::MI_ATOMIC;
1054+
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
1055+
1056+
auto &hwInfo = pDevice->getHardwareInfo();
1057+
1058+
auto commandStreamReceiver = new MockCsrHw<FamilyType>(*pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield());
1059+
pDevice->resetCommandStreamReceiver(commandStreamReceiver);
1060+
auto &commandStreamCSR = commandStreamReceiver->getCS();
1061+
1062+
TagNodeBase *tagNode = commandStreamReceiver->getTimestampPacketAllocator()->getTag();
1063+
uint64_t gpuAddress = TimestampPacketHelper::getContextEndGpuAddress(*tagNode);
1064+
1065+
TimestampPacketDependencies timestampPacketDependencies;
1066+
timestampPacketDependencies.barrierNodes.add(tagNode);
1067+
1068+
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
1069+
dispatchFlags.barrierTimestampPacketNodes = &timestampPacketDependencies.barrierNodes;
1070+
1071+
commandStreamReceiver->staticWorkPartitioningEnabled = true;
1072+
commandStreamReceiver->activePartitions = 2;
1073+
1074+
size_t expectedSize = MemorySynchronizationCommands<FamilyType>::getSizeForPipeControlWithPostSyncOperation(hwInfo) +
1075+
sizeof(MI_ATOMIC) + sizeof(MI_SEMAPHORE_WAIT) +
1076+
sizeof(MI_BATCH_BUFFER_START) +
1077+
2 * sizeof(uint32_t);
1078+
size_t estimatedCmdSize = commandStreamReceiver->getCmdSizeForStallingCommands(dispatchFlags);
1079+
EXPECT_EQ(expectedSize, estimatedCmdSize);
1080+
1081+
commandStreamReceiver->programStallingCommandsForBarrier(commandStreamCSR, dispatchFlags);
1082+
EXPECT_EQ(estimatedCmdSize, commandStreamCSR.getUsed());
1083+
EXPECT_EQ(2u, tagNode->getPacketsUsed());
1084+
1085+
parseCommands<FamilyType>(commandStreamCSR, 0);
1086+
findHardwareCommands<FamilyType>();
1087+
auto cmdItor = cmdList.begin();
1088+
1089+
if (MemorySynchronizationCommands<FamilyType>::isPipeControlWArequired(hwInfo)) {
1090+
PIPE_CONTROL *pipeControl = genCmdCast<PIPE_CONTROL *>(*cmdItor);
1091+
ASSERT_NE(nullptr, pipeControl);
1092+
cmdItor++;
1093+
if (MemorySynchronizationCommands<FamilyType>::getSizeForSingleAdditionalSynchronization(hwInfo) > 0) {
1094+
cmdItor++;
1095+
}
1096+
}
1097+
PIPE_CONTROL *pipeControl = genCmdCast<PIPE_CONTROL *>(*cmdItor);
1098+
ASSERT_NE(nullptr, pipeControl);
1099+
EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation());
1100+
EXPECT_TRUE(pipeControl->getCommandStreamerStallEnable());
1101+
EXPECT_EQ(0u, pipeControl->getImmediateData());
1102+
EXPECT_EQ(gpuAddress, UnitTestHelper<FamilyType>::getPipeControlPostSyncAddress(*pipeControl));
1103+
EXPECT_TRUE(pipeControl->getWorkloadPartitionIdOffsetEnable());
1104+
cmdItor++;
1105+
1106+
if (MemorySynchronizationCommands<FamilyType>::getSizeForSingleAdditionalSynchronization(hwInfo) > 0) {
1107+
cmdItor++;
1108+
}
1109+
1110+
MI_ATOMIC *miAtomic = genCmdCast<MI_ATOMIC *>(*cmdItor);
1111+
ASSERT_NE(nullptr, miAtomic);
1112+
cmdItor++;
1113+
1114+
MI_SEMAPHORE_WAIT *miSemaphore = genCmdCast<MI_SEMAPHORE_WAIT *>(*cmdItor);
1115+
ASSERT_NE(nullptr, miSemaphore);
1116+
cmdItor++;
1117+
1118+
MI_BATCH_BUFFER_START *bbStart = genCmdCast<MI_BATCH_BUFFER_START *>(*cmdItor);
1119+
ASSERT_NE(nullptr, bbStart);
1120+
}

‎shared/source/command_stream/command_stream_receiver_hw.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -70,6 +70,7 @@ class CommandStreamReceiverHw : public CommandStreamReceiver {
7070
size_t getCmdSizeForActivePartitionConfig() const;
7171
size_t getCmdSizeForStallingCommands(const DispatchFlags &dispatchFlags) const;
7272
size_t getCmdSizeForStallingNoPostSyncCommands() const;
73+
size_t getCmdSizeForStallingPostSyncCommands() const;
7374

7475
bool isComputeModeNeeded() const;
7576
bool isPipelineSelectAlreadyProgrammed() const;
@@ -149,6 +150,7 @@ class CommandStreamReceiverHw : public CommandStreamReceiver {
149150
void programVFEState(LinearStream &csr, DispatchFlags &dispatchFlags, uint32_t maxFrontEndThreads);
150151
void programStallingCommandsForBarrier(LinearStream &cmdStream, DispatchFlags &dispatchFlags);
151152
void programStallingNoPostSyncCommandsForBarrier(LinearStream &cmdStream);
153+
void programStallingPostSyncCommandsForBarrier(LinearStream &cmdStream, TagNodeBase &tagNode);
152154
void programEngineModeCommands(LinearStream &csr, const DispatchFlags &dispatchFlags);
153155
void programEngineModeEpliogue(LinearStream &csr, const DispatchFlags &dispatchFlags);
154156
void programActivePartitionConfigFlushTask(LinearStream &csr);

‎shared/source/command_stream/command_stream_receiver_hw_base.inl

Lines changed: 3 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -660,17 +660,8 @@ inline void CommandStreamReceiverHw<GfxFamily>::programStallingCommandsForBarrie
660660
auto barrierTimestampPacketNodes = dispatchFlags.barrierTimestampPacketNodes;
661661

662662
if (barrierTimestampPacketNodes && barrierTimestampPacketNodes->peekNodes().size() != 0) {
663-
auto barrierTimestampPacketGpuAddress = TimestampPacketHelper::getContextEndGpuAddress(*dispatchFlags.barrierTimestampPacketNodes->peekNodes()[0]);
664-
665-
PipeControlArgs args(true);
666-
MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
667-
cmdStream,
668-
PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA,
669-
barrierTimestampPacketGpuAddress,
670-
0,
671-
peekHwInfo(),
672-
args);
673-
dispatchFlags.barrierTimestampPacketNodes->makeResident(*this);
663+
programStallingPostSyncCommandsForBarrier(cmdStream, *barrierTimestampPacketNodes->peekNodes()[0]);
664+
barrierTimestampPacketNodes->makeResident(*this);
674665
} else {
675666
programStallingNoPostSyncCommandsForBarrier(cmdStream);
676667
}
@@ -1474,7 +1465,7 @@ template <typename GfxFamily>
14741465
size_t CommandStreamReceiverHw<GfxFamily>::getCmdSizeForStallingCommands(const DispatchFlags &dispatchFlags) const {
14751466
auto barrierTimestampPacketNodes = dispatchFlags.barrierTimestampPacketNodes;
14761467
if (barrierTimestampPacketNodes && barrierTimestampPacketNodes->peekNodes().size() > 0) {
1477-
return MemorySynchronizationCommands<GfxFamily>::getSizeForPipeControlWithPostSyncOperation(peekHwInfo());
1468+
return getCmdSizeForStallingPostSyncCommands();
14781469
} else {
14791470
return getCmdSizeForStallingNoPostSyncCommands();
14801471
}

‎shared/source/command_stream/command_stream_receiver_hw_bdw_and_later.inl

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -159,12 +159,30 @@ inline size_t CommandStreamReceiverHw<GfxFamily>::getCmdSizeForStallingNoPostSyn
159159
return sizeof(typename GfxFamily::PIPE_CONTROL);
160160
}
161161

162+
template <typename GfxFamily>
163+
inline size_t CommandStreamReceiverHw<GfxFamily>::getCmdSizeForStallingPostSyncCommands() const {
164+
return MemorySynchronizationCommands<GfxFamily>::getSizeForPipeControlWithPostSyncOperation(peekHwInfo());
165+
}
166+
162167
template <typename GfxFamily>
163168
inline void CommandStreamReceiverHw<GfxFamily>::programStallingNoPostSyncCommandsForBarrier(LinearStream &cmdStream) {
164169
PipeControlArgs args;
165170
MemorySynchronizationCommands<GfxFamily>::addPipeControl(cmdStream, args);
166171
}
167172

173+
template <typename GfxFamily>
174+
inline void CommandStreamReceiverHw<GfxFamily>::programStallingPostSyncCommandsForBarrier(LinearStream &cmdStream, TagNodeBase &tagNode) {
175+
auto barrierTimestampPacketGpuAddress = TimestampPacketHelper::getContextEndGpuAddress(tagNode);
176+
PipeControlArgs args(true);
177+
MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
178+
cmdStream,
179+
PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA,
180+
barrierTimestampPacketGpuAddress,
181+
0,
182+
peekHwInfo(),
183+
args);
184+
}
185+
168186
template <typename GfxFamily>
169187
inline void CommandStreamReceiverHw<GfxFamily>::configurePostSyncWriteOffset() {
170188
}

‎shared/source/command_stream/command_stream_receiver_hw_xehp_and_later.inl

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -206,6 +206,17 @@ inline size_t CommandStreamReceiverHw<GfxFamily>::getCmdSizeForStallingNoPostSyn
206206
}
207207
}
208208

209+
template <typename GfxFamily>
210+
inline size_t CommandStreamReceiverHw<GfxFamily>::getCmdSizeForStallingPostSyncCommands() const {
211+
if (this->activePartitions > 1 && this->staticWorkPartitioningEnabled) {
212+
return ImplicitScalingDispatch<GfxFamily>::getBarrierSize(peekHwInfo(),
213+
false,
214+
true);
215+
} else {
216+
return MemorySynchronizationCommands<GfxFamily>::getSizeForPipeControlWithPostSyncOperation(peekHwInfo());
217+
}
218+
}
219+
209220
template <typename GfxFamily>
210221
inline void CommandStreamReceiverHw<GfxFamily>::programStallingNoPostSyncCommandsForBarrier(LinearStream &cmdStream) {
211222
PipeControlArgs args;
@@ -223,6 +234,32 @@ inline void CommandStreamReceiverHw<GfxFamily>::programStallingNoPostSyncCommand
223234
}
224235
}
225236

237+
template <typename GfxFamily>
238+
inline void CommandStreamReceiverHw<GfxFamily>::programStallingPostSyncCommandsForBarrier(LinearStream &cmdStream, TagNodeBase &tagNode) {
239+
auto barrierTimestampPacketGpuAddress = TimestampPacketHelper::getContextEndGpuAddress(tagNode);
240+
PipeControlArgs args(true);
241+
if (this->activePartitions > 1 && this->staticWorkPartitioningEnabled) {
242+
args.workloadPartitionOffset = true;
243+
ImplicitScalingDispatch<GfxFamily>::dispatchBarrierCommands(cmdStream,
244+
this->deviceBitfield,
245+
args,
246+
peekHwInfo(),
247+
barrierTimestampPacketGpuAddress,
248+
0,
249+
false,
250+
false);
251+
tagNode.setPacketsUsed(this->activePartitions);
252+
} else {
253+
MemorySynchronizationCommands<GfxFamily>::addPipeControlAndProgramPostSyncOperation(
254+
cmdStream,
255+
PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA,
256+
barrierTimestampPacketGpuAddress,
257+
0,
258+
peekHwInfo(),
259+
args);
260+
}
261+
}
262+
226263
template <typename GfxFamily>
227264
inline void CommandStreamReceiverHw<GfxFamily>::configurePostSyncWriteOffset() {
228265
this->postSyncWriteOffset = ImplicitScalingDispatch<GfxFamily>::getPostSyncOffset();

‎shared/test/common/libult/ult_command_stream_receiver.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,9 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
4848
using BaseClass::programEnginePrologue;
4949
using BaseClass::programPerDssBackedBuffer;
5050
using BaseClass::programPreamble;
51+
using BaseClass::programStallingCommandsForBarrier;
5152
using BaseClass::programStallingNoPostSyncCommandsForBarrier;
53+
using BaseClass::programStallingPostSyncCommandsForBarrier;
5254
using BaseClass::programStateSip;
5355
using BaseClass::programVFEState;
5456
using BaseClass::requiresInstructionCacheFlush;

0 commit comments

Comments
 (0)