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