1 /*
2 * Copyright (C) 2018-2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/memory_manager/unified_memory_manager.h"
9 #include "shared/test/common/test_macros/test.h"
10
11 #include "opencl/source/event/event.h"
12 #include "opencl/test/unit_test/fixtures/cl_device_fixture.h"
13 #include "opencl/test/unit_test/fixtures/image_fixture.h"
14 #include "opencl/test/unit_test/mocks/mock_buffer.h"
15 #include "opencl/test/unit_test/mocks/mock_command_queue.h"
16 #include "opencl/test/unit_test/mocks/mock_context.h"
17 #include "opencl/test/unit_test/mocks/mock_kernel.h"
18 #include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
19
20 using namespace NEO;
21
22 class ZeroSizeEnqueueHandlerTest : public Test<ClDeviceFixture> {
23 public:
24 MockContext context;
25 cl_int retVal;
26 };
27
28 class ZeroSizeEnqueueHandlerTestZeroGws : public ZeroSizeEnqueueHandlerTest {
29 public:
SetUp()30 void SetUp() override {
31 ZeroSizeEnqueueHandlerTest::SetUp();
32
33 testGwsInputs[0] = std::make_tuple(1, nullptr);
34 testGwsInputs[1] = std::make_tuple(2, nullptr);
35 testGwsInputs[2] = std::make_tuple(3, nullptr);
36 testGwsInputs[3] = std::make_tuple(1, zeroGWS0);
37 testGwsInputs[4] = std::make_tuple(2, zeroGWS00);
38 testGwsInputs[5] = std::make_tuple(2, zeroGWS01);
39 testGwsInputs[6] = std::make_tuple(2, zeroGWS10);
40 testGwsInputs[7] = std::make_tuple(3, zeroGWS000);
41 testGwsInputs[8] = std::make_tuple(3, zeroGWS011);
42 testGwsInputs[9] = std::make_tuple(3, zeroGWS101);
43 testGwsInputs[10] = std::make_tuple(3, zeroGWS110);
44 testGwsInputs[11] = std::make_tuple(3, zeroGWS001);
45 testGwsInputs[12] = std::make_tuple(3, zeroGWS010);
46 testGwsInputs[13] = std::make_tuple(3, zeroGWS100);
47 }
48
49 size_t zeroGWS0[1] = {0};
50 size_t zeroGWS00[2] = {0, 0};
51 size_t zeroGWS01[2] = {0, 1};
52 size_t zeroGWS10[2] = {1, 0};
53 size_t zeroGWS000[3] = {0, 0, 0};
54 size_t zeroGWS011[3] = {0, 1, 1};
55 size_t zeroGWS101[3] = {1, 0, 1};
56 size_t zeroGWS110[3] = {1, 1, 0};
57 size_t zeroGWS001[3] = {0, 0, 1};
58 size_t zeroGWS010[3] = {0, 1, 0};
59 size_t zeroGWS100[3] = {1, 0, 0};
60
61 std::tuple<unsigned int, size_t *> testGwsInputs[14];
62 };
63
HWTEST_F(ZeroSizeEnqueueHandlerTestZeroGws,GivenZeroSizeEnqueueIsDetectedWhenEnqueingKernelThenCommandMarkerShouldBeEnqueued)64 HWTEST_F(ZeroSizeEnqueueHandlerTestZeroGws, GivenZeroSizeEnqueueIsDetectedWhenEnqueingKernelThenCommandMarkerShouldBeEnqueued) {
65 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
66
67 MockKernelWithInternals mockKernel(*pClDevice);
68
69 for (auto testInput : testGwsInputs) {
70 auto workDim = std::get<0>(testInput);
71 auto gws = std::get<1>(testInput);
72 mockCmdQ->lastCommandType = static_cast<cl_command_type>(CL_COMMAND_COPY_BUFFER);
73
74 retVal = mockCmdQ->enqueueKernel(mockKernel.mockKernel, workDim, nullptr, gws, nullptr, 0, nullptr, nullptr);
75 EXPECT_EQ(CL_SUCCESS, retVal);
76 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
77 }
78 }
79
HWTEST_F(ZeroSizeEnqueueHandlerTestZeroGws,GivenZeroSizeEnqueueIsDetectedAndLocalWorkSizeIsSetWhenEnqueingKernelThenNoExceptionIsThrown)80 HWTEST_F(ZeroSizeEnqueueHandlerTestZeroGws, GivenZeroSizeEnqueueIsDetectedAndLocalWorkSizeIsSetWhenEnqueingKernelThenNoExceptionIsThrown) {
81 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
82
83 MockKernelWithInternals mockKernel(*pClDevice);
84 mockKernel.mockProgram->setAllowNonUniform(true);
85
86 auto workDim = 1;
87 auto gws = zeroGWS0;
88 size_t lws[1] = {1};
89
90 EXPECT_NO_THROW(retVal = mockCmdQ->enqueueKernel(mockKernel.mockKernel, workDim, nullptr, gws, lws, 0, nullptr, nullptr));
91 EXPECT_EQ(CL_SUCCESS, retVal);
92 }
93
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenEnqueingKernelThenEventCommandTypeShoudBeUnchanged)94 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenEnqueingKernelThenEventCommandTypeShoudBeUnchanged) {
95 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
96
97 cl_event event;
98 MockKernelWithInternals mockKernel(*pClDevice);
99 size_t zeroGWS[] = {0, 0, 0};
100 mockCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, zeroGWS, nullptr, 0, nullptr, &event);
101 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
102
103 auto pEvent = (Event *)event;
104 cl_command_type cmdType = 0;
105 size_t sizeReturned = 0;
106 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
107 ASSERT_EQ(CL_SUCCESS, result);
108 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_NDRANGE_KERNEL), cmdType);
109 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
110 delete pEvent;
111 }
112
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenReadingBufferThenCommandMarkerShouldBeEnqueued)113 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenReadingBufferThenCommandMarkerShouldBeEnqueued) {
114 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
115
116 MockBuffer buffer;
117 size_t memory[1];
118 size_t zeroSize = 0;
119 mockCmdQ->enqueueReadBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, nullptr, 0, nullptr, nullptr);
120 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
121 }
122
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenReadingBufferThenEventCommandTypeShouldBeUnchanged)123 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenReadingBufferThenEventCommandTypeShouldBeUnchanged) {
124 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
125
126 cl_event event;
127 MockBuffer buffer;
128 size_t memory[1];
129 size_t zeroSize = 0;
130 mockCmdQ->enqueueReadBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, nullptr, 0, nullptr, &event);
131 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
132
133 auto pEvent = (Event *)event;
134 cl_command_type cmdType = 0;
135 size_t sizeReturned = 0;
136 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
137 ASSERT_EQ(CL_SUCCESS, result);
138 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_READ_BUFFER), cmdType);
139 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
140 delete pEvent;
141 }
142
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenReadingBufferRectThenCommandMarkerShouldBeEnqueued)143 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenReadingBufferRectThenCommandMarkerShouldBeEnqueued) {
144 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
145
146 MockBuffer buffer;
147 size_t memory[1];
148 size_t bufferOrigin[] = {0, 0, 0};
149 size_t hostOrigin[] = {0, 0, 0};
150
151 size_t zeroRegion000[] = {0, 0, 0};
152 mockCmdQ->enqueueReadBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion000, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
153 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
154
155 size_t zeroRegion011[] = {0, 1, 1};
156 mockCmdQ->enqueueReadBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion011, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
157 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
158
159 size_t zeroRegion101[] = {1, 0, 1};
160 mockCmdQ->enqueueReadBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion101, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
161 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
162
163 size_t zeroRegion110[] = {1, 1, 0};
164 mockCmdQ->enqueueReadBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion110, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
165 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
166
167 size_t zeroRegion001[] = {0, 0, 1};
168 mockCmdQ->enqueueReadBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion001, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
169 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
170
171 size_t zeroRegion010[] = {0, 1, 0};
172 mockCmdQ->enqueueReadBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion010, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
173 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
174
175 size_t zeroRegion100[] = {1, 0, 0};
176 mockCmdQ->enqueueReadBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion100, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
177 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
178 }
179
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenReadingBufferRectThenEventCommandTypeShouldBeUnchanged)180 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenReadingBufferRectThenEventCommandTypeShouldBeUnchanged) {
181 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
182
183 cl_event event;
184 MockBuffer buffer;
185 size_t memory[1];
186 size_t bufferOrigin[] = {0, 0, 0};
187 size_t hostOrigin[] = {0, 0, 0};
188 size_t zeroRegion[] = {0, 0, 0};
189 mockCmdQ->enqueueReadBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion, 0, 0, 0, 0, memory, 0, nullptr, &event);
190 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
191
192 auto pEvent = (Event *)event;
193 cl_command_type cmdType = 0;
194 size_t sizeReturned = 0;
195 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
196 ASSERT_EQ(CL_SUCCESS, result);
197 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_READ_BUFFER_RECT), cmdType);
198 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
199 delete pEvent;
200 }
201
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenWritingBufferThenCommandMarkerShouldBeEnqueued)202 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenWritingBufferThenCommandMarkerShouldBeEnqueued) {
203 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
204
205 MockBuffer buffer;
206 size_t memory[1];
207 size_t zeroSize = 0;
208 mockCmdQ->enqueueWriteBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, nullptr, 0, nullptr, nullptr);
209 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
210 }
211
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenWritingBufferThenEventCommandTypeShouldBeUnchanged)212 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenWritingBufferThenEventCommandTypeShouldBeUnchanged) {
213 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
214
215 cl_event event;
216 MockBuffer buffer;
217 size_t memory[1];
218 size_t zeroSize = 0;
219 mockCmdQ->enqueueWriteBuffer(&buffer, CL_FALSE, 0, zeroSize, memory, nullptr, 0, nullptr, &event);
220 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
221
222 auto pEvent = (Event *)event;
223 cl_command_type cmdType = 0;
224 size_t sizeReturned = 0;
225 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
226 ASSERT_EQ(CL_SUCCESS, result);
227 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_WRITE_BUFFER), cmdType);
228 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
229 delete pEvent;
230 }
231
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenWritingBufferRectThenCommandMarkerShouldBeEnqueued)232 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenWritingBufferRectThenCommandMarkerShouldBeEnqueued) {
233 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
234
235 MockBuffer buffer;
236 size_t memory[1];
237 size_t bufferOrigin[] = {0, 0, 0};
238 size_t hostOrigin[] = {0, 0, 0};
239
240 size_t zeroRegion000[] = {0, 0, 0};
241 mockCmdQ->enqueueWriteBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion000, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
242 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
243
244 size_t zeroRegion011[] = {0, 1, 1};
245 mockCmdQ->enqueueWriteBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion011, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
246 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
247
248 size_t zeroRegion101[] = {1, 0, 1};
249 mockCmdQ->enqueueWriteBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion101, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
250 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
251
252 size_t zeroRegion110[] = {1, 1, 0};
253 mockCmdQ->enqueueWriteBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion110, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
254 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
255
256 size_t zeroRegion001[] = {0, 0, 1};
257 mockCmdQ->enqueueWriteBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion001, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
258 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
259
260 size_t zeroRegion010[] = {0, 1, 0};
261 mockCmdQ->enqueueWriteBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion010, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
262 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
263
264 size_t zeroRegion100[] = {1, 0, 0};
265 mockCmdQ->enqueueWriteBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion100, 0, 0, 0, 0, memory, 0, nullptr, nullptr);
266 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
267 }
268
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenWritingBufferRectThenEventCommandTypeShouldBeUnchanged)269 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenWritingBufferRectThenEventCommandTypeShouldBeUnchanged) {
270 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
271
272 cl_event event;
273 MockBuffer buffer;
274 size_t memory[1];
275 size_t bufferOrigin[] = {0, 0, 0};
276 size_t hostOrigin[] = {0, 0, 0};
277 size_t zeroRegion[] = {0, 0, 0};
278 mockCmdQ->enqueueWriteBufferRect(&buffer, CL_FALSE, bufferOrigin, hostOrigin, zeroRegion, 0, 0, 0, 0, memory, 0, nullptr, &event);
279 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
280
281 auto pEvent = (Event *)event;
282 cl_command_type cmdType = 0;
283 size_t sizeReturned = 0;
284 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
285 ASSERT_EQ(CL_SUCCESS, result);
286 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_WRITE_BUFFER_RECT), cmdType);
287 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
288 delete pEvent;
289 }
290
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferThenCommandMarkerShouldBeEnqueued)291 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferThenCommandMarkerShouldBeEnqueued) {
292 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
293
294 MockBuffer srcBuffer;
295 MockBuffer dstBuffer;
296 size_t zeroSize = 0;
297 mockCmdQ->enqueueCopyBuffer(&srcBuffer, &dstBuffer, 0, 0, zeroSize, 0, nullptr, nullptr);
298 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
299 }
300
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferThenEventCommandTypeShouldBeUnchanged)301 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferThenEventCommandTypeShouldBeUnchanged) {
302 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
303
304 cl_event event;
305 MockBuffer srcBuffer;
306 MockBuffer dstBuffer;
307 size_t zeroSize = 0;
308 mockCmdQ->enqueueCopyBuffer(&srcBuffer, &dstBuffer, 0, 0, zeroSize, 0, nullptr, &event);
309 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
310
311 auto pEvent = (Event *)event;
312 cl_command_type cmdType = 0;
313 size_t sizeReturned = 0;
314 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
315 ASSERT_EQ(CL_SUCCESS, result);
316 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_COPY_BUFFER), cmdType);
317 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
318 delete pEvent;
319 }
320
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferRectThenCommandMarkerShouldBeEnqueued)321 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferRectThenCommandMarkerShouldBeEnqueued) {
322 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
323
324 MockBuffer srcBuffer;
325 MockBuffer dstBuffer;
326 size_t srcOrigin[3] = {1024u, 1, 0};
327 size_t dstOrigin[3] = {1024u, 1, 0};
328
329 size_t zeroRegion000[3] = {0, 0, 0};
330 mockCmdQ->enqueueCopyBufferRect(&srcBuffer, &dstBuffer, srcOrigin, dstOrigin, zeroRegion000, 0, 0, 0, 0, 0, nullptr, nullptr);
331 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
332
333 size_t zeroRegion011[3] = {0, 1, 1};
334 mockCmdQ->enqueueCopyBufferRect(&srcBuffer, &dstBuffer, srcOrigin, dstOrigin, zeroRegion011, 0, 0, 0, 0, 0, nullptr, nullptr);
335 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
336
337 size_t zeroRegion101[3] = {1, 0, 1};
338 mockCmdQ->enqueueCopyBufferRect(&srcBuffer, &dstBuffer, srcOrigin, dstOrigin, zeroRegion101, 0, 0, 0, 0, 0, nullptr, nullptr);
339 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
340
341 size_t zeroRegion110[3] = {1, 1, 0};
342 mockCmdQ->enqueueCopyBufferRect(&srcBuffer, &dstBuffer, srcOrigin, dstOrigin, zeroRegion110, 0, 0, 0, 0, 0, nullptr, nullptr);
343 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
344
345 size_t zeroRegion001[3] = {0, 0, 1};
346 mockCmdQ->enqueueCopyBufferRect(&srcBuffer, &dstBuffer, srcOrigin, dstOrigin, zeroRegion001, 0, 0, 0, 0, 0, nullptr, nullptr);
347 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
348
349 size_t zeroRegion010[3] = {0, 1, 0};
350 mockCmdQ->enqueueCopyBufferRect(&srcBuffer, &dstBuffer, srcOrigin, dstOrigin, zeroRegion010, 0, 0, 0, 0, 0, nullptr, nullptr);
351 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
352
353 size_t zeroRegion100[3] = {1, 0, 0};
354 mockCmdQ->enqueueCopyBufferRect(&srcBuffer, &dstBuffer, srcOrigin, dstOrigin, zeroRegion100, 0, 0, 0, 0, 0, nullptr, nullptr);
355 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
356 }
357
HWTEST_F(ZeroSizeEnqueueHandlerTest,WhenCopyingBufferZeroSizeEnqueueIsDetectedWhenCopyingBufferRectThenEventCommandTypeShouldBeUnchanged)358 HWTEST_F(ZeroSizeEnqueueHandlerTest, WhenCopyingBufferZeroSizeEnqueueIsDetectedWhenCopyingBufferRectThenEventCommandTypeShouldBeUnchanged) {
359 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
360
361 cl_event event;
362 MockBuffer srcBuffer;
363 MockBuffer dstBuffer;
364 size_t srcOrigin[3] = {1024u, 1, 0};
365 size_t dstOrigin[3] = {1024u, 1, 0};
366 size_t zeroRegion[3] = {0, 0, 0};
367 mockCmdQ->enqueueCopyBufferRect(&srcBuffer, &dstBuffer, srcOrigin, dstOrigin, zeroRegion, 0, 0, 0, 0, 0, nullptr, &event);
368 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
369
370 auto pEvent = (Event *)event;
371 cl_command_type cmdType = 0;
372 size_t sizeReturned = 0;
373 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
374 ASSERT_EQ(CL_SUCCESS, result);
375 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_COPY_BUFFER_RECT), cmdType);
376 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
377 delete pEvent;
378 }
379
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenFillingBufferThenCommandMarkerShouldBeEnqueued)380 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenFillingBufferThenCommandMarkerShouldBeEnqueued) {
381 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
382
383 MockBuffer buffer;
384 cl_int pattern = 0xDEADBEEF;
385 size_t zeroSize = 0;
386 mockCmdQ->enqueueFillBuffer(&buffer, &pattern, sizeof(pattern), 0, zeroSize, 0, nullptr, nullptr);
387 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
388 }
389
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenFillingBufferThenEventCommandTypeShouldBeUnchanged)390 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenFillingBufferThenEventCommandTypeShouldBeUnchanged) {
391 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
392
393 cl_event event;
394 MockBuffer buffer;
395 cl_int pattern = 0xDEADBEEF;
396 size_t zeroSize = 0;
397 mockCmdQ->enqueueFillBuffer(&buffer, &pattern, sizeof(pattern), 0, zeroSize, 0, nullptr, &event);
398 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
399
400 auto pEvent = (Event *)event;
401 cl_command_type cmdType = 0;
402 size_t sizeReturned = 0;
403 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
404 ASSERT_EQ(CL_SUCCESS, result);
405 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_FILL_BUFFER), cmdType);
406 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
407 delete pEvent;
408 }
409
410 struct ZeroSizeEnqueueHandlerImageTest : ZeroSizeEnqueueHandlerTest {
SetUpZeroSizeEnqueueHandlerImageTest411 void SetUp() override {
412 REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
413 ZeroSizeEnqueueHandlerTest::SetUp();
414 }
415 };
416
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenReadingImageThenCommandMarkerShouldBeEnqueued)417 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenReadingImageThenCommandMarkerShouldBeEnqueued) {
418 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
419
420 std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
421 size_t memory[1];
422 size_t origin[3] = {1024u, 1, 0};
423
424 size_t zeroRegion000[3] = {0, 0, 0};
425 mockCmdQ->enqueueReadImage(image.get(), CL_FALSE, origin, zeroRegion000, 0, 0, memory, nullptr, 0, nullptr, nullptr);
426 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
427
428 size_t zeroRegion011[3] = {0, 1, 1};
429 mockCmdQ->enqueueReadImage(image.get(), CL_FALSE, origin, zeroRegion011, 0, 0, memory, nullptr, 0, nullptr, nullptr);
430 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
431
432 size_t zeroRegion101[3] = {1, 0, 1};
433 mockCmdQ->enqueueReadImage(image.get(), CL_FALSE, origin, zeroRegion101, 0, 0, memory, nullptr, 0, nullptr, nullptr);
434 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
435
436 size_t zeroRegion110[3] = {1, 1, 0};
437 mockCmdQ->enqueueReadImage(image.get(), CL_FALSE, origin, zeroRegion110, 0, 0, memory, nullptr, 0, nullptr, nullptr);
438 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
439
440 size_t zeroRegion001[3] = {0, 0, 1};
441 mockCmdQ->enqueueReadImage(image.get(), CL_FALSE, origin, zeroRegion001, 0, 0, memory, nullptr, 0, nullptr, nullptr);
442 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
443
444 size_t zeroRegion010[3] = {0, 1, 0};
445 mockCmdQ->enqueueReadImage(image.get(), CL_FALSE, origin, zeroRegion010, 0, 0, memory, nullptr, 0, nullptr, nullptr);
446 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
447
448 size_t zeroRegion100[3] = {1, 0, 0};
449 mockCmdQ->enqueueReadImage(image.get(), CL_FALSE, origin, zeroRegion100, 0, 0, memory, nullptr, 0, nullptr, nullptr);
450 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
451 }
452
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenReadingImageThenEventCommandTypeShouldBeUnchanged)453 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenReadingImageThenEventCommandTypeShouldBeUnchanged) {
454 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
455
456 cl_event event;
457 std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
458 size_t memory[1];
459 size_t origin[3] = {1024u, 1, 0};
460 size_t zeroRegion[3] = {0, 0, 0};
461 mockCmdQ->enqueueReadImage(image.get(), CL_FALSE, origin, zeroRegion, 0, 0, memory, nullptr, 0, nullptr, &event);
462 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
463
464 auto pEvent = (Event *)event;
465 cl_command_type cmdType = 0;
466 size_t sizeReturned = 0;
467 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
468 ASSERT_EQ(CL_SUCCESS, result);
469 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_READ_IMAGE), cmdType);
470 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
471 delete pEvent;
472 }
473
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenWritingImageThenCommandMarkerShouldBeEnqueued)474 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenWritingImageThenCommandMarkerShouldBeEnqueued) {
475 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
476
477 std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
478 size_t memory[1];
479 size_t origin[3] = {1024u, 1, 0};
480
481 size_t zeroRegion000[3] = {0, 0, 0};
482 mockCmdQ->enqueueWriteImage(image.get(), CL_FALSE, origin, zeroRegion000, 0, 0, memory, nullptr, 0, nullptr, nullptr);
483 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
484
485 size_t zeroRegion011[3] = {0, 1, 1};
486 mockCmdQ->enqueueWriteImage(image.get(), CL_FALSE, origin, zeroRegion011, 0, 0, memory, nullptr, 0, nullptr, nullptr);
487 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
488
489 size_t zeroRegion101[3] = {1, 0, 1};
490 mockCmdQ->enqueueWriteImage(image.get(), CL_FALSE, origin, zeroRegion101, 0, 0, memory, nullptr, 0, nullptr, nullptr);
491 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
492
493 size_t zeroRegion110[3] = {1, 1, 0};
494 mockCmdQ->enqueueWriteImage(image.get(), CL_FALSE, origin, zeroRegion110, 0, 0, memory, nullptr, 0, nullptr, nullptr);
495 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
496
497 size_t zeroRegion001[3] = {0, 0, 1};
498 mockCmdQ->enqueueWriteImage(image.get(), CL_FALSE, origin, zeroRegion001, 0, 0, memory, nullptr, 0, nullptr, nullptr);
499 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
500
501 size_t zeroRegion010[3] = {0, 1, 0};
502 mockCmdQ->enqueueWriteImage(image.get(), CL_FALSE, origin, zeroRegion010, 0, 0, memory, nullptr, 0, nullptr, nullptr);
503 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
504
505 size_t zeroRegion100[3] = {1, 0, 0};
506 mockCmdQ->enqueueWriteImage(image.get(), CL_FALSE, origin, zeroRegion100, 0, 0, memory, nullptr, 0, nullptr, nullptr);
507 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
508 }
509
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenWritingImageThenEventCommandTypeShouldBeUnchanged)510 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenWritingImageThenEventCommandTypeShouldBeUnchanged) {
511 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
512
513 cl_event event;
514 std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
515 size_t memory[1];
516 size_t origin[3] = {1024u, 1, 0};
517 size_t zeroRegion[3] = {0, 0, 0};
518 mockCmdQ->enqueueWriteImage(image.get(), CL_FALSE, origin, zeroRegion, 0, 0, memory, nullptr, 0, nullptr, &event);
519 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
520
521 auto pEvent = (Event *)event;
522 cl_command_type cmdType = 0;
523 size_t sizeReturned = 0;
524 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
525 ASSERT_EQ(CL_SUCCESS, result);
526 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_WRITE_IMAGE), cmdType);
527 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
528 delete pEvent;
529 }
530
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingImageThenCommandMarkerShouldBeEnqueued)531 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingImageThenCommandMarkerShouldBeEnqueued) {
532 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
533
534 std::unique_ptr<Image> srcImage(Image2dHelper<>::create(&context));
535 std::unique_ptr<Image> dstImage(Image2dHelper<>::create(&context));
536 size_t srcOrigin[3] = {1024u, 1, 0};
537 size_t dstOrigin[3] = {1024u, 1, 0};
538
539 size_t zeroRegion000[3] = {0, 0, 0};
540 mockCmdQ->enqueueCopyImage(srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, zeroRegion000, 0, nullptr, nullptr);
541 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
542
543 size_t zeroRegion011[3] = {0, 1, 1};
544 mockCmdQ->enqueueCopyImage(srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, zeroRegion011, 0, nullptr, nullptr);
545 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
546
547 size_t zeroRegion101[3] = {1, 0, 1};
548 mockCmdQ->enqueueCopyImage(srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, zeroRegion101, 0, nullptr, nullptr);
549 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
550
551 size_t zeroRegion110[3] = {1, 1, 0};
552 mockCmdQ->enqueueCopyImage(srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, zeroRegion110, 0, nullptr, nullptr);
553 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
554
555 size_t zeroRegion001[3] = {0, 0, 1};
556 mockCmdQ->enqueueCopyImage(srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, zeroRegion001, 0, nullptr, nullptr);
557 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
558
559 size_t zeroRegion010[3] = {0, 1, 0};
560 mockCmdQ->enqueueCopyImage(srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, zeroRegion010, 0, nullptr, nullptr);
561 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
562
563 size_t zeroRegion100[3] = {1, 0, 0};
564 mockCmdQ->enqueueCopyImage(srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, zeroRegion100, 0, nullptr, nullptr);
565 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
566 }
567
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingImageThenEventCommandTypeShouldBeUnchanged)568 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingImageThenEventCommandTypeShouldBeUnchanged) {
569 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
570
571 cl_event event;
572 std::unique_ptr<Image> srcImage(Image2dHelper<>::create(&context));
573 std::unique_ptr<Image> dstImage(Image2dHelper<>::create(&context));
574 size_t srcOrigin[3] = {1024u, 1, 0};
575 size_t dstOrigin[3] = {1024u, 1, 0};
576 size_t zeroRegion[3] = {0, 0, 0};
577 mockCmdQ->enqueueCopyImage(srcImage.get(), dstImage.get(), srcOrigin, dstOrigin, zeroRegion, 0, nullptr, &event);
578 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
579
580 auto pEvent = (Event *)event;
581 cl_command_type cmdType = 0;
582 size_t sizeReturned = 0;
583 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
584 ASSERT_EQ(CL_SUCCESS, result);
585 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_COPY_IMAGE), cmdType);
586 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
587 delete pEvent;
588 }
589
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingImageToBufferThenCommandMarkerShouldBeEnqueued)590 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingImageToBufferThenCommandMarkerShouldBeEnqueued) {
591 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
592
593 std::unique_ptr<Image> srcImage(Image2dHelper<>::create(&context));
594 std::unique_ptr<Buffer> dstBuffer(Buffer::create(&context, CL_MEM_READ_WRITE, 1024u, nullptr, retVal));
595 size_t srcOrigin[3] = {1024u, 1, 0};
596
597 size_t zeroRegion000[3] = {0, 0, 0};
598 mockCmdQ->enqueueCopyImageToBuffer(srcImage.get(), dstBuffer.get(), srcOrigin, zeroRegion000, 0, 0, nullptr, nullptr);
599 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
600
601 size_t zeroRegion011[3] = {0, 1, 1};
602 mockCmdQ->enqueueCopyImageToBuffer(srcImage.get(), dstBuffer.get(), srcOrigin, zeroRegion011, 0, 0, nullptr, nullptr);
603 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
604
605 size_t zeroRegion101[3] = {1, 0, 1};
606 mockCmdQ->enqueueCopyImageToBuffer(srcImage.get(), dstBuffer.get(), srcOrigin, zeroRegion101, 0, 0, nullptr, nullptr);
607 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
608
609 size_t zeroRegion110[3] = {1, 1, 0};
610 mockCmdQ->enqueueCopyImageToBuffer(srcImage.get(), dstBuffer.get(), srcOrigin, zeroRegion110, 0, 0, nullptr, nullptr);
611 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
612
613 size_t zeroRegion001[3] = {0, 0, 1};
614 mockCmdQ->enqueueCopyImageToBuffer(srcImage.get(), dstBuffer.get(), srcOrigin, zeroRegion001, 0, 0, nullptr, nullptr);
615 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
616
617 size_t zeroRegion010[3] = {0, 1, 0};
618 mockCmdQ->enqueueCopyImageToBuffer(srcImage.get(), dstBuffer.get(), srcOrigin, zeroRegion010, 0, 0, nullptr, nullptr);
619 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
620
621 size_t zeroRegion100[3] = {1, 0, 0};
622 mockCmdQ->enqueueCopyImageToBuffer(srcImage.get(), dstBuffer.get(), srcOrigin, zeroRegion100, 0, 0, nullptr, nullptr);
623 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
624 }
625
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingImageToBufferThenEventCommandTypeShouldBeUnchanged)626 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingImageToBufferThenEventCommandTypeShouldBeUnchanged) {
627 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
628
629 cl_event event;
630 std::unique_ptr<Image> srcImage(Image2dHelper<>::create(&context));
631 std::unique_ptr<Buffer> dstBuffer(Buffer::create(&context, CL_MEM_READ_WRITE, 1024u, nullptr, retVal));
632 size_t srcOrigin[3] = {1024u, 1, 0};
633 size_t zeroRegion[3] = {0, 0, 0};
634 mockCmdQ->enqueueCopyImageToBuffer(srcImage.get(), dstBuffer.get(), srcOrigin, zeroRegion, 0, 0, nullptr, &event);
635 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
636
637 auto pEvent = (Event *)event;
638 cl_command_type cmdType = 0;
639 size_t sizeReturned = 0;
640 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
641 ASSERT_EQ(CL_SUCCESS, result);
642 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_COPY_IMAGE_TO_BUFFER), cmdType);
643 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
644 delete pEvent;
645 }
646
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferToImageThenCommandMarkerShouldBeEnqueued)647 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferToImageThenCommandMarkerShouldBeEnqueued) {
648 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
649
650 std::unique_ptr<Buffer> srcBuffer(Buffer::create(&context, CL_MEM_READ_WRITE, 1024u, nullptr, retVal));
651 std::unique_ptr<Image> dstImage(Image2dHelper<>::create(&context));
652 size_t dstOrigin[3] = {1024u, 1, 0};
653
654 size_t zeroRegion000[3] = {0, 0, 0};
655 mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion000, 0, nullptr, nullptr);
656 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
657
658 size_t zeroRegion011[3] = {0, 1, 1};
659 mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion011, 0, nullptr, nullptr);
660 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
661
662 size_t zeroRegion101[3] = {1, 0, 1};
663 mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion101, 0, nullptr, nullptr);
664 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
665
666 size_t zeroRegion110[3] = {1, 1, 0};
667 mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion110, 0, nullptr, nullptr);
668 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
669
670 size_t zeroRegion001[3] = {0, 0, 1};
671 mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion001, 0, nullptr, nullptr);
672 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
673
674 size_t zeroRegion010[3] = {0, 1, 0};
675 mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion010, 0, nullptr, nullptr);
676 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
677
678 size_t zeroRegion100[3] = {1, 0, 0};
679 mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion100, 0, nullptr, nullptr);
680 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
681 }
682
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferToImageThenEventCommandTypeShouldBeUnchanged)683 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingBufferToImageThenEventCommandTypeShouldBeUnchanged) {
684 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
685
686 cl_event event;
687 std::unique_ptr<Buffer> srcBuffer(Buffer::create(&context, CL_MEM_READ_WRITE, 1024u, nullptr, retVal));
688 std::unique_ptr<Image> dstImage(Image2dHelper<>::create(&context));
689 size_t dstOrigin[3] = {1024u, 1, 0};
690 size_t zeroRegion[3] = {0, 0, 0};
691 mockCmdQ->enqueueCopyBufferToImage(srcBuffer.get(), dstImage.get(), 0, dstOrigin, zeroRegion, 0, nullptr, &event);
692 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
693
694 auto pEvent = (Event *)event;
695 cl_command_type cmdType = 0;
696 size_t sizeReturned = 0;
697 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
698 ASSERT_EQ(CL_SUCCESS, result);
699 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_COPY_BUFFER_TO_IMAGE), cmdType);
700 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
701 delete pEvent;
702 }
703
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenFillingImageThenCommandMarkerShouldBeEnqueued)704 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenFillingImageThenCommandMarkerShouldBeEnqueued) {
705 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
706
707 std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
708 size_t origin[3] = {1024u, 1, 1};
709 int32_t fillColor[4] = {0xCC, 0xCC, 0xCC, 0xCC};
710
711 size_t zeroRegion000[3] = {0, 0, 0};
712 mockCmdQ->enqueueFillImage(image.get(), &fillColor, origin, zeroRegion000, 0, nullptr, nullptr);
713 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
714
715 size_t zeroRegion011[3] = {0, 1, 1};
716 mockCmdQ->enqueueFillImage(image.get(), &fillColor, origin, zeroRegion011, 0, nullptr, nullptr);
717 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
718
719 size_t zeroRegion101[3] = {1, 0, 1};
720 mockCmdQ->enqueueFillImage(image.get(), &fillColor, origin, zeroRegion101, 0, nullptr, nullptr);
721 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
722
723 size_t zeroRegion110[3] = {1, 1, 0};
724 mockCmdQ->enqueueFillImage(image.get(), &fillColor, origin, zeroRegion110, 0, nullptr, nullptr);
725 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
726
727 size_t zeroRegion001[3] = {0, 0, 1};
728 mockCmdQ->enqueueFillImage(image.get(), &fillColor, origin, zeroRegion001, 0, nullptr, nullptr);
729 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
730
731 size_t zeroRegion010[3] = {0, 1, 0};
732 mockCmdQ->enqueueFillImage(image.get(), &fillColor, origin, zeroRegion010, 0, nullptr, nullptr);
733 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
734
735 size_t zeroRegion100[3] = {1, 0, 0};
736 mockCmdQ->enqueueFillImage(image.get(), &fillColor, origin, zeroRegion100, 0, nullptr, nullptr);
737 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
738 }
739
HWTEST_F(ZeroSizeEnqueueHandlerImageTest,GivenZeroSizeEnqueueIsDetectedWhenFillingImageThenEventCommandTypeShouldBeUnchanged)740 HWTEST_F(ZeroSizeEnqueueHandlerImageTest, GivenZeroSizeEnqueueIsDetectedWhenFillingImageThenEventCommandTypeShouldBeUnchanged) {
741 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
742
743 cl_event event;
744 std::unique_ptr<Image> image(Image2dHelper<>::create(&context));
745 size_t origin[3] = {1024u, 1, 1};
746 int32_t fillColor[4] = {0xCC, 0xCC, 0xCC, 0xCC};
747 size_t zeroRegion[3] = {0, 0, 0};
748 mockCmdQ->enqueueFillImage(image.get(), &fillColor, origin, zeroRegion, 0, nullptr, &event);
749 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
750
751 auto pEvent = (Event *)event;
752 cl_command_type cmdType = 0;
753 size_t sizeReturned = 0;
754 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
755 ASSERT_EQ(CL_SUCCESS, result);
756 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_FILL_IMAGE), cmdType);
757 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
758 delete pEvent;
759 }
760
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingSvmMemThenCommandMarkerShouldBeEnqueued)761 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingSvmMemThenCommandMarkerShouldBeEnqueued) {
762 REQUIRE_SVM_OR_SKIP(pDevice);
763 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
764
765 void *pSrcSVM = context.getSVMAllocsManager()->createSVMAlloc(256, {}, context.getRootDeviceIndices(), context.getDeviceBitfields());
766 void *pDstSVM = context.getSVMAllocsManager()->createSVMAlloc(256, {}, context.getRootDeviceIndices(), context.getDeviceBitfields());
767 size_t zeroSize = 0;
768 mockCmdQ->enqueueSVMMemcpy(false, pSrcSVM, pDstSVM, zeroSize, 0, nullptr, nullptr);
769 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
770
771 context.getSVMAllocsManager()->freeSVMAlloc(pSrcSVM);
772 context.getSVMAllocsManager()->freeSVMAlloc(pDstSVM);
773 }
774
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenCopyingSvmMemThenEventCommandTypeShouldBeUnchanged)775 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenCopyingSvmMemThenEventCommandTypeShouldBeUnchanged) {
776 REQUIRE_SVM_OR_SKIP(pDevice);
777 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
778
779 cl_event event;
780 void *pSrcSVM = context.getSVMAllocsManager()->createSVMAlloc(256, {}, context.getRootDeviceIndices(), context.getDeviceBitfields());
781 void *pDstSVM = context.getSVMAllocsManager()->createSVMAlloc(256, {}, context.getRootDeviceIndices(), context.getDeviceBitfields());
782 size_t zeroSize = 0;
783 mockCmdQ->enqueueSVMMemcpy(false, pSrcSVM, pDstSVM, zeroSize, 0, nullptr, &event);
784 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
785
786 auto pEvent = (Event *)event;
787 cl_command_type cmdType = 0;
788 size_t sizeReturned = 0;
789 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
790 ASSERT_EQ(CL_SUCCESS, result);
791 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_SVM_MEMCPY), cmdType);
792 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
793 delete pEvent;
794
795 context.getSVMAllocsManager()->freeSVMAlloc(pSrcSVM);
796 context.getSVMAllocsManager()->freeSVMAlloc(pDstSVM);
797 }
798
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenFillingSvmMemThenCommandMarkerShouldBeEnqueued)799 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenFillingSvmMemThenCommandMarkerShouldBeEnqueued) {
800 REQUIRE_SVM_OR_SKIP(pDevice);
801 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
802
803 void *pSVM = context.getSVMAllocsManager()->createSVMAlloc(256, {}, context.getRootDeviceIndices(), context.getDeviceBitfields());
804 const float pattern[1] = {1.2345f};
805 size_t zeroSize = 0;
806 mockCmdQ->enqueueSVMMemFill(pSVM, &pattern, sizeof(pattern), zeroSize, 0, nullptr, nullptr);
807 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
808
809 context.getSVMAllocsManager()->freeSVMAlloc(pSVM);
810 }
811
HWTEST_F(ZeroSizeEnqueueHandlerTest,GivenZeroSizeEnqueueIsDetectedWhenFillingSvmMemThenEventCommandTypeShouldBeUnchanged)812 HWTEST_F(ZeroSizeEnqueueHandlerTest, GivenZeroSizeEnqueueIsDetectedWhenFillingSvmMemThenEventCommandTypeShouldBeUnchanged) {
813 REQUIRE_SVM_OR_SKIP(pDevice);
814 auto mockCmdQ = std::unique_ptr<MockCommandQueueHw<FamilyType>>(new MockCommandQueueHw<FamilyType>(&context, pClDevice, 0));
815
816 cl_event event;
817 void *pSVM = context.getSVMAllocsManager()->createSVMAlloc(256, {}, context.getRootDeviceIndices(), context.getDeviceBitfields());
818 const float pattern[1] = {1.2345f};
819 size_t zeroSize = 0;
820 mockCmdQ->enqueueSVMMemFill(pSVM, &pattern, sizeof(pattern), zeroSize, 0, nullptr, &event);
821 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_MARKER), mockCmdQ->lastCommandType);
822
823 auto pEvent = (Event *)event;
824 cl_command_type cmdType = 0;
825 size_t sizeReturned = 0;
826 auto result = clGetEventInfo(pEvent, CL_EVENT_COMMAND_TYPE, sizeof(cmdType), &cmdType, &sizeReturned);
827 ASSERT_EQ(CL_SUCCESS, result);
828 EXPECT_EQ(static_cast<cl_command_type>(CL_COMMAND_SVM_MEMFILL), cmdType);
829 EXPECT_EQ(sizeof(cl_command_type), sizeReturned);
830 delete pEvent;
831
832 context.getSVMAllocsManager()->freeSVMAlloc(pSVM);
833 }
834