From b498fea98933264be61a0f93c2a7ee2da4f40c99 Mon Sep 17 00:00:00 2001 From: Misiak Date: Mon, 13 Jan 2020 15:54:52 +0100 Subject: [PATCH] Removed unused atomic latestTaskCountWaited Related-To: NEO-3869 Change-Id: If7e9db2645c9c9c38d65a0b200960e387441c9ca Signed-off-by: Konstanty Misiak --- runtime/command_queue/command_queue.cpp | 2 - runtime/command_queue/command_queue.h | 2 - .../command_queue/command_queue_hw_tests.cpp | 40 ++++++------ .../command_queue/enqueue_barrier_tests.cpp | 21 ++++--- .../command_queue/enqueue_kernel_2_tests.cpp | 42 ++++++++++--- .../enqueue_map_buffer_tests.cpp | 27 ++++---- ...and_stream_receiver_flush_task_2_tests.cpp | 61 +++++++++---------- unit_tests/event/event_tests.cpp | 17 +++--- unit_tests/event/user_events_tests_mt.cpp | 13 ++-- unit_tests/mocks/mock_command_queue.h | 12 ++++ .../sharings/gl/windows/gl_sharing_tests.cpp | 16 +++-- 11 files changed, 148 insertions(+), 105 deletions(-) diff --git a/runtime/command_queue/command_queue.cpp b/runtime/command_queue/command_queue.cpp index 70c079fa59..57305230d4 100644 --- a/runtime/command_queue/command_queue.cpp +++ b/runtime/command_queue/command_queue.cpp @@ -148,9 +148,7 @@ void CommandQueue::waitUntilComplete(uint32_t taskCountToWait, FlushStamp flushS getGpgpuCommandStreamReceiver().waitForTaskCountWithKmdNotifyFallback(taskCountToWait, flushStampToWait, useQuickKmdSleep, forcePowerSavingMode); - DEBUG_BREAK_IF(getHwTag() < taskCountToWait); - latestTaskCountWaited = taskCountToWait; if (auto bcsCsr = getBcsCommandStreamReceiver()) { bcsCsr->waitForTaskCountWithKmdNotifyFallback(bcsTaskCount, 0, false, false); diff --git a/runtime/command_queue/command_queue.h b/runtime/command_queue/command_queue.h index 202ebda315..f73f02c86f 100644 --- a/runtime/command_queue/command_queue.h +++ b/runtime/command_queue/command_queue.h @@ -415,8 +415,6 @@ class CommandQueue : public BaseObject<_cl_command_queue> { std::unique_ptr flushStamp; - std::atomic latestTaskCountWaited{std::numeric_limits::max()}; - // virtual event that holds last Enqueue information Event *virtualEvent = nullptr; diff --git a/unit_tests/command_queue/command_queue_hw_tests.cpp b/unit_tests/command_queue/command_queue_hw_tests.cpp index 83a680c0cc..6e9a3c5710 100644 --- a/unit_tests/command_queue/command_queue_hw_tests.cpp +++ b/unit_tests/command_queue/command_queue_hw_tests.cpp @@ -181,44 +181,44 @@ HWTEST_F(CommandQueueHwTest, WhenAddMapUnmapToWaitlistEventsThenDependenciesAreN HWTEST_F(CommandQueueHwTest, givenMapCommandWhenZeroStateCommandIsSubmittedThenTaskCountIsNotBeingWaited) { auto buffer = new MockBuffer; - CommandQueueHw *pHwQ = reinterpret_cast *>(pCmdQ); + MockCommandQueueHw mockCmdQueueHw(context, pClDevice, nullptr); MockEventBuilder eventBuilder; MemObjSizeArray size = {{1, 1, 1}}; MemObjOffsetArray offset = {{0, 0, 0}}; - pHwQ->enqueueBlockedMapUnmapOperation(nullptr, - 0, - MAP, - buffer, - size, offset, false, - eventBuilder); + mockCmdQueueHw.enqueueBlockedMapUnmapOperation(nullptr, + 0, + MAP, + buffer, + size, offset, false, + eventBuilder); - EXPECT_NE(nullptr, pHwQ->virtualEvent); - pHwQ->virtualEvent->setStatus(CL_COMPLETE); + EXPECT_NE(nullptr, mockCmdQueueHw.virtualEvent); + mockCmdQueueHw.virtualEvent->setStatus(CL_COMPLETE); + EXPECT_EQ(std::numeric_limits::max(), mockCmdQueueHw.latestTaskCountWaited); - EXPECT_EQ(std::numeric_limits::max(), pHwQ->latestTaskCountWaited); buffer->decRefInternal(); } HWTEST_F(CommandQueueHwTest, givenMapCommandWhenZeroStateCommandIsSubmittedOnNonZeroCopyBufferThenTaskCountIsBeingWaited) { auto buffer = new MockBuffer; buffer->isZeroCopy = false; - CommandQueueHw *pHwQ = reinterpret_cast *>(pCmdQ); + MockCommandQueueHw mockCmdQueueHw(context, pClDevice, nullptr); MockEventBuilder eventBuilder; MemObjSizeArray size = {{1, 1, 1}}; MemObjOffsetArray offset = {{0, 0, 0}}; - pHwQ->enqueueBlockedMapUnmapOperation(nullptr, - 0, - MAP, - buffer, - size, offset, false, - eventBuilder); + mockCmdQueueHw.enqueueBlockedMapUnmapOperation(nullptr, + 0, + MAP, + buffer, + size, offset, false, + eventBuilder); - EXPECT_NE(nullptr, pHwQ->virtualEvent); - pHwQ->virtualEvent->setStatus(CL_COMPLETE); + EXPECT_NE(nullptr, mockCmdQueueHw.virtualEvent); + mockCmdQueueHw.virtualEvent->setStatus(CL_COMPLETE); + EXPECT_EQ(1u, mockCmdQueueHw.latestTaskCountWaited); - EXPECT_EQ(1u, pHwQ->latestTaskCountWaited); buffer->decRefInternal(); } diff --git a/unit_tests/command_queue/enqueue_barrier_tests.cpp b/unit_tests/command_queue/enqueue_barrier_tests.cpp index b35e10ee43..74c21d1622 100644 --- a/unit_tests/command_queue/enqueue_barrier_tests.cpp +++ b/unit_tests/command_queue/enqueue_barrier_tests.cpp @@ -1,10 +1,11 @@ /* - * Copyright (C) 2017-2019 Intel Corporation + * Copyright (C) 2017-2020 Intel Corporation * * SPDX-License-Identifier: MIT * */ +#include "runtime/command_queue/command_queue_hw.h" #include "runtime/command_queue/gpgpu_walker.h" #include "runtime/command_stream/command_stream_receiver.h" #include "runtime/event/user_event.h" @@ -12,6 +13,7 @@ #include "test.h" #include "unit_tests/command_queue/command_enqueue_fixture.h" #include "unit_tests/gen_common/gen_cmd_parse.h" +#include "unit_tests/mocks/mock_command_queue.h" using namespace NEO; @@ -187,10 +189,12 @@ HWTEST_F(BarrierTest, WhenEnqueingBarrierWithWaitListThenDependenciesShouldSync) delete pEvent; } HWTEST_F(BarrierTest, givenNotBlockedCommandQueueAndEnqueueBarrierWithWaitlistReturningEventWhenCallIsMadeThenDontWaitUntilEventIsSignaled) { + MockCommandQueueHw mockCmdQueue(context, pClDevice, nullptr); + // In N:1, event.level <= pCmdQ.level - Event event1(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 5, 15); - Event event2(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 6, 16); - Event event3(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 1, 17); + Event event1(&mockCmdQueue, CL_COMMAND_NDRANGE_KERNEL, 5, 15); + Event event2(&mockCmdQueue, CL_COMMAND_NDRANGE_KERNEL, 6, 16); + Event event3(&mockCmdQueue, CL_COMMAND_NDRANGE_KERNEL, 1, 17); cl_event eventWaitList[] = { &event1, @@ -199,17 +203,18 @@ HWTEST_F(BarrierTest, givenNotBlockedCommandQueueAndEnqueueBarrierWithWaitlistRe cl_uint numEventsInWaitList = sizeof(eventWaitList) / sizeof(eventWaitList[0]); cl_event event = nullptr; - auto latestTaskCountWaitedBeforeEnqueue = this->pCmdQ->latestTaskCountWaited.load(); - auto retVal = pCmdQ->enqueueBarrierWithWaitList( + auto latestTaskCountWaitedBeforeEnqueue = mockCmdQueue.latestTaskCountWaited.load(); + auto retVal = mockCmdQueue.enqueueBarrierWithWaitList( numEventsInWaitList, eventWaitList, &event); - auto &csr = pCmdQ->getGpgpuCommandStreamReceiver(); + auto &csr = mockCmdQueue.getGpgpuCommandStreamReceiver(); EXPECT_EQ(CL_SUCCESS, retVal); - EXPECT_EQ(latestTaskCountWaitedBeforeEnqueue, this->pCmdQ->latestTaskCountWaited); + EXPECT_EQ(latestTaskCountWaitedBeforeEnqueue, mockCmdQueue.latestTaskCountWaited); auto pEvent = castToObject(event); + EXPECT_NE(nullptr, pEvent); if (csr.peekTimestampPacketWriteEnabled()) { EXPECT_EQ(csr.peekTaskCount(), pEvent->peekTaskCount()); diff --git a/unit_tests/command_queue/enqueue_kernel_2_tests.cpp b/unit_tests/command_queue/enqueue_kernel_2_tests.cpp index 13bdd6083d..004c3d4301 100644 --- a/unit_tests/command_queue/enqueue_kernel_2_tests.cpp +++ b/unit_tests/command_queue/enqueue_kernel_2_tests.cpp @@ -555,15 +555,42 @@ HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfWhenBeingDispatchedThenL3 patchData.Size = 256; patchData.DataParamOffset = 64; + MockCommandQueueHw mockCmdQueue(context, pClDevice, nullptr); MockKernelWithInternals mockKernel(*pClDevice); + mockKernel.crossThreadData[64] = 0; mockKernel.kernelInfo.patchInfo.pAllocateStatelessPrintfSurface = &patchData; - auto &csr = pCmdQ->getGpgpuCommandStreamReceiver(); + auto &csr = mockCmdQueue.getGpgpuCommandStreamReceiver(); auto latestSentTaskCount = csr.peekTaskCount(); - enqueueKernel(mockKernel); + + cl_uint workDim = 1; + size_t globalWorkOffset[3] = {0, 0, 0}; + + cl_uint numEventsInWaitList = 0; + cl_event *eventWaitList = nullptr; + cl_event *event = nullptr; + + FillValues(); + // Compute # of expected work items + expectedWorkItems = 1; + for (auto i = 0u; i < workDim; i++) { + expectedWorkItems *= globalWorkSize[i]; + } + + auto retVal = mockCmdQueue.enqueueKernel( + mockKernel, + workDim, + globalWorkOffset, + globalWorkSize, + localWorkSize, + numEventsInWaitList, + eventWaitList, + event); + ASSERT_EQ(CL_SUCCESS, retVal); + auto newLatestSentTaskCount = csr.peekTaskCount(); EXPECT_GT(newLatestSentTaskCount, latestSentTaskCount); - EXPECT_EQ(pCmdQ->latestTaskCountWaited, newLatestSentTaskCount); + EXPECT_EQ(mockCmdQueue.latestTaskCountWaited, newLatestSentTaskCount); } HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUnblockedThenL3CacheIsFlushed) { @@ -575,10 +602,11 @@ HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueKernelPrintfTest, GivenKernelWithPrintfBlocke patchData.Size = 256; patchData.DataParamOffset = 64; + MockCommandQueueHw mockCommandQueue(context, pClDevice, nullptr); MockKernelWithInternals mockKernel(*pClDevice); mockKernel.crossThreadData[64] = 0; mockKernel.kernelInfo.patchInfo.pAllocateStatelessPrintfSurface = &patchData; - auto &csr = pCmdQ->getGpgpuCommandStreamReceiver(); + auto &csr = mockCommandQueue.getGpgpuCommandStreamReceiver(); auto latestSentDcFlushTaskCount = csr.peekTaskCount(); cl_uint workDim = 1; @@ -587,7 +615,7 @@ HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueKernelPrintfTest, GivenKernelWithPrintfBlocke FillValues(); cl_event blockedEvent = &userEvent; - auto retVal = pCmdQ->enqueueKernel( + auto retVal = mockCommandQueue.enqueueKernel( mockKernel, workDim, globalWorkOffset, @@ -600,11 +628,11 @@ HWCMDTEST_P(IGFX_GEN8_CORE, EnqueueKernelPrintfTest, GivenKernelWithPrintfBlocke userEvent.setStatus(CL_COMPLETE); - parseCommands(*pCmdQ); + parseCommands(mockCommandQueue); auto newLatestSentDCFlushTaskCount = csr.peekTaskCount(); EXPECT_GT(newLatestSentDCFlushTaskCount, latestSentDcFlushTaskCount); - EXPECT_EQ(pCmdQ->latestTaskCountWaited, newLatestSentDCFlushTaskCount); + EXPECT_EQ(mockCommandQueue.latestTaskCountWaited, newLatestSentDCFlushTaskCount); } HWTEST_P(EnqueueKernelPrintfTest, GivenKernelWithPrintfBlockedByEventWhenEventUnblockedThenOutputPrinted) { diff --git a/unit_tests/command_queue/enqueue_map_buffer_tests.cpp b/unit_tests/command_queue/enqueue_map_buffer_tests.cpp index 66d71d3f7e..482dddec1b 100644 --- a/unit_tests/command_queue/enqueue_map_buffer_tests.cpp +++ b/unit_tests/command_queue/enqueue_map_buffer_tests.cpp @@ -14,6 +14,7 @@ #include "unit_tests/fixtures/buffer_fixture.h" #include "unit_tests/fixtures/device_fixture.h" #include "unit_tests/mocks/mock_buffer.h" +#include "unit_tests/mocks/mock_command_queue.h" #include "unit_tests/mocks/mock_context.h" #include "unit_tests/mocks/mock_kernel.h" @@ -260,7 +261,7 @@ TEST_F(EnqueueMapBufferTest, GivenValidArgsWhenMappingBufferThenSuccessIsReturne EXPECT_EQ(CL_SUCCESS, retVal); } -TEST_F(EnqueueMapBufferTest, givenNonBlockingReadOnlyMapBufferOnZeroCopyBufferWhenItIsCalledThenSynchronizationIsNotMadeUntilWaitForEvents) { +HWTEST_F(EnqueueMapBufferTest, givenNonBlockingReadOnlyMapBufferOnZeroCopyBufferWhenItIsCalledThenSynchronizationIsNotMadeUntilWaitForEvents) { DebugManagerStateRestore dbgRestore; DebugManager.flags.EnableAsyncEventsHandler.set(false); cl_event mapEventReturned = nullptr; @@ -285,18 +286,20 @@ TEST_F(EnqueueMapBufferTest, givenNonBlockingReadOnlyMapBufferOnZeroCopyBufferWh EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_NE(nullptr, buffer); - auto &commandStreamReceiver = pCmdQ->getGpgpuCommandStreamReceiver(); + MockCommandQueueHw mockCmdQueue(context, pClDevice, nullptr); + + auto &commandStreamReceiver = mockCmdQueue.getGpgpuCommandStreamReceiver(); uint32_t taskCount = commandStreamReceiver.peekTaskCount(); EXPECT_EQ(0u, taskCount); // enqueue something that can be finished... - retVal = clEnqueueNDRangeKernel(pCmdQ, kernel, 1, 0, &GWS, nullptr, 0, nullptr, nullptr); + retVal = clEnqueueNDRangeKernel(&mockCmdQueue, kernel, 1, 0, &GWS, nullptr, 0, nullptr, nullptr); EXPECT_EQ(retVal, CL_SUCCESS); EXPECT_EQ(1u, commandStreamReceiver.peekTaskCount()); auto ptrResult = clEnqueueMapBuffer( - pCmdQ, + &mockCmdQueue, buffer, CL_FALSE, CL_MAP_READ, @@ -334,14 +337,14 @@ TEST_F(EnqueueMapBufferTest, givenNonBlockingReadOnlyMapBufferOnZeroCopyBufferWh //wait for event do not sent flushTask EXPECT_EQ(1u, commandStreamReceiver.peekTaskCount()); - EXPECT_EQ(1u, pCmdQ->latestTaskCountWaited); + EXPECT_EQ(1u, mockCmdQueue.latestTaskCountWaited); EXPECT_TRUE(neoEvent->updateStatusAndCheckCompletion()); EXPECT_EQ(1u, callbackCalled); retVal = clEnqueueUnmapMemObject( - pCmdQ, + &mockCmdQueue, buffer, ptrResult, 0, @@ -514,7 +517,7 @@ TEST_F(EnqueueMapBufferTest, givenNonBlockingMapBufferAfterL3IsAlreadyFlushedThe clReleaseEvent(eventReturned); } -TEST_F(EnqueueMapBufferTest, GivenBufferThatIsNotZeroCopyWhenNonBlockingMapIsCalledThenFinishIsCalledAndDataTransferred) { +HWTEST_F(EnqueueMapBufferTest, GivenBufferThatIsNotZeroCopyWhenNonBlockingMapIsCalledThenFinishIsCalledAndDataTransferred) { const auto bufferSize = 100; auto localSize = bufferSize; char misaligned[bufferSize] = {1}; @@ -540,16 +543,18 @@ TEST_F(EnqueueMapBufferTest, GivenBufferThatIsNotZeroCopyWhenNonBlockingMapIsCal auto pBuffer = castToObject(buffer); ASSERT_FALSE(pBuffer->isMemObjZeroCopy()); + MockCommandQueueHw mockCmdQueue(context, pClDevice, nullptr); + // enqueue something that can be finished - retVal = clEnqueueNDRangeKernel(pCmdQ, kernel, 1, 0, &GWS, nullptr, 0, nullptr, nullptr); + retVal = clEnqueueNDRangeKernel(&mockCmdQueue, kernel, 1, 0, &GWS, nullptr, 0, nullptr, nullptr); EXPECT_EQ(retVal, CL_SUCCESS); - auto &commandStreamReceiver = pCmdQ->getGpgpuCommandStreamReceiver(); + auto &commandStreamReceiver = mockCmdQueue.getGpgpuCommandStreamReceiver(); uint32_t taskCount = commandStreamReceiver.peekTaskCount(); EXPECT_EQ(1u, taskCount); auto ptrResult = clEnqueueMapBuffer( - pCmdQ, + &mockCmdQueue, buffer, CL_FALSE, CL_MAP_READ, @@ -566,7 +571,7 @@ TEST_F(EnqueueMapBufferTest, GivenBufferThatIsNotZeroCopyWhenNonBlockingMapIsCal commandStreamReceiver.peekTaskCount(); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); - EXPECT_EQ(1u, pCmdQ->latestTaskCountWaited); + EXPECT_EQ(1u, mockCmdQueue.latestTaskCountWaited); retVal = clReleaseMemObject(buffer); EXPECT_EQ(CL_SUCCESS, retVal); diff --git a/unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp b/unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp index 7192a9522a..467a9ef24d 100644 --- a/unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp +++ b/unit_tests/command_stream/command_stream_receiver_flush_task_2_tests.cpp @@ -103,57 +103,57 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, FlushTaskWithTaskCSPassedAsCommand HWTEST_F(CommandStreamReceiverFlushTaskTests, TrackSentTagsWhenEmptyQueue) { MockContext ctx(pClDevice); - CommandQueueHw commandQueue(&ctx, pClDevice, 0); + MockCommandQueueHw mockCmdQueue(&ctx, pClDevice, nullptr); auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); uint32_t taskCount = 0; taskLevel = taskCount; - commandQueue.taskCount = taskCount; - commandQueue.taskLevel = taskCount; + mockCmdQueue.taskCount = taskCount; + mockCmdQueue.taskLevel = taskCount; commandStreamReceiver.taskLevel = taskCount; commandStreamReceiver.taskCount = taskCount; EXPECT_EQ(0u, commandStreamReceiver.peekLatestSentTaskCount()); - commandQueue.finish(); + mockCmdQueue.finish(); EXPECT_EQ(0u, commandStreamReceiver.peekLatestSentTaskCount()); - commandQueue.finish(); + mockCmdQueue.finish(); //nothings sent to the HW, no need to bump tags EXPECT_EQ(0u, commandStreamReceiver.peekLatestSentTaskCount()); - EXPECT_EQ(0u, commandQueue.latestTaskCountWaited); + EXPECT_EQ(0u, mockCmdQueue.latestTaskCountWaited); } HWTEST_F(CommandStreamReceiverFlushTaskTests, TrackSentTagsWhenNonDcFlushWithInitialTaskCountZero) { MockContext ctx(pClDevice); MockKernelWithInternals kernel(*pClDevice); - CommandQueueHw commandQueue(&ctx, pClDevice, 0); + MockCommandQueueHw mockCmdQueue(&ctx, pClDevice, nullptr); auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); size_t GWS = 1; uint32_t taskCount = 0; taskLevel = taskCount; - commandQueue.taskCount = taskCount; - commandQueue.taskLevel = taskCount; + mockCmdQueue.taskCount = taskCount; + mockCmdQueue.taskLevel = taskCount; commandStreamReceiver.taskLevel = taskCount; commandStreamReceiver.taskCount = taskCount; EXPECT_EQ(0u, commandStreamReceiver.peekLatestSentTaskCount()); // finish after enqueued kernel(cmdq task count = 1) - commandQueue.enqueueKernel(kernel, 1, nullptr, &GWS, nullptr, 0, nullptr, nullptr); - commandQueue.finish(); + mockCmdQueue.enqueueKernel(kernel, 1, nullptr, &GWS, nullptr, 0, nullptr, nullptr); + mockCmdQueue.finish(); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); - EXPECT_EQ(1u, commandQueue.latestTaskCountWaited); + EXPECT_EQ(1u, mockCmdQueue.latestTaskCountWaited); EXPECT_EQ(1u, commandStreamReceiver.peekTaskCount()); // finish again - dont call flush task - commandQueue.finish(); + mockCmdQueue.finish(); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); - EXPECT_EQ(1u, commandQueue.latestTaskCountWaited); + EXPECT_EQ(1u, mockCmdQueue.latestTaskCountWaited); EXPECT_EQ(1u, commandStreamReceiver.peekTaskCount()); } HWTEST_F(CommandStreamReceiverFlushTaskTests, TrackSentTagsWhenDcFlush) { MockContext ctx(pClDevice); MockKernelWithInternals kernel(*pClDevice); - CommandQueueHw commandQueue(&ctx, pClDevice, 0); + MockCommandQueueHw mockCmdQueue(&ctx, pClDevice, nullptr); auto &commandStreamReceiver = pDevice->getUltCommandStreamReceiver(); size_t GWS = 1; size_t tempBuffer[] = {0, 1, 2}; @@ -164,41 +164,39 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, TrackSentTagsWhenDcFlush) { uint32_t taskCount = 0; taskLevel = taskCount; - commandQueue.taskCount = taskCount; - commandQueue.taskLevel = taskCount; + mockCmdQueue.taskCount = taskCount; + mockCmdQueue.taskLevel = taskCount; commandStreamReceiver.taskLevel = taskCount; commandStreamReceiver.taskCount = taskCount; EXPECT_EQ(0u, commandStreamReceiver.peekLatestSentTaskCount()); // finish(dcFlush=true) from blocking MapBuffer after enqueued kernel - commandQueue.enqueueKernel(kernel, 1, nullptr, &GWS, nullptr, 0, nullptr, nullptr); + mockCmdQueue.enqueueKernel(kernel, 1, nullptr, &GWS, nullptr, 0, nullptr, nullptr); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); - auto ptr = commandQueue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_READ, 0, sizeof(tempBuffer), 0, nullptr, nullptr, retVal); + auto ptr = mockCmdQueue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_READ, 0, sizeof(tempBuffer), 0, nullptr, nullptr, retVal); EXPECT_EQ(retVal, CL_SUCCESS); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); // cmdQ task count = 2, finish again - commandQueue.finish(); + mockCmdQueue.finish(); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); - EXPECT_EQ(1u, commandQueue.latestTaskCountWaited); // finish again - dont flush task again - commandQueue.finish(); + mockCmdQueue.finish(); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); - EXPECT_EQ(1u, commandQueue.latestTaskCountWaited); // finish(dcFlush=true) from MapBuffer again - dont call FinishTask n finished queue - retVal = commandQueue.enqueueUnmapMemObject(buffer, ptr, 0, nullptr, nullptr); + retVal = mockCmdQueue.enqueueUnmapMemObject(buffer, ptr, 0, nullptr, nullptr); EXPECT_EQ(retVal, CL_SUCCESS); - ptr = commandQueue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_READ, 0, sizeof(tempBuffer), 0, nullptr, nullptr, retVal); + ptr = mockCmdQueue.enqueueMapBuffer(buffer, CL_TRUE, CL_MAP_READ, 0, sizeof(tempBuffer), 0, nullptr, nullptr, retVal); EXPECT_EQ(retVal, CL_SUCCESS); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); //cleanup - retVal = commandQueue.enqueueUnmapMemObject(buffer, ptr, 0, nullptr, nullptr); + retVal = mockCmdQueue.enqueueUnmapMemObject(buffer, ptr, 0, nullptr, nullptr); EXPECT_EQ(retVal, CL_SUCCESS); retVal = clReleaseMemObject(buffer); @@ -301,11 +299,11 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, typedef typename FamilyType::PIPE_CONTROL PIPE_CONTROL; MockContext ctx(pClDevice); - CommandQueueHw commandQueue(&ctx, pClDevice, 0); + MockCommandQueueHw mockCmdQueue(&ctx, pClDevice, nullptr); cl_event event = nullptr; auto &commandStreamReceiver = pDevice->getGpgpuCommandStreamReceiver(); - auto &commandStreamTask = commandQueue.getCS(1024); + auto &commandStreamTask = mockCmdQueue.getCS(1024); size_t tempBuffer[] = {0, 1, 2}; size_t dstBuffer[] = {5, 5, 5}; @@ -319,15 +317,14 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, // Call requiring DCFlush, nonblocking buffer->forceDisallowCPUCopy = true; - commandQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 0, 0, 0); + mockCmdQueue.enqueueReadBuffer(buffer, CL_FALSE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 0, 0, 0); EXPECT_EQ(1u, commandStreamReceiver.peekLatestSentTaskCount()); - commandQueue.enqueueReadBuffer(buffer, CL_TRUE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 0, 0, &event); + mockCmdQueue.enqueueReadBuffer(buffer, CL_TRUE, 0, sizeof(tempBuffer), dstBuffer, nullptr, 0, 0, &event); EXPECT_EQ(2u, commandStreamReceiver.peekLatestSentTaskCount()); - - EXPECT_EQ(2u, commandQueue.latestTaskCountWaited); + EXPECT_EQ(2u, mockCmdQueue.latestTaskCountWaited); // Parse command list to verify that PC was added to taskCS cmdList.clear(); diff --git a/unit_tests/event/event_tests.cpp b/unit_tests/event/event_tests.cpp index 661033d27e..d24354c47f 100644 --- a/unit_tests/event/event_tests.cpp +++ b/unit_tests/event/event_tests.cpp @@ -542,17 +542,18 @@ TEST_F(InternalsEventTest, processBlockedCommandsAbortKernelOperation) { } TEST_F(InternalsEventTest, givenBlockedKernelWithPrintfWhenSubmittedThenPrintOutput) { + MockCommandQueue mockCmdQueue(mockContext, pClDevice, nullptr); + testing::internal::CaptureStdout(); - CommandQueue cmdQ(mockContext, pClDevice, nullptr); - MockEvent event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0); + MockEvent event(&mockCmdQueue, CL_COMMAND_NDRANGE_KERNEL, 0, 0); auto cmdStream = new LinearStream(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties({pDevice->getRootDeviceIndex(), 4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER})); IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr; - cmdQ.allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 4096u, dsh); - cmdQ.allocateHeapMemory(IndirectHeap::INDIRECT_OBJECT, 4096u, ioh); - cmdQ.allocateHeapMemory(IndirectHeap::SURFACE_STATE, 4096u, ssh); + mockCmdQueue.allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 4096u, dsh); + mockCmdQueue.allocateHeapMemory(IndirectHeap::INDIRECT_OBJECT, 4096u, ioh); + mockCmdQueue.allocateHeapMemory(IndirectHeap::SURFACE_STATE, 4096u, ssh); - auto blockedCommandsData = std::make_unique(cmdStream, *cmdQ.getGpgpuCommandStreamReceiver().getInternalAllocationStorage()); + auto blockedCommandsData = std::make_unique(cmdStream, *mockCmdQueue.getGpgpuCommandStreamReceiver().getInternalAllocationStorage()); blockedCommandsData->setHeaps(dsh, ioh, ssh); SPatchAllocateStatelessPrintfSurface *pPrintfSurface = new SPatchAllocateStatelessPrintfSurface(); @@ -580,12 +581,12 @@ TEST_F(InternalsEventTest, givenBlockedKernelWithPrintfWhenSubmittedThenPrintOut std::vector v; PreemptionMode preemptionMode = pDevice->getPreemptionMode(); - auto cmd = new CommandComputeKernel(cmdQ, blockedCommandsData, v, false, false, false, std::move(printfHandler), preemptionMode, pKernel, 1); + auto cmd = new CommandComputeKernel(mockCmdQueue, blockedCommandsData, v, false, false, false, std::move(printfHandler), preemptionMode, pKernel, 1); event.setCommand(std::unique_ptr(cmd)); event.submitCommand(false); - EXPECT_EQ(1u, cmdQ.latestTaskCountWaited); + EXPECT_EQ(1u, mockCmdQueue.latestTaskCountWaited); std::string output = testing::internal::GetCapturedStdout(); EXPECT_STREQ("test", output.c_str()); diff --git a/unit_tests/event/user_events_tests_mt.cpp b/unit_tests/event/user_events_tests_mt.cpp index 854d6331f4..716d73af37 100644 --- a/unit_tests/event/user_events_tests_mt.cpp +++ b/unit_tests/event/user_events_tests_mt.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2017-2019 Intel Corporation + * Copyright (C) 2017-2020 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -7,6 +7,7 @@ #include "runtime/memory_manager/memory_manager.h" #include "unit_tests/fixtures/buffer_fixture.h" +#include "unit_tests/mocks/mock_command_queue.h" #include "event_fixture.h" @@ -108,8 +109,8 @@ TEST_F(EventTests, givenUserEventBlockingEnqueueWithBlockingFlagWhenUserEventIsC t.join(); } -TEST_F(EventTests, givenoneThreadUpdatingUserEventAnotherWaitingOnFinishWhenFinishIsCalledThenItWaitsForCorrectTaskCount) { - +HWTEST_F(EventTests, givenOneThreadUpdatingUserEventAnotherWaitingOnFinishWhenFinishIsCalledThenItWaitsForCorrectTaskCount) { + MockCommandQueueHw mockCmdQueue(context, pClDevice, nullptr); std::unique_ptr srcBuffer(BufferHelper<>::create()); std::unique_ptr dst(new char[srcBuffer->getSize()]); for (uint32_t i = 0; i < 100; i++) { @@ -129,7 +130,7 @@ TEST_F(EventTests, givenoneThreadUpdatingUserEventAnotherWaitingOnFinishWhenFini uEvent.setStatus(CL_COMPLETE); }); - auto retVal = pCmdQ->enqueueReadBuffer(srcBuffer.get(), CL_FALSE, 0, srcBuffer->getSize(), dst.get(), nullptr, sizeOfWaitList, eventWaitList, &returnedEvent); + auto retVal = mockCmdQueue.enqueueReadBuffer(srcBuffer.get(), CL_FALSE, 0, srcBuffer->getSize(), dst.get(), nullptr, sizeOfWaitList, eventWaitList, &returnedEvent); EXPECT_EQ(CL_SUCCESS, retVal); std::thread t2([&]() { @@ -140,8 +141,8 @@ TEST_F(EventTests, givenoneThreadUpdatingUserEventAnotherWaitingOnFinishWhenFini go = true; - clFinish(pCmdQ); - EXPECT_EQ(pCmdQ->latestTaskCountWaited, i + 1); + clFinish(&mockCmdQueue); + EXPECT_EQ(mockCmdQueue.latestTaskCountWaited, i + 1); t.join(); updateEvent = false; diff --git a/unit_tests/mocks/mock_command_queue.h b/unit_tests/mocks/mock_command_queue.h index 5f11d935bb..a5bfba8a17 100644 --- a/unit_tests/mocks/mock_command_queue.h +++ b/unit_tests/mocks/mock_command_queue.h @@ -57,6 +57,11 @@ class MockCommandQueue : public CommandQueue { return writeBufferRetValue; } + void waitUntilComplete(uint32_t taskCountToWait, FlushStamp flushStampToWait, bool useQuickKmdSleep) override { + latestTaskCountWaited = taskCountToWait; + return CommandQueue::waitUntilComplete(taskCountToWait, flushStampToWait, useQuickKmdSleep); + } + bool releaseIndirectHeapCalled = false; cl_int writeBufferRetValue = CL_SUCCESS; @@ -66,6 +71,7 @@ class MockCommandQueue : public CommandQueue { size_t writeBufferSize = 0; void *writeBufferPtr = nullptr; size_t requestedCmdStreamSize = 0; + std::atomic latestTaskCountWaited{std::numeric_limits::max()}; }; template @@ -146,6 +152,11 @@ class MockCommandQueueHw : public CommandQueueHw { notifyEnqueueReadImageCalled = true; } + void waitUntilComplete(uint32_t taskCountToWait, FlushStamp flushStampToWait, bool useQuickKmdSleep) override { + latestTaskCountWaited = taskCountToWait; + return BaseClass::waitUntilComplete(taskCountToWait, flushStampToWait, useQuickKmdSleep); + } + unsigned int lastCommandType; std::vector lastEnqueuedKernels; MultiDispatchInfo storedMultiDispatchInfo; @@ -157,6 +168,7 @@ class MockCommandQueueHw : public CommandQueueHw { bool notifyEnqueueReadImageCalled = false; bool cpuDataTransferHandlerCalled = false; BuiltinOpParams kernelParams; + std::atomic latestTaskCountWaited{std::numeric_limits::max()}; LinearStream *peekCommandStream() { return this->commandStream; diff --git a/unit_tests/sharings/gl/windows/gl_sharing_tests.cpp b/unit_tests/sharings/gl/windows/gl_sharing_tests.cpp index b8958b1a26..d7cce67f9f 100644 --- a/unit_tests/sharings/gl/windows/gl_sharing_tests.cpp +++ b/unit_tests/sharings/gl/windows/gl_sharing_tests.cpp @@ -29,6 +29,7 @@ #include "unit_tests/mocks/gl/mock_gl_arb_sync_event.h" #include "unit_tests/mocks/gl/mock_gl_sharing.h" #include "unit_tests/mocks/mock_async_event_handler.h" +#include "unit_tests/mocks/mock_command_queue.h" #include "unit_tests/mocks/mock_context.h" #include "unit_tests/mocks/mock_device.h" #include "unit_tests/mocks/mock_event.h" @@ -598,18 +599,15 @@ TEST_F(glSharingTests, givenHwCommandQueueWhenAcquireAndReleaseCallsAreMadeWithE EXPECT_EQ(CL_SUCCESS, retVal); } -TEST_F(glSharingTests, givenCommandQueueWhenReleaseGlObjectIsCalledThenFinishIsCalled) { - auto commandQueue = clCreateCommandQueue(&context, context.getDevice(0), 0, nullptr); +HWTEST_F(glSharingTests, givenCommandQueueWhenReleaseGlObjectIsCalledThenFinishIsCalled) { + MockCommandQueueHw mockCmdQueue(&context, context.getDevice(0), nullptr); auto glBuffer = clCreateFromGLBuffer(&context, 0, bufferId, nullptr); - auto neoQueue = castToObject(commandQueue); - clEnqueueAcquireGLObjects(commandQueue, 1, &glBuffer, 0, nullptr, nullptr); - neoQueue->taskCount = 5u; - clEnqueueReleaseGLObjects(commandQueue, 1, &glBuffer, 0, nullptr, nullptr); + EXPECT_EQ(CL_SUCCESS, clEnqueueAcquireGLObjects(&mockCmdQueue, 1, &glBuffer, 0, nullptr, nullptr)); + mockCmdQueue.taskCount = 5u; + EXPECT_EQ(CL_SUCCESS, clEnqueueReleaseGLObjects(&mockCmdQueue, 1, &glBuffer, 0, nullptr, nullptr)); + EXPECT_EQ(5u, mockCmdQueue.latestTaskCountWaited); - EXPECT_EQ(5u, neoQueue->latestTaskCountWaited); - - clReleaseCommandQueue(commandQueue); clReleaseMemObject(glBuffer); }