diff --git a/opencl/test/unit_test/command_queue/CMakeLists.txt b/opencl/test/unit_test/command_queue/CMakeLists.txt index 925619548b..b9b5334b00 100644 --- a/opencl/test/unit_test/command_queue/CMakeLists.txt +++ b/opencl/test/unit_test/command_queue/CMakeLists.txt @@ -9,7 +9,8 @@ set(IGDRCL_SRCS_tests_command_queue ${CMAKE_CURRENT_SOURCE_DIR}/blit_enqueue_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/buffer_operations_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/command_enqueue_fixture.h - ${CMAKE_CURRENT_SOURCE_DIR}/command_queue_hw_tests.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/command_queue_hw_1_tests.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/command_queue_hw_2_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/command_queue_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/csr_selection_args_tests.cpp ${CMAKE_CURRENT_SOURCE_DIR}/dispatch_walker_tests.cpp diff --git a/opencl/test/unit_test/command_queue/command_queue_fixture.cpp b/opencl/test/unit_test/command_queue/command_queue_fixture.cpp index b0ee54d0cf..afb6fb78f7 100644 --- a/opencl/test/unit_test/command_queue/command_queue_fixture.cpp +++ b/opencl/test/unit_test/command_queue/command_queue_fixture.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -124,4 +124,37 @@ void CommandQueueFixture::TearDown() { delete pCmdQ; pCmdQ = nullptr; } + +void OOQueueFixture ::SetUp(ClDevice *pDevice, cl_command_queue_properties properties) { + ASSERT_NE(nullptr, pDevice); + BaseClass::pCmdQ = BaseClass::createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE); + ASSERT_NE(nullptr, BaseClass::pCmdQ); +} + +void CommandQueueHwTest::SetUp() { + ClDeviceFixture::SetUp(); + cl_device_id device = pClDevice; + ContextFixture::SetUp(1, &device); + CommandQueueHwFixture::SetUp(pClDevice, 0); +} + +void CommandQueueHwTest::TearDown() { + CommandQueueHwFixture::TearDown(); + ContextFixture::TearDown(); + ClDeviceFixture::TearDown(); +} + +void OOQueueHwTest::SetUp() { + ClDeviceFixture::SetUp(); + cl_device_id device = pClDevice; + ContextFixture::SetUp(1, &device); + OOQueueFixture::SetUp(pClDevice, 0); +} + +void OOQueueHwTest::TearDown() { + OOQueueFixture::TearDown(); + ContextFixture::TearDown(); + ClDeviceFixture::TearDown(); +} + } // namespace NEO diff --git a/opencl/test/unit_test/command_queue/command_queue_fixture.h b/opencl/test/unit_test/command_queue/command_queue_fixture.h index 2cebeb320b..7bc93edf68 100644 --- a/opencl/test/unit_test/command_queue/command_queue_fixture.h +++ b/opencl/test/unit_test/command_queue/command_queue_fixture.h @@ -54,11 +54,7 @@ struct CommandQueueHwFixture { struct OOQueueFixture : public CommandQueueHwFixture { typedef CommandQueueHwFixture BaseClass; - void SetUp(ClDevice *pDevice, cl_command_queue_properties properties) override { - ASSERT_NE(nullptr, pDevice); - BaseClass::pCmdQ = BaseClass::createCommandQueue(pDevice, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE); - ASSERT_NE(nullptr, BaseClass::pCmdQ); - } + void SetUp(ClDevice *pDevice, cl_command_queue_properties properties) override; }; struct CommandQueueFixture { @@ -123,4 +119,37 @@ struct CommandQueueHwBlitTest : ClDeviceFixture, ContextFixture, CommandQueueHwF using IoqCommandQueueHwBlitTest = CommandQueueHwBlitTest; using OoqCommandQueueHwBlitTest = CommandQueueHwBlitTest; +struct CommandQueueHwTest + : public ClDeviceFixture, + public ContextFixture, + public CommandQueueHwFixture, + ::testing::Test { + + using ContextFixture::SetUp; + + void SetUp() override; + + void TearDown() override; + + cl_command_queue_properties properties; + const HardwareInfo *pHwInfo = nullptr; +}; + +struct OOQueueHwTest : public ClDeviceFixture, + public ContextFixture, + public OOQueueFixture, + ::testing::Test { + using ContextFixture::SetUp; + + OOQueueHwTest() { + } + + void SetUp() override; + + void SetUp(ClDevice *pDevice, cl_command_queue_properties properties) override { + } + + void TearDown() override; +}; + } // namespace NEO diff --git a/opencl/test/unit_test/command_queue/command_queue_hw_tests.cpp b/opencl/test/unit_test/command_queue/command_queue_hw_1_tests.cpp similarity index 62% rename from opencl/test/unit_test/command_queue/command_queue_hw_tests.cpp rename to opencl/test/unit_test/command_queue/command_queue_hw_1_tests.cpp index 346fdc2b14..fcc178e41d 100644 --- a/opencl/test/unit_test/command_queue/command_queue_hw_tests.cpp +++ b/opencl/test/unit_test/command_queue/command_queue_hw_1_tests.cpp @@ -5,11 +5,7 @@ * */ -#include "shared/source/command_stream/wait_status.h" -#include "shared/test/common/cmd_parse/hw_parse.h" -#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/helpers/unit_test_helper.h" -#include "shared/test/common/libult/ult_command_stream_receiver.h" #include "shared/test/common/mocks/mock_allocation_properties.h" #include "shared/test/common/mocks/mock_builtins.h" #include "shared/test/common/mocks/mock_csr.h" @@ -18,69 +14,15 @@ #include "shared/test/unit_test/helpers/gtest_helpers.h" #include "shared/test/unit_test/utilities/base_object_utils.h" -#include "opencl/source/built_ins/builtins_dispatch_builder.h" -#include "opencl/source/helpers/dispatch_info_builder.h" #include "opencl/test/unit_test/command_queue/command_queue_fixture.h" #include "opencl/test/unit_test/fixtures/buffer_fixture.h" #include "opencl/test/unit_test/fixtures/image_fixture.h" -#include "opencl/test/unit_test/mocks/mock_buffer.h" #include "opencl/test/unit_test/mocks/mock_command_queue.h" #include "opencl/test/unit_test/mocks/mock_event.h" #include "opencl/test/unit_test/mocks/mock_kernel.h" using namespace NEO; -struct CommandQueueHwTest - : public ClDeviceFixture, - public ContextFixture, - public CommandQueueHwFixture, - ::testing::Test { - - using ContextFixture::SetUp; - - void SetUp() override { - ClDeviceFixture::SetUp(); - cl_device_id device = pClDevice; - ContextFixture::SetUp(1, &device); - CommandQueueHwFixture::SetUp(pClDevice, 0); - } - - void TearDown() override { - CommandQueueHwFixture::TearDown(); - ContextFixture::TearDown(); - ClDeviceFixture::TearDown(); - } - - cl_command_queue_properties properties; - const HardwareInfo *pHwInfo = nullptr; -}; - -struct OOQueueHwTest : public ClDeviceFixture, - public ContextFixture, - public OOQueueFixture, - ::testing::Test { - using ContextFixture::SetUp; - - OOQueueHwTest() { - } - - void SetUp() override { - ClDeviceFixture::SetUp(); - cl_device_id device = pClDevice; - ContextFixture::SetUp(1, &device); - OOQueueFixture::SetUp(pClDevice, 0); - } - - void SetUp(ClDevice *pDevice, cl_command_queue_properties properties) override { - } - - void TearDown() override { - OOQueueFixture::TearDown(); - ContextFixture::TearDown(); - ClDeviceFixture::TearDown(); - } -}; - HWTEST_F(CommandQueueHwTest, WhenConstructingTwoCommandQueuesThenOnlyOneDebugSurfaceIsAllocated) { ExecutionEnvironment *executionEnvironment = platform()->peekExecutionEnvironment(); executionEnvironment->rootDeviceEnvironments[0]->debugger.reset(new MockActiveSourceLevelDebugger(new MockOsLibrary)); @@ -563,7 +505,7 @@ HWTEST_F(CommandQueueHwTest, whenReleaseQueueCalledThenFlushIsCalled) { mockCmdQ->decRefInternal(); } -typedef CommandQueueHwTest BlockedCommandQueueTest; +using BlockedCommandQueueTest = CommandQueueHwTest; HWTEST_F(BlockedCommandQueueTest, givenCommandQueueWhenBlockedCommandIsBeingSubmittedThenQueueHeapsAreNotUsed) { UserEvent userEvent(context); @@ -669,7 +611,7 @@ HWTEST_F(BlockedCommandQueueTest, givenEnqueueBlockedByUserEventWhenItIsEnqueued EXPECT_EQ(currentRefCount, mockKernel->getRefInternalCount()); } -typedef CommandQueueHwTest CommandQueueHwRefCountTest; +using CommandQueueHwRefCountTest = CommandQueueHwTest; HWTEST_F(CommandQueueHwRefCountTest, givenBlockedCmdQWhenNewBlockedEnqueueReplacesVirtualEventThenPreviousVirtualEventDecrementsCmdQRefCount) { cl_int retVal = 0; @@ -905,221 +847,6 @@ HWTEST_F(CommandQueueHwTest, GivenMultiTileQueueWhenEventNotCompletedAndFinishIs ev->decRefInternal(); } -void CloneMdi(MultiDispatchInfo &dst, const MultiDispatchInfo &src) { - for (auto &srcDi : src) { - dst.push(srcDi); - } - dst.setBuiltinOpParams(src.peekBuiltinOpParams()); -} - -struct MockBuilder : BuiltinDispatchInfoBuilder { - using BuiltinDispatchInfoBuilder::BuiltinDispatchInfoBuilder; - bool buildDispatchInfos(MultiDispatchInfo &d) const override { - wasBuildDispatchInfosWithBuiltinOpParamsCalled = true; - paramsReceived.multiDispatchInfo.setBuiltinOpParams(d.peekBuiltinOpParams()); - return true; - } - bool buildDispatchInfos(MultiDispatchInfo &d, Kernel *kernel, - const uint32_t dim, const Vec3 &gws, const Vec3 &elws, const Vec3 &offset) const override { - paramsReceived.kernel = kernel; - paramsReceived.gws = gws; - paramsReceived.elws = elws; - paramsReceived.offset = offset; - wasBuildDispatchInfosWithKernelParamsCalled = true; - - DispatchInfoBuilder dispatchInfoBuilder(clDevice); - dispatchInfoBuilder.setKernel(paramsToUse.kernel); - dispatchInfoBuilder.setDispatchGeometry(dim, paramsToUse.gws, paramsToUse.elws, paramsToUse.offset); - dispatchInfoBuilder.bake(d); - - CloneMdi(paramsReceived.multiDispatchInfo, d); - return true; - } - - mutable bool wasBuildDispatchInfosWithBuiltinOpParamsCalled = false; - mutable bool wasBuildDispatchInfosWithKernelParamsCalled = false; - struct Params { - MultiDispatchInfo multiDispatchInfo; - Kernel *kernel = nullptr; - Vec3 gws = Vec3{0, 0, 0}; - Vec3 elws = Vec3{0, 0, 0}; - Vec3 offset = Vec3{0, 0, 0}; - }; - - mutable Params paramsReceived; - Params paramsToUse; -}; - -struct BuiltinParamsCommandQueueHwTests : public CommandQueueHwTest { - - void SetUpImpl(EBuiltInOps::Type operation) { - auto builtIns = new MockBuiltins(); - pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()]->builtins.reset(builtIns); - - auto swapBuilder = pClExecutionEnvironment->setBuiltinDispatchInfoBuilder( - rootDeviceIndex, - operation, - std::unique_ptr(new MockBuilder(*builtIns, pCmdQ->getClDevice()))); - - mockBuilder = static_cast(&BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder( - operation, - *pClDevice)); - } - - MockBuilder *mockBuilder; -}; - -HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadWriteBufferCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) { - - SetUpImpl(EBuiltInOps::CopyBufferToBuffer); - BufferDefaults::context = context; - auto buffer = clUniquePtr(BufferHelper<>::create()); - - char array[3 * MemoryConstants::cacheLineSize]; - char *ptr = &array[MemoryConstants::cacheLineSize]; - ptr = alignUp(ptr, MemoryConstants::cacheLineSize); - ptr -= 1; - - cl_int status = pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 0, ptr, nullptr, 0, 0, nullptr); - EXPECT_EQ(CL_SUCCESS, status); - - void *alignedPtr = alignDown(ptr, 4); - size_t ptrOffset = ptrDiff(ptr, alignedPtr); - Vec3 offset = {0, 0, 0}; - - auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); - - EXPECT_EQ(alignedPtr, builtinParams.dstPtr); - EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x); - EXPECT_EQ(offset, builtinParams.srcOffset); - - status = pCmdQ->enqueueWriteBuffer(buffer.get(), CL_FALSE, 0, 0, ptr, nullptr, 0, 0, nullptr); - EXPECT_EQ(CL_SUCCESS, status); - - builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); - - EXPECT_EQ(alignedPtr, builtinParams.srcPtr); - EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x); - EXPECT_EQ(offset, builtinParams.dstOffset); -} - -HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueWriteImageCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) { - - SetUpImpl(EBuiltInOps::CopyBufferToImage3d); - - std::unique_ptr dstImage(ImageHelper>::create(context)); - - auto imageDesc = dstImage->getImageDesc(); - size_t origin[] = {0, 0, 0}; - size_t region[] = {imageDesc.image_width, imageDesc.image_height, 0}; - - size_t rowPitch = dstImage->getHostPtrRowPitch(); - size_t slicePitch = dstImage->getHostPtrSlicePitch(); - - char array[3 * MemoryConstants::cacheLineSize]; - char *ptr = &array[MemoryConstants::cacheLineSize]; - ptr = alignUp(ptr, MemoryConstants::cacheLineSize); - ptr -= 1; - - void *alignedPtr = alignDown(ptr, 4); - size_t ptrOffset = ptrDiff(ptr, alignedPtr); - Vec3 offset = {0, 0, 0}; - - cl_int status = pCmdQ->enqueueWriteImage(dstImage.get(), - CL_FALSE, - origin, - region, - rowPitch, - slicePitch, - ptr, - nullptr, - 0, - 0, - nullptr); - EXPECT_EQ(CL_SUCCESS, status); - - auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); - EXPECT_EQ(alignedPtr, builtinParams.srcPtr); - EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x); - EXPECT_EQ(offset, builtinParams.dstOffset); -} - -HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadImageCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) { - - SetUpImpl(EBuiltInOps::CopyImage3dToBuffer); - - std::unique_ptr dstImage(ImageHelper>::create(context)); - - auto imageDesc = dstImage->getImageDesc(); - size_t origin[] = {0, 0, 0}; - size_t region[] = {imageDesc.image_width, imageDesc.image_height, 0}; - - size_t rowPitch = dstImage->getHostPtrRowPitch(); - size_t slicePitch = dstImage->getHostPtrSlicePitch(); - - char array[3 * MemoryConstants::cacheLineSize]; - char *ptr = &array[MemoryConstants::cacheLineSize]; - ptr = alignUp(ptr, MemoryConstants::cacheLineSize); - ptr -= 1; - - void *alignedPtr = alignDown(ptr, 4); - size_t ptrOffset = ptrDiff(ptr, alignedPtr); - Vec3 offset = {0, 0, 0}; - - cl_int status = pCmdQ->enqueueReadImage(dstImage.get(), - CL_FALSE, - origin, - region, - rowPitch, - slicePitch, - ptr, - nullptr, - 0, - 0, - nullptr); - EXPECT_EQ(CL_SUCCESS, status); - - auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); - EXPECT_EQ(alignedPtr, builtinParams.dstPtr); - EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x); - EXPECT_EQ(offset, builtinParams.srcOffset); -} - -HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadWriteBufferRectCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) { - - SetUpImpl(EBuiltInOps::CopyBufferRect); - - BufferDefaults::context = context; - auto buffer = clUniquePtr(BufferHelper<>::create()); - - size_t bufferOrigin[3] = {0, 0, 0}; - size_t hostOrigin[3] = {0, 0, 0}; - size_t region[3] = {0, 0, 0}; - - char array[3 * MemoryConstants::cacheLineSize]; - char *ptr = &array[MemoryConstants::cacheLineSize]; - ptr = alignUp(ptr, MemoryConstants::cacheLineSize); - ptr -= 1; - - cl_int status = pCmdQ->enqueueReadBufferRect(buffer.get(), CL_FALSE, bufferOrigin, hostOrigin, region, 0, 0, 0, 0, ptr, 0, 0, nullptr); - - void *alignedPtr = alignDown(ptr, 4); - size_t ptrOffset = ptrDiff(ptr, alignedPtr); - Vec3 offset = {0, 0, 0}; - auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); - - EXPECT_EQ(alignedPtr, builtinParams.dstPtr); - EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x); - EXPECT_EQ(offset, builtinParams.srcOffset); - - status = pCmdQ->enqueueWriteBufferRect(buffer.get(), CL_FALSE, bufferOrigin, hostOrigin, region, 0, 0, 0, 0, ptr, 0, 0, nullptr); - EXPECT_EQ(CL_SUCCESS, status); - - builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); - EXPECT_EQ(alignedPtr, builtinParams.srcPtr); - EXPECT_EQ(offset, builtinParams.dstOffset); - EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x); -} HWTEST_F(CommandQueueHwTest, givenCommandQueueThatIsBlockedAndUsesCpuCopyWhenEventIsReturnedThenItIsNotReady) { CommandQueueHw *cmdQHw = static_cast *>(this->pCmdQ); MockBuffer buffer; @@ -1170,45 +897,6 @@ HWTEST_F(CommandQueueHwTest, givenEventWithRecordedCommandWhenSubmitCommandIsCal t.join(); } -HWTEST_F(CommandQueueHwTest, GivenBuiltinKernelWhenBuiltinDispatchInfoBuilderIsProvidedThenThisBuilderIsUsedForCreatingDispatchInfo) { - CommandQueueHw *cmdQHw = static_cast *>(this->pCmdQ); - - MockKernelWithInternals mockKernelToUse(*pClDevice); - MockBuilder builder(*pDevice->getBuiltIns(), *pClDevice); - builder.paramsToUse.gws.x = 11; - builder.paramsToUse.elws.x = 13; - builder.paramsToUse.offset.x = 17; - builder.paramsToUse.kernel = mockKernelToUse.mockKernel; - - MockKernelWithInternals mockKernelToSend(*pClDevice); - mockKernelToSend.kernelInfo.builtinDispatchBuilder = &builder; - NullSurface s; - Surface *surfaces[] = {&s}; - size_t gws[3] = {3, 0, 0}; - size_t lws[3] = {5, 0, 0}; - size_t off[3] = {7, 0, 0}; - - EXPECT_FALSE(builder.wasBuildDispatchInfosWithBuiltinOpParamsCalled); - EXPECT_FALSE(builder.wasBuildDispatchInfosWithKernelParamsCalled); - - cmdQHw->template enqueueHandler(surfaces, false, mockKernelToSend.mockKernel, 1, off, gws, lws, lws, 0, nullptr, nullptr); - - EXPECT_FALSE(builder.wasBuildDispatchInfosWithBuiltinOpParamsCalled); - EXPECT_TRUE(builder.wasBuildDispatchInfosWithKernelParamsCalled); - - EXPECT_EQ(Vec3(gws[0], gws[1], gws[2]), builder.paramsReceived.gws); - EXPECT_EQ(Vec3(lws[0], lws[1], lws[2]), builder.paramsReceived.elws); - EXPECT_EQ(Vec3(off[0], off[1], off[2]), builder.paramsReceived.offset); - EXPECT_EQ(mockKernelToSend.mockKernel, builder.paramsReceived.kernel); - - auto dispatchInfo = builder.paramsReceived.multiDispatchInfo.begin(); - EXPECT_EQ(1U, builder.paramsReceived.multiDispatchInfo.size()); - EXPECT_EQ(builder.paramsToUse.gws.x, dispatchInfo->getGWS().x); - EXPECT_EQ(builder.paramsToUse.elws.x, dispatchInfo->getEnqueuedWorkgroupSize().x); - EXPECT_EQ(builder.paramsToUse.offset.x, dispatchInfo->getOffset().x); - EXPECT_EQ(builder.paramsToUse.kernel, dispatchInfo->getKernel()); -} - HWTEST_F(CommandQueueHwTest, givenNonBlockedEnqueueWhenEventIsPassedThenUpdateItsFlushStamp) { CommandQueueHw *cmdQHw = static_cast *>(this->pCmdQ); MockKernelWithInternals mockKernelWithInternals(*pClDevice); @@ -1335,57 +1023,6 @@ HWTEST_F(CommandQueueHwTest, givenBlockedOutOfOrderQueueWhenUserEventIsSubmitted clReleaseEvent(userEvent); } -HWTEST_F(OOQueueHwTest, givenBlockedOutOfOrderCmdQueueAndAsynchronouslyCompletedEventWhenEnqueueCompletesVirtualEventThenUpdatedTaskLevelIsPassedToEnqueueAndFlushTask) { - CommandQueueHw *cmdQHw = static_cast *>(this->pCmdQ); - - int32_t executionStamp = 0; - auto mockCSR = new MockCsr(executionStamp, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield()); - pDevice->resetCommandStreamReceiver(mockCSR); - - MockKernelWithInternals mockKernelWithInternals(*pClDevice); - auto mockKernel = mockKernelWithInternals.mockKernel; - size_t offset = 0; - size_t size = 1; - - class MockEventWithSetCompleteOnUpdate : public Event { - public: - MockEventWithSetCompleteOnUpdate(CommandQueue *cmdQueue, cl_command_type cmdType, - uint32_t taskLevel, uint32_t taskCount) : Event(cmdQueue, cmdType, taskLevel, taskCount) { - } - void updateExecutionStatus() override { - setStatus(CL_COMPLETE); - } - }; - - Event event(cmdQHw, CL_COMMAND_NDRANGE_KERNEL, 10, 0); - - uint32_t virtualEventTaskLevel = 77; - uint32_t virtualEventTaskCount = 80; - MockEventWithSetCompleteOnUpdate virtualEvent(cmdQHw, CL_COMMAND_NDRANGE_KERNEL, virtualEventTaskLevel, virtualEventTaskCount); - - cl_event blockedEvent = &event; - - // Put Queue in blocked state by assigning virtualEvent - virtualEvent.incRefInternal(); - event.addChild(virtualEvent); - cmdQHw->virtualEvent = &virtualEvent; - - cmdQHw->taskLevel = 23; - cmdQHw->enqueueKernel(mockKernel, 1, &offset, &size, &size, 1, &blockedEvent, nullptr); - //new virtual event is created on enqueue, bind it to the created virtual event - EXPECT_NE(cmdQHw->virtualEvent, &virtualEvent); - - event.setStatus(CL_SUBMITTED); - - virtualEvent.Event::updateExecutionStatus(); - EXPECT_FALSE(cmdQHw->isQueueBlocked()); - - //+1 due to dependency between virtual event & new virtual event - //new virtual event is actually responsible for command delivery - EXPECT_EQ(virtualEventTaskLevel + 1, cmdQHw->taskLevel); - EXPECT_EQ(virtualEventTaskLevel + 1, mockCSR->lastTaskLevelToFlushTask); -} - HWTEST_F(CommandQueueHwTest, givenWalkerSplitEnqueueNDRangeWhenNoBlockedThenKernelMakeResidentCalledOnce) { KernelInfo kernelInfo; MockKernelWithInternals mockKernelWithInternals(*pClDevice); @@ -1521,276 +1158,3 @@ HWTEST_F(CommandQueueHwTest, givenNoGpuHangWhenFinishingCommandQueueHwThenWaitFo EXPECT_EQ(1, mockCmdQueueHw.waitForAllEnginesCalledCount); EXPECT_EQ(CL_SUCCESS, finishResult); } - -HWTEST_F(IoqCommandQueueHwBlitTest, givenGpgpuCsrWhenEnqueueingSubsequentBlitsThenGpgpuCommandStreamIsNotObtained) { - auto &gpgpuCsr = pDevice->getUltCommandStreamReceiver(); - auto srcBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; - auto dstBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; - - cl_int retVal = pCmdQ->enqueueCopyBuffer( - srcBuffer.get(), - dstBuffer.get(), - 0, - 0, - 1, - 0, - nullptr, - nullptr); - ASSERT_EQ(CL_SUCCESS, retVal); - EXPECT_EQ(0, gpgpuCsr.ensureCommandBufferAllocationCalled); - - retVal = pCmdQ->enqueueCopyBuffer( - srcBuffer.get(), - dstBuffer.get(), - 0, - 0, - 1, - 0, - nullptr, - nullptr); - ASSERT_EQ(CL_SUCCESS, retVal); - EXPECT_EQ(0, gpgpuCsr.ensureCommandBufferAllocationCalled); -} - -HWTEST_F(IoqCommandQueueHwBlitTest, givenGpgpuCsrWhenEnqueueingBlitAfterNotFlushedKernelThenGpgpuCommandStreamIsObtained) { - auto &gpgpuCsr = pDevice->getUltCommandStreamReceiver(); - auto srcBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; - auto dstBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; - pCmdQ->getGpgpuCommandStreamReceiver().overrideDispatchPolicy(DispatchMode::BatchedDispatch); - - MockKernelWithInternals mockKernelWithInternals(*pClDevice); - size_t offset = 0; - size_t size = 1; - cl_int retVal = pCmdQ->enqueueKernel(mockKernelWithInternals.mockKernel, 1, &offset, &size, &size, 0, nullptr, nullptr); - ASSERT_EQ(CL_SUCCESS, retVal); - EXPECT_NE(0, gpgpuCsr.ensureCommandBufferAllocationCalled); - const auto ensureCommandBufferAllocationCalledAfterKernel = gpgpuCsr.ensureCommandBufferAllocationCalled; - - retVal = pCmdQ->enqueueCopyBuffer( - srcBuffer.get(), - dstBuffer.get(), - 0, - 0, - 1, - 0, - nullptr, - nullptr); - ASSERT_EQ(CL_SUCCESS, retVal); - EXPECT_NE(ensureCommandBufferAllocationCalledAfterKernel, gpgpuCsr.ensureCommandBufferAllocationCalled); -} - -HWTEST_F(IoqCommandQueueHwBlitTest, givenGpgpuCsrWhenEnqueueingBlitAfterFlushedKernelThenGpgpuCommandStreamIsNotObtained) { - auto &gpgpuCsr = pDevice->getUltCommandStreamReceiver(); - auto srcBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; - auto dstBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; - - DebugManagerStateRestore restorer; - DebugManager.flags.ForceCacheFlushForBcs.set(0); - - MockKernelWithInternals mockKernelWithInternals(*pClDevice); - size_t offset = 0; - size_t size = 1; - cl_int retVal = pCmdQ->enqueueKernel(mockKernelWithInternals.mockKernel, 1, &offset, &size, &size, 0, nullptr, nullptr); - ASSERT_EQ(CL_SUCCESS, retVal); - EXPECT_NE(0, gpgpuCsr.ensureCommandBufferAllocationCalled); - const auto ensureCommandBufferAllocationCalledAfterKernel = gpgpuCsr.ensureCommandBufferAllocationCalled; - - retVal = pCmdQ->enqueueCopyBuffer( - srcBuffer.get(), - dstBuffer.get(), - 0, - 0, - 1, - 0, - nullptr, - nullptr); - ASSERT_EQ(CL_SUCCESS, retVal); - EXPECT_EQ(ensureCommandBufferAllocationCalledAfterKernel, gpgpuCsr.ensureCommandBufferAllocationCalled); -} - -HWTEST_F(OoqCommandQueueHwBlitTest, givenBlitAfterBarrierWhenEnqueueingCommandThenWaitForBarrierOnBlit) { - using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; - using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; - - if (pCmdQ->getTimestampPacketContainer() == nullptr) { - GTEST_SKIP(); - } - DebugManagerStateRestore restore{}; - DebugManager.flags.DoCpuCopyOnReadBuffer.set(0); - DebugManager.flags.ForceCacheFlushForBcs.set(0); - DebugManager.flags.UpdateTaskCountFromWait.set(1); - - MockKernelWithInternals mockKernelWithInternals(*pClDevice); - MockKernel *kernel = mockKernelWithInternals.mockKernel; - size_t offset = 0; - size_t gws = 1; - BufferDefaults::context = context; - auto buffer = clUniquePtr(BufferHelper<>::create()); - char ptr[1] = {}; - - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); - auto ccsStart = pCmdQ->getGpgpuCommandStreamReceiver().getCS().getUsed(); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueBarrierWithWaitList(0, nullptr, nullptr)); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); - - uint64_t barrierNodeAddress = 0u; - { - HardwareParse ccsHwParser; - ccsHwParser.parseCommands(pCmdQ->getGpgpuCommandStreamReceiver().getCS(0), ccsStart); - - const auto pipeControlItor = find(ccsHwParser.cmdList.begin(), ccsHwParser.cmdList.end()); - auto pipeControl = genCmdCast(*pipeControlItor); - EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation()); - barrierNodeAddress = pipeControl->getAddress() | (static_cast(pipeControl->getAddressHigh()) << 32); - - // There shouldn't be any semaphores before the barrier - const auto semaphoreItor = find(ccsHwParser.cmdList.begin(), pipeControlItor); - EXPECT_EQ(pipeControlItor, semaphoreItor); - } - - { - HardwareParse bcsHwParser; - bcsHwParser.parseCommands(pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0), 0u); - - const auto semaphoreItor = find(bcsHwParser.cmdList.begin(), bcsHwParser.cmdList.end()); - auto semaphore = genCmdCast(*semaphoreItor); - EXPECT_EQ(barrierNodeAddress, semaphore->getSemaphoreGraphicsAddress()); - - const auto pipeControlItor = find(semaphoreItor, bcsHwParser.cmdList.end()); - EXPECT_EQ(bcsHwParser.cmdList.end(), pipeControlItor); - } - - EXPECT_EQ(CL_SUCCESS, pCmdQ->finish()); -} - -HWTEST_F(OoqCommandQueueHwBlitTest, givenBlitBeforeBarrierWhenEnqueueingCommandThenWaitForBlitBeforeBarrier) { - using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; - using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; - using XY_COPY_BLT = typename FamilyType::XY_COPY_BLT; - - if (pCmdQ->getTimestampPacketContainer() == nullptr) { - GTEST_SKIP(); - } - DebugManagerStateRestore restore{}; - DebugManager.flags.DoCpuCopyOnReadBuffer.set(0); - DebugManager.flags.ForceCacheFlushForBcs.set(0); - DebugManager.flags.UpdateTaskCountFromWait.set(1); - - MockKernelWithInternals mockKernelWithInternals(*pClDevice); - MockKernel *kernel = mockKernelWithInternals.mockKernel; - size_t offset = 0; - size_t gws = 1; - BufferDefaults::context = context; - auto buffer = clUniquePtr(BufferHelper<>::create()); - char ptr[1] = {}; - - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); - uint64_t lastBlitNodeAddress = TimestampPacketHelper::getContextEndGpuAddress(*pCmdQ->getTimestampPacketContainer()->peekNodes()[0]); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); - auto ccsStart = pCmdQ->getGpgpuCommandStreamReceiver().getCS().getUsed(); - auto bcsStart = pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0).getUsed(); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueBarrierWithWaitList(0, nullptr, nullptr)); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); - - uint64_t barrierNodeAddress = 0u; - { - HardwareParse ccsHwParser; - ccsHwParser.parseCommands(pCmdQ->getGpgpuCommandStreamReceiver().getCS(0), ccsStart); - - const auto semaphoreItor = find(ccsHwParser.cmdList.begin(), ccsHwParser.cmdList.end()); - const auto semaphore = genCmdCast(*semaphoreItor); - EXPECT_EQ(lastBlitNodeAddress, semaphore->getSemaphoreGraphicsAddress()); - - const auto pipeControlItor = find(semaphoreItor, ccsHwParser.cmdList.end()); - const auto pipeControl = genCmdCast(*pipeControlItor); - EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation()); - barrierNodeAddress = pipeControl->getAddress() | (static_cast(pipeControl->getAddressHigh()) << 32); - - // There shouldn't be any more semaphores before the barrier - EXPECT_EQ(pipeControlItor, find(std::next(semaphoreItor), pipeControlItor)); - } - - { - HardwareParse bcsHwParser; - bcsHwParser.parseCommands(pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0), bcsStart); - - const auto semaphoreItor = find(bcsHwParser.cmdList.begin(), bcsHwParser.cmdList.end()); - const auto semaphore = genCmdCast(*semaphoreItor); - EXPECT_EQ(barrierNodeAddress, semaphore->getSemaphoreGraphicsAddress()); - EXPECT_EQ(bcsHwParser.cmdList.end(), find(semaphoreItor, bcsHwParser.cmdList.end())); - - // Only one barrier semaphore from first BCS enqueue - const auto blitItor = find(bcsHwParser.cmdList.begin(), bcsHwParser.cmdList.end()); - EXPECT_EQ(1u, findAll(bcsHwParser.cmdList.begin(), blitItor).size()); - } - - EXPECT_EQ(CL_SUCCESS, pCmdQ->finish()); -} - -HWTEST_F(OoqCommandQueueHwBlitTest, givenBlockedBlitAfterBarrierWhenEnqueueingCommandThenWaitForBlitBeforeBarrier) { - using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; - using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; - - if (pCmdQ->getTimestampPacketContainer() == nullptr) { - GTEST_SKIP(); - } - DebugManagerStateRestore restore{}; - DebugManager.flags.DoCpuCopyOnReadBuffer.set(0); - DebugManager.flags.ForceCacheFlushForBcs.set(0); - DebugManager.flags.UpdateTaskCountFromWait.set(1); - - UserEvent userEvent; - cl_event userEventWaitlist[] = {&userEvent}; - MockKernelWithInternals mockKernelWithInternals(*pClDevice); - MockKernel *kernel = mockKernelWithInternals.mockKernel; - size_t offset = 0; - size_t gws = 1; - BufferDefaults::context = context; - auto buffer = clUniquePtr(BufferHelper<>::create()); - char ptr[1] = {}; - - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); - uint64_t lastBlitNodeAddress = TimestampPacketHelper::getContextEndGpuAddress(*pCmdQ->getTimestampPacketContainer()->peekNodes()[0]); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); - auto ccsStart = pCmdQ->getGpgpuCommandStreamReceiver().getCS().getUsed(); - auto bcsStart = pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0).getUsed(); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueBarrierWithWaitList(0, nullptr, nullptr)); - EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 1, userEventWaitlist, nullptr)); - - userEvent.setStatus(CL_COMPLETE); - - uint64_t barrierNodeAddress = 0u; - { - HardwareParse ccsHwParser; - ccsHwParser.parseCommands(pCmdQ->getGpgpuCommandStreamReceiver().getCS(0), ccsStart); - - const auto semaphoreItor = find(ccsHwParser.cmdList.begin(), ccsHwParser.cmdList.end()); - const auto semaphore = genCmdCast(*semaphoreItor); - EXPECT_EQ(lastBlitNodeAddress, semaphore->getSemaphoreGraphicsAddress()); - - const auto pipeControlItor = find(semaphoreItor, ccsHwParser.cmdList.end()); - const auto pipeControl = genCmdCast(*pipeControlItor); - EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation()); - barrierNodeAddress = pipeControl->getAddress() | (static_cast(pipeControl->getAddressHigh()) << 32); - - // There shouldn't be any more semaphores before the barrier - EXPECT_EQ(pipeControlItor, find(std::next(semaphoreItor), pipeControlItor)); - } - - { - HardwareParse bcsHwParser; - bcsHwParser.parseCommands(pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0), bcsStart); - - const auto semaphoreItor = find(bcsHwParser.cmdList.begin(), bcsHwParser.cmdList.end()); - const auto semaphore = genCmdCast(*semaphoreItor); - EXPECT_EQ(barrierNodeAddress, semaphore->getSemaphoreGraphicsAddress()); - EXPECT_EQ(bcsHwParser.cmdList.end(), find(semaphoreItor, bcsHwParser.cmdList.end())); - } - - EXPECT_EQ(CL_SUCCESS, pCmdQ->finish()); -} diff --git a/opencl/test/unit_test/command_queue/command_queue_hw_2_tests.cpp b/opencl/test/unit_test/command_queue/command_queue_hw_2_tests.cpp new file mode 100644 index 0000000000..02dd38dd80 --- /dev/null +++ b/opencl/test/unit_test/command_queue/command_queue_hw_2_tests.cpp @@ -0,0 +1,601 @@ +/* + * Copyright (C) 2018-2022 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "shared/test/common/cmd_parse/hw_parse.h" +#include "shared/test/common/mocks/mock_builtins.h" +#include "shared/test/common/mocks/mock_csr.h" +#include "shared/test/unit_test/utilities/base_object_utils.h" + +#include "opencl/source/built_ins/builtins_dispatch_builder.h" +#include "opencl/source/helpers/dispatch_info_builder.h" +#include "opencl/test/unit_test/command_queue/command_queue_fixture.h" +#include "opencl/test/unit_test/fixtures/buffer_fixture.h" +#include "opencl/test/unit_test/fixtures/image_fixture.h" +#include "opencl/test/unit_test/mocks/mock_command_queue.h" +#include "opencl/test/unit_test/mocks/mock_event.h" +#include "opencl/test/unit_test/mocks/mock_kernel.h" + +using namespace NEO; + +void CloneMdi(MultiDispatchInfo &dst, const MultiDispatchInfo &src) { + for (auto &srcDi : src) { + dst.push(srcDi); + } + dst.setBuiltinOpParams(src.peekBuiltinOpParams()); +} + +struct MockBuilder : BuiltinDispatchInfoBuilder { + using BuiltinDispatchInfoBuilder::BuiltinDispatchInfoBuilder; + bool buildDispatchInfos(MultiDispatchInfo &d) const override { + wasBuildDispatchInfosWithBuiltinOpParamsCalled = true; + paramsReceived.multiDispatchInfo.setBuiltinOpParams(d.peekBuiltinOpParams()); + return true; + } + bool buildDispatchInfos(MultiDispatchInfo &d, Kernel *kernel, + const uint32_t dim, const Vec3 &gws, const Vec3 &elws, const Vec3 &offset) const override { + paramsReceived.kernel = kernel; + paramsReceived.gws = gws; + paramsReceived.elws = elws; + paramsReceived.offset = offset; + wasBuildDispatchInfosWithKernelParamsCalled = true; + + DispatchInfoBuilder dispatchInfoBuilder(clDevice); + dispatchInfoBuilder.setKernel(paramsToUse.kernel); + dispatchInfoBuilder.setDispatchGeometry(dim, paramsToUse.gws, paramsToUse.elws, paramsToUse.offset); + dispatchInfoBuilder.bake(d); + + CloneMdi(paramsReceived.multiDispatchInfo, d); + return true; + } + + mutable bool wasBuildDispatchInfosWithBuiltinOpParamsCalled = false; + mutable bool wasBuildDispatchInfosWithKernelParamsCalled = false; + struct Params { + MultiDispatchInfo multiDispatchInfo; + Kernel *kernel = nullptr; + Vec3 gws = Vec3{0, 0, 0}; + Vec3 elws = Vec3{0, 0, 0}; + Vec3 offset = Vec3{0, 0, 0}; + }; + + mutable Params paramsReceived; + Params paramsToUse; +}; + +struct BuiltinParamsCommandQueueHwTests : public CommandQueueHwTest { + + void SetUpImpl(EBuiltInOps::Type operation) { + auto builtIns = new MockBuiltins(); + pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()]->builtins.reset(builtIns); + + auto swapBuilder = pClExecutionEnvironment->setBuiltinDispatchInfoBuilder( + rootDeviceIndex, + operation, + std::unique_ptr(new MockBuilder(*builtIns, pCmdQ->getClDevice()))); + + mockBuilder = static_cast(&BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder( + operation, + *pClDevice)); + } + + MockBuilder *mockBuilder; +}; + +HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadWriteBufferCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) { + + SetUpImpl(EBuiltInOps::CopyBufferToBuffer); + BufferDefaults::context = context; + auto buffer = clUniquePtr(BufferHelper<>::create()); + + char array[3 * MemoryConstants::cacheLineSize]; + char *ptr = &array[MemoryConstants::cacheLineSize]; + ptr = alignUp(ptr, MemoryConstants::cacheLineSize); + ptr -= 1; + + cl_int status = pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 0, ptr, nullptr, 0, 0, nullptr); + EXPECT_EQ(CL_SUCCESS, status); + + void *alignedPtr = alignDown(ptr, 4); + size_t ptrOffset = ptrDiff(ptr, alignedPtr); + Vec3 offset = {0, 0, 0}; + + auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); + + EXPECT_EQ(alignedPtr, builtinParams.dstPtr); + EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x); + EXPECT_EQ(offset, builtinParams.srcOffset); + + status = pCmdQ->enqueueWriteBuffer(buffer.get(), CL_FALSE, 0, 0, ptr, nullptr, 0, 0, nullptr); + EXPECT_EQ(CL_SUCCESS, status); + + builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); + + EXPECT_EQ(alignedPtr, builtinParams.srcPtr); + EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x); + EXPECT_EQ(offset, builtinParams.dstOffset); +} + +HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueWriteImageCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) { + + SetUpImpl(EBuiltInOps::CopyBufferToImage3d); + + std::unique_ptr dstImage(ImageHelper>::create(context)); + + auto imageDesc = dstImage->getImageDesc(); + size_t origin[] = {0, 0, 0}; + size_t region[] = {imageDesc.image_width, imageDesc.image_height, 0}; + + size_t rowPitch = dstImage->getHostPtrRowPitch(); + size_t slicePitch = dstImage->getHostPtrSlicePitch(); + + char array[3 * MemoryConstants::cacheLineSize]; + char *ptr = &array[MemoryConstants::cacheLineSize]; + ptr = alignUp(ptr, MemoryConstants::cacheLineSize); + ptr -= 1; + + void *alignedPtr = alignDown(ptr, 4); + size_t ptrOffset = ptrDiff(ptr, alignedPtr); + Vec3 offset = {0, 0, 0}; + + cl_int status = pCmdQ->enqueueWriteImage(dstImage.get(), + CL_FALSE, + origin, + region, + rowPitch, + slicePitch, + ptr, + nullptr, + 0, + 0, + nullptr); + EXPECT_EQ(CL_SUCCESS, status); + + auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); + EXPECT_EQ(alignedPtr, builtinParams.srcPtr); + EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x); + EXPECT_EQ(offset, builtinParams.dstOffset); +} + +HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadImageCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) { + + SetUpImpl(EBuiltInOps::CopyImage3dToBuffer); + + std::unique_ptr dstImage(ImageHelper>::create(context)); + + auto imageDesc = dstImage->getImageDesc(); + size_t origin[] = {0, 0, 0}; + size_t region[] = {imageDesc.image_width, imageDesc.image_height, 0}; + + size_t rowPitch = dstImage->getHostPtrRowPitch(); + size_t slicePitch = dstImage->getHostPtrSlicePitch(); + + char array[3 * MemoryConstants::cacheLineSize]; + char *ptr = &array[MemoryConstants::cacheLineSize]; + ptr = alignUp(ptr, MemoryConstants::cacheLineSize); + ptr -= 1; + + void *alignedPtr = alignDown(ptr, 4); + size_t ptrOffset = ptrDiff(ptr, alignedPtr); + Vec3 offset = {0, 0, 0}; + + cl_int status = pCmdQ->enqueueReadImage(dstImage.get(), + CL_FALSE, + origin, + region, + rowPitch, + slicePitch, + ptr, + nullptr, + 0, + 0, + nullptr); + EXPECT_EQ(CL_SUCCESS, status); + + auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); + EXPECT_EQ(alignedPtr, builtinParams.dstPtr); + EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x); + EXPECT_EQ(offset, builtinParams.srcOffset); +} + +HWTEST_F(BuiltinParamsCommandQueueHwTests, givenEnqueueReadWriteBufferRectCallWhenBuiltinParamsArePassedThenCheckValuesCorectness) { + + SetUpImpl(EBuiltInOps::CopyBufferRect); + + BufferDefaults::context = context; + auto buffer = clUniquePtr(BufferHelper<>::create()); + + size_t bufferOrigin[3] = {0, 0, 0}; + size_t hostOrigin[3] = {0, 0, 0}; + size_t region[3] = {0, 0, 0}; + + char array[3 * MemoryConstants::cacheLineSize]; + char *ptr = &array[MemoryConstants::cacheLineSize]; + ptr = alignUp(ptr, MemoryConstants::cacheLineSize); + ptr -= 1; + + cl_int status = pCmdQ->enqueueReadBufferRect(buffer.get(), CL_FALSE, bufferOrigin, hostOrigin, region, 0, 0, 0, 0, ptr, 0, 0, nullptr); + + void *alignedPtr = alignDown(ptr, 4); + size_t ptrOffset = ptrDiff(ptr, alignedPtr); + Vec3 offset = {0, 0, 0}; + auto builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); + + EXPECT_EQ(alignedPtr, builtinParams.dstPtr); + EXPECT_EQ(ptrOffset, builtinParams.dstOffset.x); + EXPECT_EQ(offset, builtinParams.srcOffset); + + status = pCmdQ->enqueueWriteBufferRect(buffer.get(), CL_FALSE, bufferOrigin, hostOrigin, region, 0, 0, 0, 0, ptr, 0, 0, nullptr); + EXPECT_EQ(CL_SUCCESS, status); + + builtinParams = mockBuilder->paramsReceived.multiDispatchInfo.peekBuiltinOpParams(); + EXPECT_EQ(alignedPtr, builtinParams.srcPtr); + EXPECT_EQ(offset, builtinParams.dstOffset); + EXPECT_EQ(ptrOffset, builtinParams.srcOffset.x); +} + +HWTEST_F(OOQueueHwTest, givenBlockedOutOfOrderCmdQueueAndAsynchronouslyCompletedEventWhenEnqueueCompletesVirtualEventThenUpdatedTaskLevelIsPassedToEnqueueAndFlushTask) { + CommandQueueHw *cmdQHw = static_cast *>(this->pCmdQ); + + int32_t executionStamp = 0; + auto mockCSR = new MockCsr(executionStamp, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield()); + pDevice->resetCommandStreamReceiver(mockCSR); + + MockKernelWithInternals mockKernelWithInternals(*pClDevice); + auto mockKernel = mockKernelWithInternals.mockKernel; + size_t offset = 0; + size_t size = 1; + + class MockEventWithSetCompleteOnUpdate : public Event { + public: + MockEventWithSetCompleteOnUpdate(CommandQueue *cmdQueue, cl_command_type cmdType, + uint32_t taskLevel, uint32_t taskCount) : Event(cmdQueue, cmdType, taskLevel, taskCount) { + } + void updateExecutionStatus() override { + setStatus(CL_COMPLETE); + } + }; + + Event event(cmdQHw, CL_COMMAND_NDRANGE_KERNEL, 10, 0); + + uint32_t virtualEventTaskLevel = 77; + uint32_t virtualEventTaskCount = 80; + MockEventWithSetCompleteOnUpdate virtualEvent(cmdQHw, CL_COMMAND_NDRANGE_KERNEL, virtualEventTaskLevel, virtualEventTaskCount); + + cl_event blockedEvent = &event; + + // Put Queue in blocked state by assigning virtualEvent + virtualEvent.incRefInternal(); + event.addChild(virtualEvent); + cmdQHw->virtualEvent = &virtualEvent; + + cmdQHw->taskLevel = 23; + cmdQHw->enqueueKernel(mockKernel, 1, &offset, &size, &size, 1, &blockedEvent, nullptr); + //new virtual event is created on enqueue, bind it to the created virtual event + EXPECT_NE(cmdQHw->virtualEvent, &virtualEvent); + + event.setStatus(CL_SUBMITTED); + + virtualEvent.Event::updateExecutionStatus(); + EXPECT_FALSE(cmdQHw->isQueueBlocked()); + + //+1 due to dependency between virtual event & new virtual event + //new virtual event is actually responsible for command delivery + EXPECT_EQ(virtualEventTaskLevel + 1, cmdQHw->taskLevel); + EXPECT_EQ(virtualEventTaskLevel + 1, mockCSR->lastTaskLevelToFlushTask); +} + +HWTEST_F(IoqCommandQueueHwBlitTest, givenGpgpuCsrWhenEnqueueingSubsequentBlitsThenGpgpuCommandStreamIsNotObtained) { + auto &gpgpuCsr = pDevice->getUltCommandStreamReceiver(); + auto srcBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; + auto dstBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; + + cl_int retVal = pCmdQ->enqueueCopyBuffer( + srcBuffer.get(), + dstBuffer.get(), + 0, + 0, + 1, + 0, + nullptr, + nullptr); + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_EQ(0, gpgpuCsr.ensureCommandBufferAllocationCalled); + + retVal = pCmdQ->enqueueCopyBuffer( + srcBuffer.get(), + dstBuffer.get(), + 0, + 0, + 1, + 0, + nullptr, + nullptr); + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_EQ(0, gpgpuCsr.ensureCommandBufferAllocationCalled); +} + +HWTEST_F(IoqCommandQueueHwBlitTest, givenGpgpuCsrWhenEnqueueingBlitAfterNotFlushedKernelThenGpgpuCommandStreamIsObtained) { + auto &gpgpuCsr = pDevice->getUltCommandStreamReceiver(); + auto srcBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; + auto dstBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; + pCmdQ->getGpgpuCommandStreamReceiver().overrideDispatchPolicy(DispatchMode::BatchedDispatch); + + MockKernelWithInternals mockKernelWithInternals(*pClDevice); + size_t offset = 0; + size_t size = 1; + cl_int retVal = pCmdQ->enqueueKernel(mockKernelWithInternals.mockKernel, 1, &offset, &size, &size, 0, nullptr, nullptr); + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_NE(0, gpgpuCsr.ensureCommandBufferAllocationCalled); + const auto ensureCommandBufferAllocationCalledAfterKernel = gpgpuCsr.ensureCommandBufferAllocationCalled; + + retVal = pCmdQ->enqueueCopyBuffer( + srcBuffer.get(), + dstBuffer.get(), + 0, + 0, + 1, + 0, + nullptr, + nullptr); + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_NE(ensureCommandBufferAllocationCalledAfterKernel, gpgpuCsr.ensureCommandBufferAllocationCalled); +} + +HWTEST_F(IoqCommandQueueHwBlitTest, givenGpgpuCsrWhenEnqueueingBlitAfterFlushedKernelThenGpgpuCommandStreamIsNotObtained) { + auto &gpgpuCsr = pDevice->getUltCommandStreamReceiver(); + auto srcBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; + auto dstBuffer = std::unique_ptr{BufferHelper<>::create(pContext)}; + + DebugManagerStateRestore restorer; + DebugManager.flags.ForceCacheFlushForBcs.set(0); + + MockKernelWithInternals mockKernelWithInternals(*pClDevice); + size_t offset = 0; + size_t size = 1; + cl_int retVal = pCmdQ->enqueueKernel(mockKernelWithInternals.mockKernel, 1, &offset, &size, &size, 0, nullptr, nullptr); + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_NE(0, gpgpuCsr.ensureCommandBufferAllocationCalled); + const auto ensureCommandBufferAllocationCalledAfterKernel = gpgpuCsr.ensureCommandBufferAllocationCalled; + + retVal = pCmdQ->enqueueCopyBuffer( + srcBuffer.get(), + dstBuffer.get(), + 0, + 0, + 1, + 0, + nullptr, + nullptr); + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_EQ(ensureCommandBufferAllocationCalledAfterKernel, gpgpuCsr.ensureCommandBufferAllocationCalled); +} + +HWTEST_F(OoqCommandQueueHwBlitTest, givenBlitAfterBarrierWhenEnqueueingCommandThenWaitForBarrierOnBlit) { + using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + + if (pCmdQ->getTimestampPacketContainer() == nullptr) { + GTEST_SKIP(); + } + DebugManagerStateRestore restore{}; + DebugManager.flags.DoCpuCopyOnReadBuffer.set(0); + DebugManager.flags.ForceCacheFlushForBcs.set(0); + DebugManager.flags.UpdateTaskCountFromWait.set(1); + + MockKernelWithInternals mockKernelWithInternals(*pClDevice); + MockKernel *kernel = mockKernelWithInternals.mockKernel; + size_t offset = 0; + size_t gws = 1; + BufferDefaults::context = context; + auto buffer = clUniquePtr(BufferHelper<>::create()); + char ptr[1] = {}; + + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); + auto ccsStart = pCmdQ->getGpgpuCommandStreamReceiver().getCS().getUsed(); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueBarrierWithWaitList(0, nullptr, nullptr)); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); + + uint64_t barrierNodeAddress = 0u; + { + HardwareParse ccsHwParser; + ccsHwParser.parseCommands(pCmdQ->getGpgpuCommandStreamReceiver().getCS(0), ccsStart); + + const auto pipeControlItor = find(ccsHwParser.cmdList.begin(), ccsHwParser.cmdList.end()); + auto pipeControl = genCmdCast(*pipeControlItor); + EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation()); + barrierNodeAddress = pipeControl->getAddress() | (static_cast(pipeControl->getAddressHigh()) << 32); + + // There shouldn't be any semaphores before the barrier + const auto semaphoreItor = find(ccsHwParser.cmdList.begin(), pipeControlItor); + EXPECT_EQ(pipeControlItor, semaphoreItor); + } + + { + HardwareParse bcsHwParser; + bcsHwParser.parseCommands(pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0), 0u); + + const auto semaphoreItor = find(bcsHwParser.cmdList.begin(), bcsHwParser.cmdList.end()); + auto semaphore = genCmdCast(*semaphoreItor); + EXPECT_EQ(barrierNodeAddress, semaphore->getSemaphoreGraphicsAddress()); + + const auto pipeControlItor = find(semaphoreItor, bcsHwParser.cmdList.end()); + EXPECT_EQ(bcsHwParser.cmdList.end(), pipeControlItor); + } + + EXPECT_EQ(CL_SUCCESS, pCmdQ->finish()); +} + +HWTEST_F(OoqCommandQueueHwBlitTest, givenBlitBeforeBarrierWhenEnqueueingCommandThenWaitForBlitBeforeBarrier) { + using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + using XY_COPY_BLT = typename FamilyType::XY_COPY_BLT; + + if (pCmdQ->getTimestampPacketContainer() == nullptr) { + GTEST_SKIP(); + } + DebugManagerStateRestore restore{}; + DebugManager.flags.DoCpuCopyOnReadBuffer.set(0); + DebugManager.flags.ForceCacheFlushForBcs.set(0); + DebugManager.flags.UpdateTaskCountFromWait.set(1); + + MockKernelWithInternals mockKernelWithInternals(*pClDevice); + MockKernel *kernel = mockKernelWithInternals.mockKernel; + size_t offset = 0; + size_t gws = 1; + BufferDefaults::context = context; + auto buffer = clUniquePtr(BufferHelper<>::create()); + char ptr[1] = {}; + + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); + uint64_t lastBlitNodeAddress = TimestampPacketHelper::getContextEndGpuAddress(*pCmdQ->getTimestampPacketContainer()->peekNodes()[0]); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); + auto ccsStart = pCmdQ->getGpgpuCommandStreamReceiver().getCS().getUsed(); + auto bcsStart = pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0).getUsed(); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueBarrierWithWaitList(0, nullptr, nullptr)); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); + + uint64_t barrierNodeAddress = 0u; + { + HardwareParse ccsHwParser; + ccsHwParser.parseCommands(pCmdQ->getGpgpuCommandStreamReceiver().getCS(0), ccsStart); + + const auto semaphoreItor = find(ccsHwParser.cmdList.begin(), ccsHwParser.cmdList.end()); + const auto semaphore = genCmdCast(*semaphoreItor); + EXPECT_EQ(lastBlitNodeAddress, semaphore->getSemaphoreGraphicsAddress()); + + const auto pipeControlItor = find(semaphoreItor, ccsHwParser.cmdList.end()); + const auto pipeControl = genCmdCast(*pipeControlItor); + EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation()); + barrierNodeAddress = pipeControl->getAddress() | (static_cast(pipeControl->getAddressHigh()) << 32); + + // There shouldn't be any more semaphores before the barrier + EXPECT_EQ(pipeControlItor, find(std::next(semaphoreItor), pipeControlItor)); + } + + { + HardwareParse bcsHwParser; + bcsHwParser.parseCommands(pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0), bcsStart); + + const auto semaphoreItor = find(bcsHwParser.cmdList.begin(), bcsHwParser.cmdList.end()); + const auto semaphore = genCmdCast(*semaphoreItor); + EXPECT_EQ(barrierNodeAddress, semaphore->getSemaphoreGraphicsAddress()); + EXPECT_EQ(bcsHwParser.cmdList.end(), find(semaphoreItor, bcsHwParser.cmdList.end())); + + // Only one barrier semaphore from first BCS enqueue + const auto blitItor = find(bcsHwParser.cmdList.begin(), bcsHwParser.cmdList.end()); + EXPECT_EQ(1u, findAll(bcsHwParser.cmdList.begin(), blitItor).size()); + } + + EXPECT_EQ(CL_SUCCESS, pCmdQ->finish()); +} + +HWTEST_F(OoqCommandQueueHwBlitTest, givenBlockedBlitAfterBarrierWhenEnqueueingCommandThenWaitForBlitBeforeBarrier) { + using MI_SEMAPHORE_WAIT = typename FamilyType::MI_SEMAPHORE_WAIT; + using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL; + + if (pCmdQ->getTimestampPacketContainer() == nullptr) { + GTEST_SKIP(); + } + DebugManagerStateRestore restore{}; + DebugManager.flags.DoCpuCopyOnReadBuffer.set(0); + DebugManager.flags.ForceCacheFlushForBcs.set(0); + DebugManager.flags.UpdateTaskCountFromWait.set(1); + + UserEvent userEvent; + cl_event userEventWaitlist[] = {&userEvent}; + MockKernelWithInternals mockKernelWithInternals(*pClDevice); + MockKernel *kernel = mockKernelWithInternals.mockKernel; + size_t offset = 0; + size_t gws = 1; + BufferDefaults::context = context; + auto buffer = clUniquePtr(BufferHelper<>::create()); + char ptr[1] = {}; + + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 0, nullptr, nullptr)); + uint64_t lastBlitNodeAddress = TimestampPacketHelper::getContextEndGpuAddress(*pCmdQ->getTimestampPacketContainer()->peekNodes()[0]); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueKernel(kernel, 1, &offset, &gws, nullptr, 0, nullptr, nullptr)); + auto ccsStart = pCmdQ->getGpgpuCommandStreamReceiver().getCS().getUsed(); + auto bcsStart = pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0).getUsed(); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueBarrierWithWaitList(0, nullptr, nullptr)); + EXPECT_EQ(CL_SUCCESS, pCmdQ->enqueueReadBuffer(buffer.get(), CL_FALSE, 0, 1u, ptr, nullptr, 1, userEventWaitlist, nullptr)); + + userEvent.setStatus(CL_COMPLETE); + + uint64_t barrierNodeAddress = 0u; + { + HardwareParse ccsHwParser; + ccsHwParser.parseCommands(pCmdQ->getGpgpuCommandStreamReceiver().getCS(0), ccsStart); + + const auto semaphoreItor = find(ccsHwParser.cmdList.begin(), ccsHwParser.cmdList.end()); + const auto semaphore = genCmdCast(*semaphoreItor); + EXPECT_EQ(lastBlitNodeAddress, semaphore->getSemaphoreGraphicsAddress()); + + const auto pipeControlItor = find(semaphoreItor, ccsHwParser.cmdList.end()); + const auto pipeControl = genCmdCast(*pipeControlItor); + EXPECT_EQ(PIPE_CONTROL::POST_SYNC_OPERATION::POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA, pipeControl->getPostSyncOperation()); + barrierNodeAddress = pipeControl->getAddress() | (static_cast(pipeControl->getAddressHigh()) << 32); + + // There shouldn't be any more semaphores before the barrier + EXPECT_EQ(pipeControlItor, find(std::next(semaphoreItor), pipeControlItor)); + } + + { + HardwareParse bcsHwParser; + bcsHwParser.parseCommands(pCmdQ->getBcsCommandStreamReceiver(aub_stream::ENGINE_BCS)->getCS(0), bcsStart); + + const auto semaphoreItor = find(bcsHwParser.cmdList.begin(), bcsHwParser.cmdList.end()); + const auto semaphore = genCmdCast(*semaphoreItor); + EXPECT_EQ(barrierNodeAddress, semaphore->getSemaphoreGraphicsAddress()); + EXPECT_EQ(bcsHwParser.cmdList.end(), find(semaphoreItor, bcsHwParser.cmdList.end())); + } + + EXPECT_EQ(CL_SUCCESS, pCmdQ->finish()); +} + +HWTEST_F(CommandQueueHwTest, GivenBuiltinKernelWhenBuiltinDispatchInfoBuilderIsProvidedThenThisBuilderIsUsedForCreatingDispatchInfo) { + CommandQueueHw *cmdQHw = static_cast *>(this->pCmdQ); + + MockKernelWithInternals mockKernelToUse(*pClDevice); + MockBuilder builder(*pDevice->getBuiltIns(), *pClDevice); + builder.paramsToUse.gws.x = 11; + builder.paramsToUse.elws.x = 13; + builder.paramsToUse.offset.x = 17; + builder.paramsToUse.kernel = mockKernelToUse.mockKernel; + + MockKernelWithInternals mockKernelToSend(*pClDevice); + mockKernelToSend.kernelInfo.builtinDispatchBuilder = &builder; + NullSurface s; + Surface *surfaces[] = {&s}; + size_t gws[3] = {3, 0, 0}; + size_t lws[3] = {5, 0, 0}; + size_t off[3] = {7, 0, 0}; + + EXPECT_FALSE(builder.wasBuildDispatchInfosWithBuiltinOpParamsCalled); + EXPECT_FALSE(builder.wasBuildDispatchInfosWithKernelParamsCalled); + + cmdQHw->template enqueueHandler(surfaces, false, mockKernelToSend.mockKernel, 1, off, gws, lws, lws, 0, nullptr, nullptr); + + EXPECT_FALSE(builder.wasBuildDispatchInfosWithBuiltinOpParamsCalled); + EXPECT_TRUE(builder.wasBuildDispatchInfosWithKernelParamsCalled); + + EXPECT_EQ(Vec3(gws[0], gws[1], gws[2]), builder.paramsReceived.gws); + EXPECT_EQ(Vec3(lws[0], lws[1], lws[2]), builder.paramsReceived.elws); + EXPECT_EQ(Vec3(off[0], off[1], off[2]), builder.paramsReceived.offset); + EXPECT_EQ(mockKernelToSend.mockKernel, builder.paramsReceived.kernel); + + auto dispatchInfo = builder.paramsReceived.multiDispatchInfo.begin(); + EXPECT_EQ(1U, builder.paramsReceived.multiDispatchInfo.size()); + EXPECT_EQ(builder.paramsToUse.gws.x, dispatchInfo->getGWS().x); + EXPECT_EQ(builder.paramsToUse.elws.x, dispatchInfo->getEnqueuedWorkgroupSize().x); + EXPECT_EQ(builder.paramsToUse.offset.x, dispatchInfo->getOffset().x); + EXPECT_EQ(builder.paramsToUse.kernel, dispatchInfo->getKernel()); +} diff --git a/opencl/test/unit_test/fixtures/CMakeLists.txt b/opencl/test/unit_test/fixtures/CMakeLists.txt index 4dac1eef05..4ae92a681c 100644 --- a/opencl/test/unit_test/fixtures/CMakeLists.txt +++ b/opencl/test/unit_test/fixtures/CMakeLists.txt @@ -9,8 +9,6 @@ set(IGDRCL_SRCS_tests_fixtures ${CMAKE_CURRENT_SOURCE_DIR}/buffer_enqueue_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/cl_preemption_fixture.cpp ${CMAKE_CURRENT_SOURCE_DIR}/cl_preemption_fixture.h - ${CMAKE_CURRENT_SOURCE_DIR}/context_fixture.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/context_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/d3d_test_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/dispatch_flags_fixture.h ${CMAKE_CURRENT_SOURCE_DIR}/device_info_fixture.h diff --git a/opencl/test/unit_test/fixtures/context_fixture.h b/opencl/test/unit_test/fixtures/context_fixture.h index d98a393684..64d95bfcd0 100644 --- a/opencl/test/unit_test/fixtures/context_fixture.h +++ b/opencl/test/unit_test/fixtures/context_fixture.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -13,8 +13,8 @@ class MockContext; class ContextFixture { protected: - virtual void SetUp(cl_uint numDevices, cl_device_id *pDeviceList); - virtual void TearDown(); + void SetUp(cl_uint numDevices, cl_device_id *pDeviceList); + void TearDown(); MockContext *pContext = nullptr; }; diff --git a/opencl/test/unit_test/helpers/dispatch_info_builder_tests.cpp b/opencl/test/unit_test/helpers/dispatch_info_builder_tests.cpp index c1d1255c0a..6dbd5a6b86 100644 --- a/opencl/test/unit_test/helpers/dispatch_info_builder_tests.cpp +++ b/opencl/test/unit_test/helpers/dispatch_info_builder_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -55,7 +55,7 @@ class DispatchInfoBuilderFixture : public ContextFixture, public ClDeviceFixture pKernel->isBuiltIn = true; } - void TearDown() override { + void TearDown() { delete pKernel; delete pProgram; diff --git a/opencl/test/unit_test/helpers/dispatch_info_tests.cpp b/opencl/test/unit_test/helpers/dispatch_info_tests.cpp index 60ba84ddcf..d2e3c47dc1 100644 --- a/opencl/test/unit_test/helpers/dispatch_info_tests.cpp +++ b/opencl/test/unit_test/helpers/dispatch_info_tests.cpp @@ -40,7 +40,7 @@ class DispatchInfoFixture : public ContextFixture, public ClDeviceFixture { pKernel = new MockKernel(pProgram, *pKernelInfo, *pClDevice); pKernel->slmTotalSize = 128; } - void TearDown() override { + void TearDown() { delete pKernel; delete pProgram; diff --git a/opencl/test/unit_test/kernel/kernel_accelerator_arg_tests.cpp b/opencl/test/unit_test/kernel/kernel_accelerator_arg_tests.cpp index 7d4e55eec0..e17ba408c2 100644 --- a/opencl/test/unit_test/kernel/kernel_accelerator_arg_tests.cpp +++ b/opencl/test/unit_test/kernel/kernel_accelerator_arg_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -64,7 +64,7 @@ class KernelArgAcceleratorFixture : public ContextFixture, public ClDeviceFixtur pKernel->setCrossThreadData(&pCrossThreadData[0], sizeof(pCrossThreadData)); } - void TearDown() override { + void TearDown() { delete pKernel; delete pProgram; diff --git a/opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.h b/opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.h index f26c7b30dd..55f21677f4 100644 --- a/opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.h +++ b/opencl/test/unit_test/kernel/kernel_arg_buffer_fixture.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -30,7 +30,7 @@ class KernelArgBufferFixture : public ContextFixture, public ClDeviceFixture { public: void SetUp(); - void TearDown() override; + void TearDown(); cl_int retVal = CL_SUCCESS; MockProgram *pProgram = nullptr; diff --git a/opencl/test/unit_test/kernel/kernel_arg_buffer_tests.cpp b/opencl/test/unit_test/kernel/kernel_arg_buffer_tests.cpp index bb4051f6df..338889c539 100644 --- a/opencl/test/unit_test/kernel/kernel_arg_buffer_tests.cpp +++ b/opencl/test/unit_test/kernel/kernel_arg_buffer_tests.cpp @@ -744,7 +744,7 @@ class KernelArgBufferFixtureBindless : public KernelArgBufferFixture { pKernelInfo->argAsPtr(0).stateless = undefined; pKernelInfo->argAsPtr(0).bindful = undefined; } - void TearDown() override { + void TearDown() { delete pBuffer; KernelArgBufferFixture::TearDown(); } diff --git a/opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp b/opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp index 0e6f730ec5..adcc47abf4 100644 --- a/opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp +++ b/opencl/test/unit_test/kernel/kernel_arg_pipe_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2021 Intel Corporation + * Copyright (C) 2018-2022 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -56,7 +56,7 @@ class KernelArgPipeFixture : public ContextFixture, public ClDeviceFixture { pKernel->setKernelArgHandler(0, &Kernel::setArgPipe); } - void TearDown() override { + void TearDown() { delete pKernel; delete pProgram; diff --git a/opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp b/opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp index fb863d42fa..71ac0c4442 100644 --- a/opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp +++ b/opencl/test/unit_test/kernel/kernel_arg_svm_tests.cpp @@ -53,7 +53,7 @@ class KernelArgSvmFixture_ : public ContextFixture, public ClDeviceFixture { pKernel->setCrossThreadData(pCrossThreadData, sizeof(pCrossThreadData)); } - void TearDown() override { + void TearDown() { delete pKernel; delete pProgram; diff --git a/opencl/test/unit_test/libult/CMakeLists.txt b/opencl/test/unit_test/libult/CMakeLists.txt index c6f7b4b01a..556d071671 100644 --- a/opencl/test/unit_test/libult/CMakeLists.txt +++ b/opencl/test/unit_test/libult/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright (C) 2018-2021 Intel Corporation +# Copyright (C) 2018-2022 Intel Corporation # # SPDX-License-Identifier: MIT # @@ -45,6 +45,8 @@ set(IGDRCL_SRCS_LIB_ULT_ENV ${NEO_SOURCE_DIR}/opencl/test/unit_test/fixtures/buffer_fixture.h ${NEO_SOURCE_DIR}/opencl/test/unit_test/fixtures/cl_device_fixture.cpp ${NEO_SOURCE_DIR}/opencl/test/unit_test/fixtures/cl_device_fixture.h + ${NEO_SOURCE_DIR}/opencl/test/unit_test/fixtures/context_fixture.cpp + ${NEO_SOURCE_DIR}/opencl/test/unit_test/fixtures/context_fixture.h ${NEO_SOURCE_DIR}/opencl/test/unit_test/fixtures/program_fixture.cpp ${NEO_SOURCE_DIR}/opencl/test/unit_test/fixtures/program_fixture.h ${NEO_SOURCE_DIR}/opencl/test/unit_test/indirect_heap/indirect_heap_fixture.cpp