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

performance: Signal inOrder counter with pipe control

Browse Source 
When on DC flush platform signal inOrder counter directly with pipe
control. Skip not needed inOrder timestamp with its reset and semaphore.
Currently only for non profiling immediate cmd list case.

Related-To: NEO-13441

Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>
This commit is contained in:
Lukasz Jobczyk
2024-12-18 15:07:04 +00:00
committed by Compute-Runtime-Automation
parent 9a14fe2478
commit 085988c5e9
8 changed files with 106 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/cmdlist/cmdlist_hw.h
View File

@@ -185,7 +185,7 @@ struct CommandListCoreFamily : public CommandListImp {
void appendWaitOnInOrderDependency(std::shared_ptr<NEO::InOrderExecInfo> &inOrderExecInfo, CommandToPatchContainer *outListCommands,
uint64_t waitValue, uint32_t offset, bool relaxedOrderingAllowed, bool implicitDependency,
bool skipAddingWaitEventsToResidency, bool noopDispatch, bool copyOffloadOperation);
void appendSignalInOrderDependencyCounter(Event *signalEvent, bool copyOffloadOperation);
void appendSignalInOrderDependencyCounter(Event *signalEvent, bool copyOffloadOperation, bool stall);
void handleInOrderDependencyCounter(Event *signalEvent, bool nonWalkerInOrderCmdsChaining, bool copyOffloadOperation);
ze_result_t appendWriteGlobalTimestamp(uint64_t *dstptr, ze_event_handle_t hSignalEvent,

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

@@ -186,7 +186,7 @@ void CommandListCoreFamily<gfxCoreFamily>::handleInOrderDependencyCounter(Event
inOrderExecInfo->setAllocationOffset(newOffset);
inOrderExecInfo->initializeAllocationsFromHost();
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(nullptr, copyOffloadOperation); // signal counter on new offset
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(nullptr, copyOffloadOperation, false); // signal counter on new offset
}
inOrderExecInfo->addCounterValue(getInOrderIncrementValue());
@@ -587,7 +587,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendEventReset(ze_event_hand
}
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(event, false);
appendSignalInOrderDependencyCounter(event, false, false);
}
handleInOrderDependencyCounter(event, false, false);
event->unsetInOrderExecInfo();
@@ -635,7 +635,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryRangesBarrier(uint
addToMappedEventList(signalEvent);
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -1416,7 +1416,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendCopyImageBlit(NEO::Graph
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, false, false, true);
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -1677,7 +1677,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryCopy(void *dstptr,
NEO::PipeControlArgs args;
NEO::MemorySynchronizationCommands<GfxFamily>::addSingleBarrier(*commandContainer.getCommandStream(), args);
}
appendSignalInOrderDependencyCounter(signalEvent, isCopyOnlyEnabled);
appendSignalInOrderDependencyCounter(signalEvent, isCopyOnlyEnabled, false);
}
if (!isCopyOnlyEnabled || inOrderCopyOnlySignalingAllowed) {
@@ -1782,7 +1782,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryCopyRegion(void *d
if (this->isInOrderExecutionEnabled()) {
if (inOrderCopyOnlySignalingAllowed) {
appendSignalInOrderDependencyCounter(signalEvent, isCopyOnlyEnabled);
appendSignalInOrderDependencyCounter(signalEvent, isCopyOnlyEnabled, false);
handleInOrderDependencyCounter(signalEvent, false, isCopyOnlyEnabled);
}
} else {
@@ -2223,7 +2223,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryFill(void *ptr,
NEO::PipeControlArgs args;
NEO::MemorySynchronizationCommands<GfxFamily>::addSingleBarrier(*commandContainer.getCommandStream(), args);
}
appendSignalInOrderDependencyCounter(signalEvent, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false);
} else {
nonWalkerInOrderCmdChaining = isInOrderNonWalkerSignalingRequired(signalEvent);
}
@@ -2295,7 +2295,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendBlitFill(void *ptr,
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, false, false, true);
if (isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
}
@@ -2536,7 +2536,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendSignalEvent(ze_event_han
}
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(event, false);
appendSignalInOrderDependencyCounter(event, false, false);
}
handleInOrderDependencyCounter(event, false, false);
@@ -2746,7 +2746,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitOnEvents(uint32_t nu
if (apiRequest) {
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(nullptr, copyOffloadOperation);
appendSignalInOrderDependencyCounter(nullptr, copyOffloadOperation, false);
}
handleInOrderDependencyCounter(nullptr, false, copyOffloadOperation);
}
@@ -2789,13 +2789,26 @@ void CommandListCoreFamily<gfxCoreFamily>::appendSdiInOrderCounterSignalling(uin
}
template <GFXCORE_FAMILY gfxCoreFamily>
void CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(Event *signalEvent, bool copyOffloadOperation) {
void CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(Event *signalEvent, bool copyOffloadOperation, bool stall) {
uint64_t deviceAllocGpuVa = inOrderExecInfo->getBaseDeviceAddress();
uint64_t signalValue = inOrderExecInfo->getCounterValue() + getInOrderIncrementValue();
auto cmdStream = commandContainer.getCommandStream();
if (this->inOrderAtomicSignalingEnabled) {
if (stall) {
NEO::PipeControlArgs args;
args.dcFlushEnable = true;
args.workloadPartitionOffset = partitionCount > 1;
NEO::MemorySynchronizationCommands<GfxFamily>::addBarrierWithPostSyncOperation(
*cmdStream,
NEO::PostSyncMode::immediateData,
deviceAllocGpuVa + inOrderExecInfo->getAllocationOffset(),
signalValue,
device->getNEODevice()->getRootDeviceEnvironment(),
args);
} else if (this->inOrderAtomicSignalingEnabled) {
using ATOMIC_OPCODES = typename GfxFamily::MI_ATOMIC::ATOMIC_OPCODES;
using DATA_SIZE = typename GfxFamily::MI_ATOMIC::DATA_SIZE;
@@ -3016,7 +3029,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWriteGlobalTimestamp(
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, false, false, isCopyOnly(false));
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -3575,7 +3588,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendBarrier(ze_event_handle_
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, this->isInOrderExecutionEnabled(), false, isCopyOnly(false));
if (isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -3742,7 +3755,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWaitOnMemory(void *desc,
appendSignalEventPostWalker(signalEvent, nullptr, nullptr, false, false, isCopyOnly(false));
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(signalEvent, false);
appendSignalInOrderDependencyCounter(signalEvent, false, false);
}
handleInOrderDependencyCounter(signalEvent, false, false);
@@ -3789,7 +3802,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendWriteToMemory(void *desc
}
if (this->isInOrderExecutionEnabled()) {
appendSignalInOrderDependencyCounter(nullptr, false);
appendSignalInOrderDependencyCounter(nullptr, false, false);
}
handleInOrderDependencyCounter(nullptr, false, false);

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

@@ -562,7 +562,7 @@ void CommandListCoreFamilyImmediate<gfxCoreFamily>::handleInOrderNonWalkerSignal
}
CommandListCoreFamily<gfxCoreFamily>::appendWaitOnSingleEvent(event, nullptr, nonWalkerSignalingHasRelaxedOrdering, false, CommandToPatch::Invalid);
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(event, false);
CommandListCoreFamily<gfxCoreFamily>::appendSignalInOrderDependencyCounter(event, false, false);
}
template <GFXCORE_FAMILY gfxCoreFamily>

2
level_zero/core/source/cmdlist/cmdlist_hw_skl_to_tgllp.inl
View File

@@ -301,7 +301,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
NEO::MemorySynchronizationCommands<GfxFamily>::addSingleBarrier(*commandContainer.getCommandStream(), args);
}
appendSignalInOrderDependencyCounter(event, false);
appendSignalInOrderDependencyCounter(event, false, false);
}
return ZE_RESULT_SUCCESS;

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

@@ -299,16 +299,18 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
inOrderNonWalkerSignalling = isInOrderNonWalkerSignalingRequired(eventForInOrderExec);
if (inOrderExecSignalRequired) {
if (inOrderNonWalkerSignalling) {
if (!eventForInOrderExec->getAllocation(this->device) && Event::standaloneInOrderTimestampAllocationEnabled()) {
eventForInOrderExec->resetInOrderTimestampNode(device->getInOrderTimestampAllocator()->getTag());
}
dispatchEventPostSyncOperation(eventForInOrderExec, nullptr, launchParams.outListCommands, Event::STATE_CLEARED, false, false, false, false, false);
} else {
inOrderCounterValue = this->inOrderExecInfo->getCounterValue() + getInOrderIncrementValue();
inOrderExecInfo = this->inOrderExecInfo.get();
if (eventForInOrderExec && eventForInOrderExec->isCounterBased() && !isTimestampEvent) {
eventAddress = 0;
if (!compactEvent || !this->isImmediateType() || (!compactEvent->isCounterBased() || compactEvent->isUsingContextEndOffset())) {
if (inOrderNonWalkerSignalling) {
if (!eventForInOrderExec->getAllocation(this->device) && Event::standaloneInOrderTimestampAllocationEnabled()) {
eventForInOrderExec->resetInOrderTimestampNode(device->getInOrderTimestampAllocator()->getTag());
}
dispatchEventPostSyncOperation(eventForInOrderExec, nullptr, launchParams.outListCommands, Event::STATE_CLEARED, false, false, false, false, false);
} else {
inOrderCounterValue = this->inOrderExecInfo->getCounterValue() + getInOrderIncrementValue();
inOrderExecInfo = this->inOrderExecInfo.get();
if (eventForInOrderExec && eventForInOrderExec->isCounterBased() && !isTimestampEvent) {
eventAddress = 0;
}
}
}
}
@@ -382,7 +384,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
}
if (!launchParams.makeKernelCommandView) {
if (compactEvent) {
if ((compactEvent && (!compactEvent->isCounterBased() || compactEvent->isUsingContextEndOffset() || !this->isImmediateType()))) {
void **syncCmdBuffer = nullptr;
if (launchParams.outSyncCommand != nullptr) {
launchParams.outSyncCommand->type = CommandToPatch::SignalEventPostSyncPipeControl;
@@ -406,8 +408,12 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendLaunchKernelWithParams(K
if (inOrderExecSignalRequired) {
if (inOrderNonWalkerSignalling) {
if (!launchParams.skipInOrderNonWalkerSignaling) {
appendWaitOnSingleEvent(eventForInOrderExec, launchParams.outListCommands, false, false, CommandToPatch::CbEventTimestampPostSyncSemaphoreWait);
appendSignalInOrderDependencyCounter(eventForInOrderExec, false);
if ((compactEvent && (compactEvent->isCounterBased() && !compactEvent->isUsingContextEndOffset() && this->isImmediateType()))) {
appendSignalInOrderDependencyCounter(eventForInOrderExec, false, true);
} else {
appendWaitOnSingleEvent(eventForInOrderExec, launchParams.outListCommands, false, false, CommandToPatch::CbEventTimestampPostSyncSemaphoreWait);
appendSignalInOrderDependencyCounter(eventForInOrderExec, false, false);
}
}
} else {
launchParams.skipInOrderNonWalkerSignaling = false;

2
level_zero/core/source/device/bcs_split.h
View File

@@ -143,7 +143,7 @@ struct BcsSplit {
cmdList->appendEventForProfilingAllWalkers(this->events.marker[markerEventIndex], nullptr, nullptr, false, true, false, true);
if (cmdList->isInOrderExecutionEnabled()) {
cmdList->appendSignalInOrderDependencyCounter(signalEvent, false);
cmdList->appendSignalInOrderDependencyCounter(signalEvent, false, false);
}
cmdList->handleInOrderDependencyCounter(signalEvent, false, false);

88
level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist_1.cpp
View File

@@ -2415,9 +2415,6 @@ HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenAddingRelaxedOrderingEventsTh
HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenProgrammingWalkerThenSignalSyncAllocation, IsAtLeastXeHpCore) {
using WalkerVariant = typename FamilyType::WalkerVariant;
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
uint32_t counterOffset = 64;
@@ -2475,29 +2472,17 @@ HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenProgrammingWalkerThenSignalSy
using PostSyncType = std::decay_t<decltype(postSync)>;
if (isCompactEvent) {
auto eventEndGpuVa = events[0]->getCompletionFieldGpuAddress(device);
EXPECT_EQ(PostSyncType::OPERATION::OPERATION_NO_WRITE, postSync.getOperation());
auto pcItor = find<PIPE_CONTROL *>(walkerItor, cmdList.end());
ASSERT_NE(cmdList.end(), pcItor);
auto pcCmd = genCmdCast<PIPE_CONTROL *>(*pcItor);
auto semaphoreItor = find<MI_SEMAPHORE_WAIT *>(pcItor, cmdList.end());
ASSERT_NE(cmdList.end(), semaphoreItor);
auto semaphoreCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*semaphoreItor);
ASSERT_NE(nullptr, semaphoreCmd);
EXPECT_EQ(static_cast<uint32_t>(Event::State::STATE_CLEARED), semaphoreCmd->getSemaphoreDataDword());
EXPECT_EQ(eventEndGpuVa, semaphoreCmd->getSemaphoreGraphicsAddress());
EXPECT_EQ(MI_SEMAPHORE_WAIT::COMPARE_OPERATION::COMPARE_OPERATION_SAD_NOT_EQUAL_SDD, semaphoreCmd->getCompareOperation());
auto sdiCmd = genCmdCast<MI_STORE_DATA_IMM *>(++semaphoreCmd);
ASSERT_NE(nullptr, sdiCmd);
EXPECT_EQ(immCmdList->inOrderExecInfo->getBaseDeviceAddress() + counterOffset, sdiCmd->getAddress());
EXPECT_EQ(immCmdList->isQwordInOrderCounter(), sdiCmd->getStoreQword());
EXPECT_EQ(2u, sdiCmd->getDataDword0());
uint64_t address = pcCmd->getAddressHigh();
address <<= 32;
address |= pcCmd->getAddress();
EXPECT_EQ(immCmdList->inOrderExecInfo->getBaseDeviceAddress() + counterOffset, address);
EXPECT_EQ(2u, pcCmd->getImmediateData());
} else {
if (!immCmdList->inOrderExecInfo->isAtomicDeviceSignalling()) {
EXPECT_EQ(PostSyncType::OPERATION::OPERATION_WRITE_IMMEDIATE_DATA, postSync.getOperation());
@@ -4250,6 +4235,7 @@ HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenProgrammingCounterWithOverflo
HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenProgrammingCounterWithOverflowThenHandleItCorrectly, IsAtLeastXeHpCore) {
using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
using WalkerVariant = typename FamilyType::WalkerVariant;
auto immCmdList = createImmCmdList<gfxCoreFamily>();
@@ -4283,22 +4269,21 @@ HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenProgrammingCounterWithOverflo
expectedCounter = std::numeric_limits<uint32_t>::max();
WalkerVariant walkerVariant = NEO::UnitTestHelper<FamilyType>::getWalkerVariant(*walkerItor);
std::visit([isCompactEvent, &semaphoreItor, &immCmdList, &cmdList, expectedCounter](auto &&walker) {
std::visit([isCompactEvent, &semaphoreItor, &walkerItor, &immCmdList, &cmdList, expectedCounter](auto &&walker) {
auto &postSync = walker->getPostSync();
using PostSyncType = std::decay_t<decltype(postSync)>;
if (isCompactEvent) {
EXPECT_NE(cmdList.end(), semaphoreItor);
auto sdiItor = find<MI_STORE_DATA_IMM *>(semaphoreItor, cmdList.end());
ASSERT_NE(cmdList.end(), sdiItor);
auto pcItor = find<PIPE_CONTROL *>(walkerItor, cmdList.end());
ASSERT_NE(cmdList.end(), pcItor);
auto pcCmd = genCmdCast<PIPE_CONTROL *>(*pcItor);
auto sdiCmd = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
ASSERT_NE(nullptr, sdiCmd);
EXPECT_EQ(immCmdList->inOrderExecInfo->getBaseDeviceAddress(), sdiCmd->getAddress());
EXPECT_EQ(getLowPart(expectedCounter), sdiCmd->getDataDword0());
EXPECT_EQ(getHighPart(expectedCounter), sdiCmd->getDataDword1());
uint64_t address = pcCmd->getAddressHigh();
address <<= 32;
address |= pcCmd->getAddress();
EXPECT_EQ(immCmdList->inOrderExecInfo->getBaseDeviceAddress(), address);
EXPECT_EQ(expectedCounter, pcCmd->getImmediateData());
EXPECT_EQ(PostSyncType::OPERATION::OPERATION_NO_WRITE, postSync.getOperation());
} else {
@@ -4314,27 +4299,30 @@ HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenProgrammingCounterWithOverflo
walkerVariant);
} else {
ASSERT_NE(cmdList.end(), semaphoreItor);
if (isCompactEvent) {
// commands chaining
semaphoreItor = find<MI_SEMAPHORE_WAIT *>(++semaphoreItor, cmdList.end());
ASSERT_NE(cmdList.end(), semaphoreItor);
}
auto semaphoreCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*semaphoreItor);
ASSERT_NE(nullptr, semaphoreCmd);
EXPECT_EQ(std::numeric_limits<uint32_t>::max(), semaphoreCmd->getSemaphoreDataDword());
EXPECT_EQ(baseGpuVa, semaphoreCmd->getSemaphoreGraphicsAddress());
auto sdiCmd = genCmdCast<MI_STORE_DATA_IMM *>(++semaphoreCmd);
ASSERT_NE(nullptr, sdiCmd);
offset = device->getL0GfxCoreHelper().getImmediateWritePostSyncOffset();
if (isCompactEvent) {
auto pcItor = find<PIPE_CONTROL *>(walkerItor, cmdList.end());
ASSERT_NE(cmdList.end(), pcItor);
auto pcCmd = genCmdCast<PIPE_CONTROL *>(*pcItor);
uint64_t address = pcCmd->getAddressHigh();
address <<= 32;
address |= pcCmd->getAddress();
EXPECT_EQ(immCmdList->inOrderExecInfo->getBaseDeviceAddress(), address);
} else {
ASSERT_NE(cmdList.end(), semaphoreItor);
EXPECT_EQ(baseGpuVa + offset, sdiCmd->getAddress());
EXPECT_EQ(1u, sdiCmd->getDataDword0());
auto semaphoreCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*semaphoreItor);
ASSERT_NE(nullptr, semaphoreCmd);
EXPECT_EQ(std::numeric_limits<uint32_t>::max(), semaphoreCmd->getSemaphoreDataDword());
EXPECT_EQ(baseGpuVa, semaphoreCmd->getSemaphoreGraphicsAddress());
auto sdiCmd = genCmdCast<MI_STORE_DATA_IMM *>(++semaphoreCmd);
ASSERT_NE(nullptr, sdiCmd);
EXPECT_EQ(baseGpuVa + offset, sdiCmd->getAddress());
EXPECT_EQ(1u, sdiCmd->getDataDword0());
}
}
EXPECT_EQ(expectedCounter, immCmdList->inOrderExecInfo->getCounterValue());

43
level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist_2.cpp
View File

@@ -1793,7 +1793,7 @@ HWTEST2_F(StandaloneInOrderTimestampAllocationTests, givenDebugFlagSetWhenAssign
EXPECT_EQ(static_cast<uint32_t>(Event::STATE_INITIAL), *tag0Data);
}
HWTEST2_F(StandaloneInOrderTimestampAllocationTests, givenNonWalkerCounterSignalingWhenPassedNonProfilingEventThenAssignAllocation, IsAtLeastXeHpCore) {
HWTEST2_F(StandaloneInOrderTimestampAllocationTests, givenNonWalkerCounterSignalingWhenPassedNonProfilingEventThenNotAssignAllocation, IsAtLeastXeHpCore) {
auto eventPool = createEvents<FamilyType>(1, false);
auto eventHandle = events[0]->toHandle();
@@ -1805,7 +1805,11 @@ HWTEST2_F(StandaloneInOrderTimestampAllocationTests, givenNonWalkerCounterSignal
bool isCompactEvent = cmdList->compactL3FlushEvent(cmdList->getDcFlushRequired(events[0]->isSignalScope()));
EXPECT_EQ(isCompactEvent, events[0]->getAllocation(device) != nullptr);
if (cmdList->getDcFlushRequired(events[0]->isSignalScope())) {
EXPECT_EQ(isCompactEvent, events[0]->getAllocation(device) == nullptr);
} else {
EXPECT_EQ(isCompactEvent, events[0]->getAllocation(device) != nullptr);
}
EXPECT_EQ(isCompactEvent, cmdList->isInOrderNonWalkerSignalingRequired(events[0].get()));
}
@@ -2951,6 +2955,7 @@ HWTEST2_F(MultiTileInOrderCmdListTests, givenAtomicSignallingEnabledWhenWaitingF
HWTEST2_F(MultiTileInOrderCmdListTests, givenMultiTileInOrderModeWhenProgrammingWaitOnEventsThenHandleAllEventPackets, IsAtLeastXeHpCore) {
using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT;
using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
auto immCmdList = createMultiTileImmCmdList<gfxCoreFamily>();
@@ -2969,32 +2974,16 @@ HWTEST2_F(MultiTileInOrderCmdListTests, givenMultiTileInOrderModeWhenProgramming
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(cmdList, ptrOffset(cmdStream->getCpuBase(), offset), (cmdStream->getUsed() - offset)));
auto semaphoreItor = find<MI_SEMAPHORE_WAIT *>(cmdList.begin(), cmdList.end());
if (isCompactEvent) {
ASSERT_NE(cmdList.end(), semaphoreItor);
auto semaphoreCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*semaphoreItor);
auto pcItors = findAll<PIPE_CONTROL *>(cmdList.begin(), cmdList.end());
ASSERT_NE(pcItors.size(), 0u);
auto pcCmd = genCmdCast<PIPE_CONTROL *>(*pcItors.back());
ASSERT_NE(nullptr, semaphoreCmd);
auto gpuAddress = events[0]->getCompletionFieldGpuAddress(device);
while (gpuAddress != semaphoreCmd->getSemaphoreGraphicsAddress()) {
semaphoreItor = find<MI_SEMAPHORE_WAIT *>(++semaphoreItor, cmdList.end());
ASSERT_NE(cmdList.end(), semaphoreItor);
semaphoreCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(*semaphoreItor);
ASSERT_NE(nullptr, semaphoreCmd);
}
EXPECT_EQ(static_cast<uint32_t>(Event::State::STATE_CLEARED), semaphoreCmd->getSemaphoreDataDword());
EXPECT_EQ(gpuAddress, semaphoreCmd->getSemaphoreGraphicsAddress());
semaphoreCmd = genCmdCast<MI_SEMAPHORE_WAIT *>(++semaphoreCmd);
ASSERT_NE(nullptr, semaphoreCmd);
EXPECT_EQ(static_cast<uint32_t>(Event::State::STATE_CLEARED), semaphoreCmd->getSemaphoreDataDword());
EXPECT_EQ(gpuAddress + events[0]->getSinglePacketSize(), semaphoreCmd->getSemaphoreGraphicsAddress());
uint64_t address = pcCmd->getAddressHigh();
address <<= 32;
address |= pcCmd->getAddress();
EXPECT_EQ(immCmdList->inOrderExecInfo->getBaseDeviceAddress(), address);
EXPECT_EQ(immCmdList->inOrderExecInfo->getCounterValue(), pcCmd->getImmediateData());
}
}
@@ -3043,7 +3032,7 @@ HWTEST2_F(MultiTileInOrderCmdListTests, givenMultiTileInOrderModeWhenSignalingSy
auto cmdStream = immCmdList->getCmdContainer().getCommandStream();
immCmdList->inOrderAtomicSignalingEnabled = false;
immCmdList->appendSignalInOrderDependencyCounter(nullptr, false);
immCmdList->appendSignalInOrderDependencyCounter(nullptr, false, false);
GenCmdList cmdList;
ASSERT_TRUE(FamilyType::Parse::parseCommandBuffer(cmdList, cmdStream->getCpuBase(), cmdStream->getUsed()));