1 /*
2  * Copyright (C) 2018-2021 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 #include "shared/test/common/helpers/debug_manager_state_restore.h"
9 #include "shared/test/common/helpers/unit_test_helper.h"
10 #include "shared/test/common/libult/ult_command_stream_receiver.h"
11 #include "shared/test/common/mocks/mock_builtins.h"
12 #include "shared/test/common/test_macros/test.h"
13 
14 #include "opencl/source/built_ins/builtins_dispatch_builder.h"
15 #include "opencl/test/unit_test/command_queue/enqueue_copy_image_fixture.h"
16 #include "opencl/test/unit_test/fixtures/one_mip_level_image_fixture.h"
17 #include "opencl/test/unit_test/gen_common/gen_commands_common_validation.h"
18 #include "opencl/test/unit_test/mocks/mock_builtin_dispatch_info_builder.h"
19 #include "opencl/test/unit_test/mocks/mock_command_queue.h"
20 
21 #include "reg_configs_common.h"
22 
23 #include <algorithm>
24 
25 using namespace NEO;
26 
HWCMDTEST_F(IGFX_GEN8_CORE,EnqueueCopyImageTest,WhenCopyingImageThenGpgpuWalkerIsCorrect)27 HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, WhenCopyingImageThenGpgpuWalkerIsCorrect) {
28     typedef typename FamilyType::GPGPU_WALKER GPGPU_WALKER;
29     enqueueCopyImage<FamilyType>();
30 
31     auto *cmd = reinterpret_cast<GPGPU_WALKER *>(cmdWalker);
32     ASSERT_NE(nullptr, cmd);
33 
34     // Verify GPGPU_WALKER parameters
35     EXPECT_NE(0u, cmd->getThreadGroupIdXDimension());
36     EXPECT_NE(0u, cmd->getThreadGroupIdYDimension());
37     EXPECT_NE(0u, cmd->getThreadGroupIdZDimension());
38     EXPECT_NE(0u, cmd->getRightExecutionMask());
39     EXPECT_NE(0u, cmd->getBottomExecutionMask());
40     EXPECT_EQ(GPGPU_WALKER::SIMD_SIZE_SIMD32, cmd->getSimdSize());
41     EXPECT_NE(0u, cmd->getIndirectDataLength());
42     EXPECT_FALSE(cmd->getIndirectParameterEnable());
43 
44     // Compute the SIMD lane mask
45     size_t simd =
46         cmd->getSimdSize() == GPGPU_WALKER::SIMD_SIZE_SIMD32 ? 32 : cmd->getSimdSize() == GPGPU_WALKER::SIMD_SIZE_SIMD16 ? 16
47                                                                                                                          : 8;
48     uint64_t simdMask = maxNBitValue(simd);
49 
50     // Mask off lanes based on the execution masks
51     auto laneMaskRight = cmd->getRightExecutionMask() & simdMask;
52     auto lanesPerThreadX = 0;
53     while (laneMaskRight) {
54         lanesPerThreadX += laneMaskRight & 1;
55         laneMaskRight >>= 1;
56     }
57 
58     //auto numWorkItems = ( ( cmd->getThreadWidthCounterMaximum() - 1 ) * simd + lanesPerThreadX ) * cmd->getThreadGroupIdXDimension();
59     //EXPECT_EQ( expectedWorkItems, numWorkItems );
60 }
61 
HWTEST_F(EnqueueCopyImageTest,WhenCopyingImageThenTaskCountIsAlignedWithCsr)62 HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenTaskCountIsAlignedWithCsr) {
63     //this test case assumes IOQ
64     auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
65     csr.taskCount = pCmdQ->taskCount + 100;
66     csr.taskLevel = pCmdQ->taskLevel + 50;
67 
68     EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
69     EXPECT_EQ(csr.peekTaskCount(), pCmdQ->taskCount);
70     EXPECT_EQ(csr.peekTaskLevel(), pCmdQ->taskLevel + 1);
71 }
72 
HWTEST_F(EnqueueCopyImageTest,WhenCopyingImageThenTaskLevelIsIncremented)73 HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenTaskLevelIsIncremented) {
74     auto taskLevelBefore = pCmdQ->taskLevel;
75 
76     EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
77     EXPECT_GT(pCmdQ->taskLevel, taskLevelBefore);
78 }
79 
HWTEST_F(EnqueueCopyImageTest,WhenCopyingImageThenCommandsAreAdded)80 HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenCommandsAreAdded) {
81     auto usedCmdBufferBefore = pCS->getUsed();
82 
83     EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
84     EXPECT_NE(usedCmdBufferBefore, pCS->getUsed());
85 }
86 
HWTEST_F(EnqueueCopyImageTest,WhenCopyingImageThenIndirectDataGetsAdded)87 HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenIndirectDataGetsAdded) {
88     auto dshBefore = pDSH->getUsed();
89     auto iohBefore = pIOH->getUsed();
90     auto sshBefore = pSSH->getUsed();
91 
92     EnqueueCopyImageHelper<>::enqueueCopyImage(pCmdQ, srcImage, dstImage);
93     EXPECT_TRUE(UnitTestHelper<FamilyType>::evaluateDshUsage(dshBefore, pDSH->getUsed(), nullptr, rootDeviceIndex));
94     EXPECT_NE(iohBefore, pIOH->getUsed());
95     EXPECT_NE(sshBefore, pSSH->getUsed());
96 }
97 
HWTEST_F(EnqueueCopyImageTest,WhenCopyingImageThenL3ProgrammingIsCorrect)98 HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenL3ProgrammingIsCorrect) {
99     enqueueCopyImage<FamilyType>();
100     validateL3Programming<FamilyType>(cmdList, itorWalker);
101 }
102 
HWCMDTEST_F(IGFX_GEN8_CORE,EnqueueCopyImageTest,WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed)103 HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, WhenEnqueueIsDoneThenStateBaseAddressIsProperlyProgrammed) {
104     enqueueCopyImage<FamilyType>();
105     auto &ultCsr = this->pDevice->getUltCommandStreamReceiver<FamilyType>();
106 
107     auto &hwHelper = HwHelper::get(pDevice->getHardwareInfo().platform.eRenderCoreFamily);
108 
109     validateStateBaseAddress<FamilyType>(ultCsr.getMemoryManager()->getInternalHeapBaseAddress(ultCsr.rootDeviceIndex, pIOH->getGraphicsAllocation()->isAllocatedInLocalMemoryPool()),
110                                          ultCsr.getMemoryManager()->getInternalHeapBaseAddress(ultCsr.rootDeviceIndex, !hwHelper.useSystemMemoryPlacementForISA(pDevice->getHardwareInfo())),
111                                          pDSH, pIOH, pSSH, itorPipelineSelect, itorWalker, cmdList, 0llu);
112 }
113 
HWCMDTEST_F(IGFX_GEN8_CORE,EnqueueCopyImageTest,WhenCopyingImageThenMediaInterfaceDescriptorLoadIsCorrect)114 HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, WhenCopyingImageThenMediaInterfaceDescriptorLoadIsCorrect) {
115     typedef typename FamilyType::MEDIA_INTERFACE_DESCRIPTOR_LOAD MEDIA_INTERFACE_DESCRIPTOR_LOAD;
116     typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
117 
118     enqueueCopyImage<FamilyType>();
119 
120     // All state should be programmed before walker
121     auto cmd = reinterpret_cast<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdMediaInterfaceDescriptorLoad);
122     ASSERT_NE(nullptr, cmd);
123 
124     // Verify we have a valid length -- multiple of INTERFACE_DESCRIPTOR_DATAs
125     EXPECT_EQ(0u, cmd->getInterfaceDescriptorTotalLength() % sizeof(INTERFACE_DESCRIPTOR_DATA));
126 
127     // Validate the start address
128     size_t alignmentStartAddress = 64 * sizeof(uint8_t);
129     EXPECT_EQ(0u, cmd->getInterfaceDescriptorDataStartAddress() % alignmentStartAddress);
130 
131     // Validate the length
132     EXPECT_NE(0u, cmd->getInterfaceDescriptorTotalLength());
133     size_t alignmentTotalLength = 32 * sizeof(uint8_t);
134     EXPECT_EQ(0u, cmd->getInterfaceDescriptorTotalLength() % alignmentTotalLength);
135 
136     // Generically validate this command
137     FamilyType::PARSE::template validateCommand<MEDIA_INTERFACE_DESCRIPTOR_LOAD *>(cmdList.begin(), itorMediaInterfaceDescriptorLoad);
138 }
139 
HWCMDTEST_F(IGFX_GEN8_CORE,EnqueueCopyImageTest,WhenCopyingImageThenInterfaceDescriptorDataIsCorrect)140 HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, WhenCopyingImageThenInterfaceDescriptorDataIsCorrect) {
141     typedef typename FamilyType::STATE_BASE_ADDRESS STATE_BASE_ADDRESS;
142     typedef typename FamilyType::INTERFACE_DESCRIPTOR_DATA INTERFACE_DESCRIPTOR_DATA;
143 
144     enqueueCopyImage<FamilyType>();
145 
146     // Extract the interfaceDescriptorData
147     auto cmdSBA = (STATE_BASE_ADDRESS *)cmdStateBaseAddress;
148     auto &interfaceDescriptorData = *(INTERFACE_DESCRIPTOR_DATA *)cmdInterfaceDescriptorData;
149 
150     // Validate the kernel start pointer.  Technically, a kernel can start at address 0 but let's force a value.
151     auto kernelStartPointer = ((uint64_t)interfaceDescriptorData.getKernelStartPointerHigh() << 32) + interfaceDescriptorData.getKernelStartPointer();
152     EXPECT_LE(kernelStartPointer, cmdSBA->getInstructionBufferSize() * MemoryConstants::pageSize);
153 
154     size_t maxLocalSize = 256u;
155     auto localWorkSize = std::min(maxLocalSize,
156                                   Image2dDefaults::imageDesc.image_width * Image2dDefaults::imageDesc.image_height);
157     auto simd = 32u;
158     auto numThreadsPerThreadGroup = Math::divideAndRoundUp(localWorkSize, simd);
159     EXPECT_EQ(numThreadsPerThreadGroup, interfaceDescriptorData.getNumberOfThreadsInGpgpuThreadGroup());
160     EXPECT_NE(0u, interfaceDescriptorData.getCrossThreadConstantDataReadLength());
161     EXPECT_NE(0u, interfaceDescriptorData.getConstantIndirectUrbEntryReadLength());
162 
163     // We shouldn't have these pointers the same.
164     EXPECT_NE(kernelStartPointer, interfaceDescriptorData.getBindingTablePointer());
165 }
166 
HWTEST_F(EnqueueCopyImageTest,WhenCopyingImageThenSurfaceStateIsCorrect)167 HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenSurfaceStateIsCorrect) {
168     typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
169 
170     auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
171     VariableBackup<CommandQueue *> cmdQBackup(&pCmdQ, mockCmdQ.get());
172     mockCmdQ->storeMultiDispatchInfo = true;
173 
174     enqueueCopyImage<FamilyType>();
175 
176     const auto &kernelInfo = mockCmdQ->storedMultiDispatchInfo.begin()->getKernel()->getKernelInfo();
177     for (uint32_t i = 0; i < 2; ++i) {
178         uint32_t index = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(i).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
179         const auto &surfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, 0), index);
180         const auto &imageDesc = dstImage->getImageDesc();
181         EXPECT_EQ(imageDesc.image_width, surfaceState.getWidth());
182         EXPECT_EQ(imageDesc.image_height, surfaceState.getHeight());
183         EXPECT_NE(0u, surfaceState.getSurfacePitch());
184         EXPECT_NE(0u, surfaceState.getSurfaceType());
185         auto surfaceFormat = surfaceState.getSurfaceFormat();
186         bool isRedescribedFormat =
187             surfaceFormat == RENDER_SURFACE_STATE::SURFACE_FORMAT_R32G32B32A32_UINT ||
188             surfaceFormat == RENDER_SURFACE_STATE::SURFACE_FORMAT_R32G32_UINT ||
189             surfaceFormat == RENDER_SURFACE_STATE::SURFACE_FORMAT_R32_UINT ||
190             surfaceFormat == RENDER_SURFACE_STATE::SURFACE_FORMAT_R16_UINT ||
191             surfaceFormat == RENDER_SURFACE_STATE::SURFACE_FORMAT_R8_UINT;
192         EXPECT_TRUE(isRedescribedFormat);
193         EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4, surfaceState.getSurfaceHorizontalAlignment());
194         EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_VERTICAL_ALIGNMENT_VALIGN_4, surfaceState.getSurfaceVerticalAlignment());
195     }
196 
197     uint32_t srcIndex = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(0).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
198     const auto &srcSurfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, 0), srcIndex);
199     EXPECT_EQ(srcImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex())->getGpuAddress(), srcSurfaceState.getSurfaceBaseAddress());
200 
201     uint32_t dstIndex = static_cast<uint32_t>(kernelInfo.getArgDescriptorAt(1).template as<ArgDescImage>().bindful) / sizeof(RENDER_SURFACE_STATE);
202     const auto &dstSurfaceState = getSurfaceState<FamilyType>(&pCmdQ->getIndirectHeap(IndirectHeap::SURFACE_STATE, 0), dstIndex);
203     EXPECT_EQ(dstImage->getGraphicsAllocation(pClDevice->getRootDeviceIndex())->getGpuAddress(), dstSurfaceState.getSurfaceBaseAddress());
204 }
205 
HWTEST_F(EnqueueCopyImageTest,WhenCopyingImageThenNumberOfPipelineSelectsIsOne)206 HWTEST_F(EnqueueCopyImageTest, WhenCopyingImageThenNumberOfPipelineSelectsIsOne) {
207     enqueueCopyImage<FamilyType>();
208     int numCommands = getNumberOfPipelineSelectsThatEnablePipelineSelect<FamilyType>();
209     EXPECT_EQ(1, numCommands);
210 }
211 
HWTEST_F(EnqueueCopyImageTest,givenDeviceWithBlitterSupportWhenEnqueueCopyImageThenBlitEnqueueImageAllowedReturnsCorrectResult)212 HWTEST_F(EnqueueCopyImageTest, givenDeviceWithBlitterSupportWhenEnqueueCopyImageThenBlitEnqueueImageAllowedReturnsCorrectResult) {
213     DebugManagerStateRestore restorer;
214     DebugManager.flags.OverrideInvalidEngineWithDefault.set(1);
215     DebugManager.flags.EnableBlitterForEnqueueOperations.set(1);
216     DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(1);
217 
218     auto hwInfo = pClDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
219     const auto &hwInfoConfig = HwInfoConfig::get(hwInfo->platform.eProductFamily);
220     hwInfo->capabilityTable.blitterOperationsSupported = true;
221     REQUIRE_FULL_BLITTER_OR_SKIP(hwInfo);
222 
223     size_t srcOrigin[] = {0, 0, 0};
224     size_t dstOrigin[] = {0, 0, 0};
225 
226     auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pClDevice, nullptr);
227     std::unique_ptr<Image> srcImage(Image2dHelper<>::create(context));
228     std::unique_ptr<Image> dstImage(Image2dHelper<>::create(context));
229 
230     {
231         size_t region[] = {BlitterConstants::maxBlitWidth + 1, BlitterConstants::maxBlitHeight, 1};
232         EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
233         EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
234         EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
235     }
236     {
237         size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
238         size_t dstOrigin[] = {10, 10, 10};
239         EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
240         EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
241     }
242     {
243         size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
244         EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
245         EXPECT_EQ(hwInfoConfig->isBlitterFullySupported(*hwInfo), mockCmdQ->isBlitEnqueueImageAllowed);
246     }
247     {
248         DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(-1);
249         size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
250         EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
251         auto supportExpected = hwInfoConfig->isBlitterForImagesSupported();
252         EXPECT_EQ(supportExpected, mockCmdQ->isBlitEnqueueImageAllowed);
253     }
254     {
255         DebugManager.flags.EnableBlitterForEnqueueImageOperations.set(0);
256         size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
257         EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
258         EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
259     }
260     {
261         DebugManager.flags.EnableBlitterForEnqueueOperations.set(0);
262         size_t region[] = {BlitterConstants::maxBlitWidth, BlitterConstants::maxBlitHeight, 1};
263         EnqueueCopyImageHelper<>::enqueueCopyImage(mockCmdQ.get(), srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, region);
264         EXPECT_FALSE(mockCmdQ->isBlitEnqueueImageAllowed);
265     }
266 }
267 
HWCMDTEST_F(IGFX_GEN8_CORE,EnqueueCopyImageTest,WhenCopyingImageThenMediaVfeStateIsSetCorrectly)268 HWCMDTEST_F(IGFX_GEN8_CORE, EnqueueCopyImageTest, WhenCopyingImageThenMediaVfeStateIsSetCorrectly) {
269     enqueueCopyImage<FamilyType>();
270     validateMediaVFEState<FamilyType>(&pDevice->getHardwareInfo(), cmdMediaVfeState, cmdList, itorMediaVfeState);
271 }
272 
273 typedef EnqueueCopyImageMipMapTest MipMapCopyImageTest;
274 
HWTEST_P(MipMapCopyImageTest,GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCalledThenProperMipLevelsAreSet)275 HWTEST_P(MipMapCopyImageTest, GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCalledThenProperMipLevelsAreSet) {
276     cl_mem_object_type srcImageType, dstImageType;
277     std::tie(srcImageType, dstImageType) = GetParam();
278     auto builtIns = new MockBuiltins();
279     pCmdQ->getDevice().getExecutionEnvironment()->rootDeviceEnvironments[pCmdQ->getDevice().getRootDeviceIndex()]->builtins.reset(builtIns);
280     auto &origBuilder = BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(
281         EBuiltInOps::CopyImageToImage3d,
282         pCmdQ->getClDevice());
283     // substitute original builder with mock builder
284     auto oldBuilder = pClExecutionEnvironment->setBuiltinDispatchInfoBuilder(
285         rootDeviceIndex,
286         EBuiltInOps::CopyImageToImage3d,
287         std::unique_ptr<NEO::BuiltinDispatchInfoBuilder>(new MockBuiltinDispatchInfoBuilder(*builtIns, pCmdQ->getClDevice(), &origBuilder)));
288 
289     cl_int retVal = CL_SUCCESS;
290     cl_image_desc srcImageDesc = {};
291     uint32_t expectedSrcMipLevel = 3;
292     uint32_t expectedDstMipLevel = 4;
293     srcImageDesc.image_type = srcImageType;
294     srcImageDesc.num_mip_levels = 10;
295     srcImageDesc.image_width = 4;
296     srcImageDesc.image_height = 1;
297     srcImageDesc.image_depth = 1;
298 
299     cl_image_desc dstImageDesc = srcImageDesc;
300     dstImageDesc.image_type = dstImageType;
301 
302     size_t srcOrigin[] = {0, 0, 0, 0};
303     size_t dstOrigin[] = {0, 0, 0, 0};
304     size_t region[] = {srcImageDesc.image_width, 1, 1};
305     std::unique_ptr<Image> srcImage;
306     std::unique_ptr<Image> dstImage;
307 
308     switch (srcImageType) {
309     case CL_MEM_OBJECT_IMAGE1D:
310         srcOrigin[1] = expectedSrcMipLevel;
311         srcImage = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &srcImageDesc));
312         break;
313     case CL_MEM_OBJECT_IMAGE1D_ARRAY:
314         srcImageDesc.image_array_size = 2;
315         srcOrigin[2] = expectedSrcMipLevel;
316         srcImage = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &srcImageDesc));
317         break;
318     case CL_MEM_OBJECT_IMAGE2D:
319         srcOrigin[2] = expectedSrcMipLevel;
320         srcImage = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &srcImageDesc));
321         break;
322     case CL_MEM_OBJECT_IMAGE2D_ARRAY:
323         srcImageDesc.image_array_size = 2;
324         srcOrigin[3] = expectedSrcMipLevel;
325         srcImage = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &srcImageDesc));
326         break;
327     case CL_MEM_OBJECT_IMAGE3D:
328         srcOrigin[3] = expectedSrcMipLevel;
329         srcImage = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &srcImageDesc));
330         break;
331     }
332 
333     EXPECT_NE(nullptr, srcImage.get());
334 
335     switch (dstImageType) {
336     case CL_MEM_OBJECT_IMAGE1D:
337         dstOrigin[1] = expectedDstMipLevel;
338         dstImage = std::unique_ptr<Image>(ImageHelper<Image1dDefaults>::create(context, &dstImageDesc));
339         break;
340     case CL_MEM_OBJECT_IMAGE1D_ARRAY:
341         dstImageDesc.image_array_size = 2;
342         dstOrigin[2] = expectedDstMipLevel;
343         dstImage = std::unique_ptr<Image>(ImageHelper<Image1dArrayDefaults>::create(context, &dstImageDesc));
344         break;
345     case CL_MEM_OBJECT_IMAGE2D:
346         dstOrigin[2] = expectedDstMipLevel;
347         dstImage = std::unique_ptr<Image>(ImageHelper<Image2dDefaults>::create(context, &dstImageDesc));
348         break;
349     case CL_MEM_OBJECT_IMAGE2D_ARRAY:
350         dstImageDesc.image_array_size = 2;
351         dstOrigin[3] = expectedDstMipLevel;
352         dstImage = std::unique_ptr<Image>(ImageHelper<Image2dArrayDefaults>::create(context, &dstImageDesc));
353         break;
354     case CL_MEM_OBJECT_IMAGE3D:
355         dstOrigin[3] = expectedDstMipLevel;
356         dstImage = std::unique_ptr<Image>(ImageHelper<Image3dDefaults>::create(context, &dstImageDesc));
357         break;
358     }
359 
360     EXPECT_NE(nullptr, dstImage.get());
361 
362     retVal = pCmdQ->enqueueCopyImage(srcImage.get(),
363                                      dstImage.get(),
364                                      srcOrigin,
365                                      dstOrigin,
366                                      region,
367                                      0,
368                                      nullptr,
369                                      nullptr);
370 
371     EXPECT_EQ(CL_SUCCESS, retVal);
372 
373     auto &mockBuilder = static_cast<MockBuiltinDispatchInfoBuilder &>(BuiltInDispatchBuilderOp::getBuiltinDispatchInfoBuilder(EBuiltInOps::CopyImageToImage3d,
374                                                                                                                               pCmdQ->getClDevice()));
375     auto params = mockBuilder.getBuiltinOpParams();
376 
377     EXPECT_EQ(expectedSrcMipLevel, params->srcMipLevel);
378     EXPECT_EQ(expectedDstMipLevel, params->dstMipLevel);
379 
380     // restore original builder and retrieve mock builder
381     auto newBuilder = pClExecutionEnvironment->setBuiltinDispatchInfoBuilder(
382         rootDeviceIndex,
383         EBuiltInOps::CopyImageToImage3d,
384         std::move(oldBuilder));
385     EXPECT_NE(nullptr, newBuilder);
386 }
387 
388 uint32_t types[] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D};
389 
390 INSTANTIATE_TEST_CASE_P(MipMapCopyImageTest_GivenImagesWithNonZeroMipLevelsWhenCopyImageIsCalledThenProperMipLevelsAreSet,
391                         MipMapCopyImageTest,
392                         ::testing::Combine(
393                             ::testing::ValuesIn(types),
394                             ::testing::ValuesIn(types)));
395 
396 using OneMipLevelCopyImageImageTests = Test<OneMipLevelImageFixture>;
397 
HWTEST_F(OneMipLevelCopyImageImageTests,GivenNotMippedImageWhenCopyingImageThenDoNotProgramSourceAndDestinationMipLevels)398 HWTEST_F(OneMipLevelCopyImageImageTests, GivenNotMippedImageWhenCopyingImageThenDoNotProgramSourceAndDestinationMipLevels) {
399     auto dstImage = std::unique_ptr<Image>(createImage());
400     auto queue = createQueue<FamilyType>();
401     auto retVal = queue->enqueueCopyImage(
402         image.get(),
403         dstImage.get(),
404         origin,
405         origin,
406         region,
407         0,
408         nullptr,
409         nullptr);
410 
411     EXPECT_EQ(CL_SUCCESS, retVal);
412     EXPECT_TRUE(builtinOpsParamsCaptured);
413     EXPECT_EQ(0u, usedBuiltinOpsParams.srcMipLevel);
414     EXPECT_EQ(0u, usedBuiltinOpsParams.dstMipLevel);
415 }
416