intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-12 17:33:00 +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-28 15:51:30 +00:00
committed by Compute-Runtime-Automation
parent 9b2802af0e
commit 9d91e85f5c
14 changed files with 55 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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()) {