1 /*
2  * Copyright (C) 2020-2021 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 #include "shared/source/gen_common/reg_configs_common.h"
9 #include "shared/source/helpers/preamble.h"
10 #include "shared/test/common/cmd_parse/gen_cmd_parse.h"
11 #include "shared/test/common/mocks/mock_gmm_helper.h"
12 #include "shared/test/common/test_macros/test.h"
13 
14 #include "level_zero/core/test/unit_tests/mocks/mock_cmdqueue.h"
15 #include "level_zero/core/test/unit_tests/mocks/mock_kernel.h"
16 #include "level_zero/core/test/unit_tests/sources/debugger/l0_debugger_fixture.h"
17 
18 namespace L0 {
19 namespace ult {
20 
21 using L0DebuggerTest = Test<L0DebuggerHwFixture>;
22 
TEST_F(L0DebuggerTest,givenL0DebuggerWhenCallingIsLegacyThenFalseIsReturned)23 TEST_F(L0DebuggerTest, givenL0DebuggerWhenCallingIsLegacyThenFalseIsReturned) {
24     EXPECT_FALSE(neoDevice->getDebugger()->isLegacy());
25 }
26 
TEST_F(L0DebuggerTest,givenL0DebuggerWhenGettingSourceLevelDebuggerThenNullptrReturned)27 TEST_F(L0DebuggerTest, givenL0DebuggerWhenGettingSourceLevelDebuggerThenNullptrReturned) {
28     EXPECT_EQ(nullptr, neoDevice->getSourceLevelDebugger());
29 }
30 
TEST_F(L0DebuggerTest,givenL0DebuggerWhenGettingL0DebuggerThenValidDebuggerInstanceIsReturned)31 TEST_F(L0DebuggerTest, givenL0DebuggerWhenGettingL0DebuggerThenValidDebuggerInstanceIsReturned) {
32     EXPECT_NE(nullptr, device->getL0Debugger());
33 }
34 
TEST_F(L0DebuggerTest,givenL0DebuggerWhenGettingSipAllocationThenValidSipTypeIsReturned)35 TEST_F(L0DebuggerTest, givenL0DebuggerWhenGettingSipAllocationThenValidSipTypeIsReturned) {
36     neoDevice->setDebuggerActive(true);
37     auto systemRoutine = SipKernel::getSipKernel(*neoDevice).getSipAllocation();
38     ASSERT_NE(nullptr, systemRoutine);
39 
40     auto sipType = SipKernel::getSipKernelType(*neoDevice);
41     auto isHexadecimalArrayPreferred = HwHelper::get(hwInfo.platform.eRenderCoreFamily).isSipKernelAsHexadecimalArrayPreferred();
42 
43     auto expectedSipAllocation = isHexadecimalArrayPreferred
44                                      ? NEO::MockSipData::mockSipKernel->getSipAllocation()
45                                      : neoDevice->getBuiltIns()->getSipKernel(sipType, *neoDevice).getSipAllocation();
46 
47     EXPECT_EQ(expectedSipAllocation, systemRoutine);
48 }
49 
TEST_F(L0DebuggerTest,givenL0DebuggerWhenGettingStateSaveAreaHeaderThenValidSipTypeIsReturned)50 TEST_F(L0DebuggerTest, givenL0DebuggerWhenGettingStateSaveAreaHeaderThenValidSipTypeIsReturned) {
51     auto &stateSaveAreaHeader = SipKernel::getSipKernel(*neoDevice).getStateSaveAreaHeader();
52 
53     auto sipType = SipKernel::getSipKernelType(*neoDevice);
54     auto &expectedStateSaveAreaHeader = neoDevice->getBuiltIns()->getSipKernel(sipType, *neoDevice).getStateSaveAreaHeader();
55 
56     EXPECT_EQ(expectedStateSaveAreaHeader, stateSaveAreaHeader);
57 }
58 
TEST_F(L0DebuggerTest,givenProgramDebuggingEnabledWhenDebuggerIsCreatedThenFusedEusAreDisabled)59 TEST_F(L0DebuggerTest, givenProgramDebuggingEnabledWhenDebuggerIsCreatedThenFusedEusAreDisabled) {
60     EXPECT_TRUE(driverHandle->enableProgramDebugging);
61     EXPECT_FALSE(neoDevice->getHardwareInfo().capabilityTable.fusedEuEnabled);
62 }
63 
TEST(Debugger,givenL0DebuggerOFFWhenGettingStateSaveAreaHeaderThenValidSipTypeIsReturned)64 TEST(Debugger, givenL0DebuggerOFFWhenGettingStateSaveAreaHeaderThenValidSipTypeIsReturned) {
65     auto executionEnvironment = new NEO::ExecutionEnvironment();
66     executionEnvironment->prepareRootDeviceEnvironments(1);
67 
68     auto isHexadecimalArrayPreferred = HwHelper::get(defaultHwInfo->platform.eRenderCoreFamily).isSipKernelAsHexadecimalArrayPreferred();
69     if (!isHexadecimalArrayPreferred) {
70         auto mockBuiltIns = new MockBuiltins();
71         executionEnvironment->rootDeviceEnvironments[0]->builtins.reset(mockBuiltIns);
72     }
73     auto hwInfo = *NEO::defaultHwInfo.get();
74     hwInfo.featureTable.flags.ftrLocalMemory = true;
75     executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&hwInfo);
76     executionEnvironment->initializeMemoryManager();
77 
78     auto neoDevice = NEO::MockDevice::create<NEO::MockDevice>(executionEnvironment, 0u);
79     NEO::DeviceVector devices;
80     devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
81     auto driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
82     driverHandle->enableProgramDebugging = false;
83 
84     driverHandle->initialize(std::move(devices));
85     auto sipType = SipKernel::getSipKernelType(*neoDevice);
86 
87     if (isHexadecimalArrayPreferred) {
88         SipKernel::initSipKernel(sipType, *neoDevice);
89     }
90     auto &stateSaveAreaHeader = SipKernel::getSipKernel(*neoDevice).getStateSaveAreaHeader();
91 
92     if (isHexadecimalArrayPreferred) {
93         auto sipKernel = neoDevice->getRootDeviceEnvironment().sipKernels[static_cast<uint32_t>(sipType)].get();
94         ASSERT_NE(sipKernel, nullptr);
95         auto &expectedStateSaveAreaHeader = sipKernel->getStateSaveAreaHeader();
96         EXPECT_EQ(expectedStateSaveAreaHeader, stateSaveAreaHeader);
97     } else {
98         auto &expectedStateSaveAreaHeader = neoDevice->getBuiltIns()->getSipKernel(sipType, *neoDevice).getStateSaveAreaHeader();
99         EXPECT_EQ(expectedStateSaveAreaHeader, stateSaveAreaHeader);
100     }
101 }
102 
TEST(Debugger,givenDebuggingEnabledInExecEnvWhenAllocatingIsaThenSingleBankIsUsed)103 TEST(Debugger, givenDebuggingEnabledInExecEnvWhenAllocatingIsaThenSingleBankIsUsed) {
104     auto executionEnvironment = new NEO::ExecutionEnvironment();
105     executionEnvironment->prepareRootDeviceEnvironments(1);
106     executionEnvironment->setDebuggingEnabled();
107 
108     auto hwInfo = *NEO::defaultHwInfo.get();
109     hwInfo.featureTable.flags.ftrLocalMemory = true;
110     executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(&hwInfo);
111     executionEnvironment->initializeMemoryManager();
112 
113     std::unique_ptr<NEO::MockDevice> neoDevice(NEO::MockDevice::create<NEO::MockDevice>(executionEnvironment, 0u));
114 
115     auto allocation = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(
116         {neoDevice->getRootDeviceIndex(), 4096, NEO::GraphicsAllocation::AllocationType::KERNEL_ISA, neoDevice->getDeviceBitfield()});
117 
118     if (allocation->getMemoryPool() == MemoryPool::LocalMemory) {
119         EXPECT_EQ(1u, allocation->storageInfo.getMemoryBanks());
120     } else {
121         EXPECT_EQ(0u, allocation->storageInfo.getMemoryBanks());
122     }
123 
124     neoDevice->getMemoryManager()->freeGraphicsMemory(allocation);
125 }
126 
HWTEST_F(L0DebuggerTest,givenL0DebuggerWhenCreatedThenPerContextSbaTrackingBuffersAreAllocated)127 HWTEST_F(L0DebuggerTest, givenL0DebuggerWhenCreatedThenPerContextSbaTrackingBuffersAreAllocated) {
128     auto debugger = device->getL0Debugger();
129     ASSERT_NE(nullptr, debugger);
130 
131     EXPECT_NE(0u, debugger->getSbaTrackingGpuVa());
132     std::vector<NEO::GraphicsAllocation *> allocations;
133 
134     auto &allEngines = device->getNEODevice()->getMemoryManager()->getRegisteredEngines();
135 
136     for (auto &engine : allEngines) {
137         auto sbaAllocation = debugger->getSbaTrackingBuffer(engine.osContext->getContextId());
138         ASSERT_NE(nullptr, sbaAllocation);
139         allocations.push_back(sbaAllocation);
140 
141         EXPECT_EQ(NEO::GraphicsAllocation::AllocationType::DEBUG_SBA_TRACKING_BUFFER, sbaAllocation->getAllocationType());
142         EXPECT_EQ(MemoryPool::System4KBPages, sbaAllocation->getMemoryPool());
143     }
144 
145     for (uint32_t i = 0; i < allocations.size() - 1; i++) {
146         EXPECT_NE(allocations[i], allocations[i + 1]);
147     }
148 
149     EXPECT_EQ(allEngines.size(), getMockDebuggerL0Hw<FamilyType>()->perContextSbaAllocations.size());
150 }
151 
HWTEST_F(L0DebuggerTest,givenCreatedL0DebuggerThenSbaTrackingBuffersContainValidHeader)152 HWTEST_F(L0DebuggerTest, givenCreatedL0DebuggerThenSbaTrackingBuffersContainValidHeader) {
153     auto debugger = device->getL0Debugger();
154     ASSERT_NE(nullptr, debugger);
155 
156     for (auto &sbaBuffer : getMockDebuggerL0Hw<FamilyType>()->perContextSbaAllocations) {
157         auto sbaAllocation = sbaBuffer.second;
158         ASSERT_NE(nullptr, sbaAllocation);
159 
160         auto sbaHeader = reinterpret_cast<SbaTrackedAddresses *>(sbaAllocation->getUnderlyingBuffer());
161 
162         EXPECT_STREQ("sbaarea", sbaHeader->magic);
163         EXPECT_EQ(0u, sbaHeader->BindlessSamplerStateBaseAddress);
164         EXPECT_EQ(0u, sbaHeader->BindlessSurfaceStateBaseAddress);
165         EXPECT_EQ(0u, sbaHeader->DynamicStateBaseAddress);
166         EXPECT_EQ(0u, sbaHeader->GeneralStateBaseAddress);
167         EXPECT_EQ(0u, sbaHeader->IndirectObjectBaseAddress);
168         EXPECT_EQ(0u, sbaHeader->InstructionBaseAddress);
169         EXPECT_EQ(0u, sbaHeader->SurfaceStateBaseAddress);
170         EXPECT_EQ(0u, sbaHeader->Version);
171     }
172 }
173 
HWTEST_F(L0DebuggerTest,givenDebuggingEnabledWhenCommandListIsExecutedThenValidKernelDebugCommandsAreAdded)174 HWTEST_F(L0DebuggerTest, givenDebuggingEnabledWhenCommandListIsExecutedThenValidKernelDebugCommandsAreAdded) {
175     using MI_LOAD_REGISTER_IMM = typename FamilyType::MI_LOAD_REGISTER_IMM;
176     using STATE_SIP = typename FamilyType::STATE_SIP;
177 
178     ze_command_queue_desc_t queueDesc = {};
179     ze_result_t returnValue;
180     auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
181     ASSERT_NE(nullptr, commandQueue->commandStream);
182 
183     auto usedSpaceBefore = commandQueue->commandStream->getUsed();
184 
185     ze_command_list_handle_t commandLists[] = {
186         CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle()};
187     uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
188 
189     auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
190     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
191 
192     auto usedSpaceAfter = commandQueue->commandStream->getUsed();
193     ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
194 
195     GenCmdList cmdList;
196     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
197         cmdList, ptrOffset(commandQueue->commandStream->getCpuBase(), 0), usedSpaceAfter));
198 
199     auto miLoadImm = findAll<MI_LOAD_REGISTER_IMM *>(cmdList.begin(), cmdList.end());
200 
201     size_t debugModeRegisterCount = 0;
202     size_t tdDebugControlRegisterCount = 0;
203 
204     for (size_t i = 0; i < miLoadImm.size(); i++) {
205         MI_LOAD_REGISTER_IMM *miLoad = genCmdCast<MI_LOAD_REGISTER_IMM *>(*miLoadImm[i]);
206         ASSERT_NE(nullptr, miLoad);
207 
208         if (miLoad->getRegisterOffset() == DebugModeRegisterOffset<FamilyType>::registerOffset) {
209             EXPECT_EQ(DebugModeRegisterOffset<FamilyType>::debugEnabledValue, miLoad->getDataDword());
210             debugModeRegisterCount++;
211         }
212         if (miLoad->getRegisterOffset() == TdDebugControlRegisterOffset<FamilyType>::registerOffset) {
213             EXPECT_EQ(TdDebugControlRegisterOffset<FamilyType>::debugEnabledValue, miLoad->getDataDword());
214             tdDebugControlRegisterCount++;
215         }
216     }
217     // those register should not be used
218     EXPECT_EQ(0u, debugModeRegisterCount);
219     EXPECT_EQ(0u, tdDebugControlRegisterCount);
220 
221     if (!HwHelper::get(hwInfo.platform.eRenderCoreFamily).isSipWANeeded(hwInfo)) {
222         auto stateSipCmds = findAll<STATE_SIP *>(cmdList.begin(), cmdList.end());
223         ASSERT_EQ(1u, stateSipCmds.size());
224 
225         STATE_SIP *stateSip = genCmdCast<STATE_SIP *>(*stateSipCmds[0]);
226 
227         auto systemRoutine = SipKernel::getSipKernel(*neoDevice).getSipAllocation();
228         ASSERT_NE(nullptr, systemRoutine);
229         EXPECT_EQ(systemRoutine->getGpuAddressToPatch(), stateSip->getSystemInstructionPointer());
230     }
231 
232     for (auto i = 0u; i < numCommandLists; i++) {
233         auto commandList = CommandList::fromHandle(commandLists[i]);
234         commandList->destroy();
235     }
236 
237     commandQueue->destroy();
238 }
239 
240 using NotGen8Or11 = AreNotGfxCores<IGFX_GEN8_CORE, IGFX_GEN11_CORE>;
241 
HWTEST2_F(L0DebuggerTest,givenDebuggingEnabledAndRequiredGsbaWhenCommandListIsExecutedThenProgramGsbaWritesToSbaTrackingBuffer,NotGen8Or11)242 HWTEST2_F(L0DebuggerTest, givenDebuggingEnabledAndRequiredGsbaWhenCommandListIsExecutedThenProgramGsbaWritesToSbaTrackingBuffer, NotGen8Or11) {
243     using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
244     using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
245 
246     ze_command_queue_desc_t queueDesc = {};
247     ze_result_t returnValue;
248     auto cmdQ = CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue);
249     ASSERT_NE(nullptr, cmdQ);
250 
251     auto commandQueue = whitebox_cast(cmdQ);
252     auto cmdQHw = static_cast<CommandQueueHw<gfxCoreFamily> *>(cmdQ);
253 
254     if (cmdQHw->estimateStateBaseAddressCmdSize() == 0) {
255         commandQueue->destroy();
256         GTEST_SKIP();
257     }
258 
259     auto usedSpaceBefore = commandQueue->commandStream->getUsed();
260 
261     ze_command_list_handle_t commandLists[] = {
262         CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle()};
263     CommandList::fromHandle(commandLists[0])->setCommandListPerThreadScratchSize(4096);
264 
265     uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
266 
267     auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
268     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
269 
270     auto usedSpaceAfter = commandQueue->commandStream->getUsed();
271     ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
272 
273     GenCmdList cmdList;
274     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
275         cmdList, ptrOffset(commandQueue->commandStream->getCpuBase(), 0), usedSpaceAfter));
276 
277     auto sbaItor = find<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
278     ASSERT_NE(cmdList.end(), sbaItor);
279     auto cmdSba = genCmdCast<STATE_BASE_ADDRESS *>(*sbaItor);
280 
281     auto sdiItor = find<MI_STORE_DATA_IMM *>(sbaItor, cmdList.end());
282     ASSERT_NE(cmdList.end(), sdiItor);
283     auto cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
284 
285     uint64_t gsbaGpuVa = cmdSba->getGeneralStateBaseAddress();
286     EXPECT_EQ(static_cast<uint32_t>(gsbaGpuVa & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
287     EXPECT_EQ(static_cast<uint32_t>(gsbaGpuVa >> 32), cmdSdi->getDataDword1());
288 
289     auto expectedGpuVa = GmmHelper::decanonize(device->getL0Debugger()->getSbaTrackingGpuVa()) + offsetof(SbaTrackedAddresses, GeneralStateBaseAddress);
290     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
291 
292     for (auto i = 0u; i < numCommandLists; i++) {
293         auto commandList = CommandList::fromHandle(commandLists[i]);
294         commandList->destroy();
295     }
296     commandQueue->destroy();
297 }
298 
HWTEST_F(L0DebuggerTest,givenDebuggingEnabledAndDebuggerLogsWhenCommandQueueIsSynchronizedThenSbaAddressesArePrinted)299 HWTEST_F(L0DebuggerTest, givenDebuggingEnabledAndDebuggerLogsWhenCommandQueueIsSynchronizedThenSbaAddressesArePrinted) {
300     DebugManagerStateRestore restorer;
301     NEO::DebugManager.flags.DebuggerLogBitmask.set(255);
302 
303     testing::internal::CaptureStdout();
304 
305     ze_command_queue_desc_t queueDesc = {};
306     ze_result_t returnValue;
307     auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
308     ASSERT_NE(nullptr, commandQueue->commandStream);
309 
310     ze_command_list_handle_t commandLists[] = {
311         CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle()};
312     const uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
313 
314     auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
315     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
316 
317     commandQueue->synchronize(0);
318 
319     std::string output = testing::internal::GetCapturedStdout();
320     size_t pos = output.find("INFO: Debugger: SBA stored ssh");
321     EXPECT_NE(std::string::npos, pos);
322 
323     pos = output.find("Debugger: SBA ssh");
324     EXPECT_NE(std::string::npos, pos);
325 
326     auto commandList = CommandList::fromHandle(commandLists[0]);
327     commandList->destroy();
328 
329     commandQueue->destroy();
330 }
331 
332 using L0DebuggerSimpleTest = Test<DeviceFixture>;
333 
HWTEST_F(L0DebuggerSimpleTest,givenNullL0DebuggerAndDebuggerLogsWhenCommandQueueIsSynchronizedThenSbaAddressesAreNotPrinted)334 HWTEST_F(L0DebuggerSimpleTest, givenNullL0DebuggerAndDebuggerLogsWhenCommandQueueIsSynchronizedThenSbaAddressesAreNotPrinted) {
335     DebugManagerStateRestore restorer;
336     NEO::DebugManager.flags.DebuggerLogBitmask.set(255);
337 
338     EXPECT_EQ(nullptr, device->getL0Debugger());
339     testing::internal::CaptureStdout();
340 
341     ze_command_queue_desc_t queueDesc = {};
342     ze_result_t returnValue;
343     auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
344     ASSERT_NE(nullptr, commandQueue->commandStream);
345 
346     ze_command_list_handle_t commandLists[] = {
347         CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle()};
348     const uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
349 
350     auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
351     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
352 
353     commandQueue->synchronize(0);
354 
355     std::string output = testing::internal::GetCapturedStdout();
356     size_t pos = output.find("Debugger: SBA");
357     EXPECT_EQ(std::string::npos, pos);
358 
359     auto commandList = CommandList::fromHandle(commandLists[0]);
360     commandList->destroy();
361 
362     commandQueue->destroy();
363 }
364 
HWTEST_F(L0DebuggerTest,givenL0DebuggerAndDebuggerLogsDisabledWhenCommandQueueIsSynchronizedThenSbaAddressesAreNotPrinted)365 HWTEST_F(L0DebuggerTest, givenL0DebuggerAndDebuggerLogsDisabledWhenCommandQueueIsSynchronizedThenSbaAddressesAreNotPrinted) {
366     DebugManagerStateRestore restorer;
367     NEO::DebugManager.flags.DebuggerLogBitmask.set(0);
368 
369     EXPECT_NE(nullptr, device->getL0Debugger());
370     testing::internal::CaptureStdout();
371 
372     ze_command_queue_desc_t queueDesc = {};
373     ze_result_t returnValue;
374     auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
375     ASSERT_NE(nullptr, commandQueue->commandStream);
376 
377     ze_command_list_handle_t commandLists[] = {
378         CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle()};
379     const uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
380 
381     auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
382     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
383 
384     commandQueue->synchronize(0);
385 
386     std::string output = testing::internal::GetCapturedStdout();
387     size_t pos = output.find("Debugger: SBA");
388     EXPECT_EQ(std::string::npos, pos);
389 
390     auto commandList = CommandList::fromHandle(commandLists[0]);
391     commandList->destroy();
392 
393     commandQueue->destroy();
394 }
395 
HWTEST2_F(L0DebuggerTest,givenDebuggingEnabledWhenNonCopyCommandListIsInititalizedOrResetThenSSHAddressIsTracked,NotGen8Or11)396 HWTEST2_F(L0DebuggerTest, givenDebuggingEnabledWhenNonCopyCommandListIsInititalizedOrResetThenSSHAddressIsTracked, NotGen8Or11) {
397     using STATE_BASE_ADDRESS = typename FamilyType::STATE_BASE_ADDRESS;
398 
399     size_t usedSpaceBefore = 0;
400     ze_result_t returnValue;
401     ze_command_list_handle_t commandListHandle = CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle();
402     auto commandList = CommandList::fromHandle(commandListHandle);
403 
404     auto usedSpaceAfter = commandList->commandContainer.getCommandStream()->getUsed();
405     ASSERT_GT(usedSpaceAfter, usedSpaceBefore);
406 
407     GenCmdList cmdList;
408     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(
409         cmdList, commandList->commandContainer.getCommandStream()->getCpuBase(), usedSpaceAfter));
410 
411     auto sbaItor = find<STATE_BASE_ADDRESS *>(cmdList.begin(), cmdList.end());
412     ASSERT_NE(cmdList.end(), sbaItor);
413     auto cmdSba = genCmdCast<STATE_BASE_ADDRESS *>(*sbaItor);
414 
415     uint64_t sshGpuVa = cmdSba->getSurfaceStateBaseAddress();
416     auto expectedGpuVa = commandList->commandContainer.getIndirectHeap(NEO::HeapType::SURFACE_STATE)->getHeapGpuBase();
417     EXPECT_EQ(expectedGpuVa, sshGpuVa);
418     EXPECT_EQ(1u, getMockDebuggerL0Hw<FamilyType>()->captureStateBaseAddressCount);
419 
420     commandList->reset();
421     EXPECT_EQ(2u, getMockDebuggerL0Hw<FamilyType>()->captureStateBaseAddressCount);
422 
423     commandList->destroy();
424 }
425 
HWTEST_F(L0DebuggerTest,givenDebuggerWhenAppendingKernelToCommandListThenBindlessSurfaceStateForDebugSurfaceIsProgrammedAtOffsetZero)426 HWTEST_F(L0DebuggerTest, givenDebuggerWhenAppendingKernelToCommandListThenBindlessSurfaceStateForDebugSurfaceIsProgrammedAtOffsetZero) {
427     using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
428 
429     Mock<::L0::Kernel> kernel;
430     ze_result_t returnValue;
431     std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
432     ze_group_count_t groupCount{1, 1, 1};
433     auto result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr);
434     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
435 
436     commandList->close();
437 
438     auto *ssh = commandList->commandContainer.getIndirectHeap(NEO::HeapType::SURFACE_STATE);
439 
440     auto debugSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ssh->getCpuBase());
441     auto debugSurface = static_cast<L0::DeviceImp *>(device)->getDebugSurface();
442 
443     SURFACE_STATE_BUFFER_LENGTH length;
444     length.Length = static_cast<uint32_t>(debugSurface->getUnderlyingBufferSize() - 1);
445 
446     EXPECT_EQ(length.SurfaceState.Depth + 1u, debugSurfaceState->getDepth());
447     EXPECT_EQ(length.SurfaceState.Width + 1u, debugSurfaceState->getWidth());
448     EXPECT_EQ(length.SurfaceState.Height + 1u, debugSurfaceState->getHeight());
449     EXPECT_EQ(debugSurface->getGpuAddress(), debugSurfaceState->getSurfaceBaseAddress());
450 
451     EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, debugSurfaceState->getSurfaceType());
452     EXPECT_EQ(RENDER_SURFACE_STATE::COHERENCY_TYPE_GPU_COHERENT, debugSurfaceState->getCoherencyType());
453 }
454 
HWTEST_F(L0DebuggerTest,givenDebuggerWhenAppendingKernelToCommandListThenDebugSurfaceiIsProgrammedWithL3DisabledMOCS)455 HWTEST_F(L0DebuggerTest, givenDebuggerWhenAppendingKernelToCommandListThenDebugSurfaceiIsProgrammedWithL3DisabledMOCS) {
456     using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
457 
458     Mock<::L0::Kernel> kernel;
459     ze_result_t returnValue;
460     std::unique_ptr<L0::CommandList> commandList(L0::CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue));
461     ze_group_count_t groupCount{1, 1, 1};
462     auto result = commandList->appendLaunchKernel(kernel.toHandle(), &groupCount, nullptr, 0, nullptr);
463     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
464 
465     commandList->close();
466 
467     auto *ssh = commandList->commandContainer.getIndirectHeap(NEO::HeapType::SURFACE_STATE);
468     auto debugSurfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(ssh->getCpuBase());
469 
470     const auto mocsNoCache = device->getNEODevice()->getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED) >> 1;
471     const auto actualMocs = debugSurfaceState->getMemoryObjectControlState();
472 
473     EXPECT_EQ(actualMocs, mocsNoCache);
474 }
475 
HWTEST2_F(L0DebuggerTest,givenDebuggingEnabledWhenCommandListIsExecutedThenSbaBufferIsPushedToResidencyContainer,IsAtLeastSkl)476 HWTEST2_F(L0DebuggerTest, givenDebuggingEnabledWhenCommandListIsExecutedThenSbaBufferIsPushedToResidencyContainer, IsAtLeastSkl) {
477     ze_command_queue_desc_t queueDesc = {};
478 
479     std::unique_ptr<MockCommandQueueHw<gfxCoreFamily>, Deleter> commandQueue(new MockCommandQueueHw<gfxCoreFamily>(device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc));
480     commandQueue->initialize(false, false);
481 
482     ze_result_t returnValue;
483     ze_command_list_handle_t commandLists[] = {
484         CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle()};
485     uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
486 
487     auto result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
488     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
489 
490     auto sbaBuffer = device->getL0Debugger()->getSbaTrackingBuffer(neoDevice->getDefaultEngine().commandStreamReceiver->getOsContext().getContextId());
491     bool sbaFound = false;
492 
493     for (auto iter : commandQueue->residencyContainerSnapshot) {
494         if (iter == sbaBuffer) {
495             sbaFound = true;
496         }
497     }
498     EXPECT_TRUE(sbaFound);
499 
500     auto commandList = CommandList::fromHandle(commandLists[0]);
501     commandList->destroy();
502 }
503 
HWTEST_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionEnabledWithImmediateCommandListToInvokeNonKernelOperationsThenSuccessIsReturned)504 HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledWithImmediateCommandListToInvokeNonKernelOperationsThenSuccessIsReturned) {
505     DebugManagerStateRestore restorer;
506     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(true);
507 
508     void *dstPtr = nullptr;
509     ze_device_mem_alloc_desc_t deviceDesc = {};
510     ze_host_mem_alloc_desc_t hostDesc = {};
511     auto result = context->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, 16384u, 4096u, &dstPtr);
512     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
513 
514     ze_command_queue_desc_t desc = {};
515     desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
516     ze_result_t returnValue;
517     std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue));
518     ASSERT_NE(nullptr, commandList);
519 
520     EXPECT_EQ(device, commandList->device);
521     EXPECT_EQ(1u, commandList->cmdListType);
522     EXPECT_NE(nullptr, commandList->cmdQImmediate);
523 
524     ze_event_pool_desc_t eventPoolDesc = {};
525     eventPoolDesc.count = 1;
526     eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE | ZE_EVENT_POOL_FLAG_KERNEL_TIMESTAMP;
527 
528     ze_event_desc_t eventDesc = {};
529     eventDesc.index = 0;
530     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
531     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
532 
533     ze_event_handle_t event = nullptr;
534 
535     std::unique_ptr<L0::EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, returnValue));
536     EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
537     ASSERT_NE(nullptr, eventPool);
538 
539     eventPool->createEvent(&eventDesc, &event);
540 
541     std::unique_ptr<L0::Event> event_object(L0::Event::fromHandle(event));
542     ASSERT_NE(nullptr, event_object->csr);
543     ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, event_object->csr);
544 
545     returnValue = commandList->appendWaitOnEvents(1, &event);
546     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
547 
548     returnValue = commandList->appendBarrier(nullptr, 1, &event);
549     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
550 
551     returnValue = commandList->appendSignalEvent(event);
552     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
553 
554     returnValue = event_object->hostSignal();
555     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
556     EXPECT_EQ(event_object->queryStatus(), ZE_RESULT_SUCCESS);
557 
558     returnValue = commandList->appendWriteGlobalTimestamp(reinterpret_cast<uint64_t *>(dstPtr), nullptr, 0, nullptr);
559     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
560 
561     returnValue = commandList->appendEventReset(event);
562     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
563 
564     context->freeMem(dstPtr);
565 }
566 
HWTEST_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionDisabledWithImmediateCommandListToInvokeNonKernelOperationsThenSuccessIsReturned)567 HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionDisabledWithImmediateCommandListToInvokeNonKernelOperationsThenSuccessIsReturned) {
568     DebugManagerStateRestore restorer;
569     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(false);
570 
571     void *dstPtr = nullptr;
572     ze_device_mem_alloc_desc_t deviceDesc = {};
573     ze_host_mem_alloc_desc_t hostDesc = {};
574     auto result = context->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, 16384u, 4096u, &dstPtr);
575     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
576 
577     ze_command_queue_desc_t desc = {};
578     desc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
579     ze_result_t returnValue;
580     std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(productFamily, device, &desc, false, NEO::EngineGroupType::RenderCompute, returnValue));
581     ASSERT_NE(nullptr, commandList);
582 
583     EXPECT_EQ(device, commandList->device);
584     EXPECT_EQ(1u, commandList->cmdListType);
585     EXPECT_NE(nullptr, commandList->cmdQImmediate);
586 
587     ze_event_pool_desc_t eventPoolDesc = {};
588     eventPoolDesc.count = 1;
589     eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
590 
591     ze_event_desc_t eventDesc = {};
592     eventDesc.index = 0;
593     eventDesc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
594     eventDesc.wait = ZE_EVENT_SCOPE_FLAG_HOST;
595 
596     ze_event_handle_t event = nullptr;
597 
598     std::unique_ptr<L0::EventPool> eventPool(EventPool::create(driverHandle.get(), context, 0, nullptr, &eventPoolDesc, returnValue));
599     EXPECT_EQ(ZE_RESULT_SUCCESS, returnValue);
600     ASSERT_NE(nullptr, eventPool);
601 
602     eventPool->createEvent(&eventDesc, &event);
603 
604     std::unique_ptr<L0::Event> event_object(L0::Event::fromHandle(event));
605     ASSERT_NE(nullptr, event_object->csr);
606     ASSERT_EQ(static_cast<DeviceImp *>(device)->getNEODevice()->getDefaultEngine().commandStreamReceiver, event_object->csr);
607 
608     returnValue = commandList->appendWaitOnEvents(1, &event);
609     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
610 
611     returnValue = commandList->appendBarrier(nullptr, 1, &event);
612     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
613 
614     returnValue = commandList->appendSignalEvent(event);
615     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
616 
617     returnValue = event_object->hostSignal();
618     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
619     EXPECT_EQ(event_object->queryStatus(), ZE_RESULT_SUCCESS);
620 
621     returnValue = commandList->appendWriteGlobalTimestamp(reinterpret_cast<uint64_t *>(dstPtr), nullptr, 0, nullptr);
622     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
623 
624     returnValue = commandList->appendEventReset(event);
625     EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
626 
627     context->freeMem(dstPtr);
628 }
629 
HWTEST_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionEnabledForImmediateCommandListForAppendMemoryFillWithDeviceMemoryThenSuccessIsReturned)630 HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledForImmediateCommandListForAppendMemoryFillWithDeviceMemoryThenSuccessIsReturned) {
631     DebugManagerStateRestore restorer;
632     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(true);
633 
634     void *dstPtr = nullptr;
635     ze_device_mem_alloc_desc_t deviceDesc = {};
636     auto result = context->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &dstPtr);
637     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
638     int pattern = 1;
639 
640     ze_command_queue_desc_t queueDesc = {};
641     queueDesc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
642     ze_result_t returnValue = ZE_RESULT_SUCCESS;
643     auto commandList = CommandList::createImmediate(productFamily, device, &queueDesc, true, NEO::EngineGroupType::RenderCompute, returnValue);
644 
645     result = commandList->appendMemoryFill(dstPtr, reinterpret_cast<void *>(&pattern), sizeof(pattern), 4096u, nullptr, 0, nullptr);
646     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
647 
648     context->freeMem(dstPtr);
649     commandList->destroy();
650 }
651 
HWTEST_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionEnabledForImmediateCommandListForAppendMemoryFillThenSuccessIsReturned)652 HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledForImmediateCommandListForAppendMemoryFillThenSuccessIsReturned) {
653     DebugManagerStateRestore restorer;
654     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(true);
655 
656     void *dstPtr = nullptr;
657     ze_device_mem_alloc_desc_t deviceDesc = {};
658     ze_host_mem_alloc_desc_t hostDesc = {};
659     auto result = context->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, 16384u, 4096u, &dstPtr);
660     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
661     int pattern = 1;
662 
663     ze_command_queue_desc_t queueDesc = {};
664     queueDesc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
665     ze_result_t returnValue = ZE_RESULT_SUCCESS;
666     auto commandList = CommandList::createImmediate(productFamily, device, &queueDesc, true, NEO::EngineGroupType::RenderCompute, returnValue);
667 
668     result = commandList->appendMemoryFill(dstPtr, reinterpret_cast<void *>(&pattern), sizeof(pattern), 4096u, nullptr, 0, nullptr);
669     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
670 
671     context->freeMem(dstPtr);
672     commandList->destroy();
673 }
674 
HWTEST_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionDisabledForImmediateCommandListForAppendMemoryFillThenSuccessIsReturned)675 HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionDisabledForImmediateCommandListForAppendMemoryFillThenSuccessIsReturned) {
676     DebugManagerStateRestore restorer;
677     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(false);
678 
679     void *dstPtr = nullptr;
680     ze_device_mem_alloc_desc_t deviceDesc = {};
681     ze_host_mem_alloc_desc_t hostDesc = {};
682     auto result = context->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, 16384u, 4096u, &dstPtr);
683     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
684     int pattern = 1;
685 
686     ze_command_queue_desc_t queueDesc = {};
687     queueDesc.mode = ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS;
688     ze_result_t returnValue = ZE_RESULT_SUCCESS;
689     auto commandList = CommandList::createImmediate(productFamily, device, &queueDesc, true, NEO::EngineGroupType::RenderCompute, returnValue);
690 
691     result = commandList->appendMemoryFill(dstPtr, reinterpret_cast<void *>(&pattern), sizeof(pattern), 4096u, nullptr, 0, nullptr);
692     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
693 
694     context->freeMem(dstPtr);
695     commandList->destroy();
696 }
697 
HWTEST_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionEnabledForRegularCommandListForAppendMemoryFillThenSuccessIsReturned)698 HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledForRegularCommandListForAppendMemoryFillThenSuccessIsReturned) {
699     DebugManagerStateRestore restorer;
700     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(true);
701 
702     ze_command_queue_desc_t queueDesc = {};
703     ze_result_t returnValue;
704     auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
705     ASSERT_NE(nullptr, commandQueue->commandStream);
706 
707     ze_command_list_handle_t commandLists[] = {
708         CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle()};
709     const uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
710 
711     void *dstPtr = nullptr;
712     ze_device_mem_alloc_desc_t deviceDesc = {};
713     auto result = context->allocDeviceMem(device->toHandle(), &deviceDesc, 16384u, 4096u, &dstPtr);
714     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
715     int pattern = 1;
716 
717     auto commandList = CommandList::fromHandle(commandLists[0]);
718     result = commandList->appendMemoryFill(dstPtr, reinterpret_cast<void *>(&pattern), sizeof(pattern), 4096u, nullptr, 0, nullptr);
719     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
720 
721     result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
722     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
723 
724     commandQueue->synchronize(0);
725 
726     context->freeMem(dstPtr);
727     commandList->destroy();
728 
729     commandQueue->destroy();
730 }
731 
HWTEST_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionDisabledForRegularCommandListForAppendMemoryFillThenSuccessIsReturned)732 HWTEST_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionDisabledForRegularCommandListForAppendMemoryFillThenSuccessIsReturned) {
733     DebugManagerStateRestore restorer;
734     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(false);
735 
736     ze_command_queue_desc_t queueDesc = {};
737     ze_result_t returnValue;
738     auto commandQueue = whitebox_cast(CommandQueue::create(productFamily, device, neoDevice->getDefaultEngine().commandStreamReceiver, &queueDesc, false, false, returnValue));
739     ASSERT_NE(nullptr, commandQueue->commandStream);
740 
741     ze_command_list_handle_t commandLists[] = {
742         CommandList::create(productFamily, device, NEO::EngineGroupType::RenderCompute, 0u, returnValue)->toHandle()};
743     const uint32_t numCommandLists = sizeof(commandLists) / sizeof(commandLists[0]);
744 
745     void *dstPtr = nullptr;
746     ze_device_mem_alloc_desc_t deviceDesc = {};
747     ze_host_mem_alloc_desc_t hostDesc = {};
748     auto result = context->allocSharedMem(device->toHandle(), &deviceDesc, &hostDesc, 16384u, 4096u, &dstPtr);
749     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
750     int pattern = 1;
751 
752     auto commandList = CommandList::fromHandle(commandLists[0]);
753     result = commandList->appendMemoryFill(dstPtr, reinterpret_cast<void *>(&pattern), sizeof(pattern), 4096u, nullptr, 0, nullptr);
754     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
755 
756     result = commandQueue->executeCommandLists(numCommandLists, commandLists, nullptr, true);
757     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
758 
759     commandQueue->synchronize(0);
760 
761     context->freeMem(dstPtr);
762     commandList->destroy();
763 
764     commandQueue->destroy();
765 }
766 
HWTEST2_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionEnabledCommandListAndAppendPageFaultCopyThenSuccessIsReturned,IsAtLeastSkl)767 HWTEST2_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionEnabledCommandListAndAppendPageFaultCopyThenSuccessIsReturned, IsAtLeastSkl) {
768     DebugManagerStateRestore restorer;
769     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(true);
770 
771     size_t size = (sizeof(uint32_t) * 4);
772     ze_command_queue_desc_t queueDesc = {};
773     ze_result_t returnValue = ZE_RESULT_SUCCESS;
774     auto commandList = CommandList::createImmediate(productFamily, device, &queueDesc, true, NEO::EngineGroupType::RenderCompute, returnValue);
775     ASSERT_NE(nullptr, commandList);
776 
777     NEO::GraphicsAllocation srcPtr(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
778                                    reinterpret_cast<void *>(0x1234), size, 0, sizeof(uint32_t),
779                                    MemoryPool::System4KBPages);
780     NEO::GraphicsAllocation dstPtr(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
781                                    reinterpret_cast<void *>(0x2345), size, 0, sizeof(uint32_t),
782                                    MemoryPool::System4KBPages);
783 
784     auto result = commandList->appendPageFaultCopy(&dstPtr, &srcPtr, 0x100, false);
785     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
786 
787     commandList->destroy();
788 }
789 
HWTEST2_F(L0DebuggerSimpleTest,givenUseCsrImmediateSubmissionDisabledCommandListAndAppendPageFaultCopyThenSuccessIsReturned,IsAtLeastSkl)790 HWTEST2_F(L0DebuggerSimpleTest, givenUseCsrImmediateSubmissionDisabledCommandListAndAppendPageFaultCopyThenSuccessIsReturned, IsAtLeastSkl) {
791     DebugManagerStateRestore restorer;
792     NEO::DebugManager.flags.EnableFlushTaskSubmission.set(false);
793 
794     size_t size = (sizeof(uint32_t) * 4);
795     ze_command_queue_desc_t queueDesc = {};
796     ze_result_t returnValue = ZE_RESULT_SUCCESS;
797     auto commandList = CommandList::createImmediate(productFamily, device, &queueDesc, true, NEO::EngineGroupType::RenderCompute, returnValue);
798     ASSERT_NE(nullptr, commandList);
799 
800     NEO::GraphicsAllocation srcPtr(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
801                                    reinterpret_cast<void *>(0x1234), size, 0, sizeof(uint32_t),
802                                    MemoryPool::System4KBPages);
803     NEO::GraphicsAllocation dstPtr(0, NEO::GraphicsAllocation::AllocationType::INTERNAL_HOST_MEMORY,
804                                    reinterpret_cast<void *>(0x2345), size, 0, sizeof(uint32_t),
805                                    MemoryPool::System4KBPages);
806 
807     auto result = commandList->appendPageFaultCopy(&dstPtr, &srcPtr, 0x100, false);
808     ASSERT_EQ(ZE_RESULT_SUCCESS, result);
809 
810     commandList->destroy();
811 }
812 
HWTEST_F(L0DebuggerSimpleTest,givenNonZeroGpuVasWhenProgrammingSbaTrackingThenCorrectCmdsAreAddedToStream)813 HWTEST_F(L0DebuggerSimpleTest, givenNonZeroGpuVasWhenProgrammingSbaTrackingThenCorrectCmdsAreAddedToStream) {
814     using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
815     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
816 
817     debugger->sbaTrackingGpuVa.address = 0x45670000;
818     auto expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, GeneralStateBaseAddress);
819 
820     StackVec<char, 4096> buffer(4096);
821     NEO::LinearStream cmdStream(buffer.begin(), buffer.size());
822     uint64_t gsba = 0x60000;
823     uint64_t ssba = 0x1234567000;
824     uint64_t iba = 0xfff80000;
825     uint64_t ioba = 0x8100000;
826     uint64_t dsba = 0xffff0000aaaa0000;
827 
828     NEO::Debugger::SbaAddresses sbaAddresses = {};
829     sbaAddresses.GeneralStateBaseAddress = gsba;
830     sbaAddresses.SurfaceStateBaseAddress = ssba;
831     sbaAddresses.InstructionBaseAddress = iba;
832     sbaAddresses.IndirectObjectBaseAddress = ioba;
833     sbaAddresses.DynamicStateBaseAddress = dsba;
834     sbaAddresses.BindlessSurfaceStateBaseAddress = ssba;
835 
836     debugger->programSbaTrackingCommands(cmdStream, sbaAddresses);
837 
838     GenCmdList cmdList;
839     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
840 
841     EXPECT_EQ(6 * sizeof(MI_STORE_DATA_IMM), cmdStream.getUsed());
842 
843     auto sdiItor = find<MI_STORE_DATA_IMM *>(cmdList.begin(), cmdList.end());
844     ASSERT_NE(cmdList.end(), sdiItor);
845     auto cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
846 
847     EXPECT_EQ(static_cast<uint32_t>(gsba & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
848     EXPECT_EQ(static_cast<uint32_t>(gsba >> 32), cmdSdi->getDataDword1());
849     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
850     EXPECT_TRUE(cmdSdi->getStoreQword());
851 
852     sdiItor++;
853     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
854 
855     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, SurfaceStateBaseAddress);
856     EXPECT_EQ(static_cast<uint32_t>(ssba & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
857     EXPECT_EQ(static_cast<uint32_t>(ssba >> 32), cmdSdi->getDataDword1());
858     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
859     EXPECT_TRUE(cmdSdi->getStoreQword());
860 
861     sdiItor++;
862     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
863 
864     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, DynamicStateBaseAddress);
865 
866     auto decanonizedAddress = GmmHelper::decanonize(dsba);
867     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
868     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
869     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
870     EXPECT_TRUE(cmdSdi->getStoreQword());
871 
872     sdiItor++;
873     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
874 
875     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, IndirectObjectBaseAddress);
876     EXPECT_EQ(static_cast<uint32_t>(ioba & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
877     EXPECT_EQ(static_cast<uint32_t>(ioba >> 32), cmdSdi->getDataDword1());
878     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
879     EXPECT_TRUE(cmdSdi->getStoreQword());
880 
881     sdiItor++;
882     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
883 
884     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, InstructionBaseAddress);
885     EXPECT_EQ(static_cast<uint32_t>(iba & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
886     EXPECT_EQ(static_cast<uint32_t>(iba >> 32), cmdSdi->getDataDword1());
887     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
888     EXPECT_TRUE(cmdSdi->getStoreQword());
889 
890     sdiItor++;
891     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
892 
893     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, BindlessSurfaceStateBaseAddress);
894     EXPECT_EQ(static_cast<uint32_t>(ssba & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
895     EXPECT_EQ(static_cast<uint32_t>(ssba >> 32), cmdSdi->getDataDword1());
896     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
897     EXPECT_TRUE(cmdSdi->getStoreQword());
898 }
899 
HWTEST_F(L0DebuggerSimpleTest,givenCanonizedGpuVasWhenProgrammingSbaTrackingThenNonCanonicalAddressesAreStored)900 HWTEST_F(L0DebuggerSimpleTest, givenCanonizedGpuVasWhenProgrammingSbaTrackingThenNonCanonicalAddressesAreStored) {
901     using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
902     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
903 
904     debugger->sbaTrackingGpuVa.address = 0x45670000;
905     auto expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, GeneralStateBaseAddress);
906 
907     StackVec<char, 4096> buffer(4096);
908     NEO::LinearStream cmdStream(buffer.begin(), buffer.size());
909     uint64_t gsba = 0xffff800000060000;
910     uint64_t ssba = 0xffff801234567000;
911     uint64_t iba = 0xffff8000fff80000;
912     uint64_t ioba = 0xffff800008100000;
913     uint64_t dsba = 0xffff8000aaaa0000;
914 
915     NEO::Debugger::SbaAddresses sbaAddresses = {};
916     sbaAddresses.GeneralStateBaseAddress = gsba;
917     sbaAddresses.SurfaceStateBaseAddress = ssba;
918     sbaAddresses.InstructionBaseAddress = iba;
919     sbaAddresses.IndirectObjectBaseAddress = ioba;
920     sbaAddresses.DynamicStateBaseAddress = dsba;
921     sbaAddresses.BindlessSurfaceStateBaseAddress = ssba;
922 
923     debugger->programSbaTrackingCommands(cmdStream, sbaAddresses);
924 
925     GenCmdList cmdList;
926     ASSERT_TRUE(FamilyType::PARSE::parseCommandBuffer(cmdList, cmdStream.getCpuBase(), cmdStream.getUsed()));
927 
928     EXPECT_EQ(6 * sizeof(MI_STORE_DATA_IMM), cmdStream.getUsed());
929 
930     auto sdiItor = find<MI_STORE_DATA_IMM *>(cmdList.begin(), cmdList.end());
931     ASSERT_NE(cmdList.end(), sdiItor);
932     auto cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
933 
934     auto decanonizedAddress = GmmHelper::decanonize(gsba);
935     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
936     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
937     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
938     EXPECT_TRUE(cmdSdi->getStoreQword());
939 
940     sdiItor++;
941     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
942 
943     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, SurfaceStateBaseAddress);
944     decanonizedAddress = GmmHelper::decanonize(ssba);
945     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
946     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
947     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
948     EXPECT_TRUE(cmdSdi->getStoreQword());
949 
950     sdiItor++;
951     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
952 
953     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, DynamicStateBaseAddress);
954     decanonizedAddress = GmmHelper::decanonize(dsba);
955     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
956     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
957     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
958     EXPECT_TRUE(cmdSdi->getStoreQword());
959 
960     sdiItor++;
961     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
962 
963     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, IndirectObjectBaseAddress);
964     decanonizedAddress = GmmHelper::decanonize(ioba);
965     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
966     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
967     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
968     EXPECT_TRUE(cmdSdi->getStoreQword());
969 
970     sdiItor++;
971     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
972 
973     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, InstructionBaseAddress);
974     decanonizedAddress = GmmHelper::decanonize(iba);
975     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
976     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
977     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
978     EXPECT_TRUE(cmdSdi->getStoreQword());
979 
980     sdiItor++;
981     cmdSdi = genCmdCast<MI_STORE_DATA_IMM *>(*sdiItor);
982 
983     expectedGpuVa = debugger->sbaTrackingGpuVa.address + offsetof(SbaTrackedAddresses, BindlessSurfaceStateBaseAddress);
984     decanonizedAddress = GmmHelper::decanonize(ssba);
985     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress & 0x0000FFFFFFFFULL), cmdSdi->getDataDword0());
986     EXPECT_EQ(static_cast<uint32_t>(decanonizedAddress >> 32), cmdSdi->getDataDword1());
987     EXPECT_EQ(expectedGpuVa, cmdSdi->getAddress());
988     EXPECT_TRUE(cmdSdi->getStoreQword());
989 }
990 
HWTEST_F(L0DebuggerSimpleTest,givenZeroGpuVasWhenProgrammingSbaTrackingThenStreamIsNotUsed)991 HWTEST_F(L0DebuggerSimpleTest, givenZeroGpuVasWhenProgrammingSbaTrackingThenStreamIsNotUsed) {
992     using MI_STORE_DATA_IMM = typename FamilyType::MI_STORE_DATA_IMM;
993     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
994 
995     debugger->sbaTrackingGpuVa.address = 0x45670000;
996 
997     StackVec<char, 4096> buffer(4096);
998     NEO::LinearStream cmdStream(buffer.begin(), buffer.size());
999     uint64_t gsba = 0;
1000     uint64_t ssba = 0;
1001 
1002     NEO::Debugger::SbaAddresses sbaAddresses = {};
1003     sbaAddresses.GeneralStateBaseAddress = gsba;
1004     sbaAddresses.SurfaceStateBaseAddress = ssba;
1005 
1006     debugger->programSbaTrackingCommands(cmdStream, sbaAddresses);
1007 
1008     EXPECT_EQ(0u, cmdStream.getUsed());
1009 }
1010 
HWTEST_F(L0DebuggerSimpleTest,whenAllocateCalledThenDebuggerIsCreated)1011 HWTEST_F(L0DebuggerSimpleTest, whenAllocateCalledThenDebuggerIsCreated) {
1012     auto debugger = DebuggerL0Hw<FamilyType>::allocate(neoDevice);
1013     EXPECT_NE(nullptr, debugger);
1014     delete debugger;
1015 }
1016 
HWTEST_F(L0DebuggerSimpleTest,givenNotChangedSurfaceStateWhenCapturingSBAThenNoTrackingCmdsAreAdded)1017 HWTEST_F(L0DebuggerSimpleTest, givenNotChangedSurfaceStateWhenCapturingSBAThenNoTrackingCmdsAreAdded) {
1018     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
1019 
1020     debugger->sbaTrackingGpuVa.address = 0x45670000;
1021 
1022     NEO::CommandContainer container;
1023     container.initialize(neoDevice, nullptr);
1024 
1025     NEO::Debugger::SbaAddresses sba = {};
1026     sba.SurfaceStateBaseAddress = 0x123456000;
1027 
1028     debugger->captureStateBaseAddress(container, sba);
1029     auto sizeUsed = container.getCommandStream()->getUsed();
1030 
1031     EXPECT_NE(0u, sizeUsed);
1032     sba.SurfaceStateBaseAddress = 0;
1033 
1034     debugger->captureStateBaseAddress(container, sba);
1035     auto sizeUsed2 = container.getCommandStream()->getUsed();
1036 
1037     EXPECT_EQ(sizeUsed, sizeUsed2);
1038 }
1039 
HWTEST_F(L0DebuggerSimpleTest,givenChangedBaseAddressesWhenCapturingSBAThenNoTrackingCmdsAreAdded)1040 HWTEST_F(L0DebuggerSimpleTest, givenChangedBaseAddressesWhenCapturingSBAThenNoTrackingCmdsAreAdded) {
1041     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
1042 
1043     debugger->sbaTrackingGpuVa.address = 0x45670000;
1044     {
1045         NEO::CommandContainer container;
1046         container.initialize(neoDevice, nullptr);
1047 
1048         NEO::Debugger::SbaAddresses sba = {};
1049         sba.SurfaceStateBaseAddress = 0x123456000;
1050 
1051         debugger->captureStateBaseAddress(container, sba);
1052         auto sizeUsed = container.getCommandStream()->getUsed();
1053 
1054         EXPECT_NE(0u, sizeUsed);
1055     }
1056 
1057     {
1058         NEO::CommandContainer container;
1059         container.initialize(neoDevice, nullptr);
1060 
1061         NEO::Debugger::SbaAddresses sba = {};
1062         sba.GeneralStateBaseAddress = 0x123456000;
1063 
1064         debugger->captureStateBaseAddress(container, sba);
1065         auto sizeUsed = container.getCommandStream()->getUsed();
1066 
1067         EXPECT_NE(0u, sizeUsed);
1068     }
1069 
1070     {
1071         NEO::CommandContainer container;
1072         container.initialize(neoDevice, nullptr);
1073 
1074         NEO::Debugger::SbaAddresses sba = {};
1075         sba.BindlessSurfaceStateBaseAddress = 0x123456000;
1076 
1077         debugger->captureStateBaseAddress(container, sba);
1078         auto sizeUsed = container.getCommandStream()->getUsed();
1079 
1080         EXPECT_NE(0u, sizeUsed);
1081     }
1082 }
1083 
HWTEST_F(L0DebuggerTest,givenDebuggerWhenCreatedThenModuleHeapDebugAreaIsCreated)1084 HWTEST_F(L0DebuggerTest, givenDebuggerWhenCreatedThenModuleHeapDebugAreaIsCreated) {
1085     auto mockBlitMemoryToAllocation = [](const NEO::Device &device, NEO::GraphicsAllocation *memory, size_t offset, const void *hostPtr,
1086                                          Vec3<size_t> size) -> NEO::BlitOperationResult {
1087         memcpy(memory->getUnderlyingBuffer(), hostPtr, size.x);
1088         return BlitOperationResult::Success;
1089     };
1090     VariableBackup<NEO::BlitHelperFunctions::BlitMemoryToAllocationFunc> blitMemoryToAllocationFuncBackup(
1091         &NEO::BlitHelperFunctions::blitMemoryToAllocation, mockBlitMemoryToAllocation);
1092 
1093     memoryOperationsHandler->makeResidentCalledCount = 0;
1094     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
1095     auto debugArea = debugger->getModuleDebugArea();
1096 
1097     EXPECT_EQ(1, memoryOperationsHandler->makeResidentCalledCount);
1098 
1099     auto allocation = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(
1100         {neoDevice->getRootDeviceIndex(), 4096, NEO::GraphicsAllocation::AllocationType::KERNEL_ISA, neoDevice->getDeviceBitfield()});
1101 
1102     EXPECT_EQ(allocation->storageInfo.getMemoryBanks(), debugArea->storageInfo.getMemoryBanks());
1103 
1104     DebugAreaHeader *header = reinterpret_cast<DebugAreaHeader *>(debugArea->getUnderlyingBuffer());
1105     EXPECT_EQ(1u, header->pgsize);
1106     uint64_t isShared = debugArea->storageInfo.getNumBanks() == 1 ? 1 : 0;
1107     EXPECT_EQ(isShared, header->isShared);
1108 
1109     EXPECT_STREQ("dbgarea", header->magic);
1110     EXPECT_EQ(sizeof(DebugAreaHeader), header->size);
1111     EXPECT_EQ(sizeof(DebugAreaHeader), header->scratchBegin);
1112     EXPECT_EQ(MemoryConstants::pageSize64k - sizeof(DebugAreaHeader), header->scratchEnd);
1113 
1114     neoDevice->getMemoryManager()->freeGraphicsMemory(allocation);
1115 }
1116 
HWTEST_F(L0DebuggerTest,givenBindlessSipWhenModuleHeapDebugAreaIsCreatedThenReservedFieldIsSet)1117 HWTEST_F(L0DebuggerTest, givenBindlessSipWhenModuleHeapDebugAreaIsCreatedThenReservedFieldIsSet) {
1118     DebugManagerStateRestore restorer;
1119     NEO::DebugManager.flags.UseBindlessDebugSip.set(1);
1120 
1121     auto mockBlitMemoryToAllocation = [](const NEO::Device &device, NEO::GraphicsAllocation *memory, size_t offset, const void *hostPtr,
1122                                          Vec3<size_t> size) -> NEO::BlitOperationResult {
1123         memcpy(memory->getUnderlyingBuffer(), hostPtr, size.x);
1124         return BlitOperationResult::Success;
1125     };
1126     VariableBackup<NEO::BlitHelperFunctions::BlitMemoryToAllocationFunc> blitMemoryToAllocationFuncBackup(
1127         &NEO::BlitHelperFunctions::blitMemoryToAllocation, mockBlitMemoryToAllocation);
1128 
1129     memoryOperationsHandler->makeResidentCalledCount = 0;
1130     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
1131     auto debugArea = debugger->getModuleDebugArea();
1132 
1133     DebugAreaHeader *header = reinterpret_cast<DebugAreaHeader *>(debugArea->getUnderlyingBuffer());
1134     EXPECT_EQ(1u, header->reserved1);
1135 }
1136 
HWTEST_F(L0DebuggerTest,givenBindfulSipWhenModuleHeapDebugAreaIsCreatedThenReservedFieldIsNotSet)1137 HWTEST_F(L0DebuggerTest, givenBindfulSipWhenModuleHeapDebugAreaIsCreatedThenReservedFieldIsNotSet) {
1138     DebugManagerStateRestore restorer;
1139     NEO::DebugManager.flags.UseBindlessDebugSip.set(0);
1140 
1141     auto mockBlitMemoryToAllocation = [](const NEO::Device &device, NEO::GraphicsAllocation *memory, size_t offset, const void *hostPtr,
1142                                          Vec3<size_t> size) -> NEO::BlitOperationResult {
1143         memcpy(memory->getUnderlyingBuffer(), hostPtr, size.x);
1144         return BlitOperationResult::Success;
1145     };
1146     VariableBackup<NEO::BlitHelperFunctions::BlitMemoryToAllocationFunc> blitMemoryToAllocationFuncBackup(
1147         &NEO::BlitHelperFunctions::blitMemoryToAllocation, mockBlitMemoryToAllocation);
1148 
1149     memoryOperationsHandler->makeResidentCalledCount = 0;
1150     auto debugger = std::make_unique<MockDebuggerL0Hw<FamilyType>>(neoDevice);
1151     auto debugArea = debugger->getModuleDebugArea();
1152 
1153     DebugAreaHeader *header = reinterpret_cast<DebugAreaHeader *>(debugArea->getUnderlyingBuffer());
1154     EXPECT_EQ(0u, header->reserved1);
1155 }
1156 
TEST(Debugger,givenNonLegacyDebuggerWhenInitializingDeviceCapsThenUnrecoverableIsCalled)1157 TEST(Debugger, givenNonLegacyDebuggerWhenInitializingDeviceCapsThenUnrecoverableIsCalled) {
1158     class MockDebugger : public NEO::Debugger {
1159       public:
1160         MockDebugger() {
1161             isLegacyMode = false;
1162         }
1163 
1164         void captureStateBaseAddress(CommandContainer &container, SbaAddresses sba) override{};
1165     };
1166     auto executionEnvironment = new NEO::ExecutionEnvironment();
1167     auto mockBuiltIns = new MockBuiltins();
1168     executionEnvironment->prepareRootDeviceEnvironments(1);
1169     executionEnvironment->rootDeviceEnvironments[0]->builtins.reset(mockBuiltIns);
1170     executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
1171 
1172     auto debugger = new MockDebugger;
1173     executionEnvironment->rootDeviceEnvironments[0]->debugger.reset(debugger);
1174     executionEnvironment->initializeMemoryManager();
1175 
1176     EXPECT_THROW(NEO::MockDevice::create<NEO::MockDevice>(executionEnvironment, 0u), std::exception);
1177 }
1178 
1179 using NotATSOrDG2 = AreNotGfxCores<IGFX_XE_HP_CORE, IGFX_XE_HPG_CORE>;
HWTEST2_F(L0DebuggerTest,givenNotAtsOrDg2AndDebugIsActiveThenDisableL3CacheInGmmHelperIsNotSet,NotATSOrDG2)1180 HWTEST2_F(L0DebuggerTest, givenNotAtsOrDg2AndDebugIsActiveThenDisableL3CacheInGmmHelperIsNotSet, NotATSOrDG2) {
1181     EXPECT_FALSE(static_cast<MockGmmHelper *>(neoDevice->getGmmHelper())->l3CacheForDebugDisabled);
1182 }
1183 
1184 using ATSOrDG2 = IsWithinGfxCore<IGFX_XE_HP_CORE, IGFX_XE_HPG_CORE>;
HWTEST2_F(L0DebuggerTest,givenAtsOrDg2AndDebugIsActiveThenDisableL3CacheInGmmHelperIsSet,ATSOrDG2)1185 HWTEST2_F(L0DebuggerTest, givenAtsOrDg2AndDebugIsActiveThenDisableL3CacheInGmmHelperIsSet, ATSOrDG2) {
1186     EXPECT_TRUE(static_cast<MockGmmHelper *>(neoDevice->getGmmHelper())->l3CacheForDebugDisabled);
1187 }
1188 } // namespace ult
1189 } // namespace L0
1190