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