intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-24 12:23:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: Submit every marker with dependencies

Browse Source 
Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>
This commit is contained in:
Lukasz Jobczyk
2025-08-27 13:51:00 +00:00
committed by Compute-Runtime-Automation
parent 5078e5352d
commit d498f16fc3
14 changed files with 54 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
opencl/source/command_queue/command_queue.cpp
View File

@@ -1205,6 +1205,11 @@ bool CommandQueue::isBlockedCommandStreamRequired(uint32_t commandType, const Ev
return false;
}
bool CommandQueue::isDependenciesFlushForMarkerRequired(const EventsRequest &eventsRequest) const {
return this->getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled() &&
(eventsRequest.outEvent || eventsRequest.numEventsInWaitList > 0);
}
void CommandQueue::storeProperties(const cl_queue_properties *properties) {
if (properties) {
for (size_t i = 0; properties[i] != 0; i += 2) {

2
opencl/source/command_queue/command_queue.h
View File

@@ -458,6 +458,8 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
virtual void obtainTaskLevelAndBlockedStatus(TaskCountType &taskLevel, cl_uint &numEventsInWaitList, const cl_event *&eventWaitList, bool &blockQueueStatus, unsigned int commandType){};
bool isBlockedCommandStreamRequired(uint32_t commandType, const EventsRequest &eventsRequest, bool blockedQueue, bool isMarkerWithProfiling) const;
bool isDependenciesFlushForMarkerRequired(const EventsRequest &eventsRequest) const;
MOCKABLE_VIRTUAL void obtainNewTimestampPacketNodes(size_t numberOfNodes, TimestampPacketContainer &previousNodes, bool clearAllDependencies, CommandStreamReceiver &csr);
void storeProperties(const cl_queue_properties *properties);
void processProperties(const cl_queue_properties *properties);

4
opencl/source/command_queue/enqueue_common.h
View File

@@ -161,8 +161,6 @@ cl_int CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
EventBuilder eventBuilder;
setupEvent(eventBuilder, event, commandType);
const bool isFlushWithPostSyncWrite = isFlushForProfilingRequired(commandType) && ((eventBuilder.getEvent() && eventBuilder.getEvent()->isProfilingEnabled()) || multiDispatchInfo.peekBuiltinOpParams().bcsSplit);
std::unique_ptr<KernelOperation> blockedCommandsData;
std::unique_ptr<PrintfHandler> printfHandler;
TakeOwnershipWrapper<CommandQueueHw<GfxFamily>> queueOwnership(*this);
@@ -190,6 +188,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
CsrDependencies csrDeps;
BlitPropertiesContainer blitPropertiesContainer;
const bool isFlushWithPostSyncWrite = isFlushForProfilingRequired(commandType) && ((eventBuilder.getEvent() && eventBuilder.getEvent()->isProfilingEnabled()) || multiDispatchInfo.peekBuiltinOpParams().bcsSplit || this->isDependenciesFlushForMarkerRequired(eventsRequest));
if (this->context->getRootDeviceIndices().size() > 1) {
eventsRequest.fillCsrDependenciesForRootDevices(csrDeps, computeCommandStreamReceiver);
}

8
opencl/test/unit_test/command_queue/blit_enqueue_1_tests.cpp
View File

@@ -1365,11 +1365,11 @@ HWTEST_TEMPLATED_F(BlitEnqueueTaskCountTests, givenBlockedEnqueueWithoutKernelWh
userEvent.setStatus(CL_COMPLETE);
clWaitForEvents(1, &outEvent2);
EXPECT_EQ(1u, ultGpgpuCsr->latestWaitForCompletionWithTimeoutTaskCount.load());
EXPECT_EQ(2u, ultGpgpuCsr->latestWaitForCompletionWithTimeoutTaskCount.load());
EXPECT_EQ(0u, ultBcsCsr->latestWaitForCompletionWithTimeoutTaskCount.load());
clWaitForEvents(1, &outEvent1);
EXPECT_EQ(0u, ultGpgpuCsr->latestWaitForCompletionWithTimeoutTaskCount.load());
EXPECT_EQ(1u, ultGpgpuCsr->latestWaitForCompletionWithTimeoutTaskCount.load());
EXPECT_EQ(0u, ultBcsCsr->latestWaitForCompletionWithTimeoutTaskCount.load());
clReleaseEvent(outEvent1);
@@ -1486,7 +1486,7 @@ HWTEST_TEMPLATED_F(BlitEnqueueTaskCountTests, givenMarkerThatFollowsCopyOperatio
// make sure we wait for both
clWaitForEvents(1, &outEvent1);
EXPECT_EQ(ultBcsCsr->latestWaitForCompletionWithTimeoutTaskCount, ultBcsCsr->taskCount);
EXPECT_NE(ultBcsCsr->latestWaitForCompletionWithTimeoutTaskCount, ultBcsCsr->taskCount);
EXPECT_EQ(ultGpgpuCsr->latestWaitForCompletionWithTimeoutTaskCount, ultGpgpuCsr->taskCount);
clWaitForEvents(1, &outEvent1);
@@ -1512,7 +1512,7 @@ HWTEST_TEMPLATED_F(BlitEnqueueTaskCountTests, givenMarkerThatFollowsCopyOperatio
// make sure we wait for both
clWaitForEvents(1, &outEvent2);
EXPECT_EQ(ultBcsCsr->latestWaitForCompletionWithTimeoutTaskCount, ultBcsCsr->taskCount);
EXPECT_NE(ultBcsCsr->latestWaitForCompletionWithTimeoutTaskCount, ultBcsCsr->taskCount);
EXPECT_EQ(ultGpgpuCsr->latestWaitForCompletionWithTimeoutTaskCount, ultGpgpuCsr->taskCount);
clWaitForEvents(1, &outEvent2);

2
opencl/test/unit_test/command_queue/enqueue_barrier_tests.cpp
View File

@@ -270,6 +270,7 @@ HWTEST_F(BarrierTest, givenBlockedCommandQueueAndEnqueueBarrierWithWaitlistRetur
EXPECT_EQ(pEvent->peekTaskCount(), CompletionStamp::notReady);
event2.setStatus(CL_COMPLETE);
clReleaseEvent(event);
pCmdQ->finish();
}
HWTEST_F(BarrierTest, givenEmptyCommandStreamAndBlockedBarrierCommandWhenUserEventIsSignaledThenNewCommandStreamIsNotAcquired) {
@@ -313,4 +314,5 @@ HWTEST_F(BarrierTest, givenEmptyCommandStreamAndBlockedBarrierCommandWhenUserEve
EXPECT_GE(commandStream.getMaxAvailableSpace(), commandStream.getMaxAvailableSpace());
clReleaseEvent(event);
pCmdQ->finish();
}

2
opencl/test/unit_test/command_queue/enqueue_handler_tests.cpp
View File

@@ -552,7 +552,7 @@ HWTEST_F(EnqueueHandlerTest, givenExternallySynchronizedParentEventWhenRequestin
Event *ouputEvent = castToObject<Event>(outEv);
ASSERT_NE(nullptr, ouputEvent);
EXPECT_EQ(0U, ouputEvent->peekTaskCount());
EXPECT_EQ(mockCmdQ->taskCount, ouputEvent->peekTaskCount());
ouputEvent->release();
mockCmdQ->release();

33
opencl/test/unit_test/command_queue/enqueue_map_buffer_tests.cpp
View File

@@ -324,7 +324,9 @@ HWTEST_F(EnqueueMapBufferTest, givenNonBlockingReadOnlyMapBufferOnZeroCopyBuffer
EXPECT_NE(nullptr, ptrResult);
EXPECT_EQ(CL_SUCCESS, retVal);
// no dc flush required at this point
if (commandStreamReceiver.peekTimestampPacketWriteEnabled()) {
expectedTaskCount++;
}
EXPECT_EQ(expectedTaskCount, commandStreamReceiver.peekTaskCount());
taskCount = commandStreamReceiver.peekTaskCount();
@@ -332,7 +334,11 @@ HWTEST_F(EnqueueMapBufferTest, givenNonBlockingReadOnlyMapBufferOnZeroCopyBuffer
auto neoEvent = castToObject<Event>(mapEventReturned);
// if task count of csr is higher then event task count with proper dc flushing then we are fine
EXPECT_EQ(this->heaplessStateInit ? 2u : 1u, neoEvent->getCompletionStamp());
auto expectedStamp = this->heaplessStateInit ? 2u : 1u;
if (commandStreamReceiver.peekTimestampPacketWriteEnabled()) {
expectedStamp++;
}
EXPECT_EQ(expectedStamp, neoEvent->getCompletionStamp());
// this can't be completed as task count is not reached yet
EXPECT_FALSE(neoEvent->updateStatusAndCheckCompletion());
EXPECT_TRUE(CL_COMMAND_MAP_BUFFER == neoEvent->getCommandType());
@@ -369,6 +375,9 @@ HWTEST_F(EnqueueMapBufferTest, givenNonBlockingReadOnlyMapBufferOnZeroCopyBuffer
nullptr,
&unmapEventReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
if (commandStreamReceiver.peekTimestampPacketWriteEnabled()) {
expectedTaskCount++;
}
if (commandStreamReceiver.isUpdateTagFromWaitEnabled()) {
EXPECT_EQ(expectedTaskCount + 1, commandStreamReceiver.peekTaskCount());
@@ -378,6 +387,7 @@ HWTEST_F(EnqueueMapBufferTest, givenNonBlockingReadOnlyMapBufferOnZeroCopyBuffer
auto unmapEvent = castToObject<Event>(unmapEventReturned);
EXPECT_TRUE(CL_COMMAND_UNMAP_MEM_OBJECT == unmapEvent->getCommandType());
mockCmdQueue.waitUntilCompleteReturnValue = WaitStatus::ready;
retVal = clWaitForEvents(1, &unmapEventReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -474,6 +484,9 @@ TEST_F(EnqueueMapBufferTest, givenReadOnlyBufferWhenMappedOnGpuThenSetValidEvent
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clEnqueueUnmapMemObject(pCmdQ, buffer.get(), ptrResult, 0, nullptr, &unmapEventReturned);
if (commandStreamReceiver.peekTimestampPacketWriteEnabled()) {
expectedTaskCount++;
}
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(expectedTaskCount, commandStreamReceiver.peekTaskCount());
@@ -487,7 +500,7 @@ TEST_F(EnqueueMapBufferTest, givenReadOnlyBufferWhenMappedOnGpuThenSetValidEvent
clReleaseEvent(unmapEventReturned);
}
TEST_F(EnqueueMapBufferTest, givenNonBlockingMapBufferAfterL3IsAlreadyFlushedThenEventIsSignaledAsCompleted) {
HWTEST_F(EnqueueMapBufferTest, givenNonBlockingMapBufferAfterL3IsAlreadyFlushedThenEventIsSignaledAsCompleted) {
cl_event eventReturned = nullptr;
uint32_t tagHW = 0;
*pTagMemory = tagHW;
@@ -503,7 +516,7 @@ TEST_F(EnqueueMapBufferTest, givenNonBlockingMapBufferAfterL3IsAlreadyFlushedThe
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, buffer);
auto &commandStreamReceiver = pCmdQ->getGpgpuCommandStreamReceiver();
auto &commandStreamReceiver = pClDevice->getUltCommandStreamReceiver<FamilyType>();
TaskCountType taskCount = commandStreamReceiver.peekTaskCount();
auto expectedTaskCount = this->heaplessStateInit ? 1u : 0u;
@@ -530,6 +543,9 @@ TEST_F(EnqueueMapBufferTest, givenNonBlockingMapBufferAfterL3IsAlreadyFlushedThe
nullptr,
&eventReturned,
&retVal);
if (commandStreamReceiver.peekTimestampPacketWriteEnabled()) {
expectedTaskCount++;
}
EXPECT_NE(nullptr, ptrResult);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -545,14 +561,11 @@ TEST_F(EnqueueMapBufferTest, givenNonBlockingMapBufferAfterL3IsAlreadyFlushedThe
EXPECT_EQ(expectedTaskCount, commandStreamReceiver.peekLatestSentTaskCount());
// wait for events shouldn't call flush task
commandStreamReceiver.waitForTaskCountWithKmdNotifyFallbackReturnValue = WaitStatus::ready;
retVal = clWaitForEvents(1, &eventReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
if (commandStreamReceiver.isUpdateTagFromWaitEnabled()) {
EXPECT_EQ(expectedTaskCount + 1, commandStreamReceiver.peekLatestSentTaskCount());
} else {
EXPECT_EQ(expectedTaskCount, commandStreamReceiver.peekLatestSentTaskCount());
}
EXPECT_EQ(expectedTaskCount, commandStreamReceiver.peekLatestSentTaskCount());
retVal = clReleaseMemObject(buffer);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -679,7 +692,7 @@ HWTEST_F(EnqueueMapBufferTest, GivenPtrToReturnEventWhenMappingBufferThenEventIs
EXPECT_NE(nullptr, eventReturned);
auto eventObject = castToObject<Event>(eventReturned);
EXPECT_EQ(0u, eventObject->peekTaskCount());
EXPECT_EQ(pCmdQ->taskCount, eventObject->peekTaskCount());
EXPECT_TRUE(eventObject->updateStatusAndCheckCompletion());
retVal = clEnqueueUnmapMemObject(

6
opencl/test/unit_test/command_queue/enqueue_map_image_tests.cpp
View File

@@ -414,7 +414,7 @@ HWTEST_F(EnqueueMapImageTest, givenReadOnlyMapWithOutEventWhenMappedThenSetEvent
*pTagMemory = 5;
auto &commandStreamReceiver = pCmdQ->getGpgpuCommandStreamReceiver();
const auto commandStreamReceiverTaskCountBefore = commandStreamReceiver.peekTaskCount();
auto commandStreamReceiverTaskCountBefore = commandStreamReceiver.peekTaskCount();
EXPECT_EQ(pCmdQ->getHeaplessStateInitEnabled() ? 2u : 1u, commandStreamReceiver.peekTaskCount());
auto ptr = pCmdQ->enqueueMapImage(image, false, mapFlags, origin, region, nullptr, nullptr, 0,
@@ -433,6 +433,10 @@ HWTEST_F(EnqueueMapImageTest, givenReadOnlyMapWithOutEventWhenMappedThenSetEvent
retVal = clEnqueueUnmapMemObject(pCmdQ, image, ptr, 0, nullptr, &unmapEventReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
if (commandStreamReceiver.peekTimestampPacketWriteEnabled()) {
commandStreamReceiverTaskCountBefore++;
}
EXPECT_EQ(commandStreamReceiverTaskCountBefore + 1, commandStreamReceiver.peekTaskCount());
auto unmapEvent = castToObject<Event>(unmapEventReturned);

3
opencl/test/unit_test/command_queue/enqueue_marker_tests.cpp
View File

@@ -152,9 +152,6 @@ HWTEST_F(MarkerTest, WhenEnqueingMarkerThenReturnedEventShouldHaveEqualDepthToLa
ASSERT_NE(nullptr, event);
std::unique_ptr<Event> pEvent((Event *)(event));
// Shouldn't sync to CSR
// should sync to command queue last packet
EXPECT_EQ(1u, pEvent->taskLevel);
EXPECT_EQ(pCmdQ->taskLevel, pEvent->taskLevel);
}

2
opencl/test/unit_test/command_queue/enqueue_unmap_memobject_tests.cpp
View File

@@ -134,7 +134,7 @@ HWTEST_F(EnqueueUnmapMemObjTest, WhenUnmappingMemoryObjectThenEventIsUpdated) {
EXPECT_NE(nullptr, eventReturned);
auto eventObject = castToObject<Event>(eventReturned);
EXPECT_EQ(0u, eventObject->peekTaskCount());
EXPECT_EQ(pCmdQ->taskCount, eventObject->peekTaskCount());
EXPECT_TRUE(eventObject->updateStatusAndCheckCompletion());
clReleaseEvent(eventReturned);

31
opencl/test/unit_test/command_queue/get_size_required_tests.cpp
View File

@@ -52,10 +52,7 @@ HWTEST_F(GetSizeRequiredTest, WhenFinishingThenHeapsAndCommandBufferAreNotConsum
EXPECT_EQ(0u, ssh->getUsed() - usedBeforeSSH);
}
HWTEST_F(GetSizeRequiredTest, WhenEnqueuingMarkerThenHeapsAndCommandBufferAreNotConsumed) {
auto &commandStream = pCmdQ->getCS(1024);
auto usedBeforeCS = commandStream.getUsed();
HWTEST_F(GetSizeRequiredTest, WhenEnqueuingMarkerThenHeapsAreNotConsumed) {
Event event1(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 5, 15);
cl_event eventBeingWaitedOn = &event1;
cl_event eventReturned = nullptr;
@@ -64,14 +61,6 @@ HWTEST_F(GetSizeRequiredTest, WhenEnqueuingMarkerThenHeapsAndCommandBufferAreNot
&eventBeingWaitedOn,
&eventReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
size_t expectedStreamSize = 0;
if (pCmdQ->getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled() && (!pCmdQ->getGpgpuCommandStreamReceiver().isUpdateTagFromWaitEnabled())) {
expectedStreamSize = alignUp(MemorySynchronizationCommands<FamilyType>::getSizeForBarrierWithPostSyncOperation(
pDevice->getRootDeviceEnvironment(), NEO::PostSyncMode::immediateData),
MemoryConstants::cacheLineSize);
}
EXPECT_EQ(expectedStreamSize, commandStream.getUsed() - usedBeforeCS);
EXPECT_EQ(0u, dsh->getUsed() - usedBeforeDSH);
EXPECT_EQ(0u, ioh->getUsed() - usedBeforeIOH);
EXPECT_EQ(0u, ssh->getUsed() - usedBeforeSSH);
@@ -79,10 +68,7 @@ HWTEST_F(GetSizeRequiredTest, WhenEnqueuingMarkerThenHeapsAndCommandBufferAreNot
clReleaseEvent(eventReturned);
}
HWTEST_F(GetSizeRequiredTest, WhenEnqueuingBarrierThenHeapsAndCommandBufferAreNotConsumed) {
auto &commandStream = pCmdQ->getCS(1024);
auto usedBeforeCS = commandStream.getUsed();
HWTEST_F(GetSizeRequiredTest, WhenEnqueuingBarrierThenHeapsAreNotConsumed) {
Event event1(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 5, 15);
cl_event eventBeingWaitedOn = &event1;
cl_event eventReturned = nullptr;
@@ -91,16 +77,9 @@ HWTEST_F(GetSizeRequiredTest, WhenEnqueuingBarrierThenHeapsAndCommandBufferAreNo
&eventBeingWaitedOn,
&eventReturned);
EXPECT_EQ(CL_SUCCESS, retVal);
size_t expectedStreamSize = 0;
if (pCmdQ->getGpgpuCommandStreamReceiver().peekTimestampPacketWriteEnabled()) {
auto unalignedSize = MemorySynchronizationCommands<FamilyType>::getSizeForBarrierWithPostSyncOperation(pDevice->getRootDeviceEnvironment(), NEO::PostSyncMode::immediateData) +
EncodeStoreMemory<FamilyType>::getStoreDataImmSize() +
sizeof(typename FamilyType::MI_BATCH_BUFFER_END);
expectedStreamSize = alignUp(unalignedSize, MemoryConstants::cacheLineSize);
}
EXPECT_EQ(expectedStreamSize, commandStream.getUsed() - usedBeforeCS);
EXPECT_EQ(0u, dsh->getUsed() - usedBeforeDSH);
EXPECT_EQ(0u, ioh->getUsed() - usedBeforeIOH);
EXPECT_EQ(0u, ssh->getUsed() - usedBeforeSSH);
clReleaseEvent(eventReturned);
}

23
opencl/test/unit_test/command_queue/ooq_task_tests.cpp
View File

@@ -358,29 +358,6 @@ HWTEST_F(OOQTaskTests, givenSkipDcFlushOnBarrierWithEventsEnabledWhenEnqueingBar
EXPECT_FALSE(pCmdQ->isDcFlushRequiredOnStallingCommandsOnNextFlush());
}
HWTEST_F(OOQTaskTests, givenSkipDcFlushOnBarrierWithEventsEnabledWhenEnqueingBarrierWithWaitListWithEventThenDcFlushSet) {
auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver<FamilyType>();
if (false == commandStreamReceiver.peekTimestampPacketWriteEnabled()) {
GTEST_SKIP();
}
DebugManagerStateRestore restorer;
debugManager.flags.SkipDcFlushOnBarrierWithoutEvents.set(1);
const cl_uint numEventsInWaitList = 0;
const cl_event *eventWaitList = nullptr;
cl_event clEvent{};
auto retVal = pCmdQ->enqueueBarrierWithWaitList(
numEventsInWaitList,
eventWaitList,
&clEvent);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(pCmdQ->isStallingCommandsOnNextFlushRequired());
EXPECT_TRUE(pCmdQ->isDcFlushRequiredOnStallingCommandsOnNextFlush());
auto outEvent = castToObject<Event>(clEvent);
outEvent->release();
}
HWTEST_F(OOQTaskTests, givenSkipDcFlushOnBarrierWithoutEventsDisabledWhenEnqueingBarrierWithWaitListThenDcFlushSet) {
auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver<FamilyType>();
if (false == commandStreamReceiver.peekTimestampPacketWriteEnabled()) {

19
opencl/test/unit_test/helpers/timestamp_packet_2_tests.cpp
View File

@@ -335,19 +335,6 @@ HWTEST_F(TimestampPacketTests, givenTimestampPacketWriteDisabledWhenEnqueueingBa
EXPECT_FALSE(cmdQ.isStallingCommandsOnNextFlushRequired());
}
HWTEST_F(TimestampPacketTests, givenBlockedQueueWhenEnqueueingBarrierThenDontRequestPipeControlOnCsrFlush) {
auto &csr = device->getUltCommandStreamReceiver<FamilyType>();
csr.timestampPacketWriteEnabled = true;
MockCommandQueueHw<FamilyType> cmdQ(context, device.get(), nullptr);
EXPECT_FALSE(cmdQ.isStallingCommandsOnNextFlushRequired());
auto userEvent = makeReleaseable<UserEvent>();
cl_event waitlist[] = {userEvent.get()};
cmdQ.enqueueBarrierWithWaitList(1, waitlist, nullptr);
EXPECT_FALSE(cmdQ.isStallingCommandsOnNextFlushRequired());
userEvent->setStatus(CL_COMPLETE);
}
HWTEST_F(TimestampPacketTests, givenPipeControlRequestWhenEstimatingCsrStreamSizeThenAddSizeForPipeControl) {
DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -577,12 +564,12 @@ HWTEST_F(TimestampPacketTests, givenWaitlistAndOutputEventWhenEnqueueingWithoutK
auto outEvent = castToObject<Event>(clOutEvent);
EXPECT_EQ(cmdQ->timestampPacketContainer->peekNodes().at(0), cmdQNodes.peekNodes().at(0)); // no new nodes obtained
EXPECT_NE(cmdQ->timestampPacketContainer->peekNodes().at(0), cmdQNodes.peekNodes().at(0)); // new nodes obtained
EXPECT_EQ(1u, cmdQ->timestampPacketContainer->peekNodes().size());
auto &eventsNodes = outEvent->getTimestampPacketNodes()->peekNodes();
EXPECT_EQ(numEventsWithContainer + 1, eventsNodes.size()); // numEventsWithContainer + command queue
EXPECT_EQ(cmdQNodes.peekNodes().at(0), eventsNodes.at(0));
EXPECT_EQ(cmdQ->timestampPacketContainer->peekNodes().at(0), eventsNodes.at(0));
EXPECT_EQ(event0.getTimestampPacketNodes()->peekNodes().at(0), eventsNodes.at(1));
EXPECT_EQ(event1.getTimestampPacketNodes()->peekNodes().at(0), eventsNodes.at(2));
@@ -643,7 +630,7 @@ HWTEST_TEMPLATED_F(TimestampPacketTestsWithMockCsrHw2, givenBlockedEnqueueWithou
hwParserCmdQ.parseCommands<FamilyType>(taskStream, 0);
auto queueSemaphores = findAll<MI_SEMAPHORE_WAIT *>(hwParserCmdQ.cmdList.begin(), hwParserCmdQ.cmdList.end());
auto expectedQueueSemaphoresCount = 2u;
auto expectedQueueSemaphoresCount = commands[i] == CL_COMMAND_MARKER ? 2u : 3u;
if (UnitTestHelper<FamilyType>::isAdditionalMiSemaphoreWaitRequired(device->getRootDeviceEnvironment())) {
expectedQueueSemaphoresCount += 1;
}

1
opencl/test/unit_test/sharings/gl/windows/gl_sharing_tests.cpp
View File

@@ -518,6 +518,7 @@ TEST_F(GlSharingTests, givenEnabledAsyncEventsHandlerWhenAcquireGlObjectsIsCalle
EXPECT_LT(CL_SUCCESS, event->peekExecutionStatus());
EXPECT_TRUE(handler->peekIsRegisterListEmpty());
event->setStatus(CL_COMPLETE);
event->release();
}