1 /*
2 * Copyright (C) 2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/command_container/implicit_scaling.h"
9 #include "shared/source/command_stream/command_stream_receiver.h"
10 #include "shared/source/device/sub_device.h"
11 #include "shared/source/gmm_helper/client_context/gmm_client_context.h"
12 #include "shared/source/gmm_helper/gmm.h"
13 #include "shared/source/gmm_helper/gmm_helper.h"
14 #include "shared/source/helpers/basic_math.h"
15 #include "shared/test/common/helpers/debug_manager_state_restore.h"
16 #include "shared/test/common/helpers/variable_backup.h"
17 #include "shared/test/common/mocks/mock_device.h"
18 #include "shared/test/common/mocks/mock_gmm.h"
19 #include "shared/test/common/test_macros/test.h"
20
21 #include "opencl/source/cl_device/cl_device.h"
22 #include "opencl/source/helpers/cl_memory_properties_helpers.h"
23 #include "opencl/source/mem_obj/buffer.h"
24 #include "opencl/test/unit_test/mocks/mock_buffer.h"
25 #include "opencl/test/unit_test/mocks/mock_context.h"
26 #include "opencl/test/unit_test/mocks/mock_platform.h"
27
28 #include <functional>
29
30 using namespace NEO;
31
32 using XeHPAndLaterBufferTests = ::testing::Test;
33
34 using isXePlatform = IsWithinGfxCore<IGFX_XE_HP_CORE, IGFX_XE_HPC_CORE>;
35
HWTEST2_F(XeHPAndLaterBufferTests,givenContextTypeDefaultWhenBufferIsWritableAndOnlyOneTileIsAvailableThenRemainFlagsToTrue,isXePlatform)36 HWTEST2_F(XeHPAndLaterBufferTests, givenContextTypeDefaultWhenBufferIsWritableAndOnlyOneTileIsAvailableThenRemainFlagsToTrue, isXePlatform) {
37 DebugManagerStateRestore restorer;
38 DebugManager.flags.CreateMultipleSubDevices.set(1);
39 initPlatform();
40 EXPECT_EQ(0u, platform()->getClDevice(0)->getNumGenericSubDevices());
41 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
42 MockContext context(platform()->getClDevice(0));
43 context.contextType = ContextType::CONTEXT_TYPE_DEFAULT;
44
45 size_t size = 0x1000;
46 auto retVal = CL_SUCCESS;
47 auto buffer = std::unique_ptr<Buffer>(
48 Buffer::create(
49 &context,
50 CL_MEM_READ_WRITE,
51 size,
52 nullptr,
53 retVal));
54 EXPECT_EQ(CL_SUCCESS, retVal);
55
56 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
57 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
58 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
59
60 surfaceState.setDisableSupportForMultiGpuAtomics(false);
61 surfaceState.setDisableSupportForMultiGpuPartialWrites(false);
62 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
63
64 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
65 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
66 }
67
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenDebugFlagSetWhenProgramingSurfaceStateThenForceCompressionFormat)68 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenDebugFlagSetWhenProgramingSurfaceStateThenForceCompressionFormat) {
69 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
70
71 DebugManagerStateRestore restorer;
72 uint32_t compressionFormat = 3;
73
74 MockContext context;
75
76 auto gmmContext = context.getDevice(0)->getGmmHelper()->getClientContext();
77 uint32_t defaultCompressionFormat = gmmContext->getSurfaceStateCompressionFormat(GMM_RESOURCE_FORMAT::GMM_FORMAT_GENERIC_8BIT);
78
79 auto retVal = CL_SUCCESS;
80 auto gmm = new Gmm(context.getDevice(0)->getGmmHelper()->getClientContext(), nullptr, 1, 0, false);
81 gmm->isCompressionEnabled = true;
82
83 auto buffer = std::unique_ptr<Buffer>(Buffer::create(&context, CL_MEM_READ_WRITE, 1, nullptr, retVal));
84 buffer->getGraphicsAllocation(0)->setGmm(gmm, 0);
85
86 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
87
88 {
89 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
90 EXPECT_EQ(defaultCompressionFormat, surfaceState.getCompressionFormat());
91 }
92
93 {
94 DebugManager.flags.ForceBufferCompressionFormat.set(compressionFormat);
95 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
96 EXPECT_EQ(compressionFormat, surfaceState.getCompressionFormat());
97 }
98 }
99
HWTEST2_F(XeHPAndLaterBufferTests,givenContextTypeDefaultWhenBufferIsWritableThenFlipPartialFlagsToFalse,isXePlatform)100 HWTEST2_F(XeHPAndLaterBufferTests, givenContextTypeDefaultWhenBufferIsWritableThenFlipPartialFlagsToFalse, isXePlatform) {
101 DebugManagerStateRestore restorer;
102 DebugManager.flags.CreateMultipleSubDevices.set(4);
103 initPlatform();
104
105 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
106 MockContext context(platform()->getClDevice(0));
107 context.contextType = ContextType::CONTEXT_TYPE_DEFAULT;
108
109 size_t size = 0x1000;
110 auto retVal = CL_SUCCESS;
111 auto buffer = std::unique_ptr<Buffer>(
112 Buffer::create(
113 &context,
114 CL_MEM_READ_WRITE,
115 size,
116 nullptr,
117 retVal));
118 EXPECT_EQ(CL_SUCCESS, retVal);
119
120 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
121 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
122 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
123
124 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), true, true);
125
126 EXPECT_FALSE(surfaceState.getDisableSupportForMultiGpuAtomics());
127 EXPECT_FALSE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
128 }
129
HWTEST2_F(XeHPAndLaterBufferTests,givenContextTypeUnrestrictiveWhenBufferIsWritableThenFlipPartialFlagsToFalse,isXePlatform)130 HWTEST2_F(XeHPAndLaterBufferTests, givenContextTypeUnrestrictiveWhenBufferIsWritableThenFlipPartialFlagsToFalse, isXePlatform) {
131 DebugManagerStateRestore restorer;
132 DebugManager.flags.CreateMultipleSubDevices.set(4);
133 initPlatform();
134
135 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
136 MockContext context(platform()->getClDevice(0));
137 context.contextType = ContextType::CONTEXT_TYPE_UNRESTRICTIVE;
138
139 size_t size = 0x1000;
140 auto retVal = CL_SUCCESS;
141 auto buffer = std::unique_ptr<Buffer>(
142 Buffer::create(
143 &context,
144 CL_MEM_READ_WRITE,
145 size,
146 nullptr,
147 retVal));
148 EXPECT_EQ(CL_SUCCESS, retVal);
149
150 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
151 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
152 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
153
154 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), true, true);
155
156 EXPECT_FALSE(surfaceState.getDisableSupportForMultiGpuAtomics());
157 EXPECT_FALSE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
158 }
159
HWTEST2_F(XeHPAndLaterBufferTests,givenContextTypeDefaultWhenBufferIsNotWritableThenRemainPartialFlagsToTrue,isXePlatform)160 HWTEST2_F(XeHPAndLaterBufferTests, givenContextTypeDefaultWhenBufferIsNotWritableThenRemainPartialFlagsToTrue, isXePlatform) {
161 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
162 MockContext context;
163 context.contextType = ContextType::CONTEXT_TYPE_DEFAULT;
164
165 size_t size = 0x1000;
166 auto retVal = CL_SUCCESS;
167
168 auto buffer = std::unique_ptr<Buffer>(Buffer::create(
169 &context,
170 CL_MEM_READ_ONLY,
171 size,
172 nullptr,
173 retVal));
174 EXPECT_EQ(CL_SUCCESS, retVal);
175
176 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
177 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
178 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
179
180 surfaceState.setDisableSupportForMultiGpuAtomics(false);
181 surfaceState.setDisableSupportForMultiGpuPartialWrites(false);
182 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), true, false);
183
184 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
185 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
186 }
187
HWTEST2_F(XeHPAndLaterBufferTests,givenContextTypeSpecializedWhenBufferIsWritableThenRemainPartialFlagsToTrue,isXePlatform)188 HWTEST2_F(XeHPAndLaterBufferTests, givenContextTypeSpecializedWhenBufferIsWritableThenRemainPartialFlagsToTrue, isXePlatform) {
189 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
190 MockContext context;
191 context.contextType = ContextType::CONTEXT_TYPE_SPECIALIZED;
192
193 size_t size = 0x1000;
194 auto retVal = CL_SUCCESS;
195
196 auto buffer = std::unique_ptr<Buffer>(Buffer::create(
197 &context,
198 CL_MEM_READ_WRITE,
199 size,
200 nullptr,
201 retVal));
202 EXPECT_EQ(CL_SUCCESS, retVal);
203
204 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
205 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
206 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
207
208 surfaceState.setDisableSupportForMultiGpuAtomics(false);
209 surfaceState.setDisableSupportForMultiGpuPartialWrites(false);
210 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
211
212 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
213 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
214 }
215
HWTEST2_F(XeHPAndLaterBufferTests,givenDebugFlagForMultiTileSupportWhenSurfaceStateIsSetThenValuesMatch,isXePlatform)216 HWTEST2_F(XeHPAndLaterBufferTests, givenDebugFlagForMultiTileSupportWhenSurfaceStateIsSetThenValuesMatch, isXePlatform) {
217 DebugManagerStateRestore restore;
218 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
219 MockContext context;
220 context.contextType = ContextType::CONTEXT_TYPE_SPECIALIZED;
221
222 size_t size = 0x1000;
223 auto retVal = CL_SUCCESS;
224
225 auto buffer = std::unique_ptr<Buffer>(Buffer::create(
226 &context,
227 CL_MEM_READ_WRITE,
228 size,
229 nullptr,
230 retVal));
231 EXPECT_EQ(CL_SUCCESS, retVal);
232
233 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
234
235 DebugManager.flags.ForceMultiGpuAtomics.set(0);
236 DebugManager.flags.ForceMultiGpuPartialWrites.set(0);
237
238 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
239
240 EXPECT_EQ(0u, surfaceState.getDisableSupportForMultiGpuAtomics());
241 EXPECT_EQ(0u, surfaceState.getDisableSupportForMultiGpuPartialWrites());
242
243 DebugManager.flags.ForceMultiGpuAtomics.set(1);
244 DebugManager.flags.ForceMultiGpuPartialWrites.set(1);
245
246 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
247
248 EXPECT_EQ(1u, surfaceState.getDisableSupportForMultiGpuAtomics());
249 EXPECT_EQ(1u, surfaceState.getDisableSupportForMultiGpuPartialWrites());
250 }
251
HWTEST2_F(XeHPAndLaterBufferTests,givenNullContextWhenBufferAllocationIsNullThenRemainPartialFlagsToTrue,isXePlatform)252 HWTEST2_F(XeHPAndLaterBufferTests, givenNullContextWhenBufferAllocationIsNullThenRemainPartialFlagsToTrue, isXePlatform) {
253 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
254 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
255
256 auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
257
258 auto size = MemoryConstants::pageSize;
259 auto ptr = alignedMalloc(size, MemoryConstants::pageSize);
260
261 surfaceState.setDisableSupportForMultiGpuAtomics(false);
262 surfaceState.setDisableSupportForMultiGpuPartialWrites(false);
263 Buffer::setSurfaceState(device.get(), &surfaceState, false, false, size, ptr, 0, nullptr, 0, 0, false, false);
264
265 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
266 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuPartialWrites());
267
268 alignedFree(ptr);
269 }
270
271 struct MultiGpuGlobalAtomicsBufferTest : public XeHPAndLaterBufferTests,
272 public ::testing::WithParamInterface<std::tuple<unsigned int, unsigned int, bool, bool, bool>> {
273 };
274
HWTEST2_P(MultiGpuGlobalAtomicsBufferTest,givenSetArgStatefulCalledThenDisableSupportForMultiGpuAtomicsIsSetCorrectly,isXePlatform)275 HWTEST2_P(MultiGpuGlobalAtomicsBufferTest, givenSetArgStatefulCalledThenDisableSupportForMultiGpuAtomicsIsSetCorrectly, isXePlatform) {
276 unsigned int numAvailableDevices, bufferFlags;
277 bool useGlobalAtomics, areMultipleSubDevicesInContext, enableMultiGpuAtomicsOptimization;
278 std::tie(numAvailableDevices, bufferFlags, useGlobalAtomics, areMultipleSubDevicesInContext, enableMultiGpuAtomicsOptimization) = GetParam();
279
280 DebugManagerStateRestore restorer;
281 DebugManager.flags.CreateMultipleSubDevices.set(numAvailableDevices);
282 DebugManager.flags.EnableMultiGpuAtomicsOptimization.set(enableMultiGpuAtomicsOptimization);
283 initPlatform();
284
285 if (numAvailableDevices == 1) {
286 EXPECT_EQ(0u, platform()->getClDevice(0)->getNumGenericSubDevices());
287 } else {
288 EXPECT_EQ(numAvailableDevices, platform()->getClDevice(0)->getNumGenericSubDevices());
289 }
290 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
291 MockContext context(platform()->getClDevice(0));
292 context.contextType = ContextType::CONTEXT_TYPE_DEFAULT;
293
294 size_t size = 0x1000;
295 auto retVal = CL_SUCCESS;
296 auto buffer = std::unique_ptr<Buffer>(
297 Buffer::create(
298 &context,
299 bufferFlags,
300 size,
301 nullptr,
302 retVal));
303 EXPECT_EQ(CL_SUCCESS, retVal);
304
305 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
306 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
307
308 surfaceState.setDisableSupportForMultiGpuAtomics(false);
309 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), useGlobalAtomics, areMultipleSubDevicesInContext);
310
311 DeviceBitfield deviceBitfield{static_cast<uint32_t>(maxNBitValue(numAvailableDevices))};
312 bool implicitScaling = ImplicitScalingHelper::isImplicitScalingEnabled(deviceBitfield, true);
313 bool enabled = implicitScaling;
314
315 if (enableMultiGpuAtomicsOptimization) {
316 enabled = useGlobalAtomics && (enabled || areMultipleSubDevicesInContext);
317 }
318
319 EXPECT_EQ(!enabled, surfaceState.getDisableSupportForMultiGpuAtomics());
320 }
321
HWTEST2_P(MultiGpuGlobalAtomicsBufferTest,givenSetSurfaceStateCalledThenDisableSupportForMultiGpuAtomicsIsSetCorrectly,isXePlatform)322 HWTEST2_P(MultiGpuGlobalAtomicsBufferTest, givenSetSurfaceStateCalledThenDisableSupportForMultiGpuAtomicsIsSetCorrectly, isXePlatform) {
323 unsigned int numAvailableDevices, bufferFlags;
324 bool useGlobalAtomics, areMultipleSubDevicesInContext, enableMultiGpuAtomicsOptimization;
325 std::tie(numAvailableDevices, bufferFlags, useGlobalAtomics, areMultipleSubDevicesInContext, enableMultiGpuAtomicsOptimization) = GetParam();
326
327 DebugManagerStateRestore restorer;
328 DebugManager.flags.CreateMultipleSubDevices.set(numAvailableDevices);
329 DebugManager.flags.EnableMultiGpuAtomicsOptimization.set(enableMultiGpuAtomicsOptimization);
330 initPlatform();
331 if (numAvailableDevices == 1) {
332 EXPECT_EQ(0u, platform()->getClDevice(0)->getNumGenericSubDevices());
333 } else {
334 EXPECT_EQ(numAvailableDevices, platform()->getClDevice(0)->getNumGenericSubDevices());
335 }
336
337 auto size = MemoryConstants::pageSize;
338 auto ptr = alignedMalloc(size, MemoryConstants::pageSize);
339 MockGraphicsAllocation gfxAllocation(ptr, size);
340 gfxAllocation.setMemObjectsAllocationWithWritableFlags(bufferFlags == CL_MEM_READ_WRITE);
341
342 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
343 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
344 EXPECT_TRUE(surfaceState.getDisableSupportForMultiGpuAtomics());
345
346 surfaceState.setDisableSupportForMultiGpuAtomics(false);
347 Buffer::setSurfaceState(&platform()->getClDevice(0)->getDevice(), &surfaceState, false, false, 0, nullptr, 0, &gfxAllocation, bufferFlags, 0, useGlobalAtomics, areMultipleSubDevicesInContext);
348
349 DeviceBitfield deviceBitfield{static_cast<uint32_t>(maxNBitValue(numAvailableDevices))};
350 bool implicitScaling = ImplicitScalingHelper::isImplicitScalingEnabled(deviceBitfield, true);
351 bool enabled = implicitScaling;
352
353 if (enableMultiGpuAtomicsOptimization) {
354 enabled = useGlobalAtomics && (enabled || areMultipleSubDevicesInContext);
355 }
356
357 EXPECT_EQ(!enabled, surfaceState.getDisableSupportForMultiGpuAtomics());
358
359 alignedFree(ptr);
360 }
361
362 static unsigned int numAvailableDevices[] = {1, 2};
363 static unsigned int bufferFlags[] = {CL_MEM_READ_ONLY, CL_MEM_READ_WRITE};
364
365 INSTANTIATE_TEST_CASE_P(MultiGpuGlobalAtomicsBufferTest,
366 MultiGpuGlobalAtomicsBufferTest,
367 ::testing::Combine(
368 ::testing::ValuesIn(numAvailableDevices),
369 ::testing::ValuesIn(bufferFlags),
370 ::testing::Bool(),
371 ::testing::Bool(),
372 ::testing::Bool()));
373
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenBufferAllocationInDeviceMemoryWhenStatelessCompressionIsEnabledThenSetSurfaceStateWithCompressionSettings)374 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenBufferAllocationInDeviceMemoryWhenStatelessCompressionIsEnabledThenSetSurfaceStateWithCompressionSettings) {
375 DebugManagerStateRestore restorer;
376 DebugManager.flags.EnableLocalMemory.set(1);
377 DebugManager.flags.EnableStatelessCompressionWithUnifiedMemory.set(1);
378
379 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
380 using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
381
382 MockContext context;
383 size_t size = 0x1000;
384 auto retVal = CL_SUCCESS;
385 auto buffer = std::unique_ptr<Buffer>(
386 Buffer::create(
387 &context,
388 CL_MEM_READ_WRITE,
389 size,
390 nullptr,
391 retVal));
392 EXPECT_EQ(CL_SUCCESS, retVal);
393
394 auto &device = context.getDevice(0)->getDevice();
395 auto allocation = buffer->getGraphicsAllocation(device.getRootDeviceIndex());
396 auto gmm = new MockGmm(device.getGmmClientContext());
397 gmm->isCompressionEnabled = true;
398 allocation->setDefaultGmm(gmm);
399
400 EXPECT_TRUE(!MemoryPool::isSystemMemoryPool(allocation->getMemoryPool()));
401
402 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
403
404 buffer->setArgStateful(&surfaceState, false, false, false, false, device, false, false);
405
406 EXPECT_EQ(RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT, surfaceState.getCoherencyType());
407 EXPECT_TRUE(EncodeSurfaceState<FamilyType>::isAuxModeEnabled(&surfaceState, allocation->getDefaultGmm()));
408 EXPECT_EQ(static_cast<uint32_t>(DebugManager.flags.FormatForStatelessCompressionWithUnifiedMemory.get()), surfaceState.getCompressionFormat());
409 }
410
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenBufferAllocationInHostMemoryWhenStatelessCompressionIsEnabledThenDontSetSurfaceStateWithCompressionSettings)411 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenBufferAllocationInHostMemoryWhenStatelessCompressionIsEnabledThenDontSetSurfaceStateWithCompressionSettings) {
412 DebugManagerStateRestore restorer;
413 DebugManager.flags.EnableStatelessCompressionWithUnifiedMemory.set(1);
414
415 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
416 using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
417
418 MockContext context;
419 size_t size = 0x1000;
420 auto retVal = CL_SUCCESS;
421 auto buffer = std::unique_ptr<Buffer>(
422 Buffer::create(
423 &context,
424 CL_MEM_READ_WRITE,
425 size,
426 nullptr,
427 retVal));
428 EXPECT_EQ(CL_SUCCESS, retVal);
429
430 EXPECT_TRUE(MemoryPool::isSystemMemoryPool(buffer->getGraphicsAllocation(context.getDevice(0)->getRootDeviceIndex())->getMemoryPool()));
431
432 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
433
434 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
435
436 EXPECT_EQ(RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT, surfaceState.getCoherencyType());
437 EXPECT_EQ(AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE, surfaceState.getAuxiliarySurfaceMode());
438 EXPECT_EQ(0u, surfaceState.getCompressionFormat());
439 }
440
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenBufferAllocationWithoutGraphicsAllocationWhenStatelessCompressionIsEnabledThenDontSetSurfaceStateWithCompressionSettings)441 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenBufferAllocationWithoutGraphicsAllocationWhenStatelessCompressionIsEnabledThenDontSetSurfaceStateWithCompressionSettings) {
442 DebugManagerStateRestore restorer;
443 DebugManager.flags.EnableStatelessCompressionWithUnifiedMemory.set(1);
444
445 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
446 using AUXILIARY_SURFACE_MODE = typename RENDER_SURFACE_STATE::AUXILIARY_SURFACE_MODE;
447
448 MockContext context;
449 cl_float srcMemory[] = {1.0f, 2.0f, 3.0f, 4.0f};
450 std::unique_ptr<Buffer> buffer(Buffer::createBufferHw(
451 &context,
452 ClMemoryPropertiesHelper::createMemoryProperties(0, 0, 0, &context.getDevice(0)->getDevice()),
453 0,
454 0,
455 sizeof(srcMemory),
456 srcMemory,
457 srcMemory,
458 0,
459 false,
460 false,
461 false));
462 ASSERT_NE(nullptr, buffer);
463
464 RENDER_SURFACE_STATE surfaceState = FamilyType::cmdInitRenderSurfaceState;
465
466 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
467
468 EXPECT_EQ(RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT, surfaceState.getCoherencyType());
469 EXPECT_EQ(AUXILIARY_SURFACE_MODE::AUXILIARY_SURFACE_MODE_AUX_NONE, surfaceState.getAuxiliarySurfaceMode());
470 EXPECT_EQ(0u, surfaceState.getCompressionFormat());
471 }
472
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenDebugVariableForcingL1CachingWhenBufferSurfaceStateIsSetThenItIsCachedInL1)473 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenDebugVariableForcingL1CachingWhenBufferSurfaceStateIsSetThenItIsCachedInL1) {
474 DebugManagerStateRestore restorer;
475 DebugManager.flags.ForceL1Caching.set(1u);
476 MockContext context;
477 const auto size = MemoryConstants::pageSize;
478 const auto flags = CL_MEM_READ_WRITE;
479
480 auto retVal = CL_SUCCESS;
481 auto buffer = std::unique_ptr<Buffer>(Buffer::create(
482 &context,
483 flags,
484 size,
485 nullptr,
486 retVal));
487 EXPECT_EQ(CL_SUCCESS, retVal);
488
489 typename FamilyType::RENDER_SURFACE_STATE surfaceState = {};
490 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
491
492 const auto expectedMocs = context.getDevice(0)->getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST);
493 const auto actualMocs = surfaceState.getMemoryObjectControlState();
494 EXPECT_EQ(expectedMocs, actualMocs);
495 }
496
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenDebugVariableForcingL1CachingDisabledWhenBufferSurfaceStateIsSetThenItIsCachedInL3)497 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenDebugVariableForcingL1CachingDisabledWhenBufferSurfaceStateIsSetThenItIsCachedInL3) {
498 DebugManagerStateRestore restorer;
499 DebugManager.flags.ForceL1Caching.set(0u);
500 MockContext context;
501 const auto size = MemoryConstants::pageSize;
502 const auto flags = CL_MEM_READ_WRITE;
503
504 auto retVal = CL_SUCCESS;
505 auto buffer = std::unique_ptr<Buffer>(Buffer::create(
506 &context,
507 flags,
508 size,
509 nullptr,
510 retVal));
511 EXPECT_EQ(CL_SUCCESS, retVal);
512
513 typename FamilyType::RENDER_SURFACE_STATE surfaceState = {};
514 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
515
516 const auto expectedMocs = context.getDevice(0)->getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER);
517 const auto actualMocs = surfaceState.getMemoryObjectControlState();
518 EXPECT_EQ(expectedMocs, actualMocs);
519 }
520
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenBufferWhenArgumentIsConstAndAuxModeIsOnThenL3DisabledPolicyIsChoosen)521 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenBufferWhenArgumentIsConstAndAuxModeIsOnThenL3DisabledPolicyIsChoosen) {
522 MockContext context;
523 const auto size = MemoryConstants::pageSize;
524 const auto flags = CL_MEM_READ_ONLY;
525
526 auto retVal = CL_SUCCESS;
527 auto buffer = std::unique_ptr<Buffer>(Buffer::create(
528 &context,
529 flags,
530 size,
531 nullptr,
532 retVal));
533 EXPECT_EQ(CL_SUCCESS, retVal);
534
535 typename FamilyType::RENDER_SURFACE_STATE surfaceState = {};
536 buffer->setArgStateful(&surfaceState, true, true, false, false, context.getDevice(0)->getDevice(), false, false);
537
538 const auto expectedMocs = context.getDevice(0)->getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED);
539 const auto actualMocs = surfaceState.getMemoryObjectControlState();
540 EXPECT_EQ(expectedMocs, actualMocs);
541 }
542
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenBufferSetSurfaceThatMemoryPtrAndSizeIsAlignedToCachelineThenL1CacheShouldBeOn)543 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenBufferSetSurfaceThatMemoryPtrAndSizeIsAlignedToCachelineThenL1CacheShouldBeOn) {
544 MockContext context;
545
546 auto size = MemoryConstants::pageSize;
547 auto ptr = (void *)alignedMalloc(size * 2, MemoryConstants::pageSize);
548
549 using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
550 RENDER_SURFACE_STATE surfaceState = {};
551
552 auto device = std::unique_ptr<MockDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
553
554 Buffer::setSurfaceState(device.get(), &surfaceState, false, false, size, ptr, 0, nullptr, 0, 0, false, false);
555
556 auto mocs = surfaceState.getMemoryObjectControlState();
557 auto gmmHelper = device.get()->getGmmHelper();
558 EXPECT_EQ(gmmHelper->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST), mocs);
559
560 alignedFree(ptr);
561 }
562
HWCMDTEST_F(IGFX_XE_HP_CORE,XeHPAndLaterBufferTests,givenAlignedCacheableNonReadOnlyBufferThenChooseOclBufferPolicy)563 HWCMDTEST_F(IGFX_XE_HP_CORE, XeHPAndLaterBufferTests, givenAlignedCacheableNonReadOnlyBufferThenChooseOclBufferPolicy) {
564 MockContext context;
565 const auto size = MemoryConstants::pageSize;
566 const auto ptr = (void *)alignedMalloc(size * 2, MemoryConstants::pageSize);
567 const auto flags = CL_MEM_USE_HOST_PTR;
568
569 auto retVal = CL_SUCCESS;
570 auto buffer = std::unique_ptr<Buffer>(Buffer::create(
571 &context,
572 flags,
573 size,
574 ptr,
575 retVal));
576 EXPECT_EQ(CL_SUCCESS, retVal);
577
578 typename FamilyType::RENDER_SURFACE_STATE surfaceState = {};
579 buffer->setArgStateful(&surfaceState, false, false, false, false, context.getDevice(0)->getDevice(), false, false);
580
581 const auto expectedMocs = context.getDevice(0)->getDevice().getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CONST);
582 const auto actualMocs = surfaceState.getMemoryObjectControlState();
583 EXPECT_EQ(expectedMocs, actualMocs);
584
585 alignedFree(ptr);
586 }
587