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