Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: add profiling data to host signalled CB Event 

Related-To: NEO-11378

Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>
This commit is contained in:
Bartosz Dunajski 2024-05-10 09:22:13 +00:00 committed by Compute-Runtime-Automation
parent 6a24610ed1
commit 536698d276
15 changed files with 91 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/api/core/ze_event_api_entrypoints.h
View File

@ -70,7 +70,7 @@ ze_result_t zeCommandListAppendWaitOnEvents(
ze_result_t zeEventHostSignal(
ze_event_handle_t hEvent) {
return L0::Event::fromHandle(hEvent)->hostSignal();
return L0::Event::fromHandle(hEvent)->hostSignal(false);
}
ze_result_t zeEventHostSynchronize(

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

@ -1165,10 +1165,9 @@ ze_result_t CommandListCoreFamilyImmediate<gfxCoreFamily>::performCpuMemcpy(cons
if (signalEvent->isCounterBased()) {
signalEvent->updateInOrderExecState(inOrderExecInfo, inOrderExecInfo->getCounterValue(), inOrderExecInfo->getAllocationOffset());
signalEvent->setIsCompleted();
} else {
signalEvent->hostSignal();
}
signalEvent->hostSignal(true);
}
return ZE_RESULT_SUCCESS;

2
level_zero/core/source/event/event.h
View File

@ -80,7 +80,7 @@ struct EventDescriptor {
struct Event : _ze_event_handle_t {
virtual ~Event() = default;
virtual ze_result_t destroy();
virtual ze_result_t hostSignal() = 0;
virtual ze_result_t hostSignal(bool allowCounterBased) = 0;
virtual ze_result_t hostSynchronize(uint64_t timeout) = 0;
virtual ze_result_t queryStatus() = 0;
virtual ze_result_t reset() = 0;

4
level_zero/core/source/event/event_imp.h
View File

@ -30,7 +30,7 @@ struct EventImp : public Event {
~EventImp() override {}
ze_result_t hostSignal() override;
ze_result_t hostSignal(bool allowCounterBased) override;
ze_result_t hostSynchronize(uint64_t timeout) override;
@ -67,7 +67,7 @@ struct EventImp : public Event {
ze_result_t queryCounterBasedEventStatus();
void handleSuccessfulHostSynchronization();
MOCKABLE_VIRTUAL ze_result_t hostEventSetValue(TagSizeT eventValue);
ze_result_t hostEventSetValueTimestamps(TagSizeT eventVal);
MOCKABLE_VIRTUAL ze_result_t hostEventSetValueTimestamps(TagSizeT eventVal);
MOCKABLE_VIRTUAL void assignKernelEventCompletionData(void *address);
void setRemainingPackets(TagSizeT eventVal, uint64_t nextPacketGpuVa, void *nextPacketAddress, uint32_t packetsAlreadySet);
void getSynchronizedKernelTimestamps(ze_synchronized_timestamp_result_ext_t *pSynchronizedTimestampsBuffer,

11
level_zero/core/source/event/event_impl.inl
View File

@ -496,12 +496,17 @@ ze_result_t EventImp<TagSizeT>::hostEventSetValue(TagSizeT eventVal) {
}
template <typename TagSizeT>
ze_result_t EventImp<TagSizeT>::hostSignal() {
if (this->isCounterBased()) {
ze_result_t EventImp<TagSizeT>::hostSignal(bool allowCounterBased) {
if (!allowCounterBased && this->isCounterBased()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
auto status = hostEventSetValue(Event::STATE_SIGNALED);
ze_result_t status = ZE_RESULT_SUCCESS;
if (!isCounterBased() || isEventTimestampFlagSet()) {
status = hostEventSetValue(Event::STATE_SIGNALED);
}
if (status == ZE_RESULT_SUCCESS) {
this->setIsCompleted();
}

4
level_zero/core/test/unit_tests/mocks/mock_event.h
View File

@ -75,7 +75,7 @@ struct Mock<Event> : public Event {
~Mock() override;
ADDMETHOD_NOBASE(destroy, ze_result_t, ZE_RESULT_SUCCESS, ());
ADDMETHOD_NOBASE(hostSignal, ze_result_t, ZE_RESULT_SUCCESS, ());
ADDMETHOD_NOBASE(hostSignal, ze_result_t, ZE_RESULT_SUCCESS, (bool allowCounterBased));
ADDMETHOD_NOBASE(hostSynchronize, ze_result_t, ZE_RESULT_SUCCESS, (uint64_t timeout));
ADDMETHOD_NOBASE(queryStatus, ze_result_t, ZE_RESULT_SUCCESS, ());
ADDMETHOD_NOBASE(reset, ze_result_t, ZE_RESULT_SUCCESS, ());
@ -143,7 +143,7 @@ class MockEvent : public ::L0::Event {
ze_result_t destroy() override {
return ZE_RESULT_SUCCESS;
}
ze_result_t hostSignal() override {
ze_result_t hostSignal(bool allowCounterBased) override {
return ZE_RESULT_SUCCESS;
}
ze_result_t hostSynchronize(uint64_t timeout) override {

16
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
View File

@ -1050,7 +1050,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithSyncModeAndAppendSignalEvent
commandList->appendSignalEvent(event);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -1090,7 +1090,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithSyncModeAndAppendBarrierThen
commandList->appendBarrier(nullptr, 1, &event, false);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -2267,7 +2267,7 @@ HWTEST_F(CommandListCreate, GivenGpuHangWhenCreatingImmediateCommandListAndAppen
returnValue = commandList->appendSignalEvent(event);
EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
returnValue = eventObject->hostSignal();
returnValue = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, returnValue);
EXPECT_EQ(ZE_RESULT_SUCCESS, eventObject->queryStatus());
@ -2395,7 +2395,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithSyncModeAndAppendResetEventT
commandList->appendEventReset(event);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -2436,7 +2436,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendSignalEven
commandList->appendSignalEvent(event);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -2477,7 +2477,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendBarrierThe
commandList->appendBarrier(event, 0, nullptr, false);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -2521,7 +2521,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndCopyEngineAndApp
commandList->appendBarrier(event, 0, nullptr, false);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -2564,7 +2564,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendEventReset
commandList->appendEventReset(event);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);

12
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_3.cpp
View File

@ -1227,7 +1227,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendSignalEven
commandList->appendSignalEvent(event);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -1268,7 +1268,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendBarrierThe
commandList->appendBarrier(event, 0, nullptr, false);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -1311,7 +1311,7 @@ TEST_F(CommandListCreate, whenCreatingImmCmdListWithASyncModeAndAppendEventReset
commandList->appendEventReset(event);
auto result = eventObject->hostSignal();
auto result = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -1351,11 +1351,11 @@ TEST_F(CommandListCreateWithBcs, givenQueueDescriptionwhenCreatingImmediateComma
commandList->appendBarrier(nullptr, 0, nullptr, false);
commandList->appendBarrier(event->toHandle(), 2, events, false);
auto result = event->hostSignal();
auto result = event->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = event1->hostSignal();
result = event1->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
result = event2->hostSignal();
result = event2->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
}
}

2
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_8.cpp
View File

@ -1115,7 +1115,7 @@ HWTEST2_F(AppendMemoryLockedCopyTest, givenImmediateCommandListAndCpuMemcpyWithD
for (uint32_t i = 0; i < numEvents; i++) {
events[i] = std::unique_ptr<L0::Event>(Event::create<typename FamilyType::TimestampPacketType>(eventPool.get(), &eventDesc, device));
events[i]->hostSignal();
events[i]->hostSignal(false);
waitlist[i] = events[i]->toHandle();
}

8
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_event_reset.cpp
View File

@ -217,7 +217,7 @@ HWTEST_F(CommandListAppendEventReset, givenImmediateCmdlistWhenAppendingEventRes
HWTEST_F(CommandListAppendEventReset, WhenIsCompletedClearedThenSetStateSignaledWhenSignalAgain) {
event->reset();
EXPECT_FALSE(event->isAlreadyCompleted());
event->hostSignal();
event->hostSignal(false);
EXPECT_TRUE(event->isAlreadyCompleted());
}
@ -225,7 +225,7 @@ HWTEST_F(CommandListAppendEventReset, WhenIsCompletedDisabledThenDontSetStateSig
auto result = commandList->appendEventReset(event->toHandle());
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(event->isAlreadyCompleted());
event->hostSignal();
event->hostSignal(false);
EXPECT_FALSE(event->isAlreadyCompleted());
}
@ -234,7 +234,7 @@ HWTEST_F(CommandListAppendEventReset, givenRegularCommandListWhenHostCachingDisa
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(event->isAlreadyCompleted());
event->reset();
event->hostSignal();
event->hostSignal(false);
EXPECT_FALSE(event->isAlreadyCompleted());
}
@ -245,7 +245,7 @@ HWTEST_F(CommandListAppendEventReset, givenRegulatCommandListWhenHostCachingDisa
EXPECT_FALSE(event->isAlreadyCompleted());
event->reset();
event->hostSignal();
event->hostSignal(false);
EXPECT_TRUE(event->isAlreadyCompleted());
}

2
level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_wait_on_events.cpp
View File

@ -669,7 +669,7 @@ HWTEST2_F(CommandListAppendWaitOnEvent, givenImmediateCommandListWhenAppendWaitO
cmdList.csr = device->getNEODevice()->getInternalEngine().commandStreamReceiver;
cmdList.initialize(device, NEO::EngineGroupType::renderCompute, 0u);
cmdList.dcFlushSupport = false;
event->hostSignal();
event->hostSignal(false);
EXPECT_EQ(ZE_RESULT_SUCCESS, event->queryStatus());
ze_event_handle_t eventHandle = event->toHandle();

39
level_zero/core/test/unit_tests/sources/cmdlist/test_in_order_cmdlist.cpp
View File

@ -505,7 +505,7 @@ HWTEST2_F(InOrderCmdListTests, givenInOrderModeWhenHostResetOrSignalEventCalledT
EXPECT_EQ(events[0]->inOrderExecInfo.get(), immCmdList->inOrderExecInfo.get());
EXPECT_EQ(events[0]->inOrderAllocationOffset, 123u);
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, events[0]->hostSignal());
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, events[0]->hostSignal(false));
}
HWTEST2_F(InOrderCmdListTests, whenCreatingInOrderExecInfoThenReuseDeviceAlloc, IsAtLeastSkl) {
@ -3912,6 +3912,43 @@ HWTEST2_F(InOrderCmdListTests, givenImmediateCmdListWhenDoingCpuCopyThenPassInfo
context->freeMem(deviceAlloc);
}
HWTEST2_F(InOrderCmdListTests, givenProfilingEventWhenDoingCpuCopyThenSetProfilingData, IsAtLeastXeHpCore) {
auto immCmdList = createImmCmdList<gfxCoreFamily>();
immCmdList->copyThroughLockedPtrEnabled = true;
auto nonProfilingeventPool = createEvents<FamilyType>(1, false);
auto profilingeventPool = createEvents<FamilyType>(1, true);
auto eventHandle0 = events[0]->toHandle();
auto eventHandle1 = events[1]->toHandle();
EXPECT_EQ(nullptr, events[0]->inOrderExecInfo.get());
uint32_t hostCopyData = 0;
void *deviceAlloc = nullptr;
ze_device_mem_alloc_desc_t deviceDesc = {};
auto result = context->allocDeviceMem(device->toHandle(), &deviceDesc, 128, 128, &deviceAlloc);
ASSERT_EQ(result, ZE_RESULT_SUCCESS);
auto hostAddress = static_cast<uint64_t *>(immCmdList->inOrderExecInfo->getDeviceCounterAllocation()->getUnderlyingBuffer());
*hostAddress = 3;
immCmdList->appendMemoryCopy(deviceAlloc, &hostCopyData, 1, eventHandle0, 0, nullptr, false, false);
EXPECT_NE(nullptr, events[0]->inOrderExecInfo.get());
EXPECT_TRUE(events[0]->isAlreadyCompleted());
EXPECT_EQ(L0::Event::STATE_CLEARED, *static_cast<uint32_t *>(events[0]->getHostAddress()));
immCmdList->appendMemoryCopy(deviceAlloc, &hostCopyData, 1, eventHandle1, 0, nullptr, false, false);
EXPECT_NE(nullptr, events[1]->inOrderExecInfo.get());
EXPECT_TRUE(events[1]->isAlreadyCompleted());
EXPECT_NE(L0::Event::STATE_CLEARED, *static_cast<uint32_t *>(events[1]->getHostAddress()));
context->freeMem(deviceAlloc);
}
HWTEST2_F(InOrderCmdListTests, givenIncorrectInputParamsWhenAskingForEventAddressAndValueThenReturnError, IsAtLeastSkl) {
auto eventPool = createEvents<FamilyType>(1, false);
uint64_t counterValue = 0;

4
level_zero/core/test/unit_tests/sources/debugger/test_l0_debugger_1.cpp
View File

@ -345,7 +345,7 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledWithImmediat
returnValue = commandList->appendSignalEvent(event);
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
returnValue = eventObject->hostSignal();
returnValue = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);
@ -409,7 +409,7 @@ HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionDisabledWithImmedia
returnValue = commandList->appendSignalEvent(event);
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
returnValue = eventObject->hostSignal();
returnValue = eventObject->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(eventObject->queryStatus(), ZE_RESULT_SUCCESS);

28
level_zero/core/test/unit_tests/sources/event/test_event.cpp
View File

@ -1410,7 +1410,7 @@ TEST_F(EventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrectDataAndO
uint64_t gpuAddr = event->getGpuAddress(device);
EXPECT_EQ(gpuAddr, event->getPacketAddress(device));
event->hostSignal();
event->hostSignal(false);
result = event->queryStatus();
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(gpuAddr, event->getPacketAddress(device));
@ -1839,7 +1839,7 @@ TEST_F(EventPoolIPCEventResetTests, whenOpeningIpcHandleForEventPoolCreateWithIp
EXPECT_EQ(*hostAddr, Event::STATE_INITIAL);
// change state
event0->hostSignal();
event0->hostSignal(false);
EXPECT_EQ(*hostAddr, Event::STATE_SIGNALED);
// create an event from the pool with the same index as event0, but this time, since isImportedIpcPool is true, no reset should happen
@ -2015,7 +2015,7 @@ HWTEST2_F(TimestampEventCreateMultiKernel, givenEventTimestampWhenPacketCountIsS
TEST_F(TimestampEventCreate, givenEventWhenSignaledAndResetFromTheHostThenCorrectDataAreSet) {
EXPECT_NE(nullptr, event->kernelEventCompletionData);
event->hostSignal();
event->hostSignal(false);
ze_result_t result = event->queryStatus();
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@ -2897,7 +2897,7 @@ TEST_F(EventTests, WhenQueryingStatusThenSuccessIsReturned) {
auto event = whiteboxCast(getHelper<L0GfxCoreHelper>().createEvent(eventPool.get(), &eventDesc, device));
ASSERT_NE(event, nullptr);
auto result = event->hostSignal();
auto result = event->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(event->queryStatus(), ZE_RESULT_SUCCESS);
@ -2909,7 +2909,7 @@ TEST_F(EventTests, GivenResetWhenQueryingStatusThenNotReadyIsReturned) {
auto event = whiteboxCast(getHelper<L0GfxCoreHelper>().createEvent(eventPool.get(), &eventDesc, device));
ASSERT_NE(event, nullptr);
auto result = event->hostSignal();
auto result = event->hostSignal(false);
ASSERT_EQ(ZE_RESULT_SUCCESS, result);
event->setUsingContextEndOffset(true);
@ -2972,7 +2972,7 @@ TEST_F(EventTests, givenRegularEventUseMultiplePacketsWhenHostSignalThenExpectAl
event->setPacketsInUse(packetsUsed);
event->setEventTimestampFlag(false);
event->hostSignal();
event->hostSignal(false);
for (uint32_t i = 0; i < packetsUsed; i++) {
EXPECT_EQ(Event::STATE_SIGNALED, *hostAddr);
hostAddr = ptrOffset(hostAddr, event->getSinglePacketSize());
@ -3003,7 +3003,7 @@ TEST_F(EventUsedPacketSignalTests, givenEventUseMultiplePacketsWhenHostSignalThe
event->setPacketsInUse(packetsUsed);
event->setEventTimestampFlag(false);
event->hostSignal();
event->hostSignal(false);
for (uint32_t i = 0; i < packetsUsed; i++) {
EXPECT_EQ(Event::STATE_SIGNALED, *hostAddr);
hostAddr = ptrOffset(hostAddr, event->getSinglePacketSize());
@ -3577,7 +3577,7 @@ HWTEST_F(EventTests, GivenCsrTbxModeWhenEventCreatedAndSignaledThenEventAllocati
EXPECT_EQ(0u, ultCsr.writeMemoryParams.latestGpuVaChunkOffset);
EXPECT_TRUE(eventAllocation->isTbxWritable(expectedBanks));
auto status = event->hostSignal();
auto status = event->hostSignal(false);
EXPECT_EQ(ZE_RESULT_SUCCESS, status);
EXPECT_EQ(2u, ultCsr.writeMemoryParams.callCount);
@ -3682,7 +3682,7 @@ struct MockEventCompletion : public L0::EventImp<TagSizeT> {
TEST_F(EventTests, WhenQueryingStatusAfterHostSignalThenDontAccessMemoryAndReturnSuccess) {
auto event = std::make_unique<MockEventCompletion<uint32_t>>(&eventPool->getAllocation(), eventPool->getEventSize(), eventPool->getMaxKernelCount(), eventPool->getEventMaxPackets(), 1u, device);
auto result = event->hostSignal();
auto result = event->hostSignal(false);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event->queryStatus(), ZE_RESULT_SUCCESS);
EXPECT_EQ(event->assignKernelEventCompletionDataCounter, 0u);
@ -3772,7 +3772,7 @@ TEST_F(EventTests, whenAppendAdditionalCsrThenStoreUniqueCsr) {
TEST_F(EventTests, WhenQueryingStatusAfterHostSignalThatFailedThenAccessMemoryAndReturnSuccess) {
auto event = std::make_unique<MockEventCompletion<uint32_t>>(&eventPool->getAllocation(), eventPool->getEventSize(), eventPool->getMaxKernelCount(), eventPool->getEventMaxPackets(), 1u, device);
event->shouldHostEventSetValueFail = true;
event->hostSignal();
event->hostSignal(false);
EXPECT_EQ(event->queryStatus(), ZE_RESULT_SUCCESS);
EXPECT_EQ(event->assignKernelEventCompletionDataCounter, 1u);
}
@ -3788,7 +3788,7 @@ HWTEST_F(EventTests, givenQwordPacketSizeWhenSignalingThenCopyQword) {
event->setSinglePacketSize(sizeof(uint64_t));
*completionAddress = std::numeric_limits<uint64_t>::max();
event->hostSignal();
event->hostSignal(false);
EXPECT_EQ(static_cast<uint64_t>(Event::STATE_SIGNALED), *completionAddress);
@ -3800,7 +3800,7 @@ HWTEST_F(EventTests, givenQwordPacketSizeWhenSignalingThenCopyQword) {
*completionAddress = std::numeric_limits<uint64_t>::max();
event->hostSignal();
event->hostSignal(false);
if (sizeof(TimestampPacketType) == sizeof(uint32_t)) {
uint64_t expectedValue = static_cast<uint64_t>(Event::STATE_SIGNALED);
@ -4119,7 +4119,7 @@ struct EventDynamicPacketUseFixture : public DeviceFixture {
EXPECT_EQ(ZE_RESULT_NOT_READY, result);
event->resetCompletionStatus();
event->hostSignal();
event->hostSignal(false);
remainingPacketsAddress = ptrOffset(eventHostAddress, (usedPackets * packetSize));
if (event->isUsingContextEndOffset()) {
@ -4265,7 +4265,7 @@ void testQueryAllPackets(L0::Event *event, bool singlePacket) {
result = event->queryStatus();
EXPECT_EQ(ZE_RESULT_NOT_READY, result);
result = event->hostSignal();
result = event->hostSignal(false);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
eventHostAddress = firstPacketAddress;

2
level_zero/core/test/unit_tests/xe_hpc_core/test_cmdqueue_xe_hpc_core.cpp
View File

@ -1611,7 +1611,7 @@ HWTEST2_F(CommandQueueCommandsXeHpc, givenSplitBcsCopyAndImmediateCommandListWhe
EXPECT_EQ(static_cast<DeviceImp *>(testL0Device.get())->bcsSplit.events.barrier.size(), 2u);
EXPECT_EQ(static_cast<DeviceImp *>(testL0Device.get())->bcsSplit.events.createdFromLatestPool, 12u);
static_cast<DeviceImp *>(testL0Device.get())->bcsSplit.events.marker[1]->hostSignal();
static_cast<DeviceImp *>(testL0Device.get())->bcsSplit.events.marker[1]->hostSignal(false);
ret = static_cast<DeviceImp *>(testL0Device.get())->bcsSplit.events.obtainForSplit(Context::fromHandle(commandList0->getCmdListContext()), 12);