Debian Codegraph @

level_zero/tools/test/unit_tests/sources/debug/debug_session_tests.cpp

raw
1 /*
2 * Copyright (C) 2021-2026 Intel Corporation
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 */
7
8 #include "shared/source/helpers/gfx_core_helper.h"
9 #include "shared/source/sip_external_lib/sip_external_lib.h"
10 #include "shared/test/common/libult/global_environment.h"
11 #include "shared/test/common/mocks/mock_device.h"
12 #include "shared/test/common/mocks/mock_gmm_helper.h"
13 #include "shared/test/common/mocks/mock_product_helper.h"
14 #include "shared/test/common/mocks/mock_sip.h"
15 #include "shared/test/common/mocks/mock_sip_external_lib.h"
16 #include "shared/test/common/mocks/ult_device_factory.h"
17 #include "shared/test/common/test_macros/hw_test.h"
18
19 #include "level_zero/core/source/device/device.h"
20 #include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
21 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
22 #include "level_zero/core/test/unit_tests/mocks/mock_built_ins.h"
23 #include "level_zero/core/test/unit_tests/mocks/mock_device.h"
24 #include "level_zero/tools/source/debug/debug_session_imp.h"
25 #include "level_zero/tools/test/unit_tests/sources/debug/debug_session_registers_access.h"
26 #include "level_zero/tools/test/unit_tests/sources/debug/mock_debug_session.h"
27 #include "level_zero/zet_intel_gpu_debug.h"
28
29 #include "StateSaveAreaHeaderWrapper.h"
30 #include "encode_surface_state_args.h"
31
32 #include <list>
33
34 namespace NEO {
35 extern std::map<std::string, std::stringstream> virtualFileList;
36 }
37
38 namespace L0 {
39 namespace ult {
40
41 TEST(DebugSessionTest, GivenValidArgsWhenReadSipMemoryCalledThenReturnsSizeAndReadsMemory) {
42 zet_debug_config_t config = {};
43 config.pid = 0x1234;
44 auto hwInfo = *NEO::defaultHwInfo.get();
45 ze_result_t returnValue = ZE_RESULT_SUCCESS;
46 std::unique_ptr<DriverHandle> driverHandle(new DriverHandle);
47 auto neoDevice = std::unique_ptr<NEO::Device>(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
48 auto device = std::unique_ptr<L0::Device>(Device::create(driverHandle.get(), neoDevice.release(), false, &returnValue));
49 ASSERT_NE(nullptr, device);
50 auto sessionMock = std::make_unique<MockDebugSession>(config, device.get());
51
52 DebugSessionImp::SipMemoryAccessArgs args = {};
53 args.debugSession = sessionMock.get();
54 args.contextHandle = 0x1234;
55 args.gpuVa = 0x1000;
56
57 constexpr uint32_t size = 16;
58 char destination[size] = {};
59 sessionMock->readGpuMemoryCallCount = 0;
60
61 uint32_t ret = DebugSessionImp::readSipMemory(&args, 0x10, size, destination);
62 EXPECT_EQ(size, ret);
63 EXPECT_EQ(1u, sessionMock->readGpuMemoryCallCount);
64 }
65
66 TEST(DebugSessionTest, GivenReadGpuMemoryFailsWhenReadSipMemoryCalledThenReturnsZero) {
67 zet_debug_config_t config = {};
68 config.pid = 0x1234;
69 auto hwInfo = *NEO::defaultHwInfo.get();
70 ze_result_t returnValue = ZE_RESULT_SUCCESS;
71 std::unique_ptr<DriverHandle> driverHandle(new DriverHandle);
72 auto neoDevice = std::unique_ptr<NEO::Device>(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
73 auto device = std::unique_ptr<L0::Device>(Device::create(driverHandle.get(), neoDevice.release(), false, &returnValue));
74 ASSERT_NE(nullptr, device);
75 auto sessionMock = std::make_unique<MockDebugSession>(config, device.get());
76
77 DebugSessionImp::SipMemoryAccessArgs args = {};
78 args.debugSession = sessionMock.get();
79 args.contextHandle = 0x1234;
80 args.gpuVa = 0x1000;
81
82 sessionMock->forcereadGpuMemoryFailOnCount = 1;
83 char destination[8] = {};
84 uint32_t ret = DebugSessionImp::readSipMemory(&args, 0, 8, destination);
85 EXPECT_EQ(0u, ret);
86 }
87
88 TEST(DebugSessionTest, GivenValidArgsWhenWriteSipMemoryCalledThenReturnsSizeAndWritesMemory) {
89 zet_debug_config_t config = {};
90 config.pid = 0x1234;
91 auto hwInfo = *NEO::defaultHwInfo.get();
92 ze_result_t returnValue = ZE_RESULT_SUCCESS;
93 std::unique_ptr<DriverHandle> driverHandle(new DriverHandle);
94 auto neoDevice = std::unique_ptr<NEO::Device>(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
95 auto device = std::unique_ptr<L0::Device>(Device::create(driverHandle.get(), neoDevice.release(), false, &returnValue));
96 ASSERT_NE(nullptr, device);
97 auto sessionMock = std::make_unique<MockDebugSession>(config, device.get());
98
99 DebugSessionImp::SipMemoryAccessArgs args = {};
100 args.debugSession = sessionMock.get();
101 args.contextHandle = 0x5678;
102 args.gpuVa = 0x2000;
103
104 constexpr uint32_t size = 32;
105 char source[size] = {1, 2, 3, 4};
106 sessionMock->writeGpuMemoryCallCount = 0;
107
108 uint32_t ret = DebugSessionImp::writeSipMemory(&args, 0x20, size, source);
109 EXPECT_EQ(size, ret);
110 EXPECT_EQ(1u, sessionMock->writeGpuMemoryCallCount);
111 }
112
113 TEST(DebugSessionTest, GivenWriteGpuMemoryFailsWhenWriteSipMemoryCalledThenReturnsZero) {
114 zet_debug_config_t config = {};
115 config.pid = 0x1234;
116 auto hwInfo = *NEO::defaultHwInfo.get();
117 ze_result_t returnValue = ZE_RESULT_SUCCESS;
118 std::unique_ptr<DriverHandle> driverHandle(new DriverHandle);
119 auto neoDevice = std::unique_ptr<NEO::Device>(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
120 auto device = std::unique_ptr<L0::Device>(Device::create(driverHandle.get(), neoDevice.release(), false, &returnValue));
121 ASSERT_NE(nullptr, device);
122 auto sessionMock = std::make_unique<MockDebugSession>(config, device.get());
123
124 DebugSessionImp::SipMemoryAccessArgs args = {};
125 args.debugSession = sessionMock.get();
126 args.contextHandle = 0x5678;
127 args.gpuVa = 0x2000;
128
129 sessionMock->forceWriteGpuMemoryFailOnCount = 1;
130 char source[8] = {5, 6, 7, 8};
131 uint32_t ret = DebugSessionImp::writeSipMemory(&args, 0, 8, source);
132 EXPECT_EQ(0u, ret);
133 }
134
135 using DebugSessionTest = ::testing::Test;
136
137 TEST(DeviceWithDebugSessionTest, GivenSlicesEnabledWithEarlierSlicesDisabledThenAllThreadsIsPopulatedCorrectly) {
138 auto hwInfo = *NEO::defaultHwInfo;
139 hwInfo.gtSystemInfo.MaxSlicesSupported = 2;
140 hwInfo.gtSystemInfo.MaxEuPerSubSlice = 8;
141 hwInfo.gtSystemInfo.MaxSubSlicesSupported = 64;
142 hwInfo.gtSystemInfo.MaxDualSubSlicesSupported = 32;
143 hwInfo.gtSystemInfo.IsDynamicallyPopulated = true;
144 hwInfo.gtSystemInfo.MaxSlicesSupported = 2;
145 for (auto &sliceInfo : hwInfo.gtSystemInfo.SliceInfo) {
146 sliceInfo.Enabled = false;
147 }
148 hwInfo.gtSystemInfo.SliceInfo[2].Enabled = true;
149 hwInfo.gtSystemInfo.SliceInfo[3].Enabled = true;
150
151 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
152 MockDeviceImp mockDevice(neoDevice);
153 auto sessionMock = std::make_unique<MockDebugSession>(zet_debug_config_t{0x1234}, &mockDevice);
154 const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.MaxDualSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported;
155 EXPECT_EQ(1u, sessionMock->allThreads.count(EuThread::ThreadId(0, 0, numSubslicesPerSlice - 1, 0, 0)));
156 EXPECT_EQ(1u, sessionMock->allThreads.count(EuThread::ThreadId(0, 1, numSubslicesPerSlice - 1, 7, 0)));
157 EXPECT_EQ(1u, sessionMock->allThreads.count(EuThread::ThreadId(0, 2, numSubslicesPerSlice - 1, 0, 0)));
158 }
159
160 TEST(DeviceWithDebugSessionTest, GivenDeviceWithDebugSessionWhenCallingReleaseResourcesThenCloseConnectionIsCalled) {
161 ze_result_t returnValue = ZE_RESULT_SUCCESS;
162 std::unique_ptr<DriverHandle> driverHandle(new DriverHandle);
163 auto hwInfo = *NEO::defaultHwInfo;
164 auto neoDevice = std::unique_ptr<NEO::Device>(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
165 auto device = std::unique_ptr<L0::Device>(Device::create(driverHandle.get(), neoDevice.release(), false, &returnValue));
166 ASSERT_NE(nullptr, device);
167
168 zet_debug_config_t config = {};
169 auto session = new DebugSessionMock(config, device.get());
170 static_cast<Device *>(device.get())->setDebugSession(session);
171 static_cast<Device *>(device.get())->releaseResources();
172
173 EXPECT_TRUE(session->closeConnectionCalled);
174 }
175
176 TEST(DebugSessionTest, givenNullDeviceWhenDebugSessionCreatedThenAllThreadsAreEmpty) {
177 auto sessionMock = std::make_unique<MockDebugSession>(zet_debug_config_t{0x1234}, nullptr);
178 EXPECT_TRUE(sessionMock->allThreads.empty());
179 }
180
181 TEST(DebugSessionTest, givenApplyResumeWaCalledThenWAIsApplied) {
182 zet_debug_config_t config = {};
183 config.pid = 0x1234;
184 auto hwInfo = *NEO::defaultHwInfo.get();
185
186 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
187 MockDeviceImp mockDevice(neoDevice);
188
189 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
190 auto &l0GfxCoreHelper = neoDevice->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
191
192 size_t bitmaskSize = 32;
193 auto bitmask = std::make_unique<uint8_t[]>(bitmaskSize);
194 bitmask.get()[0] = 1;
195 sessionMock->applyResumeWa(bitmask.get(), bitmaskSize);
196 if (l0GfxCoreHelper.isResumeWARequired()) {
197 EXPECT_EQ(1, bitmask.get()[4]);
198 } else {
199 EXPECT_EQ(0, bitmask.get()[4]);
200 }
201 }
202
203 TEST(DebugSessionTest, givenAllStoppedThreadsWhenInterruptCalledThenErrorNotAvailableReturned) {
204 zet_debug_config_t config = {};
205 config.pid = 0x1234;
206 auto hwInfo = *NEO::defaultHwInfo.get();
207
208 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
209 MockDeviceImp mockDevice(neoDevice);
210
211 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
212
213 for (uint32_t i = 0; i < hwInfo.gtSystemInfo.NumThreadsPerEu; i++) {
214 EuThread::ThreadId thread(0, 0, 0, 0, i);
215 sessionMock->allThreads[thread]->stopThread(1u);
216 sessionMock->allThreads[thread]->reportAsStopped();
217 }
218
219 ze_device_thread_t apiThread = {0, 0, 0, UINT32_MAX};
220 auto result = sessionMock->interrupt(apiThread);
221
222 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
223 }
224
225 TEST(DebugSessionTest, givenNoPendingInterruptWhenSendInterruptCalledThenInterruptImpNotCalled) {
226 zet_debug_config_t config = {};
227 config.pid = 0x1234;
228 auto hwInfo = *NEO::defaultHwInfo.get();
229
230 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
231 MockDeviceImp mockDevice(neoDevice);
232
233 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
234 sessionMock->interruptSent = true;
235
236 sessionMock->sendInterrupts();
237 EXPECT_EQ(0u, sessionMock->interruptImpCalled);
238 }
239
240 TEST(DebugSessionTest, givenPendingInterruptWhenNewInterruptForThreadCalledThenErrorNotReadyReturned) {
241 zet_debug_config_t config = {};
242 config.pid = 0x1234;
243 auto hwInfo = *NEO::defaultHwInfo.get();
244
245 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
246 MockDeviceImp mockDevice(neoDevice);
247
248 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
249
250 ze_device_thread_t apiThread = {0, 0, 0, 1};
251
252 sessionMock->pendingInterrupts.push_back({apiThread, false});
253 auto result = sessionMock->interrupt(apiThread);
254
255 EXPECT_EQ(ZE_RESULT_NOT_READY, result);
256 }
257
258 TEST(DebugSessionTest, givenInterruptAlreadySentWhenSendInterruptCalledSecondTimeThenEarlyReturns) {
259 zet_debug_config_t config = {};
260 config.pid = 0x1234;
261 auto hwInfo = *NEO::defaultHwInfo.get();
262
263 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
264 MockDeviceImp mockDevice(neoDevice);
265
266 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
267
268 sessionMock->threadStopped = 0;
269
270 ze_device_thread_t apiThread = {0, 0, 0, 1};
271 auto result = sessionMock->interrupt(apiThread);
272 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
273
274 sessionMock->sendInterrupts();
275 EXPECT_EQ(1u, sessionMock->interruptImpCalled);
276 EXPECT_EQ(0u, sessionMock->expectedAttentionEvents);
277
278 ze_device_thread_t apiThread2 = {0, 0, 0, 2};
279 result = sessionMock->interrupt(apiThread2);
280 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
281
282 sessionMock->sendInterrupts();
283 EXPECT_EQ(1u, sessionMock->interruptImpCalled);
284 }
285
286 TEST(DebugSessionTest, givenInterruptRequestWhenInterruptImpFailsInSendInterruptThenApiEventsArePushed) {
287 zet_debug_config_t config = {};
288 config.pid = 0x1234;
289 auto hwInfo = *NEO::defaultHwInfo.get();
290
291 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
292 MockDeviceImp mockDevice(neoDevice);
293
294 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
295
296 sessionMock->readRegistersResult = ZE_RESULT_SUCCESS;
297 sessionMock->interruptImpResult = ZE_RESULT_ERROR_UNKNOWN;
298 ze_device_thread_t apiThread = {0, 0, 0, 1};
299 auto result = sessionMock->interrupt(apiThread);
300 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
301
302 sessionMock->sendInterrupts();
303 EXPECT_EQ(1u, sessionMock->interruptImpCalled);
304
305 EXPECT_EQ(1u, sessionMock->apiEvents.size());
306
307 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE, sessionMock->apiEvents.front().type);
308 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread, sessionMock->apiEvents.front().info.thread.thread));
309
310 EXPECT_EQ(0u, sessionMock->pendingInterrupts.size());
311 }
312
313 TEST(DebugSessionTest, givenPendingInteruptWhenHandlingThreadWithAttentionThenPendingInterruptIsMarkedComplete) {
314 zet_debug_config_t config = {};
315 config.pid = 0x1234;
316 auto hwInfo = *NEO::defaultHwInfo.get();
317
318 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
319 MockDeviceImp mockDevice(neoDevice);
320
321 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
322
323 ze_device_thread_t apiThread = {0, 0, 0, 0};
324 EuThread::ThreadId thread(0, 0, 0, 0, 0);
325
326 auto result = sessionMock->interrupt(apiThread);
327 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
328
329 sessionMock->sendInterrupts();
330 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(thread, 1u, sessionMock->stateSaveAreaHeader.data());
331
332 EXPECT_TRUE(sessionMock->allThreads[thread]->isStopped());
333
334 EXPECT_FALSE(sessionMock->pendingInterrupts[0].second);
335 EXPECT_EQ(1u, sessionMock->newlyStoppedThreads.size());
336
337 sessionMock->triggerEvents = true;
338
339 std::vector<EuThread::ThreadId> resumeThreads;
340 std::vector<EuThread::ThreadId> stoppedThreadsToReport;
341 std::vector<EuThread::ThreadId> interruptedThreads;
342
343 sessionMock->fillResumeAndStoppedThreadsFromNewlyStopped(resumeThreads, stoppedThreadsToReport, interruptedThreads);
344 EXPECT_EQ(1u, interruptedThreads.size());
345 EXPECT_TRUE(sessionMock->pendingInterrupts[0].second);
346
347 sessionMock->generateEventsForPendingInterrupts();
348
349 ASSERT_EQ(1u, sessionMock->apiEvents.size());
350
351 zet_debug_event_t debugEvent = {};
352 sessionMock->readEvent(0, &debugEvent);
353
354 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED, debugEvent.type);
355 EXPECT_EQ(apiThread.thread, debugEvent.info.thread.thread.thread);
356 EXPECT_EQ(apiThread.eu, debugEvent.info.thread.thread.eu);
357 EXPECT_EQ(apiThread.subslice, debugEvent.info.thread.thread.subslice);
358 EXPECT_EQ(apiThread.slice, debugEvent.info.thread.thread.slice);
359
360 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
361 }
362
363 TEST(DebugSessionTest, givenPreviouslyStoppedThreadAndPendingInterruptWhenHandlingThreadWithAttentionThenPendingInterruptIsNotMarkedCompleteAndInterruptGeneratesUnavailableEvent) {
364 zet_debug_config_t config = {};
365 config.pid = 0x1234;
366 auto hwInfo = *NEO::defaultHwInfo.get();
367
368 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
369 MockDeviceImp mockDevice(neoDevice);
370
371 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
372
373 ze_device_thread_t apiThread = {0, 0, 0, 0};
374 EuThread::ThreadId thread(0, 0, 0, 0, 0);
375
376 auto result = sessionMock->interrupt(apiThread);
377 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
378
379 sessionMock->sendInterrupts();
380
381 // stop thread for a reason different than interrupt exception (forceException)
382 sessionMock->onlyForceException = false;
383 sessionMock->allThreads[thread]->stopThread(1u);
384
385 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(thread, 1u, sessionMock->stateSaveAreaHeader.data());
386
387 EXPECT_TRUE(sessionMock->allThreads[thread]->isStopped());
388
389 EXPECT_FALSE(sessionMock->pendingInterrupts[0].second);
390 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
391
392 sessionMock->expectedAttentionEvents = 0;
393 sessionMock->checkTriggerEventsForAttention();
394 sessionMock->generateEventsAndResumeStoppedThreads();
395
396 EXPECT_EQ(1u, sessionMock->apiEvents.size());
397 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE, sessionMock->apiEvents.front().type);
398 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread, sessionMock->apiEvents.front().info.thread.thread));
399 }
400
401 TEST(DebugSessionTest, givenThreadsStoppedOnBreakpointAndInterruptedWhenHandlingThreadsStateThenThreadsWithBreakpointExceptionsHaveDistinctEventsTriggered) {
402 zet_debug_config_t config = {};
403 config.pid = 0x1234;
404 auto hwInfo = *NEO::defaultHwInfo.get();
405
406 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
407 MockDeviceImp mockDevice(neoDevice);
408
409 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
410
411 sessionMock->callBaseIsForceExceptionOrForceExternalHaltOnlyExceptionReason = true;
412
413 {
414 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
415 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
416 pStateSaveAreaHeader->regHeader.state_area_offset +
417 pStateSaveAreaHeader->regHeader.state_save_size * 16;
418 sessionMock->stateSaveAreaHeader.resize(size);
419 }
420
421 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data()))->regHeader.cr;
422 uint32_t cr0[8] = {0, 0, 0, 0, 0, 0, 0, 0};
423
424 ze_device_thread_t interruptThread = {UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX};
425 ze_device_thread_t bpThread = {0, 0, 0, 0};
426 EuThread::ThreadId threadWithBp(0, 0, 0, 0, 0);
427 EuThread::ThreadId threadWithFe(0, 0, 0, 0, 1);
428
429 auto result = sessionMock->interrupt(interruptThread);
430 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
431
432 sessionMock->sendInterrupts();
433
434 cr0[1] = 1 << 15 | 1 << 31;
435 sessionMock->registersAccessHelper(sessionMock->allThreads[threadWithBp].get(), regdesc, 0, 1, 0, cr0, true);
436
437 cr0[1] = 1 << 26;
438 sessionMock->registersAccessHelper(sessionMock->allThreads[threadWithFe].get(), regdesc, 0, 1, 0, cr0, true);
439
440 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(threadWithBp, 1u, sessionMock->stateSaveAreaHeader.data());
441 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(threadWithFe, 1u, sessionMock->stateSaveAreaHeader.data());
442
443 EXPECT_TRUE(sessionMock->allThreads[threadWithBp]->isStopped());
444 EXPECT_TRUE(sessionMock->allThreads[threadWithFe]->isStopped());
445
446 sessionMock->expectedAttentionEvents = 0;
447 sessionMock->checkTriggerEventsForAttention();
448
449 sessionMock->generateEventsAndResumeStoppedThreads();
450
451 EXPECT_EQ(2u, sessionMock->apiEvents.size());
452
453 uint32_t stoppedEvents = 0;
454 bool interruptEventFound = false;
455 bool bpThreadFound = false;
456 for (uint32_t i = 0; i < 2; i++) {
457
458 zet_debug_event_t outputEvent = {};
459 auto result = sessionMock->readEvent(0, &outputEvent);
460 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
461
462 if (result == ZE_RESULT_SUCCESS) {
463 if (outputEvent.type == ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED) {
464 stoppedEvents++;
465 if (DebugSession::areThreadsEqual(interruptThread, outputEvent.info.thread.thread)) {
466 interruptEventFound = true;
467 } else if (DebugSession::areThreadsEqual(bpThread, outputEvent.info.thread.thread)) {
468 bpThreadFound = true;
469 }
470 }
471 }
472 }
473
474 EXPECT_EQ(2u, stoppedEvents);
475 EXPECT_TRUE(bpThreadFound);
476 EXPECT_TRUE(interruptEventFound);
477 }
478
479 TEST(DebugSessionTest, givenStoppedThreadWhenAddingNewlyStoppedThenThreadIsNotAdded) {
480 zet_debug_config_t config = {};
481 config.pid = 0x1234;
482 auto hwInfo = *NEO::defaultHwInfo.get();
483
484 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
485 MockDeviceImp mockDevice(neoDevice);
486
487 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
488
489 EuThread::ThreadId thread(0, 0, 0, 0, 0);
490 sessionMock->allThreads[thread]->stopThread(1u);
491
492 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(thread, 1u, sessionMock->stateSaveAreaHeader.data());
493
494 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
495 }
496
497 TEST(DebugSessionTest, givenNoPendingInterruptAndStoppedThreadWithForceExceptionOnlyWhenAddingNewlyStoppedThenThreadIsNotReportedAsStopped) {
498 zet_debug_config_t config = {};
499 config.pid = 0x1234;
500 auto hwInfo = *NEO::defaultHwInfo.get();
501
502 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
503 MockDeviceImp mockDevice(neoDevice);
504
505 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
506
507 EuThread::ThreadId thread(0, 0, 0, 0, 0);
508 sessionMock->skipReadSystemRoutineIdent = 1;
509 sessionMock->threadStopped = true;
510 sessionMock->onlyForceException = true;
511
512 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(thread, 1u, sessionMock->stateSaveAreaHeader.data());
513
514 EXPECT_EQ(1u, sessionMock->newlyStoppedThreads.size());
515 EXPECT_FALSE(sessionMock->allThreads[thread]->isReportedAsStopped());
516 }
517
518 TEST(DebugSessionTest, givenNoPendingInterruptAndStoppedThreadWhenGeneratingEventsFromStoppedThreadsThenThreadIsReportedAsStoppedAfterReadingEvent) {
519 zet_debug_config_t config = {};
520 config.pid = 0x1234;
521 auto hwInfo = *NEO::defaultHwInfo.get();
522
523 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
524 MockDeviceImp mockDevice(neoDevice);
525
526 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
527
528 EuThread::ThreadId thread(0, 0, 0, 0, 0);
529 sessionMock->skipReadSystemRoutineIdent = 1;
530 sessionMock->threadStopped = true;
531 sessionMock->onlyForceException = false;
532 sessionMock->triggerEvents = true;
533
534 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(thread, 1u, sessionMock->stateSaveAreaHeader.data());
535
536 EXPECT_EQ(1u, sessionMock->newlyStoppedThreads.size());
537 EXPECT_FALSE(sessionMock->allThreads[thread]->isReportedAsStopped());
538
539 sessionMock->generateEventsAndResumeStoppedThreads();
540 EXPECT_FALSE(sessionMock->allThreads[thread]->isReportedAsStopped());
541
542 EXPECT_EQ(1u, sessionMock->apiEvents.size());
543 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED, sessionMock->apiEvents.front().type);
544
545 zet_debug_event_t outputEvent;
546 sessionMock->readEvent(0, &outputEvent);
547 EXPECT_TRUE(sessionMock->allThreads[thread]->isReportedAsStopped());
548 }
549
550 TEST(DebugSessionTest, givenNoStoppedThreadWhenAddingNewlyStoppedThenThreadIsNotAdded) {
551 zet_debug_config_t config = {};
552 config.pid = 0x1234;
553 auto hwInfo = *NEO::defaultHwInfo.get();
554
555 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
556 MockDeviceImp mockDevice(neoDevice);
557
558 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
559 sessionMock->threadStopped = 0;
560
561 EuThread::ThreadId thread(0, 0, 0, 0, 0);
562 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(thread, 1u, sessionMock->stateSaveAreaHeader.data());
563
564 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
565 }
566
567 TEST(DebugSessionTest, givenV3SipHeaderWhenCalculatingThreadOffsetThenCorrectResultReturned) {
568 zet_debug_config_t config = {};
569 config.pid = 0x1234;
570 auto hwInfo = *NEO::defaultHwInfo.get();
571
572 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
573 MockDeviceImp mockDevice(neoDevice);
574
575 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice, true, 3);
576 ze_device_thread_t thread = {0, 0, 0, 0};
577 EuThread::ThreadId threadId(0, thread);
578
579 auto threadSlotOffset = sessionMock->calculateThreadSlotOffset(threadId);
580 auto pStateSaveAreaHeader = reinterpret_cast<NEO::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
581 size_t expectedOffset = pStateSaveAreaHeader->versionHeader.size * 8 + pStateSaveAreaHeader->regHeaderV3.state_area_offset + ((((threadId.slice * pStateSaveAreaHeader->regHeaderV3.num_subslices_per_slice + threadId.subslice) * pStateSaveAreaHeader->regHeaderV3.num_eus_per_subslice + threadId.eu) * pStateSaveAreaHeader->regHeaderV3.num_threads_per_eu + threadId.thread) * pStateSaveAreaHeader->regHeaderV3.state_save_size);
582 EXPECT_EQ(threadSlotOffset, expectedOffset);
583 }
584
585 TEST(DebugSessionTest, givenSipHeaderGreaterThan3WhenCalculatingThreadOffsetThenZeroReturned) {
586 zet_debug_config_t config = {};
587 config.pid = 0x1234;
588 auto hwInfo = *NEO::defaultHwInfo.get();
589
590 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
591 MockDeviceImp mockDevice(neoDevice);
592
593 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice, true, 3);
594 ze_device_thread_t thread = {0, 0, 0, 0};
595 EuThread::ThreadId threadId(0, thread);
596 auto versionHeader = &reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data())->versionHeader;
597 versionHeader->version.major = 4;
598
599 EXPECT_EQ(0u, sessionMock->calculateThreadSlotOffset(threadId));
600 }
601
602 TEST(DebugSessionTest, givenStoppedThreadAndNoSrMagicWhenAddingNewlyStoppedThenThreadIsNotAddedToNewlyStopped) {
603 zet_debug_config_t config = {};
604 config.pid = 0x1234;
605 auto hwInfo = *NEO::defaultHwInfo.get();
606
607 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
608 MockDeviceImp mockDevice(neoDevice);
609
610 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
611 ASSERT_NE(nullptr, sessionMock);
612 sessionMock->skipCheckThreadIsResumed = false;
613 sessionMock->skipReadSystemRoutineIdent = false;
614
615 {
616 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
617 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
618 pStateSaveAreaHeader->regHeader.state_area_offset +
619 pStateSaveAreaHeader->regHeader.state_save_size * 16;
620 sessionMock->stateSaveAreaHeader.resize(size);
621 }
622
623 auto stateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
624 ze_device_thread_t thread = {0, 0, 0, 0};
625 EuThread::ThreadId threadId(0, thread);
626
627 auto threadSlotOffset = sessionMock->calculateThreadSlotOffset(threadId);
628 auto srMagicOffset = threadSlotOffset + stateSaveAreaHeader->regHeader.sr_magic_offset;
629 SIP::sr_ident srMagic = {{0}};
630 sessionMock->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(stateSaveAreaHeader) + srMagicOffset);
631
632 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(threadId, 1u, sessionMock->stateSaveAreaHeader.data());
633
634 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
635 }
636
637 TEST(DebugSessionTest, givenStoppedThreadAndValidSrMagicWhenAddingNewlyStoppedThenThreadIsAddedToNewlyStopped) {
638 zet_debug_config_t config = {};
639 config.pid = 0x1234;
640 auto hwInfo = *NEO::defaultHwInfo.get();
641
642 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
643 MockDeviceImp mockDevice(neoDevice);
644
645 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
646 ASSERT_NE(nullptr, sessionMock);
647 sessionMock->skipCheckThreadIsResumed = false;
648 sessionMock->skipReadSystemRoutineIdent = false;
649
650 {
651 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
652 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
653 pStateSaveAreaHeader->regHeader.state_area_offset +
654 pStateSaveAreaHeader->regHeader.state_save_size * 16;
655 sessionMock->stateSaveAreaHeader.resize(size);
656 }
657
658 auto stateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
659 ze_device_thread_t thread = {0, 0, 0, 0};
660 EuThread::ThreadId threadId(0, thread);
661
662 auto threadSlotOffset = sessionMock->calculateThreadSlotOffset(threadId);
663 auto srMagicOffset = threadSlotOffset + stateSaveAreaHeader->regHeader.sr_magic_offset;
664 SIP::sr_ident srMagic;
665 srMagic.version.major = 2;
666 srMagic.version.minor = 0;
667 srMagic.count = 1;
668 sessionMock->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(stateSaveAreaHeader) + srMagicOffset);
669
670 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(threadId, 1u, sessionMock->stateSaveAreaHeader.data());
671
672 EXPECT_EQ(1u, sessionMock->newlyStoppedThreads.size());
673 }
674
675 TEST(DebugSessionTest, givenNoInterruptsSentWhenGenerateEventsAndResumeCalledThenTriggerEventsNotChanged) {
676 zet_debug_config_t config = {};
677 config.pid = 0x1234;
678 auto hwInfo = *NEO::defaultHwInfo.get();
679
680 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
681 MockDeviceImp mockDevice(neoDevice);
682
683 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
684
685 sessionMock->interruptSent = false;
686 sessionMock->triggerEvents = false;
687
688 sessionMock->generateEventsAndResumeStoppedThreads();
689 EXPECT_FALSE(sessionMock->triggerEvents);
690 }
691
692 TEST(DebugSessionTest, givenTriggerEventsWhenGenerateEventsAndResumeCalledThenEventsGeneratedAndThreadsResumed) {
693 zet_debug_config_t config = {};
694 config.pid = 0x1234;
695 auto hwInfo = *NEO::defaultHwInfo.get();
696
697 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
698 MockDeviceImp mockDevice(neoDevice);
699
700 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
701
702 ze_device_thread_t apiThread = {0, 0, 0, 1};
703 ze_device_thread_t apiThread2 = {0, 0, 1, 1};
704 sessionMock->pendingInterrupts.push_back({apiThread, true});
705
706 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(EuThread::ThreadId(0, apiThread2), 1u, sessionMock->stateSaveAreaHeader.data());
707
708 sessionMock->triggerEvents = true;
709 sessionMock->interruptSent = true;
710
711 sessionMock->onlyForceException = false;
712
713 sessionMock->generateEventsAndResumeStoppedThreads();
714
715 EXPECT_EQ(2u, sessionMock->apiEvents.size());
716
717 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED, sessionMock->apiEvents.front().type);
718 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread, sessionMock->apiEvents.front().info.thread.thread));
719
720 sessionMock->apiEvents.pop();
721 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED, sessionMock->apiEvents.front().type);
722 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread2, sessionMock->apiEvents.front().info.thread.thread));
723
724 EXPECT_EQ(1u, sessionMock->resumeAccidentallyStoppedCalled);
725 EXPECT_EQ(0u, sessionMock->pendingInterrupts.size());
726 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
727 }
728
729 TEST(DebugSessionTest, givenPendingInterruptAfterTimeoutWhenGenerateEventsAndResumeStoppedThreadsIsCalledThenEventsUnavailableAreSentAndFlagsSetFalse) {
730 zet_debug_config_t config = {};
731 config.pid = 0x1234;
732 auto hwInfo = *NEO::defaultHwInfo.get();
733
734 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
735 MockDeviceImp mockDevice(neoDevice);
736
737 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
738
739 ze_device_thread_t apiThread = {0, 0, 0, 1};
740 sessionMock->pendingInterrupts.push_back({apiThread, false});
741
742 sessionMock->triggerEvents = false;
743 sessionMock->interruptSent = true;
744 sessionMock->returnTimeDiff = 5 * sessionMock->interruptTimeout;
745
746 sessionMock->generateEventsAndResumeStoppedThreads();
747
748 EXPECT_EQ(1u, sessionMock->apiEvents.size());
749
750 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE, sessionMock->apiEvents.front().type);
751 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread, sessionMock->apiEvents.front().info.thread.thread));
752
753 EXPECT_EQ(0u, sessionMock->pendingInterrupts.size());
754 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
755 EXPECT_FALSE(sessionMock->triggerEvents);
756 EXPECT_FALSE(sessionMock->interruptSent);
757 }
758
759 TEST(DebugSessionTest, givenPendingInterruptBeforeTimeoutWhenGenerateEventsAndResumeStoppedThreadsIsCalledThenEventsNotTriggered) {
760 zet_debug_config_t config = {};
761 config.pid = 0x1234;
762 auto hwInfo = *NEO::defaultHwInfo.get();
763
764 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
765 MockDeviceImp mockDevice(neoDevice);
766
767 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
768
769 ze_device_thread_t apiThread = {0, 0, 0, 1};
770 sessionMock->pendingInterrupts.push_back({apiThread, false});
771
772 sessionMock->triggerEvents = false;
773 sessionMock->interruptSent = true;
774 sessionMock->returnTimeDiff = sessionMock->interruptTimeout / 2;
775
776 sessionMock->generateEventsAndResumeStoppedThreads();
777
778 EXPECT_EQ(0u, sessionMock->apiEvents.size());
779 EXPECT_EQ(1u, sessionMock->pendingInterrupts.size());
780 EXPECT_FALSE(sessionMock->triggerEvents);
781 EXPECT_TRUE(sessionMock->interruptSent);
782 }
783
784 TEST(DebugSessionTest, givenErrorFromReadSystemRoutineIdentWhenCheckingThreadStateThenThreadIsNotStopped) {
785 zet_debug_config_t config = {};
786 config.pid = 0x1234;
787 auto hwInfo = *NEO::defaultHwInfo.get();
788
789 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
790 MockDeviceImp mockDevice(neoDevice);
791
792 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
793 sessionMock->readSystemRoutineIdentRetVal = false;
794 EuThread::ThreadId thread(0, 0, 0, 0, 0);
795
796 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(thread, 1u, sessionMock->stateSaveAreaHeader.data());
797
798 EXPECT_FALSE(sessionMock->allThreads[thread]->isStopped());
799 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
800 }
801
802 TEST(DebugSessionTest, givenReadSystemRoutineIdentFailsWhenCheckThreadIsResumedCalledThenThreadIsResumed) {
803 zet_debug_config_t config = {};
804 config.pid = 0x1234;
805 auto hwInfo = *NEO::defaultHwInfo.get();
806
807 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
808 MockDeviceImp deviceImp(neoDevice);
809
810 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
811 ASSERT_NE(nullptr, sessionMock);
812 sessionMock->skipCheckThreadIsResumed = false;
813 sessionMock->skipReadSystemRoutineIdent = false;
814 sessionMock->readSystemRoutineIdentRetVal = false;
815
816 ze_device_thread_t thread = {0, 0, 0, 0};
817 EuThread::ThreadId threadId(0, thread);
818
819 bool resumed = sessionMock->checkThreadIsResumed(threadId);
820 EXPECT_TRUE(resumed);
821 }
822
823 TEST(DebugSessionTest, givenSrMagicCountEqualsLastCounterWhenCheckThreadIsResumedCalledThenThreadIsNotResumed) {
824 zet_debug_config_t config = {};
825 config.pid = 0x1234;
826 auto hwInfo = *NEO::defaultHwInfo.get();
827
828 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
829 MockDeviceImp deviceImp(neoDevice);
830
831 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
832 ASSERT_NE(nullptr, sessionMock);
833 sessionMock->skipCheckThreadIsResumed = false;
834 sessionMock->skipReadSystemRoutineIdent = false;
835
836 {
837 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
838 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
839 pStateSaveAreaHeader->regHeader.state_area_offset +
840 pStateSaveAreaHeader->regHeader.state_save_size * 16;
841 sessionMock->stateSaveAreaHeader.resize(size);
842 }
843
844 auto stateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
845 ze_device_thread_t thread = {0, 0, 0, 0};
846 EuThread::ThreadId threadId(0, thread);
847
848 auto threadSlotOffset = sessionMock->calculateThreadSlotOffset(threadId);
849 auto srMagicOffset = threadSlotOffset + stateSaveAreaHeader->regHeader.sr_magic_offset;
850 SIP::sr_ident srMagic;
851 srMagic.version.major = 2;
852 srMagic.version.minor = 0;
853 srMagic.count = 5;
854 sessionMock->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(stateSaveAreaHeader) + srMagicOffset);
855
856 sessionMock->allThreads[threadId]->verifyStopped(5);
857 sessionMock->allThreads[threadId]->stopThread(1u);
858
859 bool resumed = sessionMock->checkThreadIsResumed(threadId);
860 EXPECT_FALSE(resumed);
861 }
862
863 TEST(DebugSessionTest, givenReadSystemRoutineIdentFromMemoryFailsWhenCheckThreadIsResumedWithStateSaveAreaCalledThenThreadIsResumed) {
864 zet_debug_config_t config = {};
865 config.pid = 0x1234;
866 auto hwInfo = *NEO::defaultHwInfo.get();
867
868 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
869 MockDeviceImp deviceImp(neoDevice);
870
871 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
872 ASSERT_NE(nullptr, sessionMock);
873 sessionMock->skipCheckThreadIsResumed = false;
874 sessionMock->skipReadSystemRoutineIdent = false;
875 sessionMock->readSystemRoutineIdentRetVal = false;
876
877 {
878 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
879 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
880 pStateSaveAreaHeader->regHeader.state_area_offset +
881 pStateSaveAreaHeader->regHeader.state_save_size * 16;
882 sessionMock->stateSaveAreaHeader.resize(size);
883 }
884
885 ze_device_thread_t thread = {0, 0, 0, 0};
886 EuThread::ThreadId threadId(0, thread);
887
888 bool resumed = sessionMock->checkThreadIsResumed(threadId, sessionMock->stateSaveAreaHeader.data());
889 EXPECT_TRUE(resumed);
890 }
891
892 TEST(DebugSessionTest, givenSrMagicCountEqualsLastCounterWhenCheckThreadIsResumedWithStateSaveAreaCalledThenThreadIsNotResumed) {
893 zet_debug_config_t config = {};
894 config.pid = 0x1234;
895 auto hwInfo = *NEO::defaultHwInfo.get();
896
897 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
898 MockDeviceImp deviceImp(neoDevice);
899
900 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
901 ASSERT_NE(nullptr, sessionMock);
902 sessionMock->skipCheckThreadIsResumed = false;
903 sessionMock->skipReadSystemRoutineIdent = false;
904
905 {
906 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
907 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
908 pStateSaveAreaHeader->regHeader.state_area_offset +
909 pStateSaveAreaHeader->regHeader.state_save_size * 16;
910 sessionMock->stateSaveAreaHeader.resize(size);
911 }
912
913 auto stateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
914 ze_device_thread_t thread = {0, 0, 0, 0};
915 EuThread::ThreadId threadId(0, thread);
916
917 auto threadSlotOffset = sessionMock->calculateThreadSlotOffset(threadId);
918 auto srMagicOffset = threadSlotOffset + stateSaveAreaHeader->regHeader.sr_magic_offset;
919 SIP::sr_ident srMagic;
920 srMagic.version.major = 2;
921 srMagic.version.minor = 0;
922 srMagic.count = 7;
923 sessionMock->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(stateSaveAreaHeader) + srMagicOffset);
924
925 sessionMock->allThreads[threadId]->verifyStopped(7);
926 sessionMock->allThreads[threadId]->stopThread(1u);
927
928 bool resumed = sessionMock->checkThreadIsResumed(threadId, sessionMock->stateSaveAreaHeader.data());
929 EXPECT_FALSE(resumed);
930 }
931
932 TEST(DebugSessionTest, givenVerifyStoppedReturnsFalseWhenAddThreadToNewlyStoppedFromRaisedAttentionCalledThenThreadNotAddedToNewlyStopped) {
933 zet_debug_config_t config = {};
934 config.pid = 0x1234;
935 auto hwInfo = *NEO::defaultHwInfo.get();
936
937 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
938 MockDeviceImp deviceImp(neoDevice);
939
940 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
941 ASSERT_NE(nullptr, sessionMock);
942 sessionMock->skipCheckThreadIsResumed = false;
943 sessionMock->skipReadSystemRoutineIdent = false;
944
945 {
946 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
947 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
948 pStateSaveAreaHeader->regHeader.state_area_offset +
949 pStateSaveAreaHeader->regHeader.state_save_size * 16;
950 sessionMock->stateSaveAreaHeader.resize(size);
951 }
952
953 auto stateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
954 ze_device_thread_t thread = {0, 0, 0, 0};
955 EuThread::ThreadId threadId(0, thread);
956
957 auto threadSlotOffset = sessionMock->calculateThreadSlotOffset(threadId);
958 auto srMagicOffset = threadSlotOffset + stateSaveAreaHeader->regHeader.sr_magic_offset;
959 SIP::sr_ident srMagic;
960 srMagic.version.major = 2;
961 srMagic.version.minor = 0;
962 srMagic.count = 4; // even counter - verifyStopped will return false
963 sessionMock->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(stateSaveAreaHeader) + srMagicOffset);
964
965 sessionMock->allThreads[threadId]->verifyStopped(2);
966 sessionMock->allThreads[threadId]->stopThread(1u);
967
968 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(threadId, 1u, sessionMock->stateSaveAreaHeader.data());
969
970 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
971 }
972
973 TEST(DebugSessionTest, givenGetThreadSipCounterFailsWhenCheckThreadIsResumedCalledForSipVersion5ThenThreadIsResumed) {
974 zet_debug_config_t config = {};
975 config.pid = 0x1234;
976 auto hwInfo = *NEO::defaultHwInfo.get();
977
978 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
979 MockDeviceImp deviceImp(neoDevice);
980
981 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
982 ASSERT_NE(nullptr, sessionMock);
983
984 // Create SIP version 5 header
985 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
986 stateSaveAreaHeader5.versionHeader.version.major = 5;
987 stateSaveAreaHeader5.versionHeader.version.minor = 0;
988 stateSaveAreaHeader5.versionHeader.version.patch = 0;
989 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
990 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
991
992 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
993 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
994
995 sessionMock->skipCheckThreadIsResumed = false;
996 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
997 sessionMock->getThreadSipCounterRetVal = false; // Mock getThreadSipCounter to fail
998
999 ze_device_thread_t thread = {0, 0, 0, 0};
1000 EuThread::ThreadId threadId(0, thread);
1001
1002 // When getThreadSipCounter returns false, thread is assumed resumed (line 543 condition, line 547 return)
1003 bool resumed = sessionMock->checkThreadIsResumed(threadId);
1004 EXPECT_TRUE(resumed);
1005 }
1006
1007 TEST(DebugSessionTest, givenSipCounterEqualsLastCounterWhenCheckThreadIsResumedCalledForSipVersion5ThenThreadIsNotResumed) {
1008 zet_debug_config_t config = {};
1009 config.pid = 0x1234;
1010 auto hwInfo = *NEO::defaultHwInfo.get();
1011
1012 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1013 MockDeviceImp deviceImp(neoDevice);
1014
1015 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
1016 ASSERT_NE(nullptr, sessionMock);
1017
1018 // Create SIP version 5 header
1019 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
1020 stateSaveAreaHeader5.versionHeader.version.major = 5;
1021 stateSaveAreaHeader5.versionHeader.version.minor = 0;
1022 stateSaveAreaHeader5.versionHeader.version.patch = 0;
1023 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
1024 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
1025
1026 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
1027 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
1028
1029 sessionMock->skipCheckThreadIsResumed = false;
1030 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
1031 sessionMock->getThreadSipCounterRetVal = true; // Mock getThreadSipCounter to succeed
1032 sessionMock->mockSipCounter = 10; // Mock counter value
1033
1034 ze_device_thread_t thread = {0, 0, 0, 0};
1035 EuThread::ThreadId threadId(0, thread);
1036
1037 sessionMock->allThreads[threadId]->verifyStopped(10);
1038 sessionMock->allThreads[threadId]->stopThread(1u);
1039
1040 // When sipCounter equals lastCounter, thread is not resumed (line 562 decision)
1041 bool resumed = sessionMock->checkThreadIsResumed(threadId);
1042 EXPECT_FALSE(resumed);
1043 }
1044
1045 TEST(DebugSessionTest, givenGetThreadSipCounterFailsWhenCheckThreadIsResumedWithStateSaveAreaCalledForSipVersion5ThenThreadIsResumed) {
1046 zet_debug_config_t config = {};
1047 config.pid = 0x1234;
1048 auto hwInfo = *NEO::defaultHwInfo.get();
1049
1050 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1051 MockDeviceImp deviceImp(neoDevice);
1052
1053 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
1054 ASSERT_NE(nullptr, sessionMock);
1055
1056 // Create SIP version 5 header
1057 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
1058 stateSaveAreaHeader5.versionHeader.version.major = 5;
1059 stateSaveAreaHeader5.versionHeader.version.minor = 0;
1060 stateSaveAreaHeader5.versionHeader.version.patch = 0;
1061 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
1062 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
1063
1064 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
1065 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
1066
1067 sessionMock->skipCheckThreadIsResumed = false;
1068 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
1069 sessionMock->getThreadSipCounterRetVal = false; // Mock getThreadSipCounter to fail
1070
1071 ze_device_thread_t thread = {0, 0, 0, 0};
1072 EuThread::ThreadId threadId(0, thread);
1073
1074 // When getThreadSipCounter returns false, thread is assumed resumed (line 574 condition, line 578 return)
1075 bool resumed = sessionMock->checkThreadIsResumed(threadId, sessionMock->stateSaveAreaHeader.data());
1076 EXPECT_TRUE(resumed);
1077 }
1078
1079 TEST(DebugSessionTest, givenSipCounterEqualsLastCounterWhenCheckThreadIsResumedWithStateSaveAreaCalledForSipVersion5ThenThreadIsNotResumed) {
1080 zet_debug_config_t config = {};
1081 config.pid = 0x1234;
1082 auto hwInfo = *NEO::defaultHwInfo.get();
1083
1084 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1085 MockDeviceImp deviceImp(neoDevice);
1086
1087 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
1088 ASSERT_NE(nullptr, sessionMock);
1089
1090 // Create SIP version 5 header
1091 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
1092 stateSaveAreaHeader5.versionHeader.version.major = 5;
1093 stateSaveAreaHeader5.versionHeader.version.minor = 0;
1094 stateSaveAreaHeader5.versionHeader.version.patch = 0;
1095 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
1096 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
1097
1098 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
1099 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
1100
1101 sessionMock->skipCheckThreadIsResumed = false;
1102 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
1103 sessionMock->getThreadSipCounterRetVal = true; // Mock getThreadSipCounter to succeed
1104 sessionMock->mockSipCounter = 15; // Mock counter value
1105
1106 ze_device_thread_t thread = {0, 0, 0, 0};
1107 EuThread::ThreadId threadId(0, thread);
1108
1109 sessionMock->allThreads[threadId]->verifyStopped(15);
1110 sessionMock->allThreads[threadId]->stopThread(1u);
1111
1112 // When sipCounter equals lastCounter, thread is not resumed (line 593 decision)
1113 bool resumed = sessionMock->checkThreadIsResumed(threadId, sessionMock->stateSaveAreaHeader.data());
1114 EXPECT_FALSE(resumed);
1115 }
1116
1117 TEST(DebugSessionTest, givenVerifyStoppedReturnsFalseWhenAddThreadToNewlyStoppedFromRaisedAttentionCalledForSipVersion5ThenThreadNotAddedToNewlyStopped) {
1118 zet_debug_config_t config = {};
1119 config.pid = 0x1234;
1120 auto hwInfo = *NEO::defaultHwInfo.get();
1121
1122 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1123 MockDeviceImp deviceImp(neoDevice);
1124
1125 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
1126 ASSERT_NE(nullptr, sessionMock);
1127
1128 // Create SIP version 5 header
1129 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
1130 stateSaveAreaHeader5.versionHeader.version.major = 5;
1131 stateSaveAreaHeader5.versionHeader.version.minor = 0;
1132 stateSaveAreaHeader5.versionHeader.version.patch = 0;
1133 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
1134 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
1135
1136 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
1137 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
1138
1139 sessionMock->skipCheckThreadIsResumed = false;
1140 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
1141 sessionMock->getThreadSipCounterRetVal = true; // Mock getThreadSipCounter to succeed
1142 sessionMock->mockSipCounter = 8; // Mock counter value
1143
1144 ze_device_thread_t thread = {0, 0, 0, 0};
1145 EuThread::ThreadId threadId(0, thread);
1146
1147 // Set counter to even number - verifyStopped will return false (line 818 decision)
1148 sessionMock->allThreads[threadId]->verifyStopped(6);
1149 sessionMock->allThreads[threadId]->stopThread(1u);
1150
1151 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(threadId, 1u, sessionMock->stateSaveAreaHeader.data());
1152
1153 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
1154 }
1155
1156 TEST(DebugSessionTest, givenGetThreadSipCounterFailsWhenAddThreadToNewlyStoppedFromRaisedAttentionCalledForSipVersion5ThenThreadNotAdded) {
1157 zet_debug_config_t config = {};
1158 config.pid = 0x1234;
1159 auto hwInfo = *NEO::defaultHwInfo.get();
1160
1161 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1162 MockDeviceImp deviceImp(neoDevice);
1163
1164 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
1165 ASSERT_NE(nullptr, sessionMock);
1166
1167 // Create SIP version 5 header
1168 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
1169 stateSaveAreaHeader5.versionHeader.version.major = 5;
1170 stateSaveAreaHeader5.versionHeader.version.minor = 0;
1171 stateSaveAreaHeader5.versionHeader.version.patch = 0;
1172 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
1173 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
1174
1175 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
1176 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
1177
1178 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
1179 sessionMock->getThreadSipCounterRetVal = false; // Mock getThreadSipCounter to fail
1180
1181 ze_device_thread_t thread = {0, 0, 0, 0};
1182 EuThread::ThreadId threadId(0, thread);
1183
1184 // Thread is NOT stopped initially - this is key to entering the getThreadSipCounter path
1185 EXPECT_FALSE(sessionMock->allThreads[threadId]->isStopped());
1186
1187 // When getThreadSipCounter fails, function returns early (line 825)
1188 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(threadId, 1u, sessionMock->stateSaveAreaHeader.data());
1189
1190 EXPECT_EQ(0u, sessionMock->newlyStoppedThreads.size());
1191 EXPECT_FALSE(sessionMock->allThreads[threadId]->isStopped());
1192 }
1193
1194 TEST(DebugSessionTest, givenGetThreadSipCounterSucceedsWhenAddThreadToNewlyStoppedFromRaisedAttentionCalledForSipVersion5ThenThreadAdded) {
1195 zet_debug_config_t config = {};
1196 config.pid = 0x1234;
1197 auto hwInfo = *NEO::defaultHwInfo.get();
1198
1199 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1200 MockDeviceImp deviceImp(neoDevice);
1201
1202 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
1203 ASSERT_NE(nullptr, sessionMock);
1204
1205 // Create SIP version 5 header
1206 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
1207 stateSaveAreaHeader5.versionHeader.version.major = 5;
1208 stateSaveAreaHeader5.versionHeader.version.minor = 0;
1209 stateSaveAreaHeader5.versionHeader.version.patch = 0;
1210 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
1211 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
1212
1213 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
1214 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
1215
1216 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
1217 sessionMock->getThreadSipCounterRetVal = true; // Mock getThreadSipCounter to succeed
1218 sessionMock->mockSipCounter = 7; // Odd counter - verifyStopped will return true
1219
1220 ze_device_thread_t thread = {0, 0, 0, 0};
1221 EuThread::ThreadId threadId(0, thread);
1222
1223 // Thread is NOT stopped initially - this is key to entering the getThreadSipCounter path
1224 EXPECT_FALSE(sessionMock->allThreads[threadId]->isStopped());
1225
1226 // When getThreadSipCounter succeeds and verifyStopped returns true, thread is added (line 829)
1227 sessionMock->addThreadToNewlyStoppedFromRaisedAttention(threadId, 1u, sessionMock->stateSaveAreaHeader.data());
1228
1229 EXPECT_EQ(1u, sessionMock->newlyStoppedThreads.size());
1230 EXPECT_TRUE(sessionMock->allThreads[threadId]->isStopped());
1231 }
1232
1233 TEST(DebugSessionTest, givenSipCounterNotEqualsLastCounterWhenCheckThreadIsResumedCalledForSipVersion5ThenThreadIsResumed) {
1234 zet_debug_config_t config = {};
1235 config.pid = 0x1234;
1236 auto hwInfo = *NEO::defaultHwInfo.get();
1237
1238 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1239 MockDeviceImp deviceImp(neoDevice);
1240
1241 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
1242 ASSERT_NE(nullptr, sessionMock);
1243
1244 // Create SIP version 5 header
1245 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
1246 stateSaveAreaHeader5.versionHeader.version.major = 5;
1247 stateSaveAreaHeader5.versionHeader.version.minor = 0;
1248 stateSaveAreaHeader5.versionHeader.version.patch = 0;
1249 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
1250 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
1251
1252 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
1253 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
1254
1255 sessionMock->skipCheckThreadIsResumed = false;
1256 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
1257 sessionMock->getThreadSipCounterRetVal = true; // Mock getThreadSipCounter to succeed
1258 sessionMock->mockSipCounter = 20; // Mock counter value different from last
1259
1260 ze_device_thread_t thread = {0, 0, 0, 0};
1261 EuThread::ThreadId threadId(0, thread);
1262
1263 sessionMock->allThreads[threadId]->verifyStopped(10); // Last counter = 10
1264 sessionMock->allThreads[threadId]->stopThread(1u);
1265
1266 // When sipCounter does not equal lastCounter, thread is resumed (line 565 else branch)
1267 bool resumed = sessionMock->checkThreadIsResumed(threadId);
1268 EXPECT_TRUE(resumed);
1269 }
1270
1271 TEST(DebugSessionTest, givenSipCounterNotEqualsLastCounterWhenCheckThreadIsResumedWithStateSaveAreaCalledForSipVersion5ThenThreadIsResumed) {
1272 zet_debug_config_t config = {};
1273 config.pid = 0x1234;
1274 auto hwInfo = *NEO::defaultHwInfo.get();
1275
1276 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1277 MockDeviceImp deviceImp(neoDevice);
1278
1279 auto sessionMock = std::make_unique<MockDebugSession>(config, &deviceImp);
1280 ASSERT_NE(nullptr, sessionMock);
1281
1282 // Create SIP version 5 header
1283 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
1284 stateSaveAreaHeader5.versionHeader.version.major = 5;
1285 stateSaveAreaHeader5.versionHeader.version.minor = 0;
1286 stateSaveAreaHeader5.versionHeader.version.patch = 0;
1287 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
1288 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
1289
1290 sessionMock->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
1291 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
1292
1293 sessionMock->skipCheckThreadIsResumed = false;
1294 sessionMock->skipGetThreadSipCounter = true; // Use mock, not real implementation
1295 sessionMock->getThreadSipCounterRetVal = true; // Mock getThreadSipCounter to succeed
1296 sessionMock->mockSipCounter = 25; // Mock counter value different from last
1297
1298 ze_device_thread_t thread = {0, 0, 0, 0};
1299 EuThread::ThreadId threadId(0, thread);
1300
1301 sessionMock->allThreads[threadId]->verifyStopped(15); // Last counter = 15
1302 sessionMock->allThreads[threadId]->stopThread(1u);
1303
1304 // When sipCounter does not equal lastCounter, thread is resumed (line 596 else branch)
1305 bool resumed = sessionMock->checkThreadIsResumed(threadId, sessionMock->stateSaveAreaHeader.data());
1306 EXPECT_TRUE(resumed);
1307 }
1308
1309 TEST(DebugSessionTest, givenPendingInterruptsWhenGeneratingEventsThenStoppedEventIsGeneratedForCompletedInterrupt) {
1310 zet_debug_config_t config = {};
1311 config.pid = 0x1234;
1312 auto hwInfo = *NEO::defaultHwInfo.get();
1313
1314 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1315 MockDeviceImp mockDevice(neoDevice);
1316
1317 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1318
1319 ze_device_thread_t apiThread = {0, 0, 0, 1};
1320 ze_device_thread_t apiThread2 = {0, 0, 1, 1};
1321 sessionMock->pendingInterrupts.push_back({apiThread, false});
1322 sessionMock->pendingInterrupts.push_back({apiThread2, true});
1323
1324 sessionMock->generateEventsForPendingInterrupts();
1325
1326 EXPECT_EQ(2u, sessionMock->apiEvents.size());
1327
1328 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE, sessionMock->apiEvents.front().type);
1329 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread, sessionMock->apiEvents.front().info.thread.thread));
1330 sessionMock->apiEvents.pop();
1331 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED, sessionMock->apiEvents.front().type);
1332 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread2, sessionMock->apiEvents.front().info.thread.thread));
1333
1334 EXPECT_EQ(0u, sessionMock->pendingInterrupts.size());
1335 }
1336
1337 TEST(DebugSessionTest, givenEmptyStateSaveAreaWhenGetStateSaveAreaCalledThenReadStateSaveAreaCalled) {
1338 zet_debug_config_t config = {};
1339 config.pid = 0x1234;
1340 auto hwInfo = *NEO::defaultHwInfo.get();
1341
1342 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1343 MockDeviceImp mockDevice(neoDevice);
1344
1345 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1346 decltype(sessionMock->stateSaveAreaHeader) emptyHeader;
1347 sessionMock->stateSaveAreaHeader.swap(emptyHeader);
1348
1349 auto stateSaveArea = sessionMock->getStateSaveAreaHeader();
1350 EXPECT_EQ(nullptr, stateSaveArea);
1351 EXPECT_EQ(1u, sessionMock->readStateSaveAreaHeaderCalled);
1352 }
1353
1354 TEST(DebugSessionTest, givenStoppedThreadsWhenFillingResumeAndStoppedThreadsFromNewlyStoppedThenContainerFilledBasedOnExceptionReason) {
1355 zet_debug_config_t config = {};
1356 config.pid = 0x1234;
1357 auto hwInfo = *NEO::defaultHwInfo.get();
1358
1359 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1360 MockDeviceImp mockDevice(neoDevice);
1361
1362 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1363
1364 EuThread::ThreadId thread = {0, 0, 0, 0, 1};
1365 EuThread::ThreadId thread2 = {0, 0, 0, 1, 1};
1366 EuThread::ThreadId thread3 = {0, 0, 0, 1, 2};
1367
1368 sessionMock->newlyStoppedThreads.push_back(thread);
1369 sessionMock->newlyStoppedThreads.push_back(thread2);
1370
1371 sessionMock->onlyForceException = true;
1372
1373 {
1374 std::vector<EuThread::ThreadId> resumeThreads;
1375 std::vector<EuThread::ThreadId> stoppedThreads;
1376 std::vector<EuThread::ThreadId> interruptedThreads;
1377
1378 sessionMock->allThreads[thread]->stopThread(1u);
1379 sessionMock->allThreads[thread2]->stopThread(1u);
1380
1381 sessionMock->fillResumeAndStoppedThreadsFromNewlyStopped(resumeThreads, stoppedThreads, interruptedThreads);
1382 EXPECT_EQ(2u, resumeThreads.size());
1383 EXPECT_EQ(0u, stoppedThreads.size());
1384 }
1385
1386 sessionMock->newlyStoppedThreads.push_back(thread);
1387 sessionMock->newlyStoppedThreads.push_back(thread2);
1388 sessionMock->newlyStoppedThreads.push_back(thread3);
1389
1390 sessionMock->onlyForceException = false;
1391 {
1392 std::vector<EuThread::ThreadId> resumeThreads;
1393 std::vector<EuThread::ThreadId> stoppedThreads;
1394 std::vector<EuThread::ThreadId> interruptedThreads;
1395
1396 sessionMock->allThreads[thread]->stopThread(1u);
1397 sessionMock->allThreads[thread2]->stopThread(1u);
1398
1399 sessionMock->fillResumeAndStoppedThreadsFromNewlyStopped(resumeThreads, stoppedThreads, interruptedThreads);
1400 EXPECT_EQ(0u, resumeThreads.size());
1401 EXPECT_EQ(2u, stoppedThreads.size());
1402 }
1403 }
1404
1405 TEST(DebugSessionTest, givenPFThreadWithAIPEqStartIPWhenCallingFillResumeAndStoppedThreadsFromNewlyStoppedThenCRIsNotWritten) {
1406 zet_debug_config_t config = {};
1407 config.pid = 0x1234;
1408 auto hwInfo = *NEO::defaultHwInfo.get();
1409
1410 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1411 MockDeviceImp mockDevice(neoDevice);
1412
1413 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1414
1415 EuThread::ThreadId thread = {0, 0, 0, 0, 1};
1416
1417 sessionMock->newlyStoppedThreads.push_back(thread);
1418 sessionMock->onlyForceException = false;
1419 sessionMock->forceAIPEqualStartIP = true;
1420
1421 std::vector<EuThread::ThreadId> resumeThreads;
1422 std::vector<EuThread::ThreadId> stoppedThreads;
1423 std::vector<EuThread::ThreadId> interruptedThreads;
1424
1425 sessionMock->allThreads[thread]->stopThread(1u);
1426 sessionMock->allThreads[thread]->setPageFault(true);
1427
1428 sessionMock->fillResumeAndStoppedThreadsFromNewlyStopped(resumeThreads, stoppedThreads, interruptedThreads);
1429 EXPECT_EQ(0u, resumeThreads.size());
1430 EXPECT_EQ(1u, stoppedThreads.size());
1431 EXPECT_EQ(0u, sessionMock->writeRegistersCallCount);
1432 EXPECT_EQ(false, sessionMock->allThreads[thread]->getPageFault());
1433 }
1434
1435 TEST(DebugSessionTest, givenDbgRegAndCRThenisAIPequalToThreadStartIPReturnsCorrectResult) {
1436 zet_debug_config_t config = {};
1437 config.pid = 0x1234;
1438 auto hwInfo = *NEO::defaultHwInfo.get();
1439
1440 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1441 MockDeviceImp mockDevice(neoDevice);
1442
1443 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1444 sessionMock->callBaseisAIPequalToThreadStartIP = true;
1445 uint32_t dbg[4] = {0xDEADBEEF, 0, 0, 0};
1446 uint32_t cr[4] = {0, 0, 0xDEADBEEF, 0};
1447 EXPECT_TRUE(sessionMock->isAIPequalToThreadStartIP(cr, dbg));
1448 cr[2] = 0x1234567;
1449 EXPECT_FALSE(sessionMock->isAIPequalToThreadStartIP(cr, dbg));
1450 }
1451
1452 TEST(DebugSessionTest, givenThreadsStoppedWithPageFaultWhenCallingfillResumeAndStoppedThreadsFromNewlyStoppedThenCRIsWritten) {
1453 zet_debug_config_t config = {};
1454 config.pid = 0x1234;
1455 auto hwInfo = *NEO::defaultHwInfo.get();
1456
1457 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1458 MockDeviceImp mockDevice(neoDevice);
1459
1460 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1461
1462 EuThread::ThreadId thread = {0, 0, 0, 0, 1};
1463
1464 sessionMock->newlyStoppedThreads.push_back(thread);
1465 sessionMock->onlyForceException = false;
1466
1467 std::vector<EuThread::ThreadId> resumeThreads;
1468 std::vector<EuThread::ThreadId> stoppedThreads;
1469 std::vector<EuThread::ThreadId> interruptedThreads;
1470
1471 sessionMock->allThreads[thread]->stopThread(1u);
1472 sessionMock->allThreads[thread]->setPageFault(true);
1473
1474 sessionMock->fillResumeAndStoppedThreadsFromNewlyStopped(resumeThreads, stoppedThreads, interruptedThreads);
1475 EXPECT_EQ(0u, resumeThreads.size());
1476 EXPECT_EQ(1u, stoppedThreads.size());
1477 EXPECT_EQ(1u, sessionMock->writeRegistersCallCount);
1478 EXPECT_EQ(ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, sessionMock->writeRegistersReg);
1479 EXPECT_EQ(false, sessionMock->allThreads[thread]->getPageFault());
1480
1481 resumeThreads.clear();
1482 stoppedThreads.clear();
1483 sessionMock->newlyStoppedThreads.push_back(thread);
1484 sessionMock->onlyForceException = true;
1485 sessionMock->fillResumeAndStoppedThreadsFromNewlyStopped(resumeThreads, stoppedThreads, interruptedThreads);
1486 EXPECT_EQ(1u, resumeThreads.size());
1487 EXPECT_EQ(0u, stoppedThreads.size());
1488 EXPECT_EQ(1u, sessionMock->writeRegistersCallCount);
1489 }
1490
1491 TEST(DebugSessionTest, givenNoThreadsStoppedWhenCallingfillResumeAndStoppedThreadsFromNewlyStoppedThenReadStateSaveAreaNotCalled) {
1492 zet_debug_config_t config = {};
1493 config.pid = 0x1234;
1494 auto hwInfo = *NEO::defaultHwInfo.get();
1495
1496 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1497 MockDeviceImp mockDevice(neoDevice);
1498
1499 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1500 std::vector<EuThread::ThreadId> resumeThreads;
1501 std::vector<EuThread::ThreadId> stoppedThreads;
1502 std::vector<EuThread::ThreadId> interruptedThreads;
1503
1504 sessionMock->fillResumeAndStoppedThreadsFromNewlyStopped(resumeThreads, stoppedThreads, interruptedThreads);
1505
1506 EXPECT_EQ(0u, sessionMock->readStateSaveAreaHeaderCalled);
1507 }
1508
1509 TEST(DebugSessionTest, givenThreadsToResumeWhenResumeAccidentallyStoppedThreadsCalledThenThreadsResumed) {
1510 class InternalMockDebugSession : public MockDebugSession {
1511 public:
1512 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
1513 bool readSystemRoutineIdent(EuThread *thread, uint64_t vmHandle, SIP::sr_ident &srMagic) override {
1514 srMagic.count = counter++;
1515 return true;
1516 }
1517
1518 int counter = 0;
1519 };
1520 zet_debug_config_t config = {};
1521 config.pid = 0x1234;
1522 auto hwInfo = *NEO::defaultHwInfo.get();
1523
1524 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1525 MockDeviceImp mockDevice(neoDevice);
1526
1527 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
1528 sessionMock->skipCheckThreadIsResumed = false;
1529
1530 EuThread::ThreadId thread = {0, 0, 0, 0, 1};
1531 EuThread::ThreadId thread2 = {0, 0, 0, 1, 1};
1532
1533 std::vector<EuThread::ThreadId> threadIds;
1534 sessionMock->allThreads[thread]->verifyStopped(1u);
1535 sessionMock->allThreads[thread2]->verifyStopped(1u);
1536
1537 threadIds.push_back(thread);
1538 threadIds.push_back(thread2);
1539
1540 sessionMock->resumeAccidentallyStoppedThreads(threadIds);
1541
1542 EXPECT_EQ(2u, sessionMock->resumeThreadCount);
1543 EXPECT_EQ(1u, sessionMock->resumeImpCalled);
1544 EXPECT_EQ(3u, sessionMock->checkThreadIsResumedCalled);
1545
1546 EXPECT_TRUE(sessionMock->allThreads[thread]->isRunning());
1547 EXPECT_TRUE(sessionMock->allThreads[thread2]->isRunning());
1548 }
1549
1550 TEST(DebugSessionTest, givenCr0RegisterWhenIsFEOrFEHOnlyExceptionReasonThenTrueReturnedForFEorFEHBitsOnly) {
1551 zet_debug_config_t config = {};
1552 config.pid = 0x1234;
1553 auto hwInfo = *NEO::defaultHwInfo.get();
1554
1555 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1556 MockDeviceImp mockDevice(neoDevice);
1557
1558 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1559
1560 uint32_t cr0[8] = {0, 0, 0, 0, 0, 0, 0, 0};
1561 cr0[1] = 1 << 26;
1562 EXPECT_TRUE(sessionMock->isForceExceptionOrForceExternalHaltOnlyExceptionReasonBase(cr0));
1563 cr0[1] = 1 << 30;
1564 EXPECT_TRUE(sessionMock->isForceExceptionOrForceExternalHaltOnlyExceptionReasonBase(cr0));
1565 cr0[1] = (1 << 26) | (1 << 30);
1566 EXPECT_TRUE(sessionMock->isForceExceptionOrForceExternalHaltOnlyExceptionReasonBase(cr0));
1567
1568 cr0[1] = (1 << 27) | (1 << 30);
1569 EXPECT_FALSE(sessionMock->isForceExceptionOrForceExternalHaltOnlyExceptionReasonBase(cr0));
1570 cr0[1] = (1 << 27) | (1 << 26);
1571 EXPECT_FALSE(sessionMock->isForceExceptionOrForceExternalHaltOnlyExceptionReasonBase(cr0));
1572 cr0[1] = (1 << 28);
1573 EXPECT_FALSE(sessionMock->isForceExceptionOrForceExternalHaltOnlyExceptionReasonBase(cr0));
1574 cr0[1] = (1 << 23);
1575 EXPECT_FALSE(sessionMock->isForceExceptionOrForceExternalHaltOnlyExceptionReasonBase(cr0));
1576 }
1577
1578 TEST(DebugSessionTest, givenSomeThreadsRunningWhenResumeCalledThenOnlyStoppedThreadsResumed) {
1579 zet_debug_config_t config = {};
1580 config.pid = 0x1234;
1581 auto hwInfo = *NEO::defaultHwInfo.get();
1582
1583 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1584 MockDeviceImp mockDevice(neoDevice);
1585
1586 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1587
1588 ze_device_thread_t thread = {0, 0, 0, UINT32_MAX};
1589
1590 for (uint32_t i = 0; i < hwInfo.gtSystemInfo.NumThreadsPerEu; i++) {
1591 EuThread::ThreadId thread(0, 0, 0, 0, i);
1592 sessionMock->allThreads[thread]->stopThread(1u);
1593 sessionMock->allThreads[thread]->reportAsStopped();
1594 }
1595
1596 EuThread::ThreadId euthread(0, 0, 0, 0, 3);
1597 sessionMock->allThreads[euthread]->resumeThread();
1598
1599 auto result = sessionMock->resume(thread);
1600
1601 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1602 EXPECT_EQ(hwInfo.gtSystemInfo.NumThreadsPerEu - 1u, sessionMock->resumeThreadCount);
1603
1604 for (uint32_t i = 0; i < hwInfo.gtSystemInfo.NumThreadsPerEu; i++) {
1605 EuThread::ThreadId thread(0, 0, 0, 0, i);
1606 EXPECT_TRUE(sessionMock->allThreads[thread]->isRunning());
1607 }
1608 }
1609
1610 TEST(DebugSessionTest, givenStoppedThreadsWhenResumeAllCalledThenOnlyReportedStoppedThreadsAreResumed) {
1611 zet_debug_config_t config = {};
1612 config.pid = 0x1234;
1613 auto hwInfo = *NEO::defaultHwInfo.get();
1614
1615 hwInfo.gtSystemInfo.EUCount = 8;
1616 hwInfo.gtSystemInfo.ThreadCount = 8 * hwInfo.gtSystemInfo.EUCount;
1617
1618 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1619 MockDeviceImp mockDevice(neoDevice);
1620
1621 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1622
1623 {
1624 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
1625 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
1626 pStateSaveAreaHeader->regHeader.state_area_offset +
1627 pStateSaveAreaHeader->regHeader.state_save_size * 16;
1628 sessionMock->stateSaveAreaHeader.resize(size);
1629 }
1630
1631 for (uint32_t i = 0; i < hwInfo.gtSystemInfo.NumThreadsPerEu; i++) {
1632 // set reportAsStopped threads from EU0
1633 EuThread::ThreadId thread(0, 0, 0, 0, i);
1634 sessionMock->allThreads[thread]->stopThread(1u);
1635 sessionMock->allThreads[thread]->reportAsStopped();
1636
1637 // stop threads from EU1, but do not report as stopped
1638 EuThread::ThreadId thread1(0, 0, 0, 1, i);
1639 sessionMock->allThreads[thread1]->stopThread(1u); // do not report as stopped
1640 }
1641
1642 ze_device_thread_t threadAll = {UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX};
1643 auto result = sessionMock->resume(threadAll);
1644
1645 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1646 // only threads from EU0 resumed
1647 EXPECT_EQ(hwInfo.gtSystemInfo.NumThreadsPerEu, sessionMock->resumeThreadCount);
1648
1649 for (uint32_t i = 0; i < hwInfo.gtSystemInfo.NumThreadsPerEu; i++) {
1650 EuThread::ThreadId thread(0, 0, 0, 0, i);
1651 EXPECT_TRUE(sessionMock->allThreads[thread]->isRunning());
1652
1653 EuThread::ThreadId thread1(0, 0, 0, 1, i);
1654 EXPECT_FALSE(sessionMock->allThreads[thread1]->isRunning());
1655 }
1656 }
1657
1658 TEST(DebugSessionTest, givenMultipleStoppedThreadsWhenResumeAllCalledThenStateSaveAreaIsReadOnceAndUsedByAllThreads) {
1659 zet_debug_config_t config = {};
1660 config.pid = 0x1234;
1661 auto hwInfo = *NEO::defaultHwInfo.get();
1662 hwInfo.gtSystemInfo.EUCount = 8;
1663 hwInfo.gtSystemInfo.ThreadCount = 8 * hwInfo.gtSystemInfo.EUCount;
1664
1665 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1666 MockDeviceImp mockDevice(neoDevice);
1667
1668 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1669
1670 {
1671 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
1672 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
1673 pStateSaveAreaHeader->regHeader.state_area_offset +
1674 pStateSaveAreaHeader->regHeader.state_save_size * 16;
1675 sessionMock->stateSaveAreaHeader.resize(size);
1676 }
1677
1678 auto threadCount = hwInfo.gtSystemInfo.NumThreadsPerEu;
1679 for (uint32_t i = 0; i < threadCount; i++) {
1680 // set reportAsStopped threads from EU0
1681 EuThread::ThreadId thread(0, 0, 0, 0, i);
1682 sessionMock->allThreads[thread]->stopThread(1u);
1683 sessionMock->allThreads[thread]->reportAsStopped();
1684 }
1685
1686 ze_device_thread_t threadAll = {UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX};
1687 auto result = sessionMock->resume(threadAll);
1688
1689 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1690 EXPECT_EQ(threadCount, sessionMock->resumeThreadCount);
1691
1692 EXPECT_EQ(threadCount, sessionMock->checkThreadIsResumedFromPassedSaveAreaCalled);
1693 EXPECT_EQ(0u, sessionMock->checkThreadIsResumedCalled);
1694
1695 for (uint32_t i = 0; i < threadCount; i++) {
1696 EuThread::ThreadId thread(0, 0, 0, 0, i);
1697 EXPECT_TRUE(sessionMock->allThreads[thread]->isRunning());
1698 }
1699
1700 // One thread stopped
1701 threadCount = 1;
1702 EuThread::ThreadId thread(0, 0, 0, 0, 0);
1703 sessionMock->allThreads[thread]->stopThread(3u);
1704 sessionMock->allThreads[thread]->reportAsStopped();
1705 sessionMock->checkThreadIsResumedFromPassedSaveAreaCalled = 0;
1706 sessionMock->resumeThreadCount = 0;
1707 sessionMock->checkThreadIsResumedCalled = 0;
1708
1709 result = sessionMock->resume(threadAll);
1710
1711 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1712 EXPECT_EQ(threadCount, sessionMock->resumeThreadCount);
1713 EXPECT_EQ(0u, sessionMock->checkThreadIsResumedFromPassedSaveAreaCalled);
1714 EXPECT_EQ(threadCount, sessionMock->checkThreadIsResumedCalled);
1715 }
1716
1717 TEST(DebugSessionTest, givenMultipleStoppedThreadsWhenResumeAllCalledThenStateSaveAreaIsReadUntilThreadsConfirmedToBeResumed) {
1718
1719 class InternalMockDebugSession : public MockDebugSession {
1720 public:
1721 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
1722 ze_result_t readGpuMemory(uint64_t memoryHandle, char *output, size_t size, uint64_t gpuVa) override {
1723 if (readCount == 0) {
1724 skipCheckThreadIsResumed = true;
1725 } else {
1726 readCount--;
1727 }
1728 return MockDebugSession::readGpuMemory(memoryHandle, output, size, gpuVa);
1729 }
1730
1731 int readCount = 0;
1732 };
1733
1734 zet_debug_config_t config = {};
1735 config.pid = 0x1234;
1736 auto hwInfo = *NEO::defaultHwInfo.get();
1737 hwInfo.gtSystemInfo.EUCount = 8;
1738 hwInfo.gtSystemInfo.ThreadCount = 8 * hwInfo.gtSystemInfo.EUCount;
1739
1740 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1741 MockDeviceImp mockDevice(neoDevice);
1742
1743 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
1744 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
1745 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
1746 pStateSaveAreaHeader->regHeader.state_area_offset +
1747 pStateSaveAreaHeader->regHeader.state_save_size * 16;
1748 sessionMock->stateSaveAreaHeader.resize(size);
1749
1750 auto threadCount = hwInfo.gtSystemInfo.NumThreadsPerEu;
1751 for (uint32_t i = 0; i < threadCount; i++) {
1752 // set reportAsStopped threads from EU0
1753 EuThread::ThreadId thread(0, 0, 0, 0, i);
1754 sessionMock->allThreads[thread]->stopThread(1u);
1755 sessionMock->allThreads[thread]->reportAsStopped();
1756 sessionMock->allThreads[thread]->verifyStopped(1);
1757
1758 auto threadSlotOffset = sessionMock->calculateThreadSlotOffset(thread);
1759 auto srMagicOffset = threadSlotOffset + pStateSaveAreaHeader->regHeader.sr_magic_offset;
1760 SIP::sr_ident srMagic;
1761 srMagic.count = 1;
1762 sessionMock->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(sessionMock->stateSaveAreaHeader.data()) + srMagicOffset);
1763 }
1764
1765 sessionMock->skipCheckThreadIsResumed = false;
1766 sessionMock->readCount = threadCount;
1767
1768 ze_device_thread_t threadAll = {UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX};
1769 auto result = sessionMock->resume(threadAll);
1770
1771 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1772 EXPECT_EQ(threadCount, sessionMock->resumeThreadCount);
1773
1774 // After threadCount reads, debug session sets skipCheckThreadIsResumed and treats
1775 // threads as resumed
1776 EXPECT_EQ(2 * threadCount, sessionMock->checkThreadIsResumedFromPassedSaveAreaCalled);
1777 EXPECT_EQ(0u, sessionMock->checkThreadIsResumedCalled);
1778
1779 for (uint32_t i = 0; i < threadCount; i++) {
1780 EuThread::ThreadId thread(0, 0, 0, 0, i);
1781 EXPECT_TRUE(sessionMock->allThreads[thread]->isRunning());
1782 }
1783 }
1784
1785 TEST(DebugSessionTest, givenMultipleStoppedThreadsAndInvalidStateSaveAreaWhenResumeAllCalledThenThreadsAreSwitchedToResumed) {
1786 zet_debug_config_t config = {};
1787 config.pid = 0x1234;
1788 auto hwInfo = *NEO::defaultHwInfo.get();
1789 hwInfo.gtSystemInfo.EUCount = 8;
1790 hwInfo.gtSystemInfo.ThreadCount = 8 * hwInfo.gtSystemInfo.EUCount;
1791
1792 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1793 MockDeviceImp mockDevice(neoDevice);
1794
1795 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1796 sessionMock->forceStateSaveAreaSize = 0;
1797
1798 auto threadCount = hwInfo.gtSystemInfo.NumThreadsPerEu;
1799 for (uint32_t i = 0; i < threadCount; i++) {
1800 EuThread::ThreadId thread(0, 0, 0, 0, i);
1801 sessionMock->allThreads[thread]->stopThread(1u);
1802 sessionMock->allThreads[thread]->reportAsStopped();
1803 }
1804
1805 ze_device_thread_t threadAll = {UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX};
1806 auto result = sessionMock->resume(threadAll);
1807
1808 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1809 EXPECT_EQ(threadCount, sessionMock->resumeThreadCount);
1810
1811 EXPECT_EQ(0u, sessionMock->checkThreadIsResumedFromPassedSaveAreaCalled);
1812 EXPECT_EQ(0u, sessionMock->checkThreadIsResumedCalled);
1813
1814 for (uint32_t i = 0; i < threadCount; i++) {
1815 EuThread::ThreadId thread(0, 0, 0, 0, i);
1816 EXPECT_TRUE(sessionMock->allThreads[thread]->isRunning());
1817 }
1818
1819 sessionMock->stateSaveAreaHeader.resize(0);
1820
1821 for (uint32_t i = 0; i < threadCount; i++) {
1822 EuThread::ThreadId thread(0, 0, 0, 0, i);
1823 sessionMock->allThreads[thread]->stopThread(1u);
1824 sessionMock->allThreads[thread]->reportAsStopped();
1825 }
1826
1827 result = sessionMock->resume(threadAll);
1828
1829 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1830 EXPECT_EQ(threadCount, sessionMock->resumeThreadCount);
1831
1832 EXPECT_EQ(0u, sessionMock->checkThreadIsResumedFromPassedSaveAreaCalled);
1833 EXPECT_EQ(0u, sessionMock->checkThreadIsResumedCalled);
1834
1835 for (uint32_t i = 0; i < threadCount; i++) {
1836 EuThread::ThreadId thread(0, 0, 0, 0, i);
1837 EXPECT_TRUE(sessionMock->allThreads[thread]->isRunning());
1838 }
1839 }
1840
1841 TEST(DebugSessionTest, givenStoppedThreadWhenResumeCalledThenStoppedThreadsAreCheckedSynchronously) {
1842 zet_debug_config_t config = {};
1843 config.pid = 0x1234;
1844 auto hwInfo = *NEO::defaultHwInfo.get();
1845
1846 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1847 MockDeviceImp mockDevice(neoDevice);
1848
1849 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1850
1851 ze_device_thread_t apiThread = {0, 0, 0, 1};
1852 EuThread::ThreadId thread(0, apiThread);
1853 sessionMock->allThreads[thread]->stopThread(1u);
1854 sessionMock->allThreads[thread]->reportAsStopped();
1855
1856 auto result = sessionMock->resume(apiThread);
1857
1858 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
1859 EXPECT_EQ(1u, sessionMock->checkStoppedThreadsAndGenerateEventsCallCount);
1860 }
1861
1862 TEST(DebugSessionTest, givenAllThreadsRunningWhenResumeCalledThenErrorUnavailableReturned) {
1863 zet_debug_config_t config = {};
1864 config.pid = 0x1234;
1865 auto hwInfo = *NEO::defaultHwInfo.get();
1866
1867 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1868 MockDeviceImp mockDevice(neoDevice);
1869
1870 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1871
1872 ze_device_thread_t thread = {0, 0, 0, 1};
1873 auto result = sessionMock->resume(thread);
1874 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
1875 }
1876
1877 TEST(DebugSessionTest, givenErrorFromResumeImpWhenResumeCalledThenErrorReturned) {
1878 zet_debug_config_t config = {};
1879 config.pid = 0x1234;
1880 auto hwInfo = *NEO::defaultHwInfo.get();
1881
1882 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1883 MockDeviceImp mockDevice(neoDevice);
1884
1885 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1886 sessionMock->resumeImpResult = ZE_RESULT_ERROR_UNKNOWN;
1887
1888 ze_device_thread_t thread = {0, 0, 0, 1};
1889 sessionMock->allThreads[EuThread::ThreadId(0, thread)]->stopThread(1u);
1890 sessionMock->allThreads[EuThread::ThreadId(0, thread)]->reportAsStopped();
1891
1892 auto result = sessionMock->resume(thread);
1893 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
1894 }
1895
1896 TEST(DebugSessionTest, givenErrorFromReadSbaBufferWhenReadSbaRegistersCalledThenErrorReturned) {
1897 zet_debug_config_t config = {};
1898 config.pid = 0x1234;
1899 auto hwInfo = *NEO::defaultHwInfo.get();
1900
1901 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1902 MockDeviceImp mockDevice(neoDevice);
1903
1904 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1905 sessionMock->readSbaBufferResult = ZE_RESULT_ERROR_UNKNOWN;
1906
1907 ze_device_thread_t thread = {0, 0, 0, 0};
1908 uint64_t sba[9];
1909 auto result = sessionMock->readSbaRegisters(EuThread::ThreadId(0, thread), 0, 9, sba);
1910 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
1911 }
1912
1913 TEST(DebugSessionTest, givenErrorFromReadRegistersWhenReadSbaRegistersCalledThenErrorReturned) {
1914 zet_debug_config_t config = {};
1915 config.pid = 0x1234;
1916 auto hwInfo = *NEO::defaultHwInfo.get();
1917
1918 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1919 MockDeviceImp mockDevice(neoDevice);
1920
1921 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1922 sessionMock->readRegistersResult = ZE_RESULT_ERROR_UNKNOWN;
1923
1924 ze_device_thread_t thread = {0, 0, 0, 0};
1925 uint64_t sba[9];
1926 auto result = sessionMock->readSbaRegisters(EuThread::ThreadId(0, thread), 0, 9, sba);
1927 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
1928 }
1929
1930 HWTEST2_F(DebugSessionTest, givenErrorFromReadMemoryWhenReadSbaRegistersCalledThenErrorReturned, IsAtLeastXeCore) {
1931 zet_debug_config_t config = {};
1932 config.pid = 0x1234;
1933 auto hwInfo = *NEO::defaultHwInfo.get();
1934
1935 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1936 MockDeviceImp mockDevice(neoDevice);
1937
1938 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1939 sessionMock->readRegistersResult = ZE_RESULT_SUCCESS;
1940 sessionMock->readMemoryResult = ZE_RESULT_ERROR_UNKNOWN;
1941 sessionMock->readRegistersSizeToFill = 6 * sizeof(uint32_t);
1942
1943 uint32_t *scratchIndex = reinterpret_cast<uint32_t *>(ptrOffset(sessionMock->regs, 5 * sizeof(uint32_t)));
1944 *scratchIndex = 1u << 10u;
1945
1946 ze_device_thread_t thread = {0, 0, 0, 0};
1947 uint64_t sba[9];
1948
1949 auto result = sessionMock->readSbaRegisters(EuThread::ThreadId(0, thread), 0, 9, sba);
1950
1951 auto &gfxCoreHelper = neoDevice->getGfxCoreHelper();
1952 EXPECT_TRUE(gfxCoreHelper.isScratchSpaceSurfaceStateAccessible());
1953 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
1954 }
1955
1956 TEST(DebugSessionTest, givenUnknownRegsetTypeWhenTypeToRegsetFlagsCalledThenZeroIsReturned) {
1957 EXPECT_EQ(0u, DebugSessionImp::typeToRegsetFlags(0));
1958 EXPECT_EQ(0u, DebugSessionImp::typeToRegsetFlags(UINT32_MAX));
1959 }
1960
1961 TEST(DebugSessionTest, givenNullptrStateSaveAreaGpuVaWhenCallingCheckIsThreadResumedThenReportThreadHasBeenResumed) {
1962 class InternalMockDebugSession : public MockDebugSession {
1963 public:
1964 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
1965 uint64_t getContextStateSaveAreaGpuVa(uint64_t memoryHandle) override {
1966 return 0;
1967 };
1968 };
1969 zet_debug_config_t config = {};
1970 config.pid = 0x1234;
1971 auto hwInfo = *NEO::defaultHwInfo.get();
1972
1973 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1974 MockDeviceImp mockDevice(neoDevice);
1975
1976 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
1977 ASSERT_NE(nullptr, sessionMock);
1978 sessionMock->skipCheckThreadIsResumed = false;
1979
1980 ze_device_thread_t thread = {0, 0, 0, 0};
1981 EuThread::ThreadId threadId(0, thread);
1982 bool resumed = sessionMock->checkThreadIsResumed(threadId);
1983
1984 EXPECT_TRUE(resumed);
1985 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
1986 }
1987
1988 TEST(DebugSessionTest, whenCallingCheckThreadIsResumedWithoutSrMagicThenThreadIsAssumedRunning) {
1989 zet_debug_config_t config = {};
1990 config.pid = 0x1234;
1991 auto hwInfo = *NEO::defaultHwInfo.get();
1992
1993 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
1994 MockDeviceImp mockDevice(neoDevice);
1995
1996 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
1997 ASSERT_NE(nullptr, sessionMock);
1998 sessionMock->skipCheckThreadIsResumed = false;
1999 sessionMock->skipReadSystemRoutineIdent = false;
2000
2001 {
2002 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
2003 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
2004 pStateSaveAreaHeader->regHeader.state_area_offset +
2005 pStateSaveAreaHeader->regHeader.state_save_size * 16;
2006 sessionMock->stateSaveAreaHeader.resize(size);
2007 }
2008
2009 auto stateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(sessionMock->stateSaveAreaHeader.data());
2010 ze_device_thread_t thread = {0, 0, 0, 0};
2011 EuThread::ThreadId threadId(0, thread);
2012
2013 auto threadSlotOffset = sessionMock->calculateThreadSlotOffset(threadId);
2014 auto srMagicOffset = threadSlotOffset + stateSaveAreaHeader->regHeader.sr_magic_offset;
2015 SIP::sr_ident srMagic = {{0}};
2016 sessionMock->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(stateSaveAreaHeader) + srMagicOffset);
2017
2018 bool resumed = sessionMock->checkThreadIsResumed(threadId);
2019
2020 EXPECT_TRUE(resumed);
2021 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2022 }
2023
2024 TEST(DebugSessionTest, givenErrorFromReadSystemRoutineIdentWhenCallingCheckThreadIsResumedThenThreadIsAssumedRunning) {
2025 zet_debug_config_t config = {};
2026 config.pid = 0x1234;
2027 auto hwInfo = *NEO::defaultHwInfo.get();
2028
2029 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2030 MockDeviceImp mockDevice(neoDevice);
2031
2032 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2033 ASSERT_NE(nullptr, sessionMock);
2034 sessionMock->skipCheckThreadIsResumed = false;
2035 sessionMock->readSystemRoutineIdentRetVal = false;
2036
2037 ze_device_thread_t thread = {0, 0, 0, 0};
2038 EuThread::ThreadId threadId(0, thread);
2039 bool resumed = sessionMock->checkThreadIsResumed(threadId);
2040 EXPECT_TRUE(resumed);
2041
2042 resumed = sessionMock->checkThreadIsResumed(threadId, sessionMock->stateSaveAreaHeader.data());
2043 EXPECT_TRUE(resumed);
2044 }
2045
2046 TEST(DebugSessionTest, givenSipVersion1WhenCallingCheckThreadIsResumedWithSaveAreaThenThreadIsAssumedRunning) {
2047 zet_debug_config_t config = {};
2048 config.pid = 0x1234;
2049 auto hwInfo = *NEO::defaultHwInfo.get();
2050
2051 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2052 MockDeviceImp mockDevice(neoDevice);
2053
2054 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2055 ASSERT_NE(nullptr, sessionMock);
2056 sessionMock->skipCheckThreadIsResumed = false;
2057 sessionMock->readSystemRoutineIdentRetVal = false;
2058 sessionMock->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(1);
2059
2060 ze_device_thread_t thread = {0, 0, 0, 0};
2061 EuThread::ThreadId threadId(0, thread);
2062
2063 bool resumed = sessionMock->checkThreadIsResumed(threadId, sessionMock->stateSaveAreaHeader.data());
2064 EXPECT_TRUE(resumed);
2065 }
2066
2067 TEST(DebugSessionTest, givenSrMagicWithCounterLessThanlLastThreadCounterThenThreadHasBeenResumed) {
2068 class InternalMockDebugSession : public MockDebugSession {
2069 public:
2070 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
2071 bool readSystemRoutineIdent(EuThread *thread, uint64_t vmHandle, SIP::sr_ident &srMagic) override {
2072 srMagic.count = 0;
2073 return true;
2074 }
2075 bool readSystemRoutineIdentFromMemory(EuThread *thread, const void *stateSaveArea, SIP::sr_ident &srMagic) override {
2076 srMagic.count = 0;
2077 return true;
2078 }
2079 };
2080 zet_debug_config_t config = {};
2081 config.pid = 0x1234;
2082 auto hwInfo = *NEO::defaultHwInfo.get();
2083
2084 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2085 MockDeviceImp mockDevice(neoDevice);
2086
2087 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
2088 ASSERT_NE(nullptr, sessionMock);
2089 sessionMock->skipCheckThreadIsResumed = false;
2090
2091 ze_device_thread_t thread = {0, 0, 0, 0};
2092 EuThread::ThreadId threadId(0, thread);
2093 sessionMock->allThreads[threadId]->verifyStopped(1u);
2094 sessionMock->allThreads[threadId]->stopThread(1u);
2095 bool resumed = sessionMock->checkThreadIsResumed(threadId);
2096
2097 EXPECT_TRUE(resumed);
2098 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2099
2100 resumed = sessionMock->checkThreadIsResumed(threadId, sessionMock->stateSaveAreaHeader.data());
2101
2102 EXPECT_TRUE(resumed);
2103 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedFromPassedSaveAreaCalled);
2104 }
2105
2106 TEST(DebugSessionTest, givenSrMagicWithCounterEqualToPrevousThenThreadHasNotBeenResumed) {
2107 class InternalMockDebugSession : public MockDebugSession {
2108 public:
2109 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
2110 bool readSystemRoutineIdent(EuThread *thread, uint64_t vmHandle, SIP::sr_ident &srMagic) override {
2111 srMagic.count = 1;
2112 return true;
2113 }
2114 };
2115 zet_debug_config_t config = {};
2116 config.pid = 0x1234;
2117 auto hwInfo = *NEO::defaultHwInfo.get();
2118
2119 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2120 MockDeviceImp mockDevice(neoDevice);
2121
2122 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
2123 ASSERT_NE(nullptr, sessionMock);
2124 sessionMock->skipCheckThreadIsResumed = false;
2125
2126 ze_device_thread_t thread = {0, 0, 0, 0};
2127 EuThread::ThreadId threadId(0, thread);
2128 sessionMock->allThreads[threadId]->verifyStopped(1u);
2129 sessionMock->allThreads[threadId]->stopThread(1u);
2130
2131 EXPECT_EQ(1u, sessionMock->allThreads[threadId]->getLastCounter());
2132
2133 bool resumed = sessionMock->checkThreadIsResumed(threadId);
2134
2135 EXPECT_FALSE(resumed);
2136 }
2137
2138 TEST(DebugSessionTest, givenSrMagicWithCounterBiggerThanPreviousThenThreadIsResumed) {
2139 class InternalMockDebugSession : public MockDebugSession {
2140 public:
2141 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
2142 bool readSystemRoutineIdent(EuThread *thread, uint64_t vmHandle, SIP::sr_ident &srMagic) override {
2143 srMagic.count = 3;
2144 return true;
2145 }
2146 };
2147 zet_debug_config_t config = {};
2148 config.pid = 0x1234;
2149 auto hwInfo = *NEO::defaultHwInfo.get();
2150
2151 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2152 MockDeviceImp mockDevice(neoDevice);
2153
2154 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
2155 ASSERT_NE(nullptr, sessionMock);
2156 sessionMock->skipCheckThreadIsResumed = false;
2157
2158 ze_device_thread_t thread = {0, 0, 0, 0};
2159 EuThread::ThreadId threadId(0, thread);
2160 sessionMock->allThreads[threadId]->verifyStopped(1u);
2161 sessionMock->allThreads[threadId]->stopThread(1u);
2162
2163 EXPECT_EQ(1u, sessionMock->allThreads[threadId]->getLastCounter());
2164
2165 bool resumed = sessionMock->checkThreadIsResumed(threadId);
2166
2167 EXPECT_TRUE(resumed);
2168 }
2169
2170 TEST(DebugSessionTest, givenSrMagicWithCounterOverflowingZeroThenThreadIsResumed) {
2171 class InternalMockDebugSession : public MockDebugSession {
2172 public:
2173 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
2174 bool readSystemRoutineIdent(EuThread *thread, uint64_t vmHandle, SIP::sr_ident &srMagic) override {
2175 srMagic.count = 0;
2176 return true;
2177 }
2178 };
2179 zet_debug_config_t config = {};
2180 config.pid = 0x1234;
2181 auto hwInfo = *NEO::defaultHwInfo.get();
2182
2183 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2184 MockDeviceImp mockDevice(neoDevice);
2185
2186 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
2187 ASSERT_NE(nullptr, sessionMock);
2188 sessionMock->skipCheckThreadIsResumed = false;
2189
2190 ze_device_thread_t thread = {0, 0, 0, 0};
2191 EuThread::ThreadId threadId(0, thread);
2192 sessionMock->allThreads[threadId]->verifyStopped(255u);
2193 sessionMock->allThreads[threadId]->stopThread(1u);
2194
2195 EXPECT_EQ(255u, sessionMock->allThreads[threadId]->getLastCounter());
2196
2197 bool resumed = sessionMock->checkThreadIsResumed(threadId);
2198 EXPECT_TRUE(resumed);
2199 }
2200
2201 TEST(DebugSessionTest, GivenBindlessSipVersion1AndResumeWARequiredWhenCallingResumeThenBitInRegisterIsWritten) {
2202 zet_debug_config_t config = {};
2203 config.pid = 0x1234;
2204 auto hwInfo = *NEO::defaultHwInfo.get();
2205
2206 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2207 MockDeviceImp mockDevice(neoDevice);
2208
2209 auto &l0GfxCoreHelper = neoDevice->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
2210
2211 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2212 ASSERT_NE(nullptr, sessionMock);
2213 sessionMock->readRegistersResult = ZE_RESULT_SUCCESS;
2214 sessionMock->writeRegistersResult = ZE_RESULT_SUCCESS;
2215 sessionMock->readMemoryResult = ZE_RESULT_SUCCESS;
2216 sessionMock->debugArea.reserved1 = 1u;
2217 sessionMock->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(1);
2218 sessionMock->skipWriteResumeCommand = false;
2219 sessionMock->skipCheckThreadIsResumed = false;
2220
2221 ze_device_thread_t thread = {0, 0, 0, 0};
2222 EuThread::ThreadId threadId(0, thread);
2223 sessionMock->allThreads[threadId]->stopThread(1u);
2224 sessionMock->allThreads[threadId]->reportAsStopped();
2225
2226 auto result = sessionMock->resume(thread);
2227 EXPECT_EQ(result, ZE_RESULT_SUCCESS);
2228
2229 if (l0GfxCoreHelper.isResumeWARequired()) {
2230 EXPECT_EQ(1u, sessionMock->readRegistersCallCount);
2231 EXPECT_EQ(1u, sessionMock->writeRegistersCallCount);
2232 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2233 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2234 EXPECT_EQ(uint32_t(ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU), sessionMock->readRegistersReg);
2235 EXPECT_EQ(uint32_t(ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU), sessionMock->writeRegistersReg);
2236 } else {
2237 EXPECT_EQ(0u, sessionMock->readRegistersCallCount);
2238 EXPECT_EQ(0u, sessionMock->writeRegistersCallCount);
2239 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2240 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2241 }
2242
2243 EXPECT_FALSE(sessionMock->allThreads[threadId]->isStopped());
2244 }
2245
2246 TEST(DebugSessionTest, GivenErrorFromReadRegisterWhenResumingThreadThenRegisterIsNotWrittenWithResumeBitAndErrorReturned) {
2247 zet_debug_config_t config = {};
2248 config.pid = 0x1234;
2249 auto hwInfo = *NEO::defaultHwInfo.get();
2250
2251 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2252 MockDeviceImp mockDevice(neoDevice);
2253
2254 auto &l0GfxCoreHelper = neoDevice->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
2255
2256 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2257 ASSERT_NE(nullptr, sessionMock);
2258 sessionMock->readRegistersResult = ZE_RESULT_ERROR_UNKNOWN;
2259 sessionMock->writeRegistersResult = ZE_RESULT_SUCCESS;
2260 sessionMock->readMemoryResult = ZE_RESULT_SUCCESS;
2261 sessionMock->debugArea.reserved1 = 1u;
2262 sessionMock->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(1);
2263 sessionMock->skipWriteResumeCommand = false;
2264 sessionMock->skipCheckThreadIsResumed = false;
2265
2266 ze_device_thread_t thread = {0, 0, 0, 0};
2267 EuThread::ThreadId threadId(0, thread);
2268 sessionMock->allThreads[threadId]->stopThread(1u);
2269 sessionMock->allThreads[threadId]->reportAsStopped();
2270
2271 auto result = sessionMock->resume(thread);
2272
2273 if (l0GfxCoreHelper.isResumeWARequired()) {
2274 EXPECT_EQ(1u, sessionMock->readRegistersCallCount);
2275 EXPECT_EQ(0u, sessionMock->writeRegistersCallCount);
2276 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2277 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2278 EXPECT_EQ(uint32_t(ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU), sessionMock->readRegistersReg);
2279 EXPECT_EQ(0u, sessionMock->writeRegistersReg);
2280 EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN);
2281 } else {
2282 EXPECT_EQ(0u, sessionMock->readRegistersCallCount);
2283 EXPECT_EQ(0u, sessionMock->writeRegistersCallCount);
2284 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2285 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2286
2287 EXPECT_EQ(result, ZE_RESULT_SUCCESS);
2288 }
2289
2290 EXPECT_FALSE(sessionMock->allThreads[threadId]->isStopped());
2291 }
2292
2293 TEST(DebugSessionTest, GivenErrorFromWriteRegisterWhenResumingThreadThenRegisterIsNotWrittenWithResumeBitAndErrorReturned) {
2294 zet_debug_config_t config = {};
2295 config.pid = 0x1234;
2296 auto hwInfo = *NEO::defaultHwInfo.get();
2297
2298 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2299 MockDeviceImp mockDevice(neoDevice);
2300
2301 auto &l0GfxCoreHelper = neoDevice->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
2302
2303 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2304 ASSERT_NE(nullptr, sessionMock);
2305 sessionMock->readRegistersResult = ZE_RESULT_SUCCESS;
2306 sessionMock->writeRegistersResult = ZE_RESULT_ERROR_UNKNOWN;
2307 sessionMock->readMemoryResult = ZE_RESULT_SUCCESS;
2308 sessionMock->debugArea.reserved1 = 1u;
2309 sessionMock->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(1);
2310 sessionMock->skipWriteResumeCommand = false;
2311 sessionMock->skipCheckThreadIsResumed = false;
2312
2313 ze_device_thread_t thread = {0, 0, 0, 0};
2314 EuThread::ThreadId threadId(0, thread);
2315 sessionMock->allThreads[threadId]->stopThread(1u);
2316 sessionMock->allThreads[threadId]->reportAsStopped();
2317
2318 auto result = sessionMock->resume(thread);
2319
2320 if (l0GfxCoreHelper.isResumeWARequired()) {
2321 EXPECT_EQ(1u, sessionMock->readRegistersCallCount);
2322 EXPECT_EQ(1u, sessionMock->writeRegistersCallCount);
2323 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2324 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2325 EXPECT_EQ(uint32_t(ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU), sessionMock->readRegistersReg);
2326 EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN);
2327 } else {
2328 EXPECT_EQ(0u, sessionMock->readRegistersCallCount);
2329 EXPECT_EQ(0u, sessionMock->writeRegistersCallCount);
2330 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2331 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2332
2333 EXPECT_EQ(result, ZE_RESULT_SUCCESS);
2334 }
2335
2336 EXPECT_FALSE(sessionMock->allThreads[threadId]->isStopped());
2337 }
2338
2339 TEST(DebugSessionTest, GivenNonBindlessSipVersion1AndResumeWARequiredWhenCallingResumeThenBitInRegisterIsWritten) {
2340 zet_debug_config_t config = {};
2341 config.pid = 0x1234;
2342 auto hwInfo = *NEO::defaultHwInfo.get();
2343
2344 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2345 MockDeviceImp mockDevice(neoDevice);
2346
2347 auto &l0GfxCoreHelper = neoDevice->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
2348
2349 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2350 ASSERT_NE(nullptr, sessionMock);
2351 sessionMock->readRegistersResult = ZE_RESULT_SUCCESS;
2352 sessionMock->writeRegistersResult = ZE_RESULT_SUCCESS;
2353 sessionMock->readMemoryResult = ZE_RESULT_SUCCESS;
2354 sessionMock->debugArea.reserved1 = 0u;
2355 sessionMock->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(1);
2356 sessionMock->skipWriteResumeCommand = false;
2357 sessionMock->skipCheckThreadIsResumed = false;
2358
2359 ze_device_thread_t thread = {0, 0, 0, 0};
2360 EuThread::ThreadId threadId(0, thread);
2361 sessionMock->allThreads[threadId]->stopThread(1u);
2362 sessionMock->allThreads[threadId]->reportAsStopped();
2363
2364 auto result = sessionMock->resume(thread);
2365 EXPECT_EQ(result, ZE_RESULT_SUCCESS);
2366
2367 if (l0GfxCoreHelper.isResumeWARequired()) {
2368 EXPECT_EQ(1u, sessionMock->readRegistersCallCount);
2369 EXPECT_EQ(1u, sessionMock->writeRegistersCallCount);
2370 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2371 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2372 EXPECT_EQ(uint32_t(ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU), sessionMock->writeRegistersReg);
2373 } else {
2374 EXPECT_EQ(0u, sessionMock->readRegistersCallCount);
2375 EXPECT_EQ(0u, sessionMock->writeRegistersCallCount);
2376 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2377 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2378 }
2379
2380 EXPECT_FALSE(sessionMock->allThreads[threadId]->isStopped());
2381 }
2382
2383 TEST(DebugSessionTest, GivenBindlessSipVersion2WhenWritingResumeFailsThenErrorIsReturned) {
2384 class InternalMockDebugSession : public MockDebugSession {
2385 public:
2386 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
2387 bool readSystemRoutineIdent(EuThread *thread, uint64_t vmHandle, SIP::sr_ident &srMagic) override {
2388 srMagic.count = ++counter;
2389 return true;
2390 }
2391
2392 private:
2393 int counter = 0;
2394 };
2395 zet_debug_config_t config = {};
2396 config.pid = 0x1234;
2397 auto hwInfo = *NEO::defaultHwInfo.get();
2398 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2399 MockDeviceImp mockDevice(neoDevice);
2400
2401 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
2402 ASSERT_NE(nullptr, sessionMock);
2403 sessionMock->writeMemoryResult = ZE_RESULT_ERROR_UNKNOWN;
2404 sessionMock->writeRegistersResult = ZE_RESULT_ERROR_UNKNOWN;
2405 sessionMock->debugArea.reserved1 = 1u;
2406
2407 sessionMock->skipWriteResumeCommand = false;
2408 sessionMock->skipCheckThreadIsResumed = false;
2409
2410 ze_device_thread_t thread = {0, 0, 0, 0};
2411 EuThread::ThreadId threadId(0, thread);
2412 sessionMock->allThreads[threadId]->verifyStopped(1);
2413 sessionMock->allThreads[threadId]->stopThread(1u);
2414 sessionMock->allThreads[threadId]->reportAsStopped();
2415
2416 auto result = sessionMock->resume(thread);
2417 EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN);
2418
2419 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2420 EXPECT_EQ(2u, sessionMock->checkThreadIsResumedCalled);
2421 }
2422
2423 TEST(DebugSessionTest, GivenBindlessSipVersion2WhenResumingThreadThenCheckIfThreadIsResumedIsCalledUntilSipCounterIsIncremented) {
2424 class InternalMockDebugSession : public MockDebugSession {
2425 public:
2426 InternalMockDebugSession(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device) {}
2427 bool readSystemRoutineIdent(EuThread *thread, uint64_t vmHandle, SIP::sr_ident &srMagic) override {
2428 if (counter > 5) {
2429 srMagic.count = 4;
2430 } else {
2431 srMagic.count = 1;
2432 }
2433
2434 counter++;
2435 return true;
2436 }
2437 int counter = 0;
2438 };
2439
2440 zet_debug_config_t config = {};
2441 config.pid = 0x1234;
2442 auto hwInfo = *NEO::defaultHwInfo.get();
2443 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2444 MockDeviceImp mockDevice(neoDevice);
2445
2446 auto sessionMock = std::make_unique<InternalMockDebugSession>(config, &mockDevice);
2447 ASSERT_NE(nullptr, sessionMock);
2448 sessionMock->debugArea.reserved1 = 1u;
2449
2450 sessionMock->skipCheckThreadIsResumed = false;
2451
2452 ze_device_thread_t thread = {0, 0, 0, 0};
2453 EuThread::ThreadId threadId(0, thread);
2454 sessionMock->allThreads[threadId]->verifyStopped(1);
2455 sessionMock->allThreads[threadId]->stopThread(1u);
2456 sessionMock->allThreads[threadId]->reportAsStopped();
2457
2458 auto result = sessionMock->resume(thread);
2459 EXPECT_EQ(result, ZE_RESULT_SUCCESS);
2460
2461 EXPECT_EQ(1u, sessionMock->writeResumeCommandCalled);
2462 EXPECT_EQ(7u, sessionMock->checkThreadIsResumedCalled);
2463
2464 sessionMock->allThreads[threadId]->verifyStopped(3);
2465 sessionMock->allThreads[threadId]->stopThread(1u);
2466 sessionMock->allThreads[threadId]->reportAsStopped();
2467
2468 sessionMock->checkThreadIsResumedCalled = 0;
2469 result = sessionMock->resume(thread);
2470 EXPECT_EQ(result, ZE_RESULT_SUCCESS);
2471
2472 EXPECT_EQ(1u, sessionMock->checkThreadIsResumedCalled);
2473 }
2474
2475 struct DebugSessionTestSwFifoFixture : public ::testing::Test {
2476 void SetUp() override {
2477 auto stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(3);
2478 zet_debug_config_t config = {};
2479 config.pid = 0x1234;
2480 auto hwInfo = *NEO::defaultHwInfo.get();
2481 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2482 MockDeviceImp mockDevice(neoDevice);
2483 session = std::make_unique<MockDebugSession>(config, &mockDevice);
2484
2485 stateSaveAreaHeaderPtr = reinterpret_cast<NEO::StateSaveAreaHeader *>(stateSaveAreaHeader.data());
2486 stateSaveAreaHeaderPtr->regHeaderV3.fifo_head = fifoHead;
2487 stateSaveAreaHeaderPtr->regHeaderV3.fifo_tail = fifoTail;
2488
2489 offsetFifo = (stateSaveAreaHeaderPtr->versionHeader.size * 8) + stateSaveAreaHeaderPtr->regHeaderV3.fifo_offset;
2490 stateSaveAreaHeader.resize(offsetFifo + stateSaveAreaHeaderPtr->regHeaderV3.fifo_size * (sizeof(SIP::fifo_node)));
2491 memcpy_s(stateSaveAreaHeader.data() + offsetFifo,
2492 fifoVecTillHead.size() * sizeof(SIP::fifo_node),
2493 fifoVecTillHead.data(),
2494 fifoVecTillHead.size() * sizeof(SIP::fifo_node));
2495 memcpy_s(stateSaveAreaHeader.data() + offsetFifo + fifoTail * sizeof(SIP::fifo_node),
2496 fifoVecFromTail.size() * sizeof(SIP::fifo_node),
2497 fifoVecFromTail.data(),
2498 fifoVecFromTail.size() * sizeof(SIP::fifo_node));
2499 session->stateSaveAreaHeader = std::move(stateSaveAreaHeader);
2500 }
2501 void TearDown() override {
2502 }
2503
2504 const std::vector<SIP::fifo_node> fifoVecTillHead = {{1, 0, 0, 0, 0}, {1, 1, 0, 0, 0}, {1, 2, 0, 0, 0}, {1, 3, 0, 0, 0}, {1, 4, 0, 0, 0}};
2505 const std::vector<SIP::fifo_node> fifoVecFromTail = {{1, 0, 1, 0, 0}, {1, 1, 1, 0, 0}, {1, 2, 1, 0, 0}, {1, 3, 1, 0, 0}, {1, 4, 1, 0, 0}, {1, 5, 1, 0, 0}};
2506 const uint32_t fifoHead = 5;
2507 const uint32_t fifoTail = 50;
2508 std::unique_ptr<L0::ult::MockDebugSession> session;
2509 NEO::StateSaveAreaHeader *stateSaveAreaHeaderPtr = nullptr;
2510 uint64_t offsetFifo = 0u;
2511 };
2512
2513 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWhenReadingSwFifoThenFifoIsCorrectlyReadAndDrained) {
2514 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2515 std::vector<EuThread::ThreadId> threadsWithAttention;
2516 session->readFifo(0, threadsWithAttention);
2517
2518 stateSaveAreaHeaderPtr = reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
2519 std::vector<SIP::fifo_node> readFifoForValidation(stateSaveAreaHeaderPtr->regHeaderV3.fifo_size);
2520 session->readGpuMemory(0, reinterpret_cast<char *>(readFifoForValidation.data()), readFifoForValidation.size() * sizeof(SIP::fifo_node),
2521 reinterpret_cast<uint64_t>(session->stateSaveAreaHeader.data()) + offsetFifo);
2522 for (size_t i = 0; i < readFifoForValidation.size(); i++) {
2523 EXPECT_EQ(readFifoForValidation[i].valid, 0);
2524 }
2525 EXPECT_EQ(stateSaveAreaHeaderPtr->regHeaderV3.fifo_head, stateSaveAreaHeaderPtr->regHeaderV3.fifo_tail);
2526
2527 EXPECT_EQ(threadsWithAttention.size(), fifoVecFromTail.size() + fifoVecTillHead.size());
2528 size_t index = 0;
2529 for (; index < fifoVecFromTail.size(); index++) {
2530 EXPECT_EQ(threadsWithAttention[index].slice, fifoVecFromTail[index].slice_id);
2531 EXPECT_EQ(threadsWithAttention[index].subslice, fifoVecFromTail[index].subslice_id);
2532 EXPECT_EQ(threadsWithAttention[index].eu, fifoVecFromTail[index].eu_id);
2533 EXPECT_EQ(threadsWithAttention[index].thread, fifoVecFromTail[index].thread_id);
2534 }
2535 for (; index < fifoVecTillHead.size(); index++) {
2536 EXPECT_EQ(threadsWithAttention[index].slice, fifoVecTillHead[index].slice_id);
2537 EXPECT_EQ(threadsWithAttention[index].subslice, fifoVecTillHead[index].subslice_id);
2538 EXPECT_EQ(threadsWithAttention[index].eu, fifoVecTillHead[index].eu_id);
2539 EXPECT_EQ(threadsWithAttention[index].thread, fifoVecTillHead[index].thread_id);
2540 }
2541 }
2542
2543 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWithHeadIndexAtZeroWhenReadingSwFifoThenFifoIsCorrectlyReadAndDrained) {
2544 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2545 stateSaveAreaHeaderPtr = reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
2546 stateSaveAreaHeaderPtr->regHeaderV3.fifo_head = 0;
2547
2548 std::vector<EuThread::ThreadId> threadsWithAttention;
2549 session->readFifo(0, threadsWithAttention);
2550
2551 std::vector<SIP::fifo_node> readFifoForValidation(stateSaveAreaHeaderPtr->regHeaderV3.fifo_size);
2552 session->readGpuMemory(0, reinterpret_cast<char *>(readFifoForValidation.data()), readFifoForValidation.size() * sizeof(SIP::fifo_node),
2553 reinterpret_cast<uint64_t>(session->stateSaveAreaHeader.data()) + offsetFifo);
2554 for (size_t i = fifoTail; i < readFifoForValidation.size(); i++) {
2555 EXPECT_EQ(readFifoForValidation[i].valid, 0);
2556 }
2557 EXPECT_EQ(stateSaveAreaHeaderPtr->regHeaderV3.fifo_head, stateSaveAreaHeaderPtr->regHeaderV3.fifo_tail);
2558
2559 EXPECT_EQ(threadsWithAttention.size(), fifoVecFromTail.size());
2560 size_t index = 0;
2561 for (; index < fifoVecFromTail.size(); index++) {
2562 EXPECT_EQ(threadsWithAttention[index].slice, fifoVecFromTail[index].slice_id);
2563 EXPECT_EQ(threadsWithAttention[index].subslice, fifoVecFromTail[index].subslice_id);
2564 EXPECT_EQ(threadsWithAttention[index].eu, fifoVecFromTail[index].eu_id);
2565 EXPECT_EQ(threadsWithAttention[index].thread, fifoVecFromTail[index].thread_id);
2566 }
2567 }
2568
2569 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoAndAttentionEventContextEmptyWhenPollSwFifoThenReadFifoIsNotCalled) {
2570 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2571 session->pollFifo();
2572
2573 EXPECT_TRUE(session->attentionEventContext.empty());
2574 EXPECT_EQ(session->readFifoCallCount, 0u);
2575 }
2576
2577 TEST_F(DebugSessionTestSwFifoFixture, GivenTimeSinceLastFifoReadLessThanPollIntervalWhenPollSwFifoThenReadFifoIsNotCalled) {
2578 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2579
2580 auto now = std::chrono::steady_clock::now();
2581 session->lastFifoReadTime = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
2582 session->fifoPollInterval = INT32_MAX;
2583 session->attentionEventContext[10] = {11, 12, 1};
2584 session->pollFifo();
2585
2586 EXPECT_EQ(session->readFifoCallCount, 0u);
2587 }
2588
2589 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWithHeadAndTailIndexEqualWhenPollSwFifoThenOneReadAndNoWriteIsDone) {
2590 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2591 stateSaveAreaHeaderPtr = reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
2592 stateSaveAreaHeaderPtr->regHeaderV3.fifo_head = fifoTail;
2593
2594 DebugManagerStateRestore stateRestore;
2595 debugManager.flags.DebugUmdFifoPollInterval.set(0);
2596 session->attentionEventContext[10] = {11, 12, 1};
2597 session->pollFifo();
2598
2599 EXPECT_EQ(session->readFifoCallCount, 1u);
2600 EXPECT_LE(session->readGpuMemoryCallCount, 1u);
2601 EXPECT_EQ(session->writeGpuMemoryCallCount, 0u);
2602 }
2603
2604 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWithHeadAndTailIndexEqualWhenSwFifoReadThenOneReadAndNoWriteIsDone) {
2605 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2606 stateSaveAreaHeaderPtr = reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
2607 stateSaveAreaHeaderPtr->regHeaderV3.fifo_head = fifoTail;
2608
2609 std::vector<EuThread::ThreadId> threadsWithAttention;
2610 session->readFifo(0, threadsWithAttention);
2611
2612 EXPECT_EQ(session->readFifoCallCount, 1u);
2613 EXPECT_LE(session->readGpuMemoryCallCount, 1u);
2614 EXPECT_EQ(session->writeGpuMemoryCallCount, 0u);
2615 }
2616
2617 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWhenWriteGpuMemoryFailsWhileInValidatingNodeDuringFifoReadThenErrorReturned) {
2618 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2619 session->writeMemoryResult = ZE_RESULT_ERROR_UNKNOWN;
2620 std::vector<EuThread::ThreadId> threadsWithAttention;
2621 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->readFifo(0, threadsWithAttention));
2622 }
2623
2624 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWhenWriteGpuMemoryFailsWhileUpdatingTailIndexDuringFifoReadThenErrorReturned) {
2625
2626 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2627 session->forceWriteGpuMemoryFailOnCount = 3;
2628 std::vector<EuThread::ThreadId> threadsWithAttention;
2629 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->readFifo(0, threadsWithAttention));
2630 }
2631
2632 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWhenReadGpuMemoryFailsDuringFifoIndicesReadingThenErrorReturned) {
2633
2634 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2635 session->forcereadGpuMemoryFailOnCount = 1;
2636 std::vector<EuThread::ThreadId> threadsWithAttention;
2637 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->readFifo(0, threadsWithAttention));
2638 }
2639
2640 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWhenReadGpuMemoryFailsDuringFifoReadingThenErrorReturned) {
2641
2642 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2643 session->forcereadGpuMemoryFailOnCount = 3;
2644 std::vector<EuThread::ThreadId> threadsWithAttention;
2645 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->readFifo(0, threadsWithAttention));
2646 }
2647
2648 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWhenReadGpuMemoryFailsDuringUpdateOfLastHeadThenErrorReturned) {
2649
2650 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2651 session->forcereadGpuMemoryFailOnCount = 4;
2652 std::vector<EuThread::ThreadId> threadsWithAttention;
2653 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->readFifo(0, threadsWithAttention));
2654 }
2655
2656 TEST(DebugSessionTest, GivenSwFifoWhenStateSaveAreaVersionIsLessThanThreeDuringFifoReadThenFifoIsNotReadAndSuccessIsReturned) {
2657 auto stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2);
2658
2659 zet_debug_config_t config = {};
2660 config.pid = 0x1234;
2661 auto hwInfo = *NEO::defaultHwInfo.get();
2662 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2663 MockDeviceImp mockDevice(neoDevice);
2664 auto session = std::make_unique<MockDebugSession>(config, &mockDevice);
2665
2666 session->stateSaveAreaHeader.clear();
2667 session->stateSaveAreaHeader.resize(stateSaveAreaHeader.size());
2668 memcpy_s(session->stateSaveAreaHeader.data(), session->stateSaveAreaHeader.size(), stateSaveAreaHeader.data(), stateSaveAreaHeader.size());
2669
2670 std::vector<EuThread::ThreadId> threadsWithAttention;
2671 EXPECT_EQ(ZE_RESULT_SUCCESS, session->readFifo(0, threadsWithAttention));
2672 }
2673
2674 TEST_F(DebugSessionTestSwFifoFixture, GivenSwFifoWhenReadingSwFifoAndIsValidNodeFailsThenFifoReadReturnsError) {
2675 EXPECT_FALSE(session->stateSaveAreaHeader.empty());
2676 std::vector<EuThread::ThreadId> threadsWithAttention;
2677 session->isValidNodeResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
2678 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, session->readFifo(0, threadsWithAttention));
2679 }
2680
2681 TEST_F(DebugSessionTest, GivenInvalidSwFifoNodeWhenCheckingIsValidNodeAndOnReadingMemoryAgainNodeTurnsValidThenSuccessReturned) {
2682 zet_debug_config_t config = {};
2683 config.pid = 0x1234;
2684 auto hwInfo = *NEO::defaultHwInfo.get();
2685 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2686 MockDeviceImp mockDevice(neoDevice);
2687 auto session = std::make_unique<MockDebugSession>(config, &mockDevice);
2688
2689 // Declare node whose valid field is 0
2690 SIP::fifo_node invalidNode = {0, 1, 1, 0, 0};
2691 EXPECT_EQ(ZE_RESULT_SUCCESS, session->isValidNode(0, reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()), invalidNode));
2692 EXPECT_FALSE(invalidNode.valid);
2693
2694 SIP::fifo_node correctedNode = {1, 1, 1, 0, 0};
2695 session->readMemoryBuffer.resize(sizeof(SIP::fifo_node));
2696 memcpy_s(session->readMemoryBuffer.data(), session->readMemoryBuffer.size(), reinterpret_cast<void *>(&correctedNode), sizeof(SIP::fifo_node));
2697
2698 EXPECT_EQ(ZE_RESULT_SUCCESS, session->isValidNode(0, reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()), invalidNode));
2699 EXPECT_TRUE(invalidNode.valid);
2700 }
2701
2702 TEST_F(DebugSessionTest, GivenInvalidSwFifoNodeWhenCheckingIsValidNodeAndOnReadingMemoryAgainReadMemoryFailsThenErrorReturned) {
2703 zet_debug_config_t config = {};
2704 config.pid = 0x1234;
2705 auto hwInfo = *NEO::defaultHwInfo.get();
2706 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2707 MockDeviceImp mockDevice(neoDevice);
2708 auto session = std::make_unique<MockDebugSession>(config, &mockDevice);
2709
2710 // Declare node whose valid field is 0
2711 SIP::fifo_node invalidNode = {0, 1, 1, 0, 0};
2712 session->readMemoryResult = ZE_RESULT_ERROR_UNKNOWN;
2713 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->isValidNode(0, reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()), invalidNode));
2714 }
2715
2716 TEST_F(DebugSessionTest, givenDumpDebugSurfaceFileWhenStateSaveAreaIsReadThenDebugSurfaceFileIsDumped) {
2717 static constexpr const char *filePath = "test_dump_file.bin";
2718 DebugManagerStateRestore restorer;
2719 NEO::debugManager.flags.DumpDebugSurfaceFile.set(filePath);
2720
2721 const std::vector<uint8_t> stateSaveAreaContent = {0xaa, 0xbb, 0xcc, 0xdd};
2722
2723 MockDeviceImp mockDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get(), 0));
2724
2725 auto session = std::make_unique<MockDebugSession>(zet_debug_config_t{}, &mockDevice);
2726 session->readMemoryBuffer.assign(stateSaveAreaContent.cbegin(), stateSaveAreaContent.cend());
2727 session->forceStateSaveAreaSize = session->readMemoryBuffer.size();
2728 session->validateAndSetStateSaveAreaHeader(0, reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()));
2729
2730 EXPECT_EQ(1u, NEO::virtualFileList.size());
2731 EXPECT_TRUE(NEO::virtualFileList.find(filePath) != NEO::virtualFileList.end());
2732 auto content = NEO::virtualFileList.at(filePath).str();
2733 EXPECT_EQ(stateSaveAreaContent, std::vector<uint8_t>(content.cbegin(), content.cend()));
2734 }
2735
2736 TEST_F(DebugSessionTest, givenNoDumpDebugSurfaceFileWhenStateSaveAreaIsReadThenDebugSurfaceFileIsNotDumped) {
2737 const std::vector<uint8_t> stateSaveAreaContent = {0xaa, 0xbb, 0xcc, 0xdd};
2738
2739 MockDeviceImp mockDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get(), 0));
2740 auto session = std::make_unique<MockDebugSession>(zet_debug_config_t{}, &mockDevice);
2741
2742 session->readMemoryBuffer.assign(stateSaveAreaContent.cbegin(), stateSaveAreaContent.cend());
2743 session->forceStateSaveAreaSize = session->readMemoryBuffer.size();
2744
2745 session->validateAndSetStateSaveAreaHeader(0, reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()));
2746
2747 EXPECT_EQ(0u, NEO::virtualFileList.size());
2748 }
2749
2750 TEST_F(DebugSessionTest, givenDumpDebugSurfaceFileWhenStateSaveAreaIsReadAndReadGpuMemoryFailsThenDebugSurfaceFileIsNotDumped) {
2751 static constexpr const char *filePath = "test_dump_file.bin";
2752 DebugManagerStateRestore restorer;
2753 NEO::debugManager.flags.DumpDebugSurfaceFile.set(filePath);
2754
2755 MockDeviceImp mockDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get(), 0));
2756
2757 auto session = std::make_unique<MockDebugSession>(zet_debug_config_t{}, &mockDevice);
2758 session->readMemoryResult = ZE_RESULT_ERROR_UNKNOWN;
2759 session->validateAndSetStateSaveAreaHeader(0, reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()));
2760
2761 EXPECT_EQ(0u, NEO::virtualFileList.size());
2762 }
2763
2764 TEST_F(DebugSessionTest, givenTssMagicCorruptedWhenStateSaveAreIsReadThenHeaderIsNotSet) {
2765 auto stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2);
2766 auto versionHeader = &reinterpret_cast<SIP::StateSaveAreaHeader *>(stateSaveAreaHeader.data())->versionHeader;
2767 versionHeader->magic[0] = '!';
2768
2769 zet_debug_config_t config = {};
2770 config.pid = 0x1234;
2771 auto hwInfo = *NEO::defaultHwInfo.get();
2772 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2773 MockDeviceImp mockDevice(neoDevice);
2774 auto session = std::make_unique<MockDebugSession>(config, &mockDevice);
2775
2776 session->readMemoryBuffer.resize(stateSaveAreaHeader.size());
2777 memcpy_s(session->readMemoryBuffer.data(), session->readMemoryBuffer.size(), stateSaveAreaHeader.data(), stateSaveAreaHeader.size());
2778
2779 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
2780 session->stateSaveAreaHeader.clear();
2781 session->validateAndSetStateSaveAreaHeader(session->allThreads[thread0]->getMemoryHandle(), reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()));
2782 EXPECT_TRUE(session->stateSaveAreaHeader.empty());
2783 }
2784
2785 TEST_F(DebugSessionTest, givenSsaHeaderVersionGreaterThan3WhenStateSaveAreIsReadThenHeaderIsNotSet) {
2786 auto stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2);
2787 auto versionHeader = &reinterpret_cast<SIP::StateSaveAreaHeader *>(stateSaveAreaHeader.data())->versionHeader;
2788 versionHeader->version.major = 4;
2789
2790 zet_debug_config_t config = {};
2791 config.pid = 0x1234;
2792 auto hwInfo = *NEO::defaultHwInfo.get();
2793 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2794 MockDeviceImp mockDevice(neoDevice);
2795 auto session = std::make_unique<MockDebugSession>(config, &mockDevice);
2796
2797 session->readMemoryBuffer.resize(stateSaveAreaHeader.size());
2798 memcpy_s(session->readMemoryBuffer.data(), session->readMemoryBuffer.size(), stateSaveAreaHeader.data(), stateSaveAreaHeader.size());
2799
2800 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
2801 session->stateSaveAreaHeader.clear();
2802 session->validateAndSetStateSaveAreaHeader(session->allThreads[thread0]->getMemoryHandle(), reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()));
2803 EXPECT_TRUE(session->stateSaveAreaHeader.empty());
2804 }
2805
2806 TEST(DebugSessionTest, givenStoppedThreadWhenGettingNotStoppedThreadsThenOnlyRunningOrUnavailableThreadsAreReturned) {
2807 zet_debug_config_t config = {};
2808 config.pid = 0x1234;
2809 auto hwInfo = *NEO::defaultHwInfo.get();
2810
2811 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2812 MockDeviceImp mockDevice(neoDevice);
2813
2814 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2815
2816 EuThread::ThreadId thread(0, 0, 0, 0, 0);
2817 sessionMock->allThreads[thread]->stopThread(1u);
2818 EuThread::ThreadId thread1(0, 0, 0, 0, 1);
2819 EXPECT_FALSE(sessionMock->allThreads[thread1]->isStopped());
2820
2821 std::vector<EuThread::ThreadId> threadsWithAtt;
2822 std::vector<EuThread::ThreadId> newStops;
2823
2824 threadsWithAtt.push_back(thread);
2825 threadsWithAtt.push_back(thread1);
2826
2827 sessionMock->getNotStoppedThreads(threadsWithAtt, newStops);
2828
2829 ASSERT_EQ(1u, newStops.size());
2830 EXPECT_EQ(thread1, newStops[0]);
2831 }
2832
2833 TEST(DebugSessionTest, givenSizeBiggerThanPreviousWhenAllocatingStateSaveAreaMemoryThenNewMemoryIsAllocated) {
2834 zet_debug_config_t config = {};
2835 config.pid = 0x1234;
2836 auto hwInfo = *NEO::defaultHwInfo.get();
2837
2838 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2839 MockDeviceImp mockDevice(neoDevice);
2840
2841 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2842
2843 EXPECT_EQ(0u, sessionMock->stateSaveAreaMemory.size());
2844 sessionMock->allocateStateSaveAreaMemory(0x1000);
2845 EXPECT_EQ(0x1000u, sessionMock->stateSaveAreaMemory.size());
2846
2847 sessionMock->allocateStateSaveAreaMemory(0x2000);
2848 EXPECT_EQ(0x2000u, sessionMock->stateSaveAreaMemory.size());
2849 }
2850
2851 TEST(DebugSessionTest, givenTheSameSizeWhenAllocatingStateSaveAreaMemoryThenNewMemoryIsNotAllocated) {
2852 zet_debug_config_t config = {};
2853 config.pid = 0x1234;
2854 auto hwInfo = *NEO::defaultHwInfo.get();
2855
2856 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
2857 MockDeviceImp mockDevice(neoDevice);
2858
2859 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
2860
2861 EXPECT_EQ(0u, sessionMock->stateSaveAreaMemory.size());
2862 sessionMock->allocateStateSaveAreaMemory(0x1000);
2863 EXPECT_EQ(0x1000u, sessionMock->stateSaveAreaMemory.size());
2864
2865 auto oldMem = sessionMock->stateSaveAreaMemory.data();
2866
2867 sessionMock->allocateStateSaveAreaMemory(0x1000);
2868 EXPECT_EQ(oldMem, sessionMock->stateSaveAreaMemory.data());
2869 }
2870
2871 using MultiTileDebugSessionTest = Test<MultipleDevicesWithCustomHwInfo>;
2872
2873 TEST_F(MultiTileDebugSessionTest, givenThreadsFromMultipleTilesWhenResumeCalledThenThreadsResumedInAllTiles) {
2874 zet_debug_config_t config = {};
2875 config.pid = 0x1234;
2876
2877 L0::Device *device = driverHandle->devices[0];
2878 L0::Device *l0Device = static_cast<Device *>(device);
2879
2880 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
2881
2882 EuThread::ThreadId threadTile0(0, 0, 0, 0, 0);
2883 EuThread::ThreadId threadTile1(1, 0, 0, 0, 0);
2884 sessionMock->allThreads[threadTile0]->stopThread(1u);
2885 sessionMock->allThreads[threadTile1]->stopThread(1u);
2886
2887 sessionMock->allThreads[threadTile0]->reportAsStopped();
2888 sessionMock->allThreads[threadTile1]->reportAsStopped();
2889
2890 ze_device_thread_t thread = {UINT32_MAX, 0, 0, 0};
2891
2892 auto result = sessionMock->resume(thread);
2893 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
2894
2895 EXPECT_TRUE(sessionMock->allThreads[threadTile0]->isRunning());
2896 EXPECT_TRUE(sessionMock->allThreads[threadTile1]->isRunning());
2897
2898 EXPECT_EQ(2u, sessionMock->resumeImpCalled);
2899
2900 sessionMock->allThreads[threadTile1]->stopThread(1u);
2901 sessionMock->allThreads[threadTile1]->reportAsStopped();
2902
2903 result = sessionMock->resume(thread);
2904 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
2905
2906 EXPECT_EQ(3u, sessionMock->resumeImpCalled);
2907 }
2908
2909 TEST_F(MultiTileDebugSessionTest, givenThreadFromSingleTileWhenResumeCalledThenThreadIsResumed) {
2910 zet_debug_config_t config = {};
2911 config.pid = 0x1234;
2912
2913 L0::Device *device = driverHandle->devices[0];
2914 L0::Device *l0Device = static_cast<Device *>(device);
2915
2916 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
2917
2918 EuThread::ThreadId threadTile0(0, 0, 0, 0, 0);
2919 sessionMock->allThreads[threadTile0]->stopThread(1u);
2920 sessionMock->allThreads[threadTile0]->reportAsStopped();
2921
2922 EuThread::ThreadId threadTile1(1, 0, 0, 0, 0);
2923 sessionMock->allThreads[threadTile1]->stopThread(1u);
2924 sessionMock->allThreads[threadTile1]->reportAsStopped();
2925
2926 ze_device_thread_t thread = {sliceCount, 0, 0, 0};
2927
2928 auto result = sessionMock->resume(thread);
2929 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
2930
2931 EXPECT_TRUE(sessionMock->allThreads[threadTile1]->isRunning());
2932
2933 EXPECT_EQ(1u, sessionMock->resumeImpCalled);
2934 EXPECT_EQ(1u, sessionMock->resumedDevices[0]);
2935
2936 ze_device_thread_t resumedThreadExpected = {0, 0, 0, 0};
2937 EXPECT_EQ(resumedThreadExpected.slice, sessionMock->resumedThreads[0][0].slice);
2938 EXPECT_EQ(resumedThreadExpected.subslice, sessionMock->resumedThreads[0][0].subslice);
2939 EXPECT_EQ(resumedThreadExpected.eu, sessionMock->resumedThreads[0][0].eu);
2940 EXPECT_EQ(resumedThreadExpected.thread, sessionMock->resumedThreads[0][0].thread);
2941
2942 thread = {0, 0, 0, 0};
2943 sessionMock->resumeImpCalled = 0;
2944 sessionMock->resumedDevices.clear();
2945
2946 result = sessionMock->resume(thread);
2947 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
2948
2949 EXPECT_TRUE(sessionMock->allThreads[threadTile1]->isRunning());
2950
2951 EXPECT_EQ(1u, sessionMock->resumeImpCalled);
2952 EXPECT_EQ(0u, sessionMock->resumedDevices[0]);
2953
2954 resumedThreadExpected = {0, 0, 0, 0};
2955 EXPECT_EQ(resumedThreadExpected.slice, sessionMock->resumedThreads[0][0].slice);
2956 EXPECT_EQ(resumedThreadExpected.subslice, sessionMock->resumedThreads[0][0].subslice);
2957 EXPECT_EQ(resumedThreadExpected.eu, sessionMock->resumedThreads[0][0].eu);
2958 EXPECT_EQ(resumedThreadExpected.thread, sessionMock->resumedThreads[0][0].thread);
2959 }
2960
2961 TEST_F(MultiTileDebugSessionTest, givenRunningThreadsWhenResumeCalledThenThreadsNotResumedAndErrorNotAvailableReturned) {
2962 zet_debug_config_t config = {};
2963 config.pid = 0x1234;
2964
2965 L0::Device *device = driverHandle->devices[0];
2966 L0::Device *l0Device = static_cast<Device *>(device);
2967
2968 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
2969
2970 EuThread::ThreadId threadTile0(0, 0, 0, 0, 0);
2971 EuThread::ThreadId threadTile1(1, 0, 0, 0, 0);
2972
2973 ze_device_thread_t thread = {UINT32_MAX, 0, 0, 0};
2974 auto result = sessionMock->resume(thread);
2975 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
2976
2977 EXPECT_EQ(0u, sessionMock->resumeImpCalled);
2978
2979 EXPECT_TRUE(sessionMock->allThreads[threadTile0]->isRunning());
2980 EXPECT_TRUE(sessionMock->allThreads[threadTile1]->isRunning());
2981 }
2982
2983 TEST_F(MultiTileDebugSessionTest, givenErrorFromResumeWithinDeviceWhenResumeCalledThenThreadsAreResumedAndErrorUnkwnownReturned) {
2984 zet_debug_config_t config = {};
2985 config.pid = 0x1234;
2986
2987 L0::Device *device = driverHandle->devices[0];
2988 L0::Device *l0Device = static_cast<Device *>(device);
2989
2990 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
2991
2992 EuThread::ThreadId threadTile0(0, 0, 0, 0, 0);
2993 EuThread::ThreadId threadTile1(1, 0, 0, 0, 0);
2994 sessionMock->allThreads[threadTile0]->stopThread(1u);
2995 sessionMock->allThreads[threadTile1]->stopThread(1u);
2996 sessionMock->allThreads[threadTile0]->reportAsStopped();
2997 sessionMock->allThreads[threadTile1]->reportAsStopped();
2998
2999 ze_device_thread_t thread = {UINT32_MAX, 0, 0, 0};
3000
3001 sessionMock->resumeImpResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
3002
3003 auto result = sessionMock->resume(thread);
3004 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
3005
3006 EXPECT_EQ(2u, sessionMock->resumeImpCalled);
3007
3008 EXPECT_TRUE(sessionMock->allThreads[threadTile0]->isRunning());
3009 EXPECT_TRUE(sessionMock->allThreads[threadTile1]->isRunning());
3010 }
3011
3012 TEST_F(MultiTileDebugSessionTest, givenOneDeviceRequestWhenSendingInterruptsThenOnlyOneInterruptCalled) {
3013 zet_debug_config_t config = {};
3014 config.pid = 0x1234;
3015
3016 L0::Device *device = driverHandle->devices[0];
3017 L0::Device *l0Device = static_cast<Device *>(device);
3018
3019 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
3020
3021 sessionMock->interruptImpResult = ZE_RESULT_SUCCESS;
3022 // Second subdevice's slice
3023 ze_device_thread_t apiThread = {sliceCount, 0, 0, 0};
3024
3025 auto result = sessionMock->interrupt(apiThread);
3026 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3027
3028 sessionMock->sendInterrupts();
3029
3030 EXPECT_EQ(1u, sessionMock->interruptImpCalled);
3031 EXPECT_TRUE(sessionMock->interruptSent);
3032 EXPECT_EQ(1u, sessionMock->interruptedDevices[0]);
3033 EXPECT_EQ(1u, sessionMock->expectedAttentionEvents);
3034 }
3035
3036 TEST_F(MultiTileDebugSessionTest, givenTwoDevicesInRequestsWhenSendingInterruptsThenTwoInterruptsCalled) {
3037 zet_debug_config_t config = {};
3038 config.pid = 0x1234;
3039
3040 L0::Device *device = driverHandle->devices[0];
3041 L0::Device *l0Device = static_cast<Device *>(device);
3042
3043 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
3044
3045 sessionMock->interruptImpResult = ZE_RESULT_SUCCESS;
3046
3047 ze_device_thread_t apiThread = {0, 0, 0, 0};
3048 ze_device_thread_t apiThread2 = {sliceCount, 0, 0, 0};
3049
3050 auto result = sessionMock->interrupt(apiThread);
3051 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3052
3053 result = sessionMock->interrupt(apiThread2);
3054 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3055
3056 sessionMock->sendInterrupts();
3057
3058 EXPECT_EQ(2u, sessionMock->interruptImpCalled);
3059 EXPECT_TRUE(sessionMock->interruptSent);
3060 EXPECT_EQ(0u, sessionMock->interruptedDevices[0]);
3061 EXPECT_EQ(1u, sessionMock->interruptedDevices[1]);
3062 EXPECT_EQ(2u, sessionMock->expectedAttentionEvents);
3063 }
3064
3065 TEST_F(MultiTileDebugSessionTest, givenTileAttachEnabledWhenSendingInterruptsThenInterruptIsSentWithCorrectDeviceIndex) {
3066 DebugManagerStateRestore restorer;
3067 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
3068 zet_debug_config_t config = {};
3069 config.pid = 0x1234;
3070
3071 L0::Device *device = driverHandle->devices[0];
3072 L0::Device *l0Device = static_cast<Device *>(device);
3073
3074 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
3075
3076 sessionMock->interruptImpResult = ZE_RESULT_SUCCESS;
3077 sessionMock->tileAttachEnabled = true;
3078 sessionMock->initialize();
3079
3080 auto tileSession1 = static_cast<MockDebugSession *>(sessionMock->tileSessions[1].first);
3081 auto tileSession0 = static_cast<MockDebugSession *>(sessionMock->tileSessions[0].first);
3082
3083 ze_device_thread_t apiThread = {0, 0, 0, 0};
3084
3085 auto result = tileSession1->interrupt(apiThread);
3086 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3087
3088 result = tileSession0->interrupt(apiThread);
3089 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3090
3091 tileSession1->sendInterrupts();
3092 tileSession0->sendInterrupts();
3093
3094 EXPECT_TRUE(tileSession1->interruptSent);
3095 EXPECT_TRUE(tileSession0->interruptSent);
3096 EXPECT_EQ(1u, tileSession1->interruptedDevices[0]);
3097 EXPECT_EQ(0u, tileSession0->interruptedDevices[0]);
3098 }
3099
3100 TEST_F(MultiTileDebugSessionTest, givenAllSlicesInRequestWhenSendingInterruptsThenTwoInterruptsCalled) {
3101 zet_debug_config_t config = {};
3102 config.pid = 0x1234;
3103
3104 L0::Device *device = driverHandle->devices[0];
3105 L0::Device *l0Device = static_cast<Device *>(device);
3106
3107 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
3108
3109 sessionMock->interruptImpResult = ZE_RESULT_SUCCESS;
3110
3111 ze_device_thread_t apiThread = {UINT32_MAX, 0, 0, 0};
3112
3113 auto result = sessionMock->interrupt(apiThread);
3114 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3115
3116 sessionMock->sendInterrupts();
3117
3118 EXPECT_EQ(2u, sessionMock->interruptImpCalled);
3119 EXPECT_TRUE(sessionMock->interruptSent);
3120 EXPECT_EQ(0u, sessionMock->interruptedDevices[0]);
3121 EXPECT_EQ(1u, sessionMock->interruptedDevices[1]);
3122 EXPECT_EQ(2u, sessionMock->expectedAttentionEvents);
3123 }
3124
3125 TEST_F(MultiTileDebugSessionTest, givenTwoInterruptsSentWhenCheckingTriggerEventsThenTriggerEventsWhenAllAttEventsReceived) {
3126 zet_debug_config_t config = {};
3127 config.pid = 0x1234;
3128
3129 L0::Device *device = driverHandle->devices[0];
3130 L0::Device *l0Device = static_cast<Device *>(device);
3131
3132 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
3133
3134 sessionMock->interruptImpResult = ZE_RESULT_SUCCESS;
3135 ze_device_thread_t apiThread = {UINT32_MAX, 0, 0, 0};
3136
3137 auto result = sessionMock->interrupt(apiThread);
3138 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3139
3140 sessionMock->sendInterrupts();
3141 EXPECT_EQ(2u, sessionMock->expectedAttentionEvents);
3142
3143 sessionMock->newAttentionRaised();
3144 EXPECT_EQ(1u, sessionMock->expectedAttentionEvents);
3145 sessionMock->checkTriggerEventsForAttention();
3146
3147 EXPECT_FALSE(sessionMock->triggerEvents);
3148
3149 sessionMock->newAttentionRaised();
3150 EXPECT_EQ(0u, sessionMock->expectedAttentionEvents);
3151 sessionMock->checkTriggerEventsForAttention();
3152
3153 EXPECT_TRUE(sessionMock->triggerEvents);
3154 }
3155
3156 TEST_F(MultiTileDebugSessionTest, givenTwoDevicesInRequestsWhenAllInterruptsReturnErrorThenAllInterruptRequestsGenerateUnavailableEvents) {
3157 zet_debug_config_t config = {};
3158 config.pid = 0x1234;
3159
3160 L0::Device *device = driverHandle->devices[0];
3161 L0::Device *l0Device = static_cast<Device *>(device);
3162
3163 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
3164
3165 sessionMock->readRegistersResult = ZE_RESULT_SUCCESS;
3166 sessionMock->interruptImpResult = ZE_RESULT_ERROR_UNKNOWN;
3167
3168 ze_device_thread_t apiThread = {0, 0, 0, 0};
3169 ze_device_thread_t apiThread2 = {sliceCount, 0, 0, 0};
3170
3171 auto result = sessionMock->interrupt(apiThread);
3172 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3173
3174 result = sessionMock->interrupt(apiThread2);
3175 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3176
3177 EXPECT_EQ(2u, sessionMock->interruptRequests.size());
3178
3179 sessionMock->sendInterrupts();
3180
3181 EXPECT_EQ(2u, sessionMock->interruptImpCalled);
3182 EXPECT_FALSE(sessionMock->interruptSent);
3183 EXPECT_EQ(0u, sessionMock->interruptedDevices[0]);
3184 EXPECT_EQ(1u, sessionMock->interruptedDevices[1]);
3185
3186 EXPECT_EQ(0u, sessionMock->expectedAttentionEvents);
3187 EXPECT_EQ(0u, sessionMock->pendingInterrupts.size());
3188
3189 EXPECT_EQ(2u, sessionMock->apiEvents.size());
3190
3191 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE, sessionMock->apiEvents.front().type);
3192 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread, sessionMock->apiEvents.front().info.thread.thread));
3193 sessionMock->apiEvents.pop();
3194 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE, sessionMock->apiEvents.front().type);
3195 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread2, sessionMock->apiEvents.front().info.thread.thread));
3196 }
3197
3198 TEST_F(MultiTileDebugSessionTest, givenAllSlicesInRequestWhenAllInterruptsReturnErrorThenAllInterruptRequestsGenerateUnavailableEvents) {
3199 zet_debug_config_t config = {};
3200 config.pid = 0x1234;
3201
3202 L0::Device *device = driverHandle->devices[0];
3203 L0::Device *l0Device = static_cast<Device *>(device);
3204
3205 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
3206
3207 sessionMock->interruptImpResult = ZE_RESULT_ERROR_UNKNOWN;
3208
3209 ze_device_thread_t apiThread = {UINT32_MAX, 0, 0, 0};
3210
3211 auto result = sessionMock->interrupt(apiThread);
3212 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3213
3214 EXPECT_EQ(1u, sessionMock->interruptRequests.size());
3215
3216 sessionMock->sendInterrupts();
3217
3218 EXPECT_EQ(2u, sessionMock->interruptImpCalled);
3219 EXPECT_FALSE(sessionMock->interruptSent);
3220 EXPECT_EQ(0u, sessionMock->interruptedDevices[0]);
3221 EXPECT_EQ(1u, sessionMock->interruptedDevices[1]);
3222
3223 EXPECT_EQ(0u, sessionMock->expectedAttentionEvents);
3224 EXPECT_EQ(0u, sessionMock->pendingInterrupts.size());
3225
3226 EXPECT_EQ(1u, sessionMock->apiEvents.size());
3227
3228 EXPECT_EQ(ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE, sessionMock->apiEvents.front().type);
3229 EXPECT_TRUE(DebugSession::areThreadsEqual(apiThread, sessionMock->apiEvents.front().info.thread.thread));
3230 }
3231
3232 TEST_F(MultiTileDebugSessionTest, GivenMultitileDeviceWhenCallingAreRequestedThreadsStoppedThenCorrectValueIsReturned) {
3233 zet_debug_config_t config = {};
3234 config.pid = 0x1234;
3235
3236 L0::Device *device = driverHandle->devices[0];
3237 L0::Device *l0Device = static_cast<Device *>(device);
3238
3239 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
3240 ASSERT_NE(nullptr, sessionMock);
3241
3242 ze_device_thread_t thread = {0, 0, 0, 0};
3243 ze_device_thread_t allSlices = {UINT32_MAX, 0, 0, 0};
3244
3245 sessionMock->allThreads[EuThread::ThreadId(0, thread)]->stopThread(1u);
3246 sessionMock->allThreads[EuThread::ThreadId(1, thread)]->stopThread(1u);
3247 sessionMock->allThreads[EuThread::ThreadId(0, thread)]->reportAsStopped();
3248 sessionMock->allThreads[EuThread::ThreadId(1, thread)]->reportAsStopped();
3249
3250 auto stopped = sessionMock->areRequestedThreadsStopped(thread);
3251 EXPECT_TRUE(stopped);
3252
3253 stopped = sessionMock->areRequestedThreadsStopped(allSlices);
3254 EXPECT_FALSE(stopped);
3255
3256 for (uint32_t i = 0; i < sliceCount; i++) {
3257 EuThread::ThreadId threadId(0, i, 0, 0, 0);
3258 sessionMock->allThreads[threadId]->stopThread(1u);
3259 sessionMock->allThreads[threadId]->reportAsStopped();
3260 }
3261
3262 stopped = sessionMock->areRequestedThreadsStopped(allSlices);
3263 EXPECT_FALSE(stopped);
3264
3265 for (uint32_t i = 0; i < sliceCount; i++) {
3266 EuThread::ThreadId threadId(1, i, 0, 0, 0);
3267 sessionMock->allThreads[threadId]->stopThread(1u);
3268 sessionMock->allThreads[threadId]->reportAsStopped();
3269 }
3270
3271 stopped = sessionMock->areRequestedThreadsStopped(allSlices);
3272 EXPECT_TRUE(stopped);
3273 }
3274
3275 using DebugSessionRegistersAccessTestV3 = Test<DebugSessionRegistersAccessV3>;
3276
3277 TEST_F(DebugSessionRegistersAccessTestV3, GivenSipVersion3WhenCallingResumeThenResumeInCmdRegisterIsWritten) {
3278 session->debugArea.reserved1 = 1u;
3279
3280 {
3281 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3282 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3283 pStateSaveAreaHeader->regHeaderV3.state_area_offset +
3284 pStateSaveAreaHeader->regHeaderV3.state_save_size * 16;
3285 session->stateSaveAreaHeader.resize(size);
3286 }
3287 session->skipWriteResumeCommand = false;
3288
3289 ze_device_thread_t thread = {0, 0, 0, 0};
3290 EuThread::ThreadId threadId(0, thread);
3291 session->allThreads[threadId]->stopThread(1u);
3292
3293 dumpRegisterState();
3294
3295 auto result = session->resume(thread);
3296 EXPECT_EQ(result, ZE_RESULT_SUCCESS);
3297
3298 EXPECT_EQ(0u, session->readRegistersCallCount);
3299 EXPECT_EQ(0u, session->writeRegistersCallCount);
3300 EXPECT_EQ(1u, session->writeResumeCommandCalled);
3301 }
3302
3303 TEST_F(DebugSessionRegistersAccessTestV3, givenV3StateSaveHeaderWhenCalculatingSrMagicOffsetResultIsCorrect) {
3304
3305 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3306 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3307 auto threadSlotOffset = session->calculateThreadSlotOffset(thread0);
3308 auto size = session->calculateSrMagicOffset(pStateSaveAreaHeader, session->allThreads[thread0].get());
3309 ASSERT_EQ(size, threadSlotOffset + pStateSaveAreaHeader->regHeaderV3.sr_magic_offset);
3310 }
3311
3312 TEST_F(DebugSessionRegistersAccessTestV3, givenStateSaveHeaderGreaterThanV3WhenCalculatingSrMagicOffsetResultIsZero) {
3313 reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data())->versionHeader.version.major = 4;
3314 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3315 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3316 EXPECT_EQ(0u, session->calculateSrMagicOffset(pStateSaveAreaHeader, session->allThreads[thread0].get()));
3317 }
3318
3319 TEST_F(DebugSessionRegistersAccessTestV3, givenTypeToRegsetDescCalledThenCorrectRegdescIsReturned) {
3320 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3321
3322 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_INVALID_INTEL_GPU, mockDevice.get()), nullptr);
3323 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.grf);
3324 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ADDR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.addr);
3325 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FLAG_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.flag);
3326 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CE_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.emask);
3327 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.sr);
3328 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.cr);
3329 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_TDR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.tdr);
3330 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ACC_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.acc);
3331 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MME_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.mme);
3332 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SP_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.sp);
3333 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DBG_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.dbg_reg);
3334 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FC_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.fc);
3335 EXPECT_NE(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU, mockDevice.get()), nullptr);
3336 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MSG_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.msg);
3337 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeaderV3.scalar);
3338 EXPECT_NE(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DEBUG_SCRATCH_INTEL_GPU, mockDevice.get()), nullptr);
3339 EXPECT_NE(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU, mockDevice.get()), nullptr);
3340 EXPECT_NE(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MODE_FLAGS_INTEL_GPU, mockDevice.get()), nullptr);
3341
3342 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, 0x1234, mockDevice.get()), nullptr);
3343 }
3344
3345 TEST_F(DebugSessionRegistersAccessTestV3, givenDeviceWithMockSipExternalLibInterfaceWhenTypeToRegsetDescCalledThenReturnsRegsetDescFromMap) {
3346 class MockSipExternalLibForTest : public MockSipExternalLib {
3347 public:
3348 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override {
3349 return 0;
3350 }
3351 bool createRegisterDescriptorMap() override {
3352 return true;
3353 }
3354 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override {
3355 // Return a test regset descriptor for GRF type
3356 if (type == static_cast<uint32_t>(0)) { // eGRF = 0
3357 static SIP::regset_desc testRegsetDesc = {0x100, 128, 16, 32};
3358 return &testRegsetDesc;
3359 }
3360 return nullptr;
3361 }
3362 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override {
3363 return true;
3364 }
3365 uint32_t getSipLibCommandRegisterType() override {
3366 return 0; // Return a test command register type
3367 }
3368 };
3369
3370 // Create a mock device that returns the mock SipExternalLib
3371 class MockDeviceWithSipLib : public NEO::MockDevice {
3372 public:
3373 MockDeviceWithSipLib() : NEO::MockDevice() {
3374 mockSipLib = std::make_unique<MockSipExternalLibForTest>();
3375 }
3376 NEO::SipExternalLib *getSipExternalLibInterface() const override {
3377 return mockSipLib.get();
3378 }
3379 std::unique_ptr<MockSipExternalLibForTest> mockSipLib;
3380 };
3381
3382 // Create the mock NEO device with SIP external lib interface
3383 auto mockNeoDevice = std::make_unique<MockDeviceWithSipLib>();
3384
3385 // Create a mock L0 device wrapper
3386 auto mockL0Device = std::make_unique<MockDeviceImp>(mockNeoDevice.release());
3387
3388 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3389
3390 // Test that when device has SIP external lib, typeToRegsetDesc uses getRegsetDescFromMap
3391 auto result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockL0Device.get());
3392 if (result != nullptr) {
3393 EXPECT_EQ(result->offset, 0x100u);
3394 EXPECT_EQ(result->num, 128u);
3395 EXPECT_EQ(result->bits, 16u);
3396 EXPECT_EQ(result->bytes, 32u);
3397 }
3398
3399 // Test with a type that returns nullptr from the mock
3400 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ADDR_INTEL_GPU, mockL0Device.get());
3401 EXPECT_EQ(nullptr, result);
3402
3403 // Test ZET_DEBUG_REGSET_TYPE_MODE_FLAGS_INTEL_GPU
3404 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MODE_FLAGS_INTEL_GPU, mockL0Device.get());
3405 if (result != nullptr) {
3406 EXPECT_EQ(result->offset, 0u);
3407 EXPECT_EQ(result->num, 1u);
3408 EXPECT_EQ(result->bits, 32u);
3409 EXPECT_EQ(result->bytes, 4u);
3410 }
3411
3412 // Test ZET_DEBUG_REGSET_TYPE_DEBUG_SCRATCH_INTEL_GPU
3413 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DEBUG_SCRATCH_INTEL_GPU, mockL0Device.get());
3414 if (result != nullptr) {
3415 EXPECT_EQ(result->offset, 0u);
3416 EXPECT_EQ(result->num, 2u);
3417 EXPECT_EQ(result->bits, 64u);
3418 EXPECT_EQ(result->bytes, 8u);
3419 }
3420
3421 // Test ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU
3422 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU, mockL0Device.get());
3423 if (result != nullptr) {
3424 EXPECT_EQ(result->offset, 0u);
3425 EXPECT_EQ(result->num, 2u);
3426 EXPECT_EQ(result->bits, 64u);
3427 EXPECT_EQ(result->bytes, 8u);
3428 }
3429
3430 // Test ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU
3431 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU, mockL0Device.get());
3432 if (result != nullptr) {
3433 // For heapless mode (which is the case with SIP external lib), SBA should return empty descriptor
3434 EXPECT_EQ(result->offset, 0u);
3435 EXPECT_EQ(result->num, 0u);
3436 EXPECT_EQ(result->bits, 0u);
3437 EXPECT_EQ(result->bytes, 0u);
3438 }
3439
3440 // Test remaining register types that go through getRegsetDescFromMap (should return nullptr from mock)
3441 // These types fall through to the default case and call getRegsetDescFromMap
3442 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FLAG_INTEL_GPU, mockL0Device.get());
3443 EXPECT_EQ(nullptr, result);
3444
3445 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CE_INTEL_GPU, mockL0Device.get());
3446 EXPECT_EQ(nullptr, result);
3447
3448 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SR_INTEL_GPU, mockL0Device.get());
3449 EXPECT_EQ(nullptr, result);
3450
3451 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, mockL0Device.get());
3452 EXPECT_EQ(nullptr, result);
3453
3454 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_TDR_INTEL_GPU, mockL0Device.get());
3455 EXPECT_EQ(nullptr, result);
3456
3457 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ACC_INTEL_GPU, mockL0Device.get());
3458 EXPECT_EQ(nullptr, result);
3459
3460 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MME_INTEL_GPU, mockL0Device.get());
3461 EXPECT_EQ(nullptr, result);
3462
3463 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SP_INTEL_GPU, mockL0Device.get());
3464 EXPECT_EQ(nullptr, result);
3465
3466 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DBG_INTEL_GPU, mockL0Device.get());
3467 EXPECT_EQ(nullptr, result);
3468
3469 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FC_INTEL_GPU, mockL0Device.get());
3470 EXPECT_EQ(nullptr, result);
3471
3472 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MSG_INTEL_GPU, mockL0Device.get());
3473 EXPECT_EQ(nullptr, result);
3474
3475 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU, mockL0Device.get());
3476 EXPECT_EQ(nullptr, result);
3477
3478 // Test invalid type
3479 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_INVALID_INTEL_GPU, mockL0Device.get());
3480 EXPECT_EQ(nullptr, result);
3481 }
3482
3483 TEST_F(DebugSessionRegistersAccessTestV3, givenDeviceWithMockSipExternalLibInterfaceWhenRegistersAccessHelperCalledThenReturnsSuccess) {
3484 class MockSipExternalLibForTest : public MockSipExternalLib {
3485 public:
3486 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override {
3487 return 0;
3488 }
3489 bool createRegisterDescriptorMap() override {
3490 return true;
3491 }
3492 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override {
3493 // Return a test regset descriptor for GRF type
3494 if (type == static_cast<uint32_t>(0)) { // eGRF = 0
3495 static SIP::regset_desc testRegsetDesc = {0x100, 128, 16, 32};
3496 return &testRegsetDesc;
3497 }
3498 return nullptr;
3499 }
3500 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override {
3501 if (registerCount) {
3502 *registerCount = 1;
3503 }
3504 if (registerStartOffset) {
3505 *registerStartOffset = 0;
3506 }
3507 return true;
3508 }
3509 uint32_t getSipLibCommandRegisterType() override {
3510 return 0; // Return a test command register type
3511 }
3512 };
3513
3514 // Create a mock device that returns the mock SipExternalLib
3515 class MockDeviceWithSipLib : public NEO::MockDevice {
3516 public:
3517 MockDeviceWithSipLib() : NEO::MockDevice() {
3518 mockSipLib = std::make_unique<MockSipExternalLibForTest>();
3519 }
3520 NEO::SipExternalLib *getSipExternalLibInterface() const override {
3521 return mockSipLib.get();
3522 }
3523 std::unique_ptr<MockSipExternalLibForTest> mockSipLib;
3524 };
3525
3526 // Create the mock NEO device with SIP external lib interface
3527 auto mockNeoDevice = std::make_unique<MockDeviceWithSipLib>();
3528
3529 // Create a mock L0 device wrapper
3530 auto mockL0Device = std::make_unique<MockDeviceImp>(mockNeoDevice.release());
3531
3532 // Create a new debug session with the mock device
3533 zet_debug_config_t config = {};
3534 config.pid = 0x1234;
3535 auto mockSession = std::make_unique<MockDebugSession>(config, mockL0Device.get());
3536 mockSession->stateSaveAreaHeader = NEO::MockSipData::createStateSaveAreaHeader(3);
3537
3538 // Setup state save area
3539 {
3540 auto pStateSaveAreaHeader = mockSession->getStateSaveAreaHeader();
3541 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3542 pStateSaveAreaHeader->regHeaderV3.state_area_offset +
3543 pStateSaveAreaHeader->regHeaderV3.state_save_size * 16;
3544 mockSession->stateSaveAreaHeader.resize(size);
3545 }
3546
3547 // Get register descriptor from the mock session using the mock device
3548 auto pStateSaveAreaHeader = mockSession->getStateSaveAreaHeader();
3549 auto *regdesc = mockSession->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockL0Device.get());
3550 if (regdesc != nullptr) {
3551 EXPECT_EQ(regdesc->offset, 0x100u);
3552 EXPECT_EQ(regdesc->num, 128u);
3553 EXPECT_EQ(regdesc->bytes, 32u);
3554 }
3555
3556 // Prepare test data for registersAccessHelper
3557 uint8_t testData[32] = {0x12, 0x34, 0x56, 0x78};
3558 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3559 SIP::regset_desc regdescTest = regdesc != nullptr ? *regdesc : SIP::regset_desc{0x100u, 128u, 0, 32u};
3560
3561 // Test registersAccessHelper for write operation
3562 auto result = mockSession->registersAccessHelper(mockSession->allThreads[thread0].get(), &regdescTest, 0, 1, 0, testData, true);
3563 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3564
3565 // Test registersAccessHelper for read operation
3566 uint8_t readData[32] = {};
3567 result = mockSession->registersAccessHelper(mockSession->allThreads[thread0].get(), &regdescTest, 0, 1, 0, readData, false);
3568 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
3569 }
3570
3571 TEST_F(DebugSessionRegistersAccessTestV3, givenSsaHeaderVersionGreaterThan3WhenTypeToRegsetDescCalledThenNullRegdescIsReturned) {
3572 reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data())->versionHeader.version.major = 4;
3573 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3574
3575 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_INVALID_INTEL_GPU, mockDevice.get()), nullptr);
3576 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockDevice.get()), nullptr);
3577 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ADDR_INTEL_GPU, mockDevice.get()), nullptr);
3578 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FLAG_INTEL_GPU, mockDevice.get()), nullptr);
3579 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CE_INTEL_GPU, mockDevice.get()), nullptr);
3580 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SR_INTEL_GPU, mockDevice.get()), nullptr);
3581 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, mockDevice.get()), nullptr);
3582 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_TDR_INTEL_GPU, mockDevice.get()), nullptr);
3583 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ACC_INTEL_GPU, mockDevice.get()), nullptr);
3584 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MME_INTEL_GPU, mockDevice.get()), nullptr);
3585 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SP_INTEL_GPU, mockDevice.get()), nullptr);
3586 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DBG_INTEL_GPU, mockDevice.get()), nullptr);
3587 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FC_INTEL_GPU, mockDevice.get()), nullptr);
3588 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU, mockDevice.get()), nullptr);
3589 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MSG_INTEL_GPU, mockDevice.get()), nullptr);
3590 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU, mockDevice.get()), nullptr);
3591 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DEBUG_SCRATCH_INTEL_GPU, mockDevice.get()), nullptr);
3592 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU, mockDevice.get()), nullptr);
3593 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MODE_FLAGS_INTEL_GPU, mockDevice.get()), nullptr);
3594
3595 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, 0x1234, mockDevice.get()), nullptr);
3596 }
3597
3598 TEST_F(DebugSessionRegistersAccessTestV3, givenSsaHeaderVersionGreaterThan3WhenGetSbaRegsetDescCalledThenNullIsReturned) {
3599 reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data())->versionHeader.version.major = 99;
3600 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3601
3602 EXPECT_EQ(DebugSessionImp::getSbaRegsetDesc(session->getConnectedDevice(), *pStateSaveAreaHeader), nullptr);
3603 }
3604
3605 TEST_F(DebugSessionRegistersAccessTestV3, givenSsaHeaderVersionGreaterThan3WhenCmdRegisterAccessHelperCalledThenNullIsReturned) {
3606 reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data())->versionHeader.version.major = 4;
3607 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3608 NEO::SipCommandRegisterValues resumeCommand = {{0}};
3609 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->cmdRegisterAccessHelper(thread0, resumeCommand, false));
3610 }
3611
3612 using DebugSessionRegistersAccessTest = Test<DebugSessionRegistersAccess>;
3613
3614 TEST_F(DebugSessionRegistersAccessTest, givenTypeToRegsetDescCalledThenCorrectRegdescIsReturned) {
3615 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3616
3617 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_INVALID_INTEL_GPU, mockDevice.get()), nullptr);
3618 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.grf);
3619 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ADDR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.addr);
3620 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FLAG_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.flag);
3621 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CE_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.emask);
3622 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.sr);
3623 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.cr);
3624 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_TDR_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.tdr);
3625 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ACC_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.acc);
3626 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MME_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.mme);
3627 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SP_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.sp);
3628 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DBG_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.dbg_reg);
3629 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FC_INTEL_GPU, mockDevice.get()), &pStateSaveAreaHeader->regHeader.fc);
3630 EXPECT_NE(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU, mockDevice.get()), nullptr);
3631 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, 0x1234, mockDevice.get()), nullptr);
3632 }
3633
3634 TEST_F(DebugSessionRegistersAccessTest, givenNoStateSaveAreWhenTypeToRegsetDescCalledThennullptrReturned) {
3635 decltype(session->stateSaveAreaHeader) emptyHeader;
3636 session->stateSaveAreaHeader.swap(emptyHeader);
3637 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3638
3639 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockDevice.get()), nullptr);
3640 }
3641
3642 TEST_F(DebugSessionRegistersAccessTest, givenValidRegisterWhenGettingSizeThenCorrectSizeIsReturned) {
3643 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
3644 EXPECT_EQ(pStateSaveAreaHeader->regHeader.grf.bytes, session->getRegisterSize(ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU));
3645 }
3646
3647 TEST_F(DebugSessionRegistersAccessTest, givenInvalidRegisterWhenGettingSizeThenZeroSizeIsReturned) {
3648 EXPECT_EQ(0u, session->getRegisterSize(ZET_DEBUG_REGSET_TYPE_INVALID_INTEL_GPU));
3649 }
3650
3651 TEST_F(DebugSessionRegistersAccessTest, givenGetThreadRegisterSetPropertiesCalledWithInvalidThreadThenErrorIsReturned) {
3652
3653 uint32_t threadCount = 0;
3654 ze_device_thread_t thread = {UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX};
3655 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, nullptr));
3656 session->areRequestedThreadsStoppedReturnValue = 0;
3657 session->allThreads[stoppedThreadId]->resumeThread();
3658 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zetDebugGetThreadRegisterSetProperties(session->toHandle(), stoppedThread, &threadCount, nullptr));
3659 }
3660
3661 TEST_F(DebugSessionRegistersAccessTest,
3662 givenNonZeroCountAndNullRegsetPointerWhenGetThreadRegisterSetPropertiesCalledTheniInvalidNullPointerIsReturned) {
3663 uint32_t threadCount = 10;
3664 ze_device_thread_t thread = stoppedThread;
3665 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_POINTER,
3666 zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, nullptr));
3667 }
3668
3669 HWTEST2_F(DebugSessionRegistersAccessTest,
3670 givenGetThreadRegisterSetPropertiesCalledWhenLargeGrfIsSetThen256GrfRegisterCountIsReported,
3671 IsXeCore) {
3672 auto mockBuiltins = new MockBuiltins();
3673 mockBuiltins->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2, 256);
3674 MockRootDeviceEnvironment::resetBuiltins(neoDevice->executionEnvironment->rootDeviceEnvironments[0].get(), mockBuiltins);
3675
3676 {
3677 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3678 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3679 pStateSaveAreaHeader->regHeader.state_area_offset +
3680 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3681 session->stateSaveAreaHeader.resize(size);
3682 }
3683
3684 ze_device_thread_t thread = stoppedThread;
3685
3686 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.cr;
3687 uint32_t cr0[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3688 cr0[0] = 0x80002000;
3689 session->registersAccessHelper(session->allThreads[stoppedThreadId].get(), regdesc, 0, 1, 0, cr0, true);
3690
3691 uint32_t threadCount = 0;
3692 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, nullptr));
3693 std::vector<zet_debug_regset_properties_t> threadRegsetProps(threadCount);
3694 ASSERT_EQ(ZE_RESULT_SUCCESS, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, threadRegsetProps.data()));
3695 EXPECT_EQ(256u, threadRegsetProps[0].count);
3696 }
3697
3698 HWTEST2_F(DebugSessionRegistersAccessTest,
3699 givenGetThreadRegisterSetPropertiesCalledWhenLargeGrfIsNotSetThen128GrfRegisterCountIsReported,
3700 IsXeCore) {
3701 auto mockBuiltins = new MockBuiltins();
3702 mockBuiltins->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2, 256);
3703 MockRootDeviceEnvironment::resetBuiltins(neoDevice->executionEnvironment->rootDeviceEnvironments[0].get(), mockBuiltins);
3704
3705 {
3706 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3707 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3708 pStateSaveAreaHeader->regHeader.state_area_offset +
3709 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3710 session->stateSaveAreaHeader.resize(size);
3711 }
3712
3713 ze_device_thread_t thread = stoppedThread;
3714
3715 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.cr;
3716 uint32_t cr0[8] = {0, 0, 0, 0, 0, 0, 0, 0};
3717 cr0[0] = 0x80000000;
3718 session->registersAccessHelper(session->allThreads[stoppedThreadId].get(), regdesc, 0, 1, 0, cr0, true);
3719
3720 uint32_t threadCount = 0;
3721 EXPECT_EQ(ZE_RESULT_SUCCESS, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, nullptr));
3722 std::vector<zet_debug_regset_properties_t> threadRegsetProps(threadCount);
3723 ASSERT_EQ(ZE_RESULT_SUCCESS, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, threadRegsetProps.data()));
3724 EXPECT_EQ(128u, threadRegsetProps[0].count);
3725 }
3726
3727 TEST_F(DebugSessionRegistersAccessTest, givenUnsupportedRegisterTypeWhenReadRegistersCalledThenErrorInvalidArgumentIsReturned) {
3728 session->areRequestedThreadsStoppedReturnValue = 1;
3729 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugReadRegisters(session->toHandle(), stoppedThread, 0x12345, 0, 1, nullptr));
3730 }
3731
3732 TEST_F(DebugSessionRegistersAccessTest, givenUnsupportedRegisterTypeWhenWriteRegistersCalledThenErrorInvalidArgumentIsReturned) {
3733 session->areRequestedThreadsStoppedReturnValue = 1;
3734
3735 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugWriteRegisters(session->toHandle(), stoppedThread, 0x12345, 0, 1, nullptr));
3736 }
3737
3738 TEST_F(DebugSessionRegistersAccessTest, givenInvalidRegistersIndicesWhenReadRegistersCalledThenErrorInvalidArgumentIsReturned) {
3739 session->areRequestedThreadsStoppedReturnValue = 1;
3740
3741 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugReadRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 128, 1, nullptr));
3742 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugReadRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 127, 2, nullptr));
3743 }
3744
3745 TEST_F(DebugSessionRegistersAccessTest, givenInvalidRegistersIndicesWhenWriteRegistersCalledThenErrorInvalidArgumentIsReturned) {
3746 session->areRequestedThreadsStoppedReturnValue = 1;
3747
3748 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugWriteRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 128, 1, nullptr));
3749 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugWriteRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 127, 2, nullptr));
3750 }
3751
3752 TEST_F(DebugSessionRegistersAccessTest, givenThreadAllWhenReadWriteRegistersCalledThenErrorNotAvailableIsReturned) {
3753 session->areRequestedThreadsStoppedReturnValue = 1;
3754
3755 ze_device_thread_t threadAll = {UINT32_MAX, UINT32_MAX, UINT32_MAX, UINT32_MAX};
3756 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zetDebugReadRegisters(session->toHandle(), threadAll, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 0, 1, nullptr));
3757 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zetDebugWriteRegisters(session->toHandle(), threadAll, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 0, 2, nullptr));
3758 }
3759
3760 TEST_F(DebugSessionRegistersAccessTest, givenInvalidSbaRegistersIndicesWhenReadSbaRegistersCalledThenErrorInvalidArgumentIsReturned) {
3761 session->areRequestedThreadsStoppedReturnValue = 1;
3762
3763 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugReadRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU, 9, 1, nullptr));
3764 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugReadRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU, 8, 2, nullptr));
3765 }
3766
3767 TEST_F(DebugSessionRegistersAccessTest, givenWriteSbaRegistersCalledThenErrorInvalidArgumentIsReturned) {
3768 session->areRequestedThreadsStoppedReturnValue = 1;
3769
3770 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zetDebugWriteRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU, 0, 1, nullptr));
3771 }
3772
3773 TEST_F(DebugSessionRegistersAccessTest, givenNoneThreadsStoppedWhenReadRegistersCalledThenErrorNotAvailableReturned) {
3774 session->areRequestedThreadsStoppedReturnValue = 0;
3775 session->allThreads[stoppedThreadId]->resumeThread();
3776 char grf[32] = {0};
3777 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zetDebugReadRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 0, 1, grf));
3778 }
3779
3780 TEST_F(DebugSessionRegistersAccessTest, givenNoneThreadsStoppedWhenWriteRegistersCalledThenErrorNotAvailableReturned) {
3781 session->areRequestedThreadsStoppedReturnValue = 0;
3782 session->allThreads[stoppedThreadId]->resumeThread();
3783 char grf[32] = {0};
3784 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zetDebugWriteRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 0, 1, grf));
3785 }
3786
3787 TEST_F(DebugSessionRegistersAccessTest, givenNoStateSaveAreaWhenReadRegistersCalledThenErrorUnknownReturned) {
3788 session->areRequestedThreadsStoppedReturnValue = 1;
3789 decltype(session->stateSaveAreaHeader) empty;
3790 session->stateSaveAreaHeader.swap(empty);
3791
3792 char grf[32] = {0};
3793 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetDebugReadRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 0, 1, grf));
3794 }
3795
3796 TEST_F(DebugSessionRegistersAccessTest, givenNoStateSaveAreaWhenWriteRegistersCalledThenErrorUnknownReturned) {
3797 session->areRequestedThreadsStoppedReturnValue = 1;
3798 decltype(session->stateSaveAreaHeader) empty;
3799 session->stateSaveAreaHeader.swap(empty);
3800
3801 char grf[32] = {0};
3802 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zetDebugWriteRegisters(session->toHandle(), stoppedThread, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 0, 1, grf));
3803 }
3804
3805 TEST_F(DebugSessionRegistersAccessTest, givenNoStateSaveAreaGpuVaWhenRegistersAccessHelperCalledThenErrorUnknownReturned) {
3806
3807 {
3808 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3809 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3810 pStateSaveAreaHeader->regHeader.state_area_offset +
3811 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3812 session->stateSaveAreaHeader.resize(size);
3813 }
3814
3815 session->returnStateSaveAreaGpuVa = false;
3816 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.grf;
3817 uint8_t r0[32];
3818 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3819 auto ret = session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, 1, 0, r0, false);
3820 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, ret);
3821 }
3822
3823 TEST_F(DebugSessionRegistersAccessTest, givenWriteGpuMemoryErrorWhenRegistersAccessHelperCalledForWriteThenErrorUnknownReturned) {
3824
3825 {
3826 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3827 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3828 pStateSaveAreaHeader->regHeader.state_area_offset +
3829 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3830 session->stateSaveAreaHeader.resize(size);
3831 }
3832
3833 session->writeMemoryResult = ZE_RESULT_ERROR_UNKNOWN;
3834 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.grf;
3835 uint8_t r0[32];
3836 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3837 auto ret = session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, 1, 0, r0, true);
3838 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, ret);
3839 }
3840
3841 TEST_F(DebugSessionRegistersAccessTest, givenReadGpuMemoryErrorWhenRegistersAccessHelperCalledForReadThenErrorUnknownReturned) {
3842
3843 {
3844 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3845 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3846 pStateSaveAreaHeader->regHeader.state_area_offset +
3847 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3848 session->stateSaveAreaHeader.resize(size);
3849 }
3850
3851 session->readMemoryResult = ZE_RESULT_ERROR_UNKNOWN;
3852 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.grf;
3853 uint8_t r0[32];
3854 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3855 auto ret = session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, 1, 0, r0, false);
3856 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, ret);
3857 }
3858
3859 TEST_F(DebugSessionRegistersAccessTest, givenNoStateSaveAreaWhenReadRegisterCalledThenErrorUnknownReturned) {
3860 session->stateSaveAreaHeader.clear();
3861
3862 auto stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2);
3863 session->readMemoryResult = ZE_RESULT_ERROR_UNKNOWN;
3864 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(stateSaveAreaHeader.data()))->regHeader.grf;
3865 uint8_t r0[32];
3866 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3867 auto ret = session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, 1, 0, r0, true);
3868 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, ret);
3869 }
3870
3871 TEST_F(DebugSessionRegistersAccessTest, GivenSipVersion2WhenWritingResumeCommandThenCmdRegIsWritten) {
3872 const uint32_t resumeValue = 0;
3873
3874 {
3875 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3876 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3877 pStateSaveAreaHeader->regHeader.state_area_offset +
3878 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3879 session->stateSaveAreaHeader.resize(size);
3880 }
3881
3882 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3883 EuThread::ThreadId thread3(0, 0, 0, 0, 3);
3884
3885 std::vector<EuThread::ThreadId> threads;
3886 threads.push_back(thread0);
3887 threads.push_back(thread3);
3888
3889 dumpRegisterState();
3890
3891 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.cmd;
3892 SIP::sip_command resumeCommand = {0};
3893 resumeCommand.command = 11;
3894 session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, 1, 0, &resumeCommand, true);
3895
3896 session->skipWriteResumeCommand = false;
3897 session->writeResumeCommand(threads);
3898
3899 session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, 1, 0, &resumeCommand, false);
3900 EXPECT_EQ(resumeValue, resumeCommand.command);
3901
3902 resumeCommand.command = 11;
3903 session->registersAccessHelper(session->allThreads[thread3].get(), regdesc, 0, 1, 0, &resumeCommand, false);
3904 EXPECT_EQ(resumeValue, resumeCommand.command);
3905 }
3906
3907 TEST_F(DebugSessionRegistersAccessTestV3, givenHeaplessFlagSetWhenIsHeaplessModeCalledThenReturnsTrue) {
3908 SIP::intelgt_state_save_area_V3 ssa = {};
3909 ssa.sip_flags = SIP::SIP_FLAG_HEAPLESS; // Heapless flag set
3910
3911 bool result = DebugSessionImp::isHeaplessMode(session->getConnectedDevice(), ssa);
3912 EXPECT_TRUE(result); // Should return true when heapless flag is set
3913 }
3914
3915 TEST_F(DebugSessionRegistersAccessTest, givenNoHeaplessFlagWhenIsHeaplessModeCalledThenReturnsFalse) {
3916 SIP::intelgt_state_save_area_V3 ssa = {};
3917 ssa.sip_flags = 0; // No heapless flag set
3918
3919 bool result = DebugSessionImp::isHeaplessMode(session->getConnectedDevice(), ssa);
3920 EXPECT_FALSE(result); // Should return false when no heapless flag
3921 }
3922
3923 TEST_F(DebugSessionRegistersAccessTest, givenValidParametersWhenRegistersAccessHelperCalledForReadThenReturnsSuccess) {
3924 {
3925 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3926 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3927 pStateSaveAreaHeader->regHeader.state_area_offset +
3928 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3929 session->stateSaveAreaHeader.resize(size);
3930 }
3931
3932 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.grf;
3933 uint8_t r0[32];
3934 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3935
3936 // Test successful read operation
3937 auto ret = session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, 1, 0, r0, false);
3938 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
3939 }
3940
3941 TEST_F(DebugSessionRegistersAccessTest, givenValidParametersWhenRegistersAccessHelperCalledForWriteThenReturnsSuccess) {
3942 {
3943 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3944 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3945 pStateSaveAreaHeader->regHeader.state_area_offset +
3946 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3947 session->stateSaveAreaHeader.resize(size);
3948 }
3949
3950 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.grf;
3951 uint8_t r0[32] = {0x12, 0x34, 0x56, 0x78}; // Test data
3952 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3953
3954 // Test successful write operation
3955 auto ret = session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, 1, 0, r0, true);
3956 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
3957 }
3958
3959 TEST_F(DebugSessionRegistersAccessTest, givenInvalidStartParameterWhenRegistersAccessHelperCalledThenReturnsInvalidArgument) {
3960 {
3961 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3962 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3963 pStateSaveAreaHeader->regHeader.state_area_offset +
3964 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3965 session->stateSaveAreaHeader.resize(size);
3966 }
3967
3968 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.grf;
3969 uint8_t r0[32];
3970 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3971
3972 // Test with start index >= regdesc->num
3973 auto ret = session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, regdesc->num, 1, 0, r0, false);
3974 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, ret);
3975 }
3976
3977 TEST_F(DebugSessionRegistersAccessTest, givenInvalidCountParameterWhenRegistersAccessHelperCalledThenReturnsInvalidArgument) {
3978 {
3979 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
3980 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
3981 pStateSaveAreaHeader->regHeader.state_area_offset +
3982 pStateSaveAreaHeader->regHeader.state_save_size * 16;
3983 session->stateSaveAreaHeader.resize(size);
3984 }
3985
3986 auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.grf;
3987 uint8_t r0[32];
3988 EuThread::ThreadId thread0(0, 0, 0, 0, 0);
3989
3990 // Test with start + count > regdesc->num
3991 auto ret = session->registersAccessHelper(session->allThreads[thread0].get(), regdesc, 0, regdesc->num + 1, 0, r0, false);
3992 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, ret);
3993 }
3994
3995 TEST_F(DebugSessionRegistersAccessTest, givenNullStateSaveAreaHeaderWhenTypeToRegsetDescCalledThenReturnsNull) {
3996 // Test decision at line 1122 - null pointer check
3997 const SIP::regset_desc *result = DebugSessionImp::typeToRegsetDesc(nullptr, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, session->getConnectedDevice());
3998 EXPECT_EQ(nullptr, result);
3999 }
4000
4001 TEST_F(DebugSessionRegistersAccessTestV3, givenVersion3StateSaveAreaWhenTypeToRegsetDescCalledWithGrfTypeThenReturnsGrfRegset) {
4002 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
4003
4004 // Test switch label at line 1135 for version 3 - GRF case
4005 const SIP::regset_desc *result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockDevice.get());
4006 EXPECT_NE(nullptr, result);
4007 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.grf);
4008 }
4009
4010 TEST_F(DebugSessionRegistersAccessTestV3, givenVersion3StateSaveAreaWhenTypeToRegsetDescCalledWithVariousTypesThenReturnsCorrectRegset) {
4011 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
4012
4013 // Test various switch labels at line 1135 for version 3
4014 const SIP::regset_desc *result;
4015
4016 // ADDR case
4017 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ADDR_INTEL_GPU, mockDevice.get());
4018 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.addr);
4019
4020 // FLAG case
4021 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FLAG_INTEL_GPU, mockDevice.get());
4022 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.flag);
4023
4024 // CE case
4025 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CE_INTEL_GPU, mockDevice.get());
4026 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.emask);
4027
4028 // SR case
4029 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SR_INTEL_GPU, mockDevice.get());
4030 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.sr);
4031
4032 // CR case
4033 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, mockDevice.get());
4034 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.cr);
4035
4036 // TDR case
4037 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_TDR_INTEL_GPU, mockDevice.get());
4038 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.tdr);
4039
4040 // ACC case
4041 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ACC_INTEL_GPU, mockDevice.get());
4042 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.acc);
4043
4044 // MME case
4045 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MME_INTEL_GPU, mockDevice.get());
4046 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.mme);
4047
4048 // SP case
4049 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SP_INTEL_GPU, mockDevice.get());
4050 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.sp);
4051
4052 // DBG case
4053 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DBG_INTEL_GPU, mockDevice.get());
4054 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.dbg_reg);
4055
4056 // FC case
4057 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FC_INTEL_GPU, mockDevice.get());
4058 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.fc);
4059
4060 // SCALAR case
4061 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU, mockDevice.get());
4062 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.scalar);
4063
4064 // MSG case
4065 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MSG_INTEL_GPU, mockDevice.get());
4066 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.msg);
4067 }
4068
4069 TEST_F(DebugSessionRegistersAccessTestV3, givenVersion3StateSaveAreaWhenTypeToRegsetDescCalledWithUnknownTypeThenReturnsNull) {
4070 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
4071
4072 // Test default case in switch (line 1135)
4073 const SIP::regset_desc *result = session->typeToRegsetDesc(pStateSaveAreaHeader, 999999, mockDevice.get()); // Invalid type
4074 EXPECT_EQ(nullptr, result);
4075 }
4076
4077 TEST_F(DebugSessionRegistersAccessTest, givenVersion2StateSaveAreaWhenTypeToRegsetDescCalledThenReturnsCorrectRegset) {
4078 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
4079
4080 // Test version < 3 path - should use regHeader instead of regHeaderV3
4081 const SIP::regset_desc *result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockDevice.get());
4082 EXPECT_NE(nullptr, result);
4083 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeader.grf);
4084
4085 // Test another case for version < 3
4086 result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ADDR_INTEL_GPU, mockDevice.get());
4087 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeader.addr);
4088 }
4089
4090 TEST_F(DebugSessionRegistersAccessTest, GivenBindlessSipVersion2WhenCallingResumeThenResumeInCmdRegisterIsWritten) {
4091 session->debugArea.reserved1 = 1u;
4092
4093 {
4094 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
4095 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
4096 pStateSaveAreaHeader->regHeader.state_area_offset +
4097 pStateSaveAreaHeader->regHeader.state_save_size * 16;
4098 session->stateSaveAreaHeader.resize(size);
4099 }
4100 session->skipWriteResumeCommand = false;
4101
4102 ze_device_thread_t thread = {0, 0, 0, 0};
4103 EuThread::ThreadId threadId(0, thread);
4104 session->allThreads[threadId]->stopThread(1u);
4105
4106 dumpRegisterState();
4107
4108 auto result = session->resume(thread);
4109 EXPECT_EQ(result, ZE_RESULT_SUCCESS);
4110
4111 EXPECT_EQ(0u, session->readRegistersCallCount);
4112 EXPECT_EQ(0u, session->writeRegistersCallCount);
4113 EXPECT_EQ(1u, session->writeResumeCommandCalled);
4114 }
4115
4116 TEST_F(DebugSessionRegistersAccessTestV3, WhenReadingDebugScratchRegisterThenErrorsHandled) {
4117 uint64_t scratch[2];
4118 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, session->readDebugScratchRegisters(5, 0, scratch));
4119 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, session->readDebugScratchRegisters(0, 5, scratch));
4120 EXPECT_EQ(ZE_RESULT_SUCCESS, session->readDebugScratchRegisters(0, 2, scratch));
4121 EXPECT_EQ(scratch[0], 0u);
4122 EXPECT_EQ(scratch[1], 0u);
4123 }
4124
4125 TEST_F(DebugSessionRegistersAccessTestV3, WhenReadingModeRegisterThenCorrectResultReturned) {
4126 auto mockBuiltins = new MockBuiltins();
4127 mockBuiltins->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(3);
4128 MockRootDeviceEnvironment::resetBuiltins(neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0].get(), mockBuiltins);
4129
4130 uint32_t modeFlags;
4131 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, session->readModeFlags(1, 1, &modeFlags));
4132 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, session->readModeFlags(0, 2, &modeFlags));
4133 EXPECT_EQ(ZE_RESULT_SUCCESS, session->readModeFlags(0, 1, &modeFlags));
4134 EXPECT_EQ(modeFlags, SIP::SIP_FLAG_HEAPLESS);
4135 neoDevice->executionEnvironment->rootDeviceEnvironments[0]->builtins.reset();
4136 }
4137
4138 TEST_F(DebugSessionRegistersAccessTest, WhenReadingSbaRegistersThenCorrectAddressesAreReturned) {
4139
4140 {
4141 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
4142 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
4143 pStateSaveAreaHeader->regHeader.state_area_offset +
4144 pStateSaveAreaHeader->regHeader.state_save_size * 16;
4145 session->stateSaveAreaHeader.resize(size);
4146 }
4147
4148 auto &gfxCoreHelper = neoDevice->getGfxCoreHelper();
4149 ze_device_thread_t thread = {0, 0, 0, 0};
4150 ze_device_thread_t thread1 = {0, 0, 0, 1};
4151 EuThread::ThreadId threadId(0, thread);
4152 EuThread::ThreadId threadId1(0, thread1);
4153 session->allThreads[threadId]->stopThread(1u);
4154 session->allThreads[threadId1]->stopThread(1u);
4155
4156 dumpRegisterState();
4157
4158 auto threadSlotOffset = session->calculateThreadSlotOffset(threadId);
4159 auto stateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
4160 auto grfOffset = threadSlotOffset + stateSaveAreaHeader->regHeader.grf.offset;
4161 uint32_t *r0Thread0 = reinterpret_cast<uint32_t *>(ptrOffset(session->stateSaveAreaHeader.data(), grfOffset));
4162 r0Thread0[4] = 0x20 << 5;
4163
4164 threadSlotOffset = session->calculateThreadSlotOffset(threadId1);
4165 grfOffset = threadSlotOffset + stateSaveAreaHeader->regHeader.grf.offset;
4166 uint32_t *r0Thread1 = reinterpret_cast<uint32_t *>(ptrOffset(session->stateSaveAreaHeader.data(), grfOffset));
4167 r0Thread1[4] = 0x24 << 5;
4168
4169 uint64_t sba[ZET_DEBUG_SBA_COUNT_INTEL_GPU];
4170 uint64_t sbaExpected[ZET_DEBUG_SBA_COUNT_INTEL_GPU];
4171
4172 for (uint32_t i = 0; i < ZET_DEBUG_SBA_COUNT_INTEL_GPU; i++) {
4173 sbaExpected[i] = i * 0x1000;
4174 }
4175
4176 session->readMemoryBuffer.assign(4 * gfxCoreHelper.getRenderSurfaceStateSize(), 5);
4177
4178 sbaExpected[ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU] = reinterpret_cast<uint64_t>(session->readMemoryBuffer.data());
4179
4180 session->sba.instructionBaseAddress = sbaExpected[ZET_DEBUG_SBA_INSTRUCTION_INTEL_GPU];
4181 session->sba.indirectObjectBaseAddress = sbaExpected[ZET_DEBUG_SBA_INDIRECT_OBJECT_INTEL_GPU];
4182 session->sba.generalStateBaseAddress = sbaExpected[ZET_DEBUG_SBA_GENERAL_STATE_INTEL_GPU];
4183 session->sba.dynamicStateBaseAddress = sbaExpected[ZET_DEBUG_SBA_DYNAMIC_STATE_INTEL_GPU];
4184 session->sba.bindlessSurfaceStateBaseAddress = sbaExpected[ZET_DEBUG_SBA_BINDLESS_SURFACE_INTEL_GPU];
4185 session->sba.bindlessSamplerStateBaseAddress = sbaExpected[ZET_DEBUG_SBA_BINDLESS_SAMPLER_INTEL_GPU];
4186 session->sba.surfaceStateBaseAddress = sbaExpected[ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU];
4187
4188 auto scratchAllocationBase = 0ULL;
4189 if (gfxCoreHelper.isScratchSpaceSurfaceStateAccessible()) {
4190 const uint32_t ptss = 128;
4191 gfxCoreHelper.setRenderSurfaceStateForScratchResource(neoDevice->getRootDeviceEnvironment(),
4192 &session->readMemoryBuffer[1 * (gfxCoreHelper.getRenderSurfaceStateSize())], 1, scratchAllocationBase, 0,
4193 ptss, nullptr, false, 6, false, true);
4194
4195 r0Thread0[5] = 1 << 10; // first surface state
4196 } else {
4197 r0Thread0[5] = 0;
4198 }
4199
4200 EXPECT_EQ(ZE_RESULT_SUCCESS, session->readSbaRegisters(threadId, 0, ZET_DEBUG_SBA_COUNT_INTEL_GPU, sba));
4201 EXPECT_EQ(0ULL, sba[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU]);
4202
4203 scratchAllocationBase = sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU];
4204 uint64_t scratchAllocationBase2 = (1ULL << 47) + 0x12000u;
4205 auto gmmHelper = neoDevice->getGmmHelper();
4206 auto scratchAllocationBase2Canonized = gmmHelper->canonize(scratchAllocationBase2);
4207
4208 if (gfxCoreHelper.isScratchSpaceSurfaceStateAccessible()) {
4209 const uint32_t ptss = 128;
4210 gfxCoreHelper.setRenderSurfaceStateForScratchResource(neoDevice->getRootDeviceEnvironment(),
4211 &session->readMemoryBuffer[1 * (gfxCoreHelper.getRenderSurfaceStateSize())], 1, scratchAllocationBase, 0,
4212 ptss, nullptr, false, 6, false, true);
4213
4214 r0Thread0[5] = 1 << 10; // first surface state
4215
4216 sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU] = scratchAllocationBase;
4217 } else {
4218 r0Thread0[3] = 1; // (2) ^ 1
4219 r0Thread0[5] = 2 << 10;
4220 sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU] = ((r0Thread0[5] >> 10) << 10) + sbaExpected[ZET_DEBUG_SBA_GENERAL_STATE_INTEL_GPU];
4221 }
4222
4223 sbaExpected[ZET_DEBUG_SBA_BINDING_TABLE_INTEL_GPU] = ((r0Thread0[4] >> 5) << 5) + sbaExpected[ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU];
4224
4225 EXPECT_EQ(ZE_RESULT_SUCCESS, session->readSbaRegisters(threadId, 0, ZET_DEBUG_SBA_COUNT_INTEL_GPU, sba));
4226
4227 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_GENERAL_STATE_INTEL_GPU], sba[ZET_DEBUG_SBA_GENERAL_STATE_INTEL_GPU]);
4228 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU], sba[ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU]);
4229 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_DYNAMIC_STATE_INTEL_GPU], sba[ZET_DEBUG_SBA_DYNAMIC_STATE_INTEL_GPU]);
4230 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_INDIRECT_OBJECT_INTEL_GPU], sba[ZET_DEBUG_SBA_INDIRECT_OBJECT_INTEL_GPU]);
4231 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_INSTRUCTION_INTEL_GPU], sba[ZET_DEBUG_SBA_INSTRUCTION_INTEL_GPU]);
4232 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_BINDLESS_SURFACE_INTEL_GPU], sba[ZET_DEBUG_SBA_BINDLESS_SURFACE_INTEL_GPU]);
4233 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_BINDLESS_SAMPLER_INTEL_GPU], sba[ZET_DEBUG_SBA_BINDLESS_SAMPLER_INTEL_GPU]);
4234 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_BINDING_TABLE_INTEL_GPU], sba[ZET_DEBUG_SBA_BINDING_TABLE_INTEL_GPU]);
4235 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU], sba[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU]);
4236
4237 if (gfxCoreHelper.isScratchSpaceSurfaceStateAccessible()) {
4238 const uint32_t ptss = 128;
4239 gfxCoreHelper.setRenderSurfaceStateForScratchResource(neoDevice->getRootDeviceEnvironment(),
4240 &session->readMemoryBuffer[2 * (gfxCoreHelper.getRenderSurfaceStateSize())], 1, scratchAllocationBase2Canonized, 0,
4241 ptss, nullptr, false, 6, false, true);
4242
4243 r0Thread1[5] = 2 << 10; // second surface state
4244
4245 sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU] = scratchAllocationBase2 + ptss;
4246 } else {
4247 r0Thread1[3] = 2; // (2) ^ 2
4248 r0Thread1[5] = 2 << 10;
4249 sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU] = ((r0Thread1[5] >> 10) << 10) + sbaExpected[ZET_DEBUG_SBA_GENERAL_STATE_INTEL_GPU];
4250 }
4251
4252 sbaExpected[ZET_DEBUG_SBA_BINDING_TABLE_INTEL_GPU] = ((r0Thread1[4] >> 5) << 5) + sbaExpected[ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU];
4253
4254 EXPECT_EQ(ZE_RESULT_SUCCESS, session->readSbaRegisters(threadId1, 0, ZET_DEBUG_SBA_COUNT_INTEL_GPU, sba));
4255
4256 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_GENERAL_STATE_INTEL_GPU], sba[ZET_DEBUG_SBA_GENERAL_STATE_INTEL_GPU]);
4257 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU], sba[ZET_DEBUG_SBA_SURFACE_STATE_INTEL_GPU]);
4258 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_DYNAMIC_STATE_INTEL_GPU], sba[ZET_DEBUG_SBA_DYNAMIC_STATE_INTEL_GPU]);
4259 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_INDIRECT_OBJECT_INTEL_GPU], sba[ZET_DEBUG_SBA_INDIRECT_OBJECT_INTEL_GPU]);
4260 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_INSTRUCTION_INTEL_GPU], sba[ZET_DEBUG_SBA_INSTRUCTION_INTEL_GPU]);
4261 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_BINDLESS_SURFACE_INTEL_GPU], sba[ZET_DEBUG_SBA_BINDLESS_SURFACE_INTEL_GPU]);
4262 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_BINDLESS_SAMPLER_INTEL_GPU], sba[ZET_DEBUG_SBA_BINDLESS_SAMPLER_INTEL_GPU]);
4263 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_BINDING_TABLE_INTEL_GPU], sba[ZET_DEBUG_SBA_BINDING_TABLE_INTEL_GPU]);
4264 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU], sba[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU]);
4265
4266 if (gfxCoreHelper.isScratchSpaceSurfaceStateAccessible()) {
4267 const uint32_t ptss = 0;
4268 gfxCoreHelper.setRenderSurfaceStateForScratchResource(neoDevice->getRootDeviceEnvironment(),
4269 &session->readMemoryBuffer[0], 1, 0xdeadbeef, 0,
4270 ptss, nullptr, false, 6, false, true);
4271
4272 r0Thread1[5] = 0; // Surface state at index 0
4273 } else {
4274 r0Thread1[3] = 0;
4275 r0Thread1[5] = 0;
4276 }
4277 sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU] = 0;
4278
4279 EXPECT_EQ(ZE_RESULT_SUCCESS, session->readSbaRegisters(threadId1, 0, ZET_DEBUG_SBA_COUNT_INTEL_GPU, sba));
4280 EXPECT_EQ(sbaExpected[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU], sba[ZET_DEBUG_SBA_SCRATCH_SPACE_INTEL_GPU]);
4281 }
4282
4283 TEST_F(DebugSessionRegistersAccessTest, GivenBindlessSipWhenCheckingMinimumSipVersionForSLMThenExpectedResultIsReturned) {
4284 session->debugArea.reserved1 = 1u;
4285
4286 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
4287 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
4288 pStateSaveAreaHeader->regHeader.state_area_offset +
4289 pStateSaveAreaHeader->regHeader.state_save_size * 16;
4290 session->stateSaveAreaHeader.resize(size);
4291
4292 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 2;
4293 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 0;
4294 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 0;
4295
4296 session->slmSipVersionCheck();
4297 EXPECT_EQ(session->sipSupportsSlm, false);
4298
4299 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 2;
4300 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 1;
4301 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 0;
4302
4303 session->slmSipVersionCheck();
4304 EXPECT_EQ(session->sipSupportsSlm, true);
4305 }
4306
4307 TEST_F(DebugSessionRegistersAccessTest, GivenBindlessSipWhenCheckingDifferentSipVersionsThenExpectedResultIsReturned) {
4308 session->debugArea.reserved1 = 1u;
4309
4310 {
4311 auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
4312 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
4313 pStateSaveAreaHeader->regHeader.state_area_offset +
4314 pStateSaveAreaHeader->regHeader.state_save_size * 16;
4315 session->stateSaveAreaHeader.resize(size);
4316 }
4317
4318 ze_device_thread_t thread = {0, 0, 0, 0};
4319 EuThread::ThreadId threadId(0, thread);
4320 session->allThreads[threadId]->stopThread(1u);
4321
4322 dumpRegisterState();
4323 session->minSlmSipVersion = {2, 2, 2};
4324 // test tssarea version
4325 // Major version cases
4326 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 2;
4327 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 2;
4328 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 2;
4329 session->slmSipVersionCheck();
4330 EXPECT_EQ(session->sipSupportsSlm, true);
4331
4332 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 1;
4333 session->slmSipVersionCheck();
4334 EXPECT_EQ(session->sipSupportsSlm, false);
4335
4336 // Minor version cases
4337 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 2;
4338 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 1;
4339 session->slmSipVersionCheck();
4340 EXPECT_EQ(session->sipSupportsSlm, false);
4341
4342 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 3;
4343 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 1;
4344 session->slmSipVersionCheck();
4345 EXPECT_EQ(session->sipSupportsSlm, true);
4346
4347 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 3;
4348 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 2;
4349 session->slmSipVersionCheck();
4350 EXPECT_EQ(session->sipSupportsSlm, true);
4351
4352 // patch version cases
4353 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 2;
4354 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 2;
4355 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 1;
4356 session->slmSipVersionCheck();
4357 EXPECT_EQ(session->sipSupportsSlm, false);
4358
4359 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 2;
4360 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 3;
4361 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 1;
4362 session->slmSipVersionCheck();
4363 EXPECT_EQ(session->sipSupportsSlm, true);
4364
4365 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 2;
4366 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 3;
4367 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 2;
4368 session->slmSipVersionCheck();
4369 EXPECT_EQ(session->sipSupportsSlm, true);
4370
4371 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 3;
4372 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 2;
4373 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 1;
4374 session->slmSipVersionCheck();
4375 EXPECT_EQ(session->sipSupportsSlm, true);
4376
4377 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 3;
4378 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 2;
4379 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 2;
4380 session->slmSipVersionCheck();
4381 EXPECT_EQ(session->sipSupportsSlm, true);
4382
4383 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.major = 3;
4384 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.minor = 3;
4385 reinterpret_cast<SIP::StateSaveArea *>(session->stateSaveAreaHeader.data())->version.patch = 1;
4386 session->slmSipVersionCheck();
4387 EXPECT_EQ(session->sipSupportsSlm, true);
4388 }
4389
4390 TEST(DebugSessionTest, GivenStoppedThreadWhenValidAddressesSizesAndOffsetsThenSlmReadIsSuccessful) {
4391
4392 zet_debug_config_t config = {};
4393 config.pid = 0x1234;
4394 auto hwInfo = *NEO::defaultHwInfo.get();
4395
4396 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
4397 MockDeviceImp mockDevice(neoDevice);
4398
4399 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
4400
4401 EuThread::ThreadId threadId(0, 0, 0, 0, 0);
4402 sessionMock->allThreads[threadId]->stopThread(1u);
4403
4404 int i;
4405 for (i = 0; i < sessionMock->slmSize; i++) {
4406 sessionMock->slmMemory[i] = i & 127;
4407 }
4408
4409 zet_debug_memory_space_desc_t desc;
4410 desc.address = 0x10000000;
4411 desc.type = ZET_DEBUG_MEMORY_SPACE_TYPE_SLM;
4412
4413 char output[EXCHANGE_BUFFER_SIZE * 3];
4414 memset(output, 0, EXCHANGE_BUFFER_SIZE * 3);
4415
4416 sessionMock->slmTesting = true;
4417 sessionMock->sipSupportsSlm = true;
4418
4419 int readSize = 7;
4420 auto retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4421 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4422 EXPECT_EQ(memcmp(output, sessionMock->slmMemory, readSize), 0);
4423 memset(output, 0, readSize);
4424
4425 int offset = 0x05;
4426 desc.address = 0x10000000 + offset;
4427 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4428 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4429 EXPECT_EQ(memcmp(output, sessionMock->slmMemory + offset, readSize), 0);
4430 memset(output, 0, readSize);
4431
4432 offset = 0x0f;
4433 desc.address = 0x10000000 + offset;
4434 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4435 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4436 EXPECT_EQ(memcmp(output, sessionMock->slmMemory + offset, readSize), 0);
4437 memset(output, 0, readSize);
4438
4439 readSize = 132;
4440 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4441 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4442 EXPECT_EQ(memcmp(output, sessionMock->slmMemory + offset, readSize), 0);
4443 memset(output, 0, readSize);
4444
4445 readSize = 230;
4446 offset = 0x0a;
4447 desc.address = 0x10000000 + offset;
4448 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4449 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4450 EXPECT_EQ(memcmp(output, sessionMock->slmMemory + offset, readSize), 0);
4451
4452 sessionMock->slmTesting = false;
4453 }
4454
4455 TEST(DebugSessionTest, GivenStoppedThreadWhenUnderInvalidConditionsThenSlmReadFailsGracefully) {
4456
4457 zet_debug_config_t config = {};
4458 config.pid = 0x1234;
4459 auto hwInfo = *NEO::defaultHwInfo.get();
4460
4461 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
4462 MockDeviceImp mockDevice(neoDevice);
4463
4464 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
4465
4466 EuThread::ThreadId threadId(0, 0, 0, 0, 0);
4467 sessionMock->allThreads[threadId]->stopThread(1u);
4468
4469 sessionMock->skipWriteResumeCommand = false;
4470
4471 zet_debug_memory_space_desc_t desc;
4472 desc.address = 0x10000000;
4473 desc.type = ZET_DEBUG_MEMORY_SPACE_TYPE_SLM;
4474
4475 constexpr int readSize = EXCHANGE_BUFFER_SIZE * 2;
4476 char output[readSize];
4477 ze_result_t retVal;
4478
4479 sessionMock->slmTesting = true;
4480
4481 memcpy_s(sessionMock->originalSlmMemory, sessionMock->slmSize, sessionMock->slmMemory, sessionMock->slmSize);
4482
4483 sessionMock->sipSupportsSlm = false;
4484
4485 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4486 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, retVal);
4487
4488 sessionMock->sipSupportsSlm = true;
4489
4490 sessionMock->resumeImpResult = ZE_RESULT_ERROR_UNKNOWN;
4491 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4492 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4493 sessionMock->resumeImpResult = ZE_RESULT_SUCCESS;
4494
4495 sessionMock->slmCmdRegisterAccessCount = 0;
4496 sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);
4497
4498 sessionMock->forceCmdAccessFail = true;
4499 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4500 EXPECT_EQ(ZE_RESULT_FORCE_UINT32, retVal);
4501 sessionMock->forceCmdAccessFail = false;
4502
4503 memcpy_s(sessionMock->slmMemory, strlen("FailReadingData"), "FailReadingData", strlen("FailReadingData"));
4504 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4505 EXPECT_EQ(ZE_RESULT_FORCE_UINT32, retVal);
4506 memcpy_s(sessionMock->slmMemory, strlen("FailReadingData"), sessionMock->originalSlmMemory, strlen("FailReadingData"));
4507
4508 sessionMock->slmCmdRegisterAccessReadyCount = 13;
4509 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4510 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, retVal);
4511 sessionMock->slmCmdRegisterAccessReadyCount = 2;
4512 sessionMock->slmCmdRegisterAccessCount = 0;
4513 sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);
4514
4515 memcpy_s(sessionMock->slmMemory, strlen("FailWaiting"), "FailWaiting", strlen("FailWaiting"));
4516 retVal = sessionMock->slmMemoryAccess<void *, false>(threadId, &desc, readSize, output);
4517 EXPECT_EQ(ZE_RESULT_FORCE_UINT32, retVal);
4518 memcpy_s(sessionMock->slmMemory, strlen("FailWaiting"), sessionMock->originalSlmMemory, strlen("FailWaiting"));
4519
4520 sessionMock->slmTesting = false;
4521 }
4522
4523 TEST(DebugSessionTest, GivenStoppedThreadWhenValidAddressesSizesAndOffsetsThenSlmWriteIsSuccessful) {
4524
4525 zet_debug_config_t config = {};
4526 config.pid = 0x1234;
4527 auto hwInfo = *NEO::defaultHwInfo.get();
4528
4529 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
4530 MockDeviceImp mockDevice(neoDevice);
4531
4532 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
4533
4534 EuThread::ThreadId threadId(0, 0, 0, 0, 0);
4535 sessionMock->allThreads[threadId]->stopThread(1u);
4536
4537 sessionMock->slmTesting = true;
4538 sessionMock->sipSupportsSlm = true;
4539
4540 int i;
4541 for (i = 0; i < sessionMock->slmSize; i++) {
4542 sessionMock->slmMemory[i] = i & 127;
4543 }
4544 memcpy_s(sessionMock->originalSlmMemory, sessionMock->slmSize, sessionMock->slmMemory, sessionMock->slmSize);
4545
4546 zet_debug_memory_space_desc_t desc;
4547 desc.address = 0x10000000;
4548 desc.type = ZET_DEBUG_MEMORY_SPACE_TYPE_SLM;
4549
4550 char input1[EXCHANGE_BUFFER_SIZE * 3];
4551 char input2[EXCHANGE_BUFFER_SIZE * 3];
4552 ze_result_t retVal;
4553
4554 int inputSize = 7;
4555 memset(input1, 0xff, inputSize);
4556
4557 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, inputSize, input1);
4558 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4559 EXPECT_EQ(memcmp(sessionMock->slmMemory, input1, inputSize), 0);
4560 EXPECT_EQ(memcmp(sessionMock->slmMemory + inputSize + 1, sessionMock->originalSlmMemory + inputSize + 1, sessionMock->slmSize - inputSize - 1), 0);
4561
4562 memset(input2, 0xbb, inputSize);
4563 int offset = 0x05;
4564 desc.address = 0x10000000 + offset;
4565 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, inputSize, input2);
4566 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4567
4568 EXPECT_EQ(memcmp(sessionMock->slmMemory, input1, offset), 0);
4569 EXPECT_EQ(memcmp(sessionMock->slmMemory + offset, input2, inputSize), 0);
4570 EXPECT_EQ(memcmp(sessionMock->slmMemory + offset + inputSize + 1, sessionMock->originalSlmMemory + offset + inputSize + 1,
4571 sessionMock->slmSize - offset - inputSize - 1),
4572 0);
4573 inputSize = 23;
4574 desc.address = 0x10000000;
4575 memset(input1, 0x0a, inputSize);
4576
4577 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, inputSize, input1);
4578 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4579
4580 EXPECT_EQ(memcmp(sessionMock->slmMemory, input1, inputSize), 0);
4581 EXPECT_EQ(memcmp(sessionMock->slmMemory + inputSize + 1, sessionMock->originalSlmMemory + inputSize + 1, sessionMock->slmSize - inputSize - 1), 0);
4582
4583 inputSize = 25;
4584 offset = 0x07;
4585 desc.address = 0x10000000 + offset;
4586
4587 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, inputSize, input2);
4588 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4589
4590 EXPECT_EQ(memcmp(sessionMock->slmMemory, input1, offset), 0);
4591 EXPECT_EQ(memcmp(sessionMock->slmMemory + offset, input2, inputSize), 0);
4592 EXPECT_EQ(memcmp(sessionMock->slmMemory + offset + inputSize + 1, sessionMock->originalSlmMemory + offset + inputSize + 1,
4593 sessionMock->slmSize - offset - inputSize - 1),
4594 0);
4595
4596 memcpy_s(sessionMock->slmMemory, offset + inputSize, sessionMock->originalSlmMemory, offset + inputSize);
4597
4598 inputSize = 27;
4599 offset = 0x0f;
4600 desc.address = 0x10000000 + offset;
4601
4602 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, inputSize, input1);
4603 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4604
4605 EXPECT_EQ(memcmp(sessionMock->slmMemory, sessionMock->originalSlmMemory, offset), 0);
4606 EXPECT_EQ(memcmp(sessionMock->slmMemory + offset, input1, inputSize), 0);
4607 EXPECT_EQ(memcmp(sessionMock->slmMemory + offset + inputSize + 1, sessionMock->originalSlmMemory + offset + inputSize + 1,
4608 sessionMock->slmSize - offset - inputSize - 1),
4609 0);
4610
4611 inputSize = 230;
4612 offset = 0x0a;
4613 desc.address = 0x10000000 + offset;
4614
4615 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, inputSize, input2);
4616 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4617
4618 EXPECT_EQ(memcmp(sessionMock->slmMemory, sessionMock->originalSlmMemory, offset), 0);
4619 EXPECT_EQ(memcmp(sessionMock->slmMemory + offset, input2, inputSize), 0);
4620 EXPECT_EQ(memcmp(sessionMock->slmMemory + offset + inputSize + 1, sessionMock->originalSlmMemory + offset + inputSize + 1,
4621 sessionMock->slmSize - offset - inputSize - 1),
4622 0);
4623
4624 sessionMock->slmTesting = false;
4625 }
4626
4627 struct DebugSessionSlmV2Test : public ::testing::Test {
4628 static constexpr uint64_t testMemoryHandle = 0xABCDEF00ULL;
4629 static constexpr size_t dataSize = 317;
4630 static constexpr uint64_t memDescAddress = 0x5372;
4631 static constexpr uint64_t slmStartOffsetResult = 0x4891;
4632
4633 struct MockDebugSessionSlmV2 : public MockDebugSession {
4634 using MockDebugSession::getSlmStartOffset;
4635 using SlmAccessProtocol = DebugSessionImp::SlmAccessProtocol;
4636 using MockDebugSession::getSlmAddresses;
4637
4638 template <typename T>
4639 struct MemAccessRecorder {
4640 T ptr;
4641 size_t size;
4642 uint64_t gpuVa;
4643 };
4644
4645 uint64_t ctxSsaGpuVaReturn = 0x20000000;
4646 std::list<ze_result_t> waitForCmdReadyReturns;
4647 ze_result_t cmdRegisterAccessHelperReturn = ZE_RESULT_SUCCESS;
4648 ze_result_t readGpuMemoryReturn = ZE_RESULT_SUCCESS;
4649 ze_result_t writeGpuMemoryReturn = ZE_RESULT_SUCCESS;
4650 std::array<char, dataSize> mockGpuMemory;
4651 std::optional<SIP::sip_command> lastSipCommand;
4652 std::optional<NEO::MockProductHelper> mockProductHelper;
4653 std::unique_ptr<MockSipExternalLib> mockSipExternalLib;
4654 std::optional<SlmAccessProtocol> forcedSlmAccessProtocol;
4655 std::optional<std::optional<SipTransferAddr>> forcedSlmAddressResult;
4656 MemAccessRecorder<char *> lastReadGpuMemory;
4657 MemAccessRecorder<const char *> lastWriteGpuMemory;
4658
4659 MockDebugSessionSlmV2(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device),
4660 mockSipExternalLib(std::make_unique<MockSipExternalLib>()) {
4661 mockSipExternalLib->getSlmStartOffsetResult = slmStartOffsetResult;
4662 }
4663
4664 ze_result_t waitForCmdReady(EuThread::ThreadId threadId, uint16_t retryCount) override {
4665 EXPECT_FALSE(waitForCmdReadyReturns.empty());
4666 ze_result_t ret = waitForCmdReadyReturns.front();
4667 waitForCmdReadyReturns.pop_front();
4668 return ret;
4669 }
4670
4671 ze_result_t cmdRegisterAccessHelper(const EuThread::ThreadId &threadId, NEO::SipCommandRegisterValues &command, bool write) override {
4672 lastSipCommand = command.sip_commandValues;
4673 return cmdRegisterAccessHelperReturn;
4674 }
4675
4676 uint64_t getContextStateSaveAreaGpuVa(uint64_t memoryHandle) override {
4677 EXPECT_EQ(memoryHandle, testMemoryHandle);
4678 return ctxSsaGpuVaReturn;
4679 }
4680
4681 ze_result_t readGpuMemory(uint64_t memoryHandle, char *output, size_t size, uint64_t gpuVa) override {
4682 EXPECT_EQ(memoryHandle, testMemoryHandle);
4683 EXPECT_LE(size, mockGpuMemory.size());
4684 memcpy_s(output, size, mockGpuMemory.data(), size);
4685 lastReadGpuMemory = {.ptr = output, .size = size, .gpuVa = gpuVa};
4686 return readGpuMemoryReturn;
4687 }
4688
4689 ze_result_t writeGpuMemory(uint64_t memoryHandle, const char *input, size_t size, uint64_t gpuVa) override {
4690 EXPECT_EQ(memoryHandle, testMemoryHandle);
4691 EXPECT_LE(size, mockGpuMemory.size());
4692 memcpy_s(mockGpuMemory.data(), size, input, size);
4693 lastWriteGpuMemory = {.ptr = input, .size = size, .gpuVa = gpuVa};
4694 return writeGpuMemoryReturn;
4695 }
4696
4697 const NEO::ProductHelper &getProductHelper() const override {
4698 return mockProductHelper ? mockProductHelper.value() : MockDebugSession::getProductHelper();
4699 }
4700
4701 NEO::SipExternalLib *getSipExternalLibInterface() const override {
4702 return mockSipExternalLib ? mockSipExternalLib.get() : MockDebugSession::getSipExternalLibInterface();
4703 }
4704
4705 SlmAccessProtocol getSlmAccessProtocol() const override {
4706 return forcedSlmAccessProtocol ? forcedSlmAccessProtocol.value() : MockDebugSession::getSlmAccessProtocol();
4707 }
4708
4709 std::optional<SipTransferAddr> getSlmAddresses(EuThread::ThreadId threadId, size_t size, const zet_debug_memory_space_desc_t *desc) override {
4710 return forcedSlmAddressResult ? forcedSlmAddressResult.value() : MockDebugSession::getSlmAddresses(threadId, size, desc);
4711 }
4712 };
4713
4714 MockDeviceImp mockDevice;
4715 MockDebugSessionSlmV2 session;
4716 EuThread::ThreadId threadId;
4717 zet_debug_memory_space_desc_t memDesc;
4718
4719 DebugSessionSlmV2Test() : mockDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(defaultHwInfo.get(), 0)),
4720 session(zet_debug_config_t{}, &mockDevice),
4721 threadId(0, 0, 0, 0, 0),
4722 memDesc{.type = ZET_DEBUG_MEMORY_SPACE_TYPE_SLM, .address = memDescAddress} {}
4723
4724 void SetUp() override {
4725 session.allThreads[threadId]->stopThread(testMemoryHandle);
4726 session.slmTesting = true;
4727 }
4728 };
4729
4730 TEST_F(DebugSessionSlmV2Test, GivenBaseCaseThenGetProductHelperIsValid) {
4731 session.getProductHelper();
4732 }
4733
4734 TEST_F(DebugSessionSlmV2Test, GivenSipExternalLibIsAvailableThenSipExternalLibIsReturned) {
4735 session.mockSipExternalLib = nullptr;
4736 session.getSipExternalLibInterface();
4737 }
4738
4739 TEST_F(DebugSessionSlmV2Test, GivenSipUsesSubslicePoolsThenSlmAccessProtocolIsV2) {
4740 session.mockProductHelper = NEO::MockProductHelper{};
4741 session.mockProductHelper->sipUsesSubslicePoolsResult = true;
4742 EXPECT_EQ(session.getSlmAccessProtocol(), DebugSessionImp::SlmAccessProtocol::v2);
4743 }
4744
4745 TEST_F(DebugSessionSlmV2Test, GivenSipDoesNotUseSubslicePoolsThenSlmAccessProtocolIsV1) {
4746 session.mockProductHelper = NEO::MockProductHelper{};
4747 session.mockProductHelper->sipUsesSubslicePoolsResult = false;
4748 EXPECT_EQ(session.getSlmAccessProtocol(), DebugSessionImp::SlmAccessProtocol::v1);
4749 }
4750
4751 TEST_F(DebugSessionSlmV2Test, GivenSipExternalLibIsAvailableThenGetSlmStartOffsetIsObtainedFromSipExternalLib) {
4752 session.mockSipExternalLib = std::make_unique<MockSipExternalLib>();
4753 session.mockSipExternalLib->getSlmStartOffsetResult = slmStartOffsetResult;
4754 uint32_t slmStartOffset = 0;
4755 EXPECT_EQ(session.getSlmStartOffset(0, threadId, &slmStartOffset), true);
4756 EXPECT_EQ(slmStartOffset, slmStartOffsetResult);
4757 }
4758
4759 TEST_F(DebugSessionSlmV2Test, GivenSlmStartOffsetIsAvailableThenGetSlmAddressReturnsCorrectValue) {
4760 session.mockSipExternalLib = std::make_unique<MockSipExternalLib>();
4761 session.mockSipExternalLib->getSlmStartOffsetResult = 0x5a00;
4762 session.ctxSsaGpuVaReturn = 0x9317b0000;
4763 const zet_debug_memory_space_desc_t desc = {
4764 .type = ZET_DEBUG_MEMORY_SPACE_TYPE_SLM,
4765 .address = 0xff00002f,
4766 };
4767 std::optional<DebugSessionImp::SipTransferAddr> result = session.getSlmAddresses(threadId, 3, &desc);
4768 ASSERT_TRUE(result.has_value());
4769 EXPECT_EQ(result->sipOffset, 0xff000020u);
4770 EXPECT_EQ(result->sipSize, 0xfu + 3u); // requested size + alignment padding
4771 EXPECT_EQ(result->gpuMemOffset, 0x9317b5a2fu); // reserved bits are masked off
4772 }
4773
4774 using DebugSessionSlmReadV2Test = DebugSessionSlmV2Test;
4775
4776 TEST_F(DebugSessionSlmReadV2Test, GivenStoppedThreadWhenValidAddressesSizesAndOffsetsThenSlmReadV2IsSuccessful) {
4777 for (size_t i = 0; i < dataSize; i++) {
4778 session.mockGpuMemory[i] = static_cast<char>(i % 73);
4779 }
4780 std::vector<char> readBuf(dataSize);
4781 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4782 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4783 ze_result_t retVal = session.slmMemoryReadV2(threadId, &memDesc, dataSize, readBuf.data());
4784 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4785 for (size_t i = 0; i < dataSize; i++) {
4786 EXPECT_EQ(readBuf[i], static_cast<char>(i % 73));
4787 }
4788 EXPECT_EQ(memcmp(session.mockGpuMemory.data(), readBuf.data(), dataSize), 0);
4789 EXPECT_EQ(session.lastSipCommand->command, static_cast<uint32_t>(NEO::SipKernel::Command::slmRead));
4790 }
4791
4792 TEST_F(DebugSessionSlmReadV2Test, SlmReadV2UsesCorrectSlmAddresses) {
4793 std::vector<char> readBuf(dataSize);
4794 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4795 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4796 session.forcedSlmAddressResult = DebugSessionImp::SipTransferAddr{
4797 .sipOffset = 0x12, .sipSize = 0x34, .gpuMemOffset = 0x56};
4798 ze_result_t retVal = session.slmMemoryReadV2(threadId, &memDesc, dataSize, readBuf.data());
4799 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4800 EXPECT_EQ(session.lastSipCommand->command, static_cast<uint32_t>(NEO::SipKernel::Command::slmRead));
4801 EXPECT_EQ(session.lastSipCommand->offset, 0x12u);
4802 EXPECT_EQ(session.lastSipCommand->size, 0x34u);
4803 EXPECT_EQ(session.lastReadGpuMemory.gpuVa, 0x56u);
4804 EXPECT_EQ(session.lastReadGpuMemory.size, dataSize);
4805 }
4806
4807 TEST_F(DebugSessionSlmReadV2Test, GivenGetSlmStartOffsetReturnsFalseThenSlmReadV2IsError) {
4808 std::vector<char> readBuf(dataSize);
4809 session.mockSipExternalLib->getSlmStartOffsetRetValue = false;
4810 ze_result_t retVal = session.slmMemoryReadV2(threadId, &memDesc, dataSize, readBuf.data());
4811 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4812 }
4813
4814 TEST_F(DebugSessionSlmReadV2Test, GivenFirstWaitForCmdReadyReturnsErrorThenSlmReadV2IsError) {
4815 std::vector<char> readBuf(dataSize);
4816 session.waitForCmdReadyReturns.push_back(ZE_RESULT_ERROR_UNKNOWN);
4817 ze_result_t retVal = session.slmMemoryReadV2(threadId, &memDesc, dataSize, readBuf.data());
4818 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4819 }
4820
4821 TEST_F(DebugSessionSlmReadV2Test, GivenSecondWaitForCmdReadyReturnsErrorThenSlmReadV2IsError) {
4822 std::vector<char> readBuf(dataSize);
4823 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4824 session.waitForCmdReadyReturns.push_back(ZE_RESULT_ERROR_UNKNOWN);
4825 ze_result_t retVal = session.slmMemoryReadV2(threadId, &memDesc, dataSize, readBuf.data());
4826 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4827 }
4828
4829 TEST_F(DebugSessionSlmReadV2Test, GivenCmdRegisterAccessHelperReturnsErrorThenSlmReadV2IsError) {
4830 std::vector<char> readBuf(dataSize);
4831 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4832 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4833 session.cmdRegisterAccessHelperReturn = ZE_RESULT_ERROR_UNKNOWN;
4834 ze_result_t retVal = session.slmMemoryReadV2(threadId, &memDesc, dataSize, readBuf.data());
4835 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4836 }
4837
4838 TEST_F(DebugSessionSlmReadV2Test, GivenResumeImpReturnsErrorThenSlmReadV2IsError) {
4839 std::vector<char> readBuf(dataSize);
4840 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4841 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4842 session.resumeImpResult = ZE_RESULT_ERROR_UNKNOWN;
4843 ze_result_t retVal = session.slmMemoryReadV2(threadId, &memDesc, dataSize, readBuf.data());
4844 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4845 }
4846
4847 using DebugSessionSlmWriteV2Test = DebugSessionSlmV2Test;
4848
4849 TEST_F(DebugSessionSlmWriteV2Test, GivenStoppedThreadWhenValidAddressesSizesAndOffsetsThenSlmWriteV2IsSuccessful) {
4850 std::vector<char> writeBuf(dataSize);
4851 for (size_t i = 0; i < dataSize; i++) {
4852 writeBuf[i] = static_cast<char>(i % 67);
4853 }
4854
4855 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4856 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4857 ze_result_t retVal = session.slmMemoryWriteV2(threadId, &memDesc, dataSize, writeBuf.data());
4858 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4859 EXPECT_EQ(memcmp(session.mockGpuMemory.data(), writeBuf.data(), dataSize), 0);
4860 EXPECT_EQ(session.lastSipCommand->command, static_cast<uint32_t>(NEO::SipKernel::Command::slmWrite));
4861 }
4862
4863 TEST_F(DebugSessionSlmWriteV2Test, SlmWriteV2UsesCorrectSlmAddresses) {
4864 std::vector<char> writeBuf(dataSize);
4865 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4866 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4867 session.forcedSlmAddressResult = DebugSessionImp::SipTransferAddr{
4868 .sipOffset = 0x12, .sipSize = 0x34, .gpuMemOffset = 0x56};
4869 ze_result_t retVal = session.slmMemoryWriteV2(threadId, &memDesc, dataSize, writeBuf.data());
4870 EXPECT_EQ(ZE_RESULT_SUCCESS, retVal);
4871 EXPECT_EQ(session.lastSipCommand->command, static_cast<uint32_t>(NEO::SipKernel::Command::slmWrite));
4872 EXPECT_EQ(session.lastSipCommand->offset, 0x12u);
4873 EXPECT_EQ(session.lastSipCommand->size, 0x34u);
4874 EXPECT_EQ(session.lastWriteGpuMemory.gpuVa, 0x56u);
4875 EXPECT_EQ(session.lastWriteGpuMemory.size, dataSize);
4876 }
4877
4878 TEST_F(DebugSessionSlmWriteV2Test, GivenGetSlmStartOffsetReturnsFalseThenSlmWriteV2IsError) {
4879 std::vector<char> writeBuf(dataSize);
4880 session.mockSipExternalLib->getSlmStartOffsetRetValue = false;
4881 ze_result_t retVal = session.slmMemoryWriteV2(threadId, &memDesc, dataSize, writeBuf.data());
4882 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4883 }
4884
4885 TEST_F(DebugSessionSlmWriteV2Test, GivenFirstWaitForCmdReadyReturnsErrorThenSlmWriteV2IsError) {
4886 std::vector<char> writeBuf(dataSize);
4887 session.waitForCmdReadyReturns.push_back(ZE_RESULT_ERROR_UNKNOWN);
4888 ze_result_t retVal = session.slmMemoryWriteV2(threadId, &memDesc, dataSize, writeBuf.data());
4889 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4890 }
4891
4892 TEST_F(DebugSessionSlmWriteV2Test, GivenSecondWaitForCmdReadyReturnsErrorThenSlmWriteV2IsError) {
4893 std::vector<char> writeBuf(dataSize);
4894 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4895 session.waitForCmdReadyReturns.push_back(ZE_RESULT_ERROR_UNKNOWN);
4896 ze_result_t retVal = session.slmMemoryWriteV2(threadId, &memDesc, dataSize, writeBuf.data());
4897 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4898 }
4899
4900 TEST_F(DebugSessionSlmWriteV2Test, GivenCmdRegisterAccessHelperReturnsErrorThenSlmWriteV2IsError) {
4901 std::vector<char> writeBuf(dataSize);
4902 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4903 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4904 session.cmdRegisterAccessHelperReturn = ZE_RESULT_ERROR_UNKNOWN;
4905 ze_result_t retVal = session.slmMemoryWriteV2(threadId, &memDesc, dataSize, writeBuf.data());
4906 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4907 }
4908
4909 TEST_F(DebugSessionSlmWriteV2Test, GivenResumeImpReturnsErrorThenSlmWriteV2IsError) {
4910 std::vector<char> writeBuf(dataSize);
4911 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4912 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4913 session.resumeImpResult = ZE_RESULT_ERROR_UNKNOWN;
4914 ze_result_t retVal = session.slmMemoryWriteV2(threadId, &memDesc, dataSize, writeBuf.data());
4915 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4916 }
4917
4918 TEST_F(DebugSessionSlmWriteV2Test, GivenWriteGpuMemoryReturnsErrorThenSlmWriteV2IsError) {
4919 std::vector<char> writeBuf(dataSize);
4920 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4921 session.waitForCmdReadyReturns.push_back(ZE_RESULT_SUCCESS);
4922 session.writeGpuMemoryReturn = ZE_RESULT_ERROR_UNKNOWN;
4923 ze_result_t retVal = session.slmMemoryWriteV2(threadId, &memDesc, dataSize, writeBuf.data());
4924 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4925 }
4926
4927 TEST(DebugSessionTest, GivenStoppedThreadWhenUnderInvalidConditionsThenSlmWriteFailsGracefully) {
4928
4929 zet_debug_config_t config = {};
4930 config.pid = 0x1234;
4931 auto hwInfo = *NEO::defaultHwInfo.get();
4932
4933 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
4934 MockDeviceImp mockDevice(neoDevice);
4935
4936 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
4937
4938 EuThread::ThreadId threadId(0, 0, 0, 0, 0);
4939 sessionMock->allThreads[threadId]->stopThread(1u);
4940
4941 sessionMock->slmTesting = true;
4942
4943 zet_debug_memory_space_desc_t desc;
4944 desc.address = 0x10000000;
4945 desc.type = ZET_DEBUG_MEMORY_SPACE_TYPE_SLM;
4946
4947 constexpr int writeSize = 16;
4948 char input[writeSize];
4949 ze_result_t retVal;
4950
4951 sessionMock->sipSupportsSlm = false;
4952
4953 retVal = sessionMock->slmMemoryAccess<void *, true>(threadId, &desc, writeSize, input);
4954 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, retVal);
4955
4956 sessionMock->sipSupportsSlm = true;
4957
4958 sessionMock->resumeImpResult = ZE_RESULT_ERROR_UNKNOWN;
4959 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, writeSize, input);
4960 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, retVal);
4961 sessionMock->resumeImpResult = ZE_RESULT_SUCCESS;
4962
4963 sessionMock->forceCmdAccessFail = true;
4964 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, writeSize, input);
4965 EXPECT_EQ(ZE_RESULT_FORCE_UINT32, retVal);
4966 sessionMock->forceCmdAccessFail = false;
4967
4968 sessionMock->slmCmdRegisterAccessReadyCount = 13;
4969 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, writeSize, input);
4970 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, retVal);
4971
4972 sessionMock->slmCmdRegisterAccessCount = 0;
4973 sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);
4974
4975 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, writeSize, input);
4976 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, retVal);
4977
4978 desc.address = 0x1000000f; // force a read
4979 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, writeSize, input);
4980 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, retVal);
4981 sessionMock->slmCmdRegisterAccessReadyCount = 2;
4982 sessionMock->slmCmdRegisterAccessCount = 0;
4983 sessionMock->slmCmdRegisterCmdvalue = static_cast<uint32_t>(NEO::SipKernel::Command::resume);
4984
4985 desc.address = 0x10000000;
4986 memcpy_s(sessionMock->slmMemory, strlen("FailWaiting"), "FailWaiting", strlen("FailWaiting"));
4987 retVal = sessionMock->slmMemoryAccess<const void *, true>(threadId, &desc, writeSize, input);
4988 EXPECT_EQ(ZE_RESULT_FORCE_UINT32, retVal);
4989 memcpy_s(sessionMock->slmMemory, strlen("FailWaiting"), sessionMock->originalSlmMemory, strlen("FailWaiting"));
4990
4991 sessionMock->slmTesting = false;
4992 }
4993
4994 TEST(DebugSessionTest, givenCanonicalOrDecanonizedAddressWhenCheckingValidAddressThenTrueReturned) {
4995 zet_debug_config_t config = {};
4996 config.pid = 0x1234;
4997 auto hwInfo = *NEO::defaultHwInfo.get();
4998
4999 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
5000 MockDeviceImp mockDevice(neoDevice);
5001
5002 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
5003
5004 zet_debug_memory_space_desc_t desc;
5005 desc.address = 0xffffffff12345678;
5006 desc.type = ZET_DEBUG_MEMORY_SPACE_TYPE_DEFAULT;
5007
5008 EXPECT_TRUE(sessionMock->isValidGpuAddress(&desc));
5009
5010 auto gmmHelper = neoDevice->getGmmHelper();
5011 auto decanonized = gmmHelper->decanonize(desc.address);
5012 desc.address = decanonized;
5013 EXPECT_TRUE(sessionMock->isValidGpuAddress(&desc));
5014 }
5015
5016 TEST(DebugSessionTest, givenInvalidAddressWhenCheckingValidAddressThenFalseIsReturned) {
5017 zet_debug_config_t config = {};
5018 config.pid = 0x1234;
5019 auto hwInfo = *NEO::defaultHwInfo.get();
5020
5021 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
5022 MockDeviceImp mockDevice(neoDevice);
5023
5024 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice);
5025 auto gmmHelper = neoDevice->getGmmHelper();
5026 auto addressWidth = gmmHelper->getAddressWidth();
5027 uint64_t address = maxNBitValue(addressWidth) << 1 | 0x4000;
5028
5029 zet_debug_memory_space_desc_t desc;
5030 desc.address = address;
5031 desc.type = ZET_DEBUG_MEMORY_SPACE_TYPE_DEFAULT;
5032
5033 EXPECT_FALSE(sessionMock->isValidGpuAddress(&desc));
5034
5035 desc.type = ZET_DEBUG_MEMORY_SPACE_TYPE_FORCE_UINT32;
5036 EXPECT_FALSE(sessionMock->isValidGpuAddress(&desc));
5037 }
5038
5039 TEST(DebugSessionTest, givenDebugSessionWhenGettingTimeDiffThenDiffReturned) {
5040 zet_debug_config_t config = {};
5041 config.pid = 0x1234;
5042
5043 auto sessionMock = std::make_unique<MockDebugSession>(config, nullptr);
5044
5045 auto now = std::chrono::high_resolution_clock::now();
5046 auto diff = sessionMock->getTimeDifferenceMilliseconds(now);
5047
5048 EXPECT_LE(0, diff);
5049 }
5050
5051 TEST(DebugSessionTest, givenDebugSessionWhenGetContextSaveAreaGpuVaCalledThenZeroIsReturned) {
5052 zet_debug_config_t config = {};
5053 config.pid = 0x1234;
5054
5055 auto sessionMock = std::make_unique<MockDebugSession>(config, nullptr);
5056 sessionMock->returnStateSaveAreaGpuVa = false;
5057
5058 EXPECT_EQ(0ULL, sessionMock->getContextStateSaveAreaGpuVa(1ULL));
5059 }
5060
5061 TEST(DebugSessionTest, givenNewAttentionRaisedWithNoExpectedAttentionThenExpectedAttentionNotChanged) {
5062 zet_debug_config_t config = {};
5063 config.pid = 0x1234;
5064
5065 auto sessionMock = std::make_unique<MockDebugSession>(config, nullptr);
5066 EXPECT_EQ(0UL, sessionMock->expectedAttentionEvents);
5067 sessionMock->newAttentionRaised();
5068 EXPECT_EQ(0UL, sessionMock->expectedAttentionEvents);
5069 }
5070
5071 TEST(DebugSessionTest, givenNoPendingInterruptsOrNoNewlyStoppedThreadsAndCheckTriggerEventsForAttentionThenDoNotTriggerEvents) {
5072 zet_debug_config_t config = {};
5073 config.pid = 0x1234;
5074
5075 auto sessionMock = std::make_unique<MockDebugSession>(config, nullptr);
5076
5077 sessionMock->triggerEvents = false;
5078 sessionMock->expectedAttentionEvents = 0;
5079 sessionMock->pendingInterrupts.clear();
5080 sessionMock->newlyStoppedThreads.clear();
5081
5082 sessionMock->checkTriggerEventsForAttention();
5083 EXPECT_FALSE(sessionMock->triggerEvents);
5084
5085 ze_device_thread_t apiThread = {0, 0, 0, 1};
5086 sessionMock->pendingInterrupts.push_back({apiThread, false});
5087
5088 sessionMock->checkTriggerEventsForAttention();
5089 EXPECT_TRUE(sessionMock->triggerEvents);
5090
5091 EuThread::ThreadId thread = {0, 0, 0, 0, 1};
5092 sessionMock->pendingInterrupts.clear();
5093 sessionMock->newlyStoppedThreads.push_back(thread);
5094
5095 EXPECT_TRUE(sessionMock->triggerEvents);
5096 }
5097
5098 TEST(DebugSessionTest, givenNoPendingInterruptsWhenSendInterruptsCalledThenNoInterruptsSent) {
5099 zet_debug_config_t config = {};
5100 config.pid = 0x1234;
5101
5102 auto sessionMock = std::make_unique<MockDebugSession>(config, nullptr);
5103 sessionMock->interruptSent = false;
5104 sessionMock->pendingInterrupts.clear();
5105 sessionMock->sendInterrupts();
5106 EXPECT_FALSE(sessionMock->interruptSent);
5107 }
5108
5109 TEST(DebugSessionTest, GivenRootDeviceAndTileAttachWhenDebugSessionIsCreatedThenThreadsAreNotCreated) {
5110 DebugManagerStateRestore restorer;
5111 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
5112
5113 zet_debug_config_t config = {};
5114 config.pid = 0x1234;
5115 auto hwInfo = *NEO::defaultHwInfo.get();
5116
5117 NEO::MockDevice *neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
5118 MockDeviceImp mockDevice(neoDevice);
5119
5120 auto sessionMock = std::make_unique<MockDebugSession>(config, &mockDevice, false);
5121 ASSERT_NE(nullptr, sessionMock);
5122
5123 EXPECT_EQ(0u, sessionMock->allThreads.size());
5124 }
5125
5126 TEST_F(MultiTileDebugSessionTest, GivenSubDeviceAndTileAttachWhenRootDeviceDebugSessionCreateFailsThenTileAttachFails) {
5127 DebugManagerStateRestore restorer;
5128 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
5129
5130 if (!hwInfo.capabilityTable.l0DebuggerSupported) {
5131 GTEST_SKIP();
5132 }
5133 zet_debug_config_t config = {};
5134 config.pid = 0x1234;
5135
5136 L0::Device *device = driverHandle->devices[0];
5137 auto neoDevice = device->getNEODevice();
5138 device->getNEODevice()->getExecutionEnvironment()->releaseRootDeviceEnvironmentResources(neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0].get());
5139 auto mockBuiltIns = new MockBuiltins();
5140 MockRootDeviceEnvironment::resetBuiltins(neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0].get(), mockBuiltIns);
5141
5142 auto osInterface = new OsInterfaceWithDebugAttach;
5143 osInterface->debugAttachAvailable = false;
5144 neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.reset(osInterface);
5145 auto subDevice0 = neoDevice->getSubDevice(0)->getSpecializedDevice<Device>();
5146
5147 zet_debug_session_handle_t debugSesion = nullptr;
5148 auto retVal = zetDebugAttach(subDevice0->toHandle(), &config, &debugSesion);
5149 EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, retVal);
5150 }
5151
5152 TEST_F(MultiTileDebugSessionTest, givenTileAttachEnabledWhenGettingDebugPropertiesThenDebugAttachIsSetForRootAndSubdevices) {
5153 DebugManagerStateRestore restorer;
5154 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
5155
5156 if (!hwInfo.capabilityTable.l0DebuggerSupported) {
5157 GTEST_SKIP();
5158 }
5159
5160 L0::Device *device = driverHandle->devices[0];
5161 auto neoDevice = device->getNEODevice();
5162 device->getNEODevice()->getExecutionEnvironment()->releaseRootDeviceEnvironmentResources(neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0].get());
5163 auto mockBuiltIns = new MockBuiltins();
5164 MockRootDeviceEnvironment::resetBuiltins(neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0].get(), mockBuiltIns);
5165
5166 neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.reset(new OsInterfaceWithDebugAttach);
5167
5168 auto subDevice0 = neoDevice->getSubDevice(0)->getSpecializedDevice<Device>();
5169 auto subDevice1 = neoDevice->getSubDevice(1)->getSpecializedDevice<Device>();
5170
5171 zet_device_debug_properties_t debugProperties = {};
5172 debugProperties.flags = ZET_DEVICE_DEBUG_PROPERTY_FLAG_FORCE_UINT32;
5173
5174 auto result = zetDeviceGetDebugProperties(device->toHandle(), &debugProperties);
5175
5176 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5177 EXPECT_EQ(zet_device_debug_property_flag_t::ZET_DEVICE_DEBUG_PROPERTY_FLAG_ATTACH, debugProperties.flags);
5178
5179 result = zetDeviceGetDebugProperties(subDevice0->toHandle(), &debugProperties);
5180
5181 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5182 EXPECT_EQ(zet_device_debug_property_flag_t::ZET_DEVICE_DEBUG_PROPERTY_FLAG_ATTACH, debugProperties.flags);
5183
5184 result = zetDeviceGetDebugProperties(subDevice1->toHandle(), &debugProperties);
5185
5186 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5187 EXPECT_EQ(zet_device_debug_property_flag_t::ZET_DEVICE_DEBUG_PROPERTY_FLAG_ATTACH, debugProperties.flags);
5188 }
5189
5190 TEST_F(MultiTileDebugSessionTest, givenTileAttachEnabledWhenAttachingToRootDeviceThenTileAttachIsDisabledAndSuccessIsReturned) {
5191 DebugManagerStateRestore restorer;
5192 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
5193
5194 zet_debug_config_t config = {};
5195 config.pid = 0x1234;
5196 zet_debug_session_handle_t debugSession = nullptr;
5197
5198 L0::Device *device = driverHandle->devices[0];
5199 auto l0Device = static_cast<Device *>(device);
5200 device->getNEODevice()->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.reset(new OsInterfaceWithDebugAttach);
5201 auto sessionMock = new MockDebugSession(config, device, true);
5202 sessionMock->initialize();
5203 l0Device->setDebugSession(sessionMock);
5204
5205 auto result = zetDebugAttach(device->toHandle(), &config, &debugSession);
5206
5207 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5208 ASSERT_NE(nullptr, debugSession);
5209 EXPECT_TRUE(sessionMock->isAttached());
5210 EXPECT_FALSE(sessionMock->tileAttachEnabled);
5211 }
5212
5213 TEST_F(MultiTileDebugSessionTest, givenTileAttachEnabledWhenAttachingToTileDevicesThenDebugSessionForRootIsCreatedAndTileSessionsAreReturned) {
5214 DebugManagerStateRestore restorer;
5215 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
5216
5217 zet_debug_config_t config = {};
5218 config.pid = 0x1234;
5219 zet_debug_session_handle_t debugSession0 = nullptr, debugSession1 = nullptr;
5220
5221 L0::Device *device = driverHandle->devices[0];
5222 auto neoDevice = device->getNEODevice();
5223 auto l0Device = static_cast<Device *>(device);
5224 neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.reset(new OsInterfaceWithDebugAttach);
5225
5226 auto sessionMock = new MockDebugSession(config, device, false);
5227 sessionMock->initialize();
5228 l0Device->setDebugSession(sessionMock);
5229
5230 auto subDevice0 = neoDevice->getSubDevice(0)->getSpecializedDevice<Device>();
5231 auto subDevice1 = neoDevice->getSubDevice(1)->getSpecializedDevice<Device>();
5232 auto tileSession1 = static_cast<MockDebugSession *>(sessionMock->tileSessions[1].first);
5233
5234 auto result = zetDebugAttach(subDevice0->toHandle(), &config, &debugSession0);
5235
5236 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5237 EXPECT_NE(nullptr, debugSession0);
5238
5239 EXPECT_TRUE(sessionMock->tileSessions[0].second);
5240 EXPECT_EQ(sessionMock->tileSessions[0].first, L0::DebugSession::fromHandle(debugSession0));
5241 EXPECT_TRUE(sessionMock->tileSessions[0].first->isAttached());
5242
5243 EXPECT_NE(nullptr, l0Device->getDebugSession(config));
5244
5245 EXPECT_FALSE(tileSession1->attachTileCalled);
5246 result = zetDebugAttach(subDevice1->toHandle(), &config, &debugSession1);
5247
5248 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5249 EXPECT_NE(nullptr, debugSession1);
5250
5251 EXPECT_TRUE(sessionMock->tileSessions[1].second);
5252 EXPECT_EQ(sessionMock->tileSessions[1].first, L0::DebugSession::fromHandle(debugSession1));
5253 EXPECT_TRUE(sessionMock->tileSessions[1].first->isAttached());
5254
5255 EXPECT_TRUE(tileSession1->attachTileCalled);
5256 EXPECT_FALSE(tileSession1->detachTileCalled);
5257
5258 result = zetDebugDetach(debugSession1);
5259
5260 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5261 EXPECT_NE(nullptr, l0Device->getDebugSession(config));
5262 EXPECT_FALSE(sessionMock->tileSessions[1].second);
5263 EXPECT_FALSE(sessionMock->tileSessions[1].first->isAttached());
5264
5265 EXPECT_TRUE(tileSession1->detachTileCalled);
5266 ASSERT_EQ(1u, sessionMock->cleanRootSessionDeviceIndices.size());
5267 EXPECT_EQ(1u, sessionMock->cleanRootSessionDeviceIndices[0]);
5268
5269 result = zetDebugDetach(debugSession0);
5270
5271 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5272 EXPECT_EQ(nullptr, l0Device->getDebugSession(config));
5273 }
5274
5275 TEST_F(MultiTileDebugSessionTest, givenTileAttachEnabledWhenTileAttachFailsDuringDebugSessionCreateThenErrorIsReturned) {
5276 DebugManagerStateRestore restorer;
5277 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
5278
5279 zet_debug_config_t config = {};
5280 config.pid = 0x1234;
5281
5282 L0::Device *device = driverHandle->devices[0];
5283 auto neoDevice = device->getNEODevice();
5284 auto l0Device = static_cast<Device *>(device);
5285 neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.reset(new OsInterfaceWithDebugAttach);
5286
5287 auto sessionMock = new MockDebugSession(config, device, false);
5288 sessionMock->initialize();
5289 l0Device->setDebugSession(sessionMock);
5290
5291 sessionMock->tileSessions[0].second = true;
5292
5293 auto subDevice0 = neoDevice->getSubDevice(0)->getSpecializedDevice<Device>();
5294 ze_result_t result = ZE_RESULT_SUCCESS;
5295
5296 auto debugSession = subDevice0->createDebugSession(config, result, false);
5297 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
5298 EXPECT_EQ(nullptr, debugSession);
5299 }
5300
5301 TEST_F(MultiTileDebugSessionTest, givenAttachedTileDeviceWhenAttachingToRootDeviceThenErrorIsReturned) {
5302 DebugManagerStateRestore restorer;
5303 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
5304
5305 zet_debug_config_t config = {};
5306 config.pid = 0x1234;
5307 zet_debug_session_handle_t debugSession0 = nullptr, debugSession1 = nullptr;
5308
5309 L0::Device *device = driverHandle->devices[0];
5310 auto neoDevice = device->getNEODevice();
5311 auto l0Device = static_cast<Device *>(device);
5312 neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.reset(new OsInterfaceWithDebugAttach);
5313
5314 auto sessionMock = new MockDebugSession(config, device, false);
5315 sessionMock->initialize();
5316 l0Device->setDebugSession(sessionMock);
5317
5318 auto subDevice0 = neoDevice->getSubDevice(0)->getSpecializedDevice<Device>();
5319 auto result = zetDebugAttach(subDevice0->toHandle(), &config, &debugSession0);
5320
5321 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5322 EXPECT_NE(nullptr, debugSession0);
5323
5324 result = zetDebugAttach(l0Device->toHandle(), &config, &debugSession1);
5325 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
5326
5327 result = zetDebugDetach(debugSession0);
5328 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5329 }
5330
5331 TEST_F(MultiTileDebugSessionTest, givenAttachedRootDeviceWhenAttachingToTiletDeviceThenErrorIsReturned) {
5332 DebugManagerStateRestore restorer;
5333 NEO::debugManager.flags.ExperimentalEnableTileAttach.set(1);
5334
5335 zet_debug_config_t config = {};
5336 config.pid = 0x1234;
5337 zet_debug_session_handle_t debugSession0 = nullptr, debugSessionRoot = nullptr;
5338
5339 L0::Device *device = driverHandle->devices[0];
5340 auto neoDevice = device->getNEODevice();
5341 auto l0Device = static_cast<Device *>(device);
5342 neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.reset(new OsInterfaceWithDebugAttach);
5343
5344 auto sessionMock = new MockDebugSession(config, device, true);
5345 sessionMock->initialize();
5346 l0Device->setDebugSession(sessionMock);
5347
5348 auto subDevice0 = neoDevice->getSubDevice(0)->getSpecializedDevice<Device>();
5349
5350 auto result = zetDebugAttach(l0Device->toHandle(), &config, &debugSessionRoot);
5351 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5352
5353 result = zetDebugAttach(subDevice0->toHandle(), &config, &debugSession0);
5354 EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
5355 EXPECT_EQ(nullptr, debugSession0);
5356
5357 result = zetDebugDetach(debugSessionRoot);
5358 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5359 }
5360
5361 TEST_F(MultiTileDebugSessionTest, givenTileSessionAndStoppedThreadWhenGettingNotStoppedThreadsThenOnlyRunningOrUnavailableThreadsReturned) {
5362 zet_debug_config_t config = {};
5363 config.pid = 0x1234;
5364
5365 L0::Device *device = driverHandle->devices[0];
5366 auto neoDevice = device->getNEODevice();
5367 auto l0Device = static_cast<Device *>(device);
5368 neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->osInterface.reset(new OsInterfaceWithDebugAttach);
5369
5370 auto sessionMock = new MockDebugSession(config, device, false);
5371 sessionMock->initialize();
5372 l0Device->setDebugSession(sessionMock);
5373
5374 EuThread::ThreadId thread(0, 0, 0, 0, 0);
5375 static_cast<MockDebugSession *>(sessionMock->tileSessions[0].first)->allThreads[thread]->stopThread(1u);
5376 EuThread::ThreadId thread1(0, 0, 0, 0, 1);
5377 EXPECT_FALSE(static_cast<MockDebugSession *>(sessionMock->tileSessions[0].first)->allThreads[thread1]->isStopped());
5378
5379 std::vector<EuThread::ThreadId> threadsWithAtt;
5380 std::vector<EuThread::ThreadId> newStops;
5381
5382 threadsWithAtt.push_back(thread);
5383 threadsWithAtt.push_back(thread1);
5384
5385 sessionMock->getNotStoppedThreads(threadsWithAtt, newStops);
5386 ASSERT_EQ(1u, newStops.size());
5387 EXPECT_EQ(thread1, newStops[0]);
5388 }
5389
5390 struct AffinityMaskForSingleSubDevice : MultipleDevicesWithCustomHwInfo {
5391 void setUp() {
5392 debugManager.flags.ZE_AFFINITY_MASK.set("0.1");
5393 MultipleDevicesWithCustomHwInfo::numSubDevices = 2;
5394 MultipleDevicesWithCustomHwInfo::setUp();
5395 }
5396
5397 void tearDown() {
5398 MultipleDevicesWithCustomHwInfo::tearDown();
5399 }
5400 DebugManagerStateRestore restorer;
5401 };
5402
5403 using AffinityMaskForSingleSubDeviceTest = Test<AffinityMaskForSingleSubDevice>;
5404
5405 TEST_F(AffinityMaskForSingleSubDeviceTest, givenDeviceDebugSessionWhenSendingInterruptsThenInterruptIsSentWithCorrectDeviceIndex) {
5406 zet_debug_config_t config = {};
5407 config.pid = 0x1234;
5408
5409 L0::Device *device = driverHandle->devices[0];
5410 L0::Device *l0Device = static_cast<Device *>(device);
5411
5412 auto sessionMock = std::make_unique<MockDebugSession>(config, l0Device);
5413
5414 sessionMock->interruptImpResult = ZE_RESULT_SUCCESS;
5415 ze_device_thread_t apiThread = {0, 0, 0, 0};
5416
5417 auto result = sessionMock->interrupt(apiThread);
5418 EXPECT_EQ(ZE_RESULT_SUCCESS, result);
5419
5420 sessionMock->sendInterrupts();
5421
5422 EXPECT_TRUE(sessionMock->interruptSent);
5423 EXPECT_EQ(1u, sessionMock->interruptedDevices[0]);
5424 }
5425
5426 TEST_F(DebugSessionRegistersAccessTestV3, givenDeviceWithSipExternalLibInterfaceWhenIsHeaplessModeCalledThenReturnsTrue) {
5427 // Test with device that has no SIP external lib interface (default mockDevice)
5428 SIP::intelgt_state_save_area_V3 ssa = {};
5429 ssa.sip_flags = 0; // No heapless flag set
5430
5431 bool result = DebugSessionImp::isHeaplessMode(mockDevice.get(), ssa);
5432 EXPECT_FALSE(result); // Should return false because no SIP interface and no heapless flag
5433 }
5434
5435 TEST_F(DebugSessionRegistersAccessTestV3, givenDeviceWithoutSipExternalLibInterfaceAndHeaplessFlagWhenIsHeaplessModeCalledThenReturnsTrue) {
5436 SIP::intelgt_state_save_area_V3 ssa = {};
5437 ssa.sip_flags = SIP::SIP_FLAG_HEAPLESS;
5438
5439 bool result = DebugSessionImp::isHeaplessMode(mockDevice.get(), ssa);
5440 EXPECT_TRUE(result); // Should return true because of heapless flag
5441 }
5442
5443 TEST_F(DebugSessionRegistersAccessTestV3, givenDeviceWithoutSipExternalLibInterfaceAndNoHeaplessFlagWhenIsHeaplessModeCalledThenReturnsFalse) {
5444 SIP::intelgt_state_save_area_V3 ssa = {};
5445 ssa.sip_flags = 0; // No heapless flag set
5446
5447 bool result = DebugSessionImp::isHeaplessMode(mockDevice.get(), ssa);
5448 EXPECT_FALSE(result); // Should return false
5449 }
5450
5451 TEST_F(DebugSessionRegistersAccessTestV3, givenDeviceWithMockSipExternalLibInterfaceWhenIsHeaplessModeCalledThenReturnsTrue) {
5452 class MockSipExternalLibForTest : public MockSipExternalLib {
5453 public:
5454 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override {
5455 return 0;
5456 }
5457 bool createRegisterDescriptorMap() override {
5458 return true;
5459 }
5460 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override {
5461 return nullptr;
5462 }
5463 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override {
5464 return true;
5465 }
5466 uint32_t getSipLibCommandRegisterType() override {
5467 return 0; // Return a test command register type
5468 }
5469 };
5470
5471 // Create a mock device that returns the mock SipExternalLib
5472 class MockDeviceWithSipLib : public NEO::MockDevice {
5473 public:
5474 MockDeviceWithSipLib() : NEO::MockDevice() {
5475 mockSipLib = std::make_unique<MockSipExternalLibForTest>();
5476 }
5477 NEO::SipExternalLib *getSipExternalLibInterface() const override {
5478 return mockSipLib.get();
5479 }
5480 std::unique_ptr<MockSipExternalLibForTest> mockSipLib;
5481 };
5482
5483 // Create the mock NEO device with SIP external lib interface
5484 auto mockNeoDevice = std::make_unique<MockDeviceWithSipLib>();
5485
5486 // Create a mock L0 device wrapper
5487 auto mockL0Device = std::make_unique<MockDeviceImp>(mockNeoDevice.release());
5488
5489 SIP::intelgt_state_save_area_V3 ssa = {};
5490 ssa.sip_flags = 0; // No heapless flag set, but device has SIP external lib
5491
5492 bool result = DebugSessionImp::isHeaplessMode(mockL0Device.get(), ssa);
5493 EXPECT_TRUE(result); // Should return true because device has SIP external lib interface
5494 }
5495
5496 TEST_F(DebugSessionRegistersAccessTest, givenRegistersAccessHelperWithInvalidStartIndexWhenCalledThenReturnsInvalidArgument) {
5497 auto threadId = stoppedThreadId;
5498 auto thread = session->allThreads[threadId].get();
5499
5500 // Create a regset descriptor with limited registers
5501 SIP::regset_desc regdesc = {0, 5, 4, 1}; // offset=0, num=5, bytes=4, numslots=1
5502
5503 uint32_t registerValues[2] = {0};
5504
5505 // Test with start index >= num registers
5506 ze_result_t result = session->registersAccessHelper(thread, &regdesc, 5, 1, 0, registerValues, false);
5507 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
5508
5509 result = session->registersAccessHelper(thread, &regdesc, 10, 1, 0, registerValues, false);
5510 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
5511 }
5512
5513 TEST_F(DebugSessionRegistersAccessTest, givenRegistersAccessHelperWithInvalidCountWhenCalledThenReturnsInvalidArgument) {
5514 auto threadId = stoppedThreadId;
5515 auto thread = session->allThreads[threadId].get();
5516
5517 // Create a regset descriptor with limited registers
5518 SIP::regset_desc regdesc = {0, 5, 4, 1}; // offset=0, num=5, bytes=4, numslots=1
5519
5520 uint32_t registerValues[10] = {0};
5521
5522 // Test with start + count > num registers
5523 ze_result_t result = session->registersAccessHelper(thread, &regdesc, 2, 4, 0, registerValues, false);
5524 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
5525
5526 result = session->registersAccessHelper(thread, &regdesc, 0, 6, 0, registerValues, false);
5527 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
5528 }
5529
5530 TEST_F(DebugSessionRegistersAccessTestV3, givenTypeToRegsetDescWithSipLibInterfaceWhenCalledWithModeFlagsTypeThenReturnsModeFlagsRegsetDesc) {
5531 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
5532
5533 auto result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MODE_FLAGS_INTEL_GPU, mockDevice.get());
5534 EXPECT_NE(nullptr, result);
5535 EXPECT_EQ(result, DebugSessionImp::getModeFlagsRegsetDesc());
5536 }
5537
5538 TEST_F(DebugSessionRegistersAccessTestV3, givenTypeToRegsetDescWithSipLibInterfaceWhenCalledWithDebugScratchTypeThenReturnsDebugScratchRegsetDesc) {
5539 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
5540
5541 auto result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DEBUG_SCRATCH_INTEL_GPU, mockDevice.get());
5542 EXPECT_NE(nullptr, result);
5543 EXPECT_EQ(result, DebugSessionImp::getDebugScratchRegsetDesc());
5544 }
5545
5546 TEST_F(DebugSessionRegistersAccessTestV3, givenTypeToRegsetDescWithSipLibInterfaceWhenCalledWithThreadScratchTypeThenReturnsThreadScratchRegsetDesc) {
5547 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
5548
5549 auto result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU, mockDevice.get());
5550 EXPECT_NE(nullptr, result);
5551 EXPECT_EQ(result, DebugSessionImp::getThreadScratchRegsetDesc());
5552 }
5553
5554 TEST_F(DebugSessionRegistersAccessTestV3, givenTypeToRegsetDescWithSipLibInterfaceWhenCalledWithSbaTypeThenReturnsSbaRegsetDesc) {
5555 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
5556
5557 auto result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SBA_INTEL_GPU, mockDevice.get());
5558 EXPECT_NE(nullptr, result);
5559 // The result should be the SBA regset descriptor from getSbaRegsetDesc
5560 }
5561
5562 TEST_F(DebugSessionRegistersAccessTestV3, givenTypeToRegsetDescWithSipLibInterfaceWhenCalledWithUnknownTypeThenCallsGetRegsetDesc) {
5563 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
5564
5565 // Test with a register type that should go to the default case
5566 auto result = session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockDevice.get());
5567 // For normal devices without SIP interface, this should return the regular GRF regset
5568 EXPECT_NE(result, nullptr);
5569 EXPECT_EQ(result, &pStateSaveAreaHeader->regHeaderV3.grf);
5570 }
5571
5572 TEST_F(DebugSessionRegistersAccessTestV3, givenTypeToRegsetDescWithoutSipLibInterfaceWhenCalledWithVersion3ThenReturnsCorrectRegsetDescForSwitchCases) {
5573 // Use the normal mockDevice which should not have a SIP external lib interface
5574
5575 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
5576 EXPECT_EQ(3u, pStateSaveAreaHeader->versionHeader.version.major);
5577
5578 // Test some specific switch cases in the version 3 branch
5579 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, mockDevice.get()),
5580 &pStateSaveAreaHeader->regHeaderV3.grf);
5581
5582 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ADDR_INTEL_GPU, mockDevice.get()),
5583 &pStateSaveAreaHeader->regHeaderV3.addr);
5584
5585 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FLAG_INTEL_GPU, mockDevice.get()),
5586 &pStateSaveAreaHeader->regHeaderV3.flag);
5587
5588 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CE_INTEL_GPU, mockDevice.get()),
5589 &pStateSaveAreaHeader->regHeaderV3.emask);
5590
5591 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SR_INTEL_GPU, mockDevice.get()),
5592 &pStateSaveAreaHeader->regHeaderV3.sr);
5593
5594 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, mockDevice.get()),
5595 &pStateSaveAreaHeader->regHeaderV3.cr);
5596
5597 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_TDR_INTEL_GPU, mockDevice.get()),
5598 &pStateSaveAreaHeader->regHeaderV3.tdr);
5599
5600 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_ACC_INTEL_GPU, mockDevice.get()),
5601 &pStateSaveAreaHeader->regHeaderV3.acc);
5602
5603 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MME_INTEL_GPU, mockDevice.get()),
5604 &pStateSaveAreaHeader->regHeaderV3.mme);
5605
5606 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SP_INTEL_GPU, mockDevice.get()),
5607 &pStateSaveAreaHeader->regHeaderV3.sp);
5608
5609 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_DBG_INTEL_GPU, mockDevice.get()),
5610 &pStateSaveAreaHeader->regHeaderV3.dbg_reg);
5611
5612 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_FC_INTEL_GPU, mockDevice.get()),
5613 &pStateSaveAreaHeader->regHeaderV3.fc);
5614
5615 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU, mockDevice.get()),
5616 &pStateSaveAreaHeader->regHeaderV3.scalar);
5617
5618 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, ZET_DEBUG_REGSET_TYPE_MSG_INTEL_GPU, mockDevice.get()),
5619 &pStateSaveAreaHeader->regHeaderV3.msg);
5620
5621 // Test default case with invalid type
5622 EXPECT_EQ(session->typeToRegsetDesc(pStateSaveAreaHeader, 0x9999, mockDevice.get()), nullptr);
5623 }
5624
5625 TEST_F(DebugSessionRegistersAccessTestV3, givenRegistersAccessHelperWithValidParametersWhenCalledThenHandlesDecisionBranches) {
5626 // Set up a proper regset_desc for testing
5627 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
5628 const SIP::regset_desc *regdesc = &pStateSaveAreaHeader->regHeaderV3.grf; // Use GRF regset
5629
5630 // Create test data
5631 uint32_t start = 0;
5632 uint32_t count = 1;
5633 uint64_t testData = 0x1234567890ABCDEF;
5634
5635 // Test the decision coverage for the function at line 1551
5636 // First test the decision when start >= regdesc->num
5637 ze_result_t result = session->registersAccessHelper(session->allThreads[stoppedThreadId].get(),
5638 regdesc, regdesc->num, count, 0, &testData, false);
5639 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
5640
5641 // Test the decision when start + count > regdesc->num
5642 result = session->registersAccessHelper(session->allThreads[stoppedThreadId].get(),
5643 regdesc, regdesc->num - 1, 2, 0, &testData, false);
5644 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
5645
5646 // Test valid parameters (should reach further into the function)
5647 result = session->registersAccessHelper(session->allThreads[stoppedThreadId].get(),
5648 regdesc, start, count, 0, &testData, false);
5649 // Result depends on memory access implementation, but should not crash
5650 // This exercises the decision paths within the function
5651 EXPECT_TRUE(result == ZE_RESULT_SUCCESS || result == ZE_RESULT_ERROR_UNKNOWN);
5652 }
5653
5654 TEST_F(DebugSessionRegistersAccessTestV3, givenSipExternalLibWhenGetRegisterSetPropertiesBinaryRetrievalFailsThenErrorUnknownReturned) {
5655 class MockSipExternalLibBinaryFail : public MockSipExternalLib {
5656 public:
5657 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override { return -1; }
5658 bool createRegisterDescriptorMap() override { return true; }
5659 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
5660 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override { return true; }
5661 uint32_t getSipLibCommandRegisterType() override { return 0; }
5662 };
5663
5664 auto neoDevice = mockDevice->getNEODevice();
5665 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5666 auto originalSipLib = rootEnv.sipExternalLib.release();
5667 rootEnv.sipExternalLib.reset(new MockSipExternalLibBinaryFail());
5668
5669 uint32_t count = 0; // query path
5670 auto ret = DebugSession::getRegisterSetProperties(mockDevice.get(), &count, nullptr);
5671 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, ret);
5672
5673 rootEnv.sipExternalLib.reset(originalSipLib);
5674 }
5675
5676 TEST_F(DebugSessionRegistersAccessTestV3, givenSipExternalLibWhenGetRegisterSetPropertiesCreateMapFailsThenErrorUnknownReturned) {
5677 class MockSipExternalLibCreateMapFail : public MockSipExternalLib {
5678 public:
5679 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override { return 0; }
5680 bool createRegisterDescriptorMap() override { return false; }
5681 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
5682 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override { return true; }
5683 uint32_t getSipLibCommandRegisterType() override { return 0; }
5684 };
5685
5686 auto neoDevice = mockDevice->getNEODevice();
5687 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5688 auto originalSipLib = rootEnv.sipExternalLib.release();
5689 rootEnv.sipExternalLib.reset(new MockSipExternalLibCreateMapFail());
5690
5691 uint32_t count = 0; // initial query count path
5692 auto ret = DebugSession::getRegisterSetProperties(mockDevice.get(), &count, nullptr);
5693 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, ret);
5694
5695 rootEnv.sipExternalLib.reset(originalSipLib);
5696 }
5697
5698 TEST_F(DebugSessionRegistersAccessTestV3, givenHeaplessModeAndSipExternalLibWhenGetRegisterSetPropertiesCalledThenThreadScratchRegsetIncluded) {
5699 // Heapless mode detection in DebugSessionImp::isHeaplessMode returns true if SIP external lib interface present.
5700 // We inject a SIP external lib and verify THREAD_SCRATCH regset appears.
5701
5702 class MockSipExternalLibMinimal : public MockSipExternalLib {
5703 public:
5704 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override {
5705 stateSaveAreaHeader.resize(sizeof(SIP::intelgt_state_save_area_V3));
5706 return 0;
5707 }
5708 bool createRegisterDescriptorMap() override { return true; }
5709 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
5710 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override { return true; }
5711 uint32_t getSipLibCommandRegisterType() override { return 0; }
5712 };
5713
5714 auto neoDevice = mockDevice->getNEODevice();
5715 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5716 auto originalSipLib = rootEnv.sipExternalLib.release();
5717 rootEnv.sipExternalLib.reset(new MockSipExternalLibMinimal());
5718
5719 uint32_t count = 0;
5720 auto ret = DebugSession::getRegisterSetProperties(mockDevice.get(), &count, nullptr);
5721 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
5722 ASSERT_GT(count, 0u);
5723 std::vector<zet_debug_regset_properties_t> props(count);
5724 ret = DebugSession::getRegisterSetProperties(mockDevice.get(), &count, props.data());
5725 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
5726 bool threadScratchFound = false;
5727 for (auto &p : props) {
5728 if (p.type == ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU) {
5729 threadScratchFound = true;
5730 break;
5731 }
5732 }
5733 EXPECT_TRUE(threadScratchFound);
5734 rootEnv.sipExternalLib.reset(originalSipLib);
5735 }
5736
5737 TEST_F(DebugSessionRegistersAccessTestV3, givenStoppedThreadAndSipExternalLibWhenGetThreadRegisterSetPropertiesCalledThenSipLibPathUsed) {
5738 class MockSipExternalLibAccess : public MockSipExternalLib {
5739 public:
5740 bool registerAccessCalled = false;
5741 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override { return 0; }
5742 bool createRegisterDescriptorMap() override { return true; }
5743 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
5744 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override {
5745 registerAccessCalled = true;
5746 if (registerCount) {
5747 *registerCount = 8;
5748 }
5749 if (registerStartOffset) {
5750 *registerStartOffset = 0;
5751 }
5752 return true;
5753 }
5754 uint32_t getSipLibCommandRegisterType() override { return 0; }
5755 };
5756 auto neoDevice = mockDevice->getNEODevice();
5757 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5758 auto originalSipLib = rootEnv.sipExternalLib.release();
5759 auto mockSipLib = new MockSipExternalLibAccess();
5760 rootEnv.sipExternalLib.reset(mockSipLib);
5761 auto threadId = stoppedThreadId;
5762 session->allThreads[threadId]->stopThread(1u);
5763 uint32_t count = 0;
5764 auto singleThread = ze_device_thread_t{static_cast<uint32_t>(threadId.slice), static_cast<uint32_t>(threadId.subslice), static_cast<uint32_t>(threadId.eu), static_cast<uint32_t>(threadId.thread)};
5765 auto ret = session->getThreadRegisterSetProperties(singleThread, &count, nullptr);
5766 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
5767 // With SIP external lib present, getRegisterAccessProperties should be invoked on session (mock sets flag)
5768 EXPECT_TRUE(session->registerAccessPropertiesCalled);
5769 rootEnv.sipExternalLib.reset(originalSipLib);
5770 }
5771
5772 TEST_F(DebugSessionRegistersAccessTestV3, givenSipExternalLibWhenRegistersAccessHelperCalledWithOutOfRangeCountThenInvalidArgumentReturned) {
5773 class MockSipExternalLibRegAccess : public MockSipExternalLib {
5774 public:
5775 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override { return 0; }
5776 bool createRegisterDescriptorMap() override { return true; }
5777 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
5778 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override {
5779 if (registerCount) {
5780 *registerCount = 4;
5781 }
5782 if (registerStartOffset) {
5783 *registerStartOffset = 0;
5784 }
5785 return true;
5786 }
5787 uint32_t getSipLibCommandRegisterType() override { return 0; }
5788 };
5789 auto neoDevice = mockDevice->getNEODevice();
5790 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5791 auto originalSipLib = rootEnv.sipExternalLib.release();
5792 rootEnv.sipExternalLib.reset(new MockSipExternalLibRegAccess());
5793 auto regdesc = &session->getStateSaveAreaHeader()->regHeaderV3.grf;
5794 auto thread = session->allThreads[stoppedThreadId].get();
5795 uint64_t data = 0;
5796 auto result = session->registersAccessHelper(thread, regdesc, 2, 3, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, &data, false);
5797 EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result);
5798 rootEnv.sipExternalLib.reset(originalSipLib);
5799 }
5800
5801 TEST_F(DebugSessionRegistersAccessTestV3, givenSipExternalLibWhenRegistersAccessHelperReadWriteCalledThenSuccessReturned) {
5802 class MockSipExternalLibRegAccess : public MockSipExternalLib {
5803 public:
5804 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override { return 0; }
5805 bool createRegisterDescriptorMap() override { return true; }
5806 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
5807 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override {
5808 if (registerCount) {
5809 *registerCount = 16;
5810 }
5811 if (registerStartOffset) {
5812 *registerStartOffset = 8;
5813 }
5814 return true;
5815 }
5816 uint32_t getSipLibCommandRegisterType() override { return 0; }
5817 };
5818 auto neoDevice = mockDevice->getNEODevice();
5819 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5820 auto originalSipLib = rootEnv.sipExternalLib.release();
5821 rootEnv.sipExternalLib.reset(new MockSipExternalLibRegAccess());
5822 auto regdesc = &session->getStateSaveAreaHeader()->regHeaderV3.grf;
5823 auto thread = session->allThreads[stoppedThreadId].get();
5824 uint8_t buffer[64] = {};
5825 auto result = session->registersAccessHelper(thread, regdesc, 0, 1, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, buffer, false);
5826 EXPECT_TRUE(result == ZE_RESULT_SUCCESS || result == ZE_RESULT_ERROR_UNKNOWN);
5827 result = session->registersAccessHelper(thread, regdesc, 0, 1, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, buffer, true);
5828 EXPECT_TRUE(result == ZE_RESULT_SUCCESS || result == ZE_RESULT_ERROR_UNKNOWN);
5829 rootEnv.sipExternalLib.reset(originalSipLib);
5830 }
5831
5832 TEST_F(DebugSessionRegistersAccessTestV3, givenSipExternalLibWhenRegistersAccessHelperCalledWithZeroGpuVaThenErrorUnknownReturned) {
5833 class MockSipExternalLibRegAccess : public MockSipExternalLib {
5834 public:
5835 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override { return 0; }
5836 bool createRegisterDescriptorMap() override { return true; }
5837 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
5838 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override {
5839 if (registerCount) {
5840 *registerCount = 16;
5841 }
5842 if (registerStartOffset) {
5843 *registerStartOffset = 0;
5844 }
5845 return true;
5846 }
5847 uint32_t getSipLibCommandRegisterType() override { return 0; }
5848 };
5849 auto neoDevice = mockDevice->getNEODevice();
5850 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5851 auto originalSipLib = rootEnv.sipExternalLib.release();
5852 rootEnv.sipExternalLib.reset(new MockSipExternalLibRegAccess());
5853 session->returnStateSaveAreaGpuVa = false; // force getContextStateSaveAreaGpuVa() to return 0
5854 auto regdesc = &session->getStateSaveAreaHeader()->regHeaderV3.grf;
5855 auto thread = session->allThreads[stoppedThreadId].get();
5856 uint32_t value = 0;
5857 auto result = session->registersAccessHelper(thread, regdesc, 0, 1, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, &value, false);
5858 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, result);
5859 rootEnv.sipExternalLib.reset(originalSipLib);
5860 }
5861
5862 TEST_F(DebugSessionRegistersAccessTestV3, givenSipExternalLibWhenCmdRegisterAccessHelperCalledThenCommandTypeUsed) {
5863 class MockSipExternalLibCmdType : public MockSipExternalLib {
5864 public:
5865 uint32_t cmdType = 0xABCDEF01;
5866 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override { return 0; }
5867 bool createRegisterDescriptorMap() override { return true; }
5868 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
5869 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override { return true; }
5870 uint32_t getSipLibCommandRegisterType() override { return cmdType; }
5871 };
5872 auto neoDevice = mockDevice->getNEODevice();
5873 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5874 auto originalSipLib = rootEnv.sipExternalLib.release();
5875 rootEnv.sipExternalLib.reset(new MockSipExternalLibCmdType());
5876 NEO::SipCommandRegisterValues cmd = {{0}};
5877 cmd.sip_commandValues.command = 0x1;
5878 auto result = session->cmdRegisterAccessHelper(stoppedThreadId, cmd, false);
5879 EXPECT_TRUE(result == ZE_RESULT_SUCCESS || result == ZE_RESULT_ERROR_UNKNOWN || result == ZE_RESULT_ERROR_INVALID_ARGUMENT);
5880 result = session->cmdRegisterAccessHelper(stoppedThreadId, cmd, true);
5881 EXPECT_TRUE(result == ZE_RESULT_SUCCESS || result == ZE_RESULT_ERROR_UNKNOWN || result == ZE_RESULT_ERROR_INVALID_ARGUMENT);
5882 rootEnv.sipExternalLib.reset(originalSipLib);
5883 }
5884
5885 // Tests for getSbaRegsetDesc function
5886 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSbaRegsetDescWhenVersionMajorIs3AndHeaplessModeThenReturnsHeaplessDescriptor) {
5887 NEO::StateSaveAreaHeader header = {};
5888 header.versionHeader.version.major = 3;
5889 header.regHeaderV3.sip_flags = SIP::SIP_FLAG_HEAPLESS;
5890
5891 auto result = L0::DebugSessionImp::getSbaRegsetDesc(mockDevice.get(), header);
5892
5893 ASSERT_NE(result, nullptr);
5894 EXPECT_EQ(result->num, 0u);
5895 EXPECT_EQ(result->offset, 0u);
5896 }
5897
5898 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSbaRegsetDescWhenVersionMajorIs3AndNotHeaplessModeThenReturnsSbaDescriptor) {
5899 NEO::StateSaveAreaHeader header = {};
5900 header.versionHeader.version.major = 3;
5901 header.regHeaderV3.sip_flags = 0; // Not heapless
5902
5903 auto result = L0::DebugSessionImp::getSbaRegsetDesc(mockDevice.get(), header);
5904
5905 ASSERT_NE(result, nullptr);
5906 EXPECT_EQ(result->num, ZET_DEBUG_SBA_COUNT_INTEL_GPU);
5907 EXPECT_EQ(result->bits, 64u);
5908 EXPECT_EQ(result->bytes, 8u);
5909 }
5910
5911 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSbaRegsetDescWhenVersionMajorIs5ThenReturnsHeaplessDescriptor) {
5912 NEO::StateSaveAreaHeader header = {};
5913 header.versionHeader.version.major = 5;
5914
5915 auto result = L0::DebugSessionImp::getSbaRegsetDesc(mockDevice.get(), header);
5916
5917 ASSERT_NE(result, nullptr);
5918 EXPECT_EQ(result->num, 0u);
5919 EXPECT_EQ(result->offset, 0u);
5920 }
5921
5922 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSbaRegsetDescWhenVersionMajorIs2ThenReturnsSbaDescriptor) {
5923 NEO::StateSaveAreaHeader header = {};
5924 header.versionHeader.version.major = 2;
5925
5926 auto result = L0::DebugSessionImp::getSbaRegsetDesc(mockDevice.get(), header);
5927
5928 ASSERT_NE(result, nullptr);
5929 EXPECT_EQ(result->num, ZET_DEBUG_SBA_COUNT_INTEL_GPU);
5930 EXPECT_EQ(result->bits, 64u);
5931 EXPECT_EQ(result->bytes, 8u);
5932 }
5933
5934 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSbaRegsetDescWhenVersionMajorIs6ThenReturnsNullptr) {
5935 NEO::StateSaveAreaHeader header = {};
5936 header.versionHeader.version.major = 6;
5937
5938 auto result = L0::DebugSessionImp::getSbaRegsetDesc(mockDevice.get(), header);
5939
5940 EXPECT_EQ(result, nullptr);
5941 }
5942
5943 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSbaRegsetDescWhenVersionMajorIs7ThenReturnsNullptr) {
5944 NEO::StateSaveAreaHeader header = {};
5945 header.versionHeader.version.major = 7;
5946
5947 auto result = L0::DebugSessionImp::getSbaRegsetDesc(mockDevice.get(), header);
5948
5949 EXPECT_EQ(result, nullptr);
5950 }
5951
5952 TEST_F(DebugSessionRegistersAccessTestV3, givenVersion3WithoutHeaplessModeWhenGetRegisterSetPropertiesCalledThenThreadScratchRegsetNotIncluded) {
5953 // Test the false branch of: isHeaplessMode(device, pStateSaveArea->regHeaderV3) || version.major == 5
5954 // Version 3, no heapless flag, no SIP external lib -> THREAD_SCRATCH should NOT be included
5955
5956 auto neoDevice = mockDevice->getNEODevice();
5957 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
5958 auto originalSipLib = rootEnv.sipExternalLib.release();
5959
5960 // Don't set SIP external lib to ensure isHeaplessMode returns false
5961 rootEnv.sipExternalLib.reset(nullptr);
5962
5963 uint32_t count = 0;
5964 auto ret = DebugSession::getRegisterSetProperties(mockDevice.get(), &count, nullptr);
5965 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
5966 ASSERT_GT(count, 0u);
5967
5968 std::vector<zet_debug_regset_properties_t> props(count);
5969 ret = DebugSession::getRegisterSetProperties(mockDevice.get(), &count, props.data());
5970 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
5971
5972 bool threadScratchFound = false;
5973 for (auto &p : props) {
5974 if (p.type == ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU) {
5975 threadScratchFound = true;
5976 break;
5977 }
5978 }
5979 EXPECT_FALSE(threadScratchFound);
5980
5981 rootEnv.sipExternalLib.reset(originalSipLib);
5982 }
5983
5984 TEST_F(DebugSessionRegistersAccessTestV3, givenVersion5WhenGetRegisterSetPropertiesCalledThenThreadScratchRegsetIncluded) {
5985 // Test the true branch of the second part: version.major == 5
5986 // This should include THREAD_SCRATCH regardless of heapless mode
5987
5988 class MockSipExternalLibForV5 : public MockSipExternalLib {
5989 public:
5990 int getSipKernelBinary(NEO::Device &device, NEO::SipKernelType type, std::vector<char> &retBinary, std::vector<char> &stateSaveAreaHeader) override {
5991 // Create a proper StateSaveAreaHeader with version 5
5992 stateSaveAreaHeader.resize(sizeof(NEO::StateSaveAreaHeader));
5993 auto pHeader = reinterpret_cast<NEO::StateSaveAreaHeader *>(stateSaveAreaHeader.data());
5994 pHeader->versionHeader.version.major = 5;
5995 pHeader->versionHeader.version.minor = 0;
5996 pHeader->versionHeader.version.patch = 0;
5997 pHeader->versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
5998 return 0;
5999 }
6000 bool createRegisterDescriptorMap() override { return true; }
6001 SIP::regset_desc *getRegsetDescFromMap(uint32_t type) override { return nullptr; }
6002 bool getSipLibRegisterAccess(void *sipHandle, SipLibThreadId sipThreadId, uint32_t sipRegisterType, uint32_t *registerCount, uint32_t *registerStartOffset) override { return true; }
6003 uint32_t getSipLibCommandRegisterType() override { return 0; }
6004 };
6005
6006 auto neoDevice = mockDevice->getNEODevice();
6007 auto &rootEnv = *neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[neoDevice->getRootDeviceIndex()];
6008 auto originalSipLib = rootEnv.sipExternalLib.release();
6009 rootEnv.sipExternalLib.reset(new MockSipExternalLibForV5());
6010
6011 // Create a version 5 state save area header manually
6012 NEO::StateSaveAreaHeader stateSaveAreaHeader5 = {};
6013 stateSaveAreaHeader5.versionHeader.version.major = 5;
6014 stateSaveAreaHeader5.versionHeader.version.minor = 0;
6015 stateSaveAreaHeader5.versionHeader.version.patch = 0;
6016 stateSaveAreaHeader5.versionHeader.size = sizeof(NEO::StateSaveAreaHeader) / 8;
6017 memcpy(stateSaveAreaHeader5.versionHeader.magic, "tssarea", 8);
6018
6019 // Initialize regHeaderV3 with minimal valid data (used for V5)
6020 stateSaveAreaHeader5.regHeaderV3.num_slices = 1;
6021 stateSaveAreaHeader5.regHeaderV3.num_subslices_per_slice = 1;
6022 stateSaveAreaHeader5.regHeaderV3.num_eus_per_subslice = 8;
6023 stateSaveAreaHeader5.regHeaderV3.num_threads_per_eu = 7;
6024 stateSaveAreaHeader5.regHeaderV3.grf = {0, 128, 512, 64};
6025
6026 auto mockBuiltins = new MockBuiltins();
6027 mockBuiltins->stateSaveAreaHeader.assign(reinterpret_cast<char *>(&stateSaveAreaHeader5),
6028 reinterpret_cast<char *>(&stateSaveAreaHeader5) + sizeof(NEO::StateSaveAreaHeader));
6029 MockRootDeviceEnvironment::resetBuiltins(neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0].get(), mockBuiltins);
6030
6031 uint32_t count = 0;
6032 auto ret = DebugSession::getRegisterSetProperties(mockDevice.get(), &count, nullptr);
6033 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
6034 ASSERT_GT(count, 0u);
6035
6036 std::vector<zet_debug_regset_properties_t> props(count);
6037 ret = DebugSession::getRegisterSetProperties(mockDevice.get(), &count, props.data());
6038 EXPECT_EQ(ZE_RESULT_SUCCESS, ret);
6039
6040 bool threadScratchFound = false;
6041 for (auto &p : props) {
6042 if (p.type == ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU) {
6043 threadScratchFound = true;
6044 break;
6045 }
6046 }
6047 EXPECT_TRUE(threadScratchFound);
6048
6049 rootEnv.sipExternalLib.reset(originalSipLib);
6050 }
6051
6052 // Tests for getSipCommandRegisterValues (non-V5 behavior)
6053 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSipCommandRegisterValuesWhenWriteTrueThenReturnsSipCommandValuesAndFullSize) {
6054 // For non-V5 versions (< 5), getSipCommandRegisterValues does not modify the size parameter
6055 NEO::SipCommandRegisterValues command = {{0}};
6056 command.sip_commandValues.command = 0x12345678;
6057 command.sip_commandValues.size = 0xABCD;
6058 command.sip_commandValues.offset = 0x9876;
6059
6060 size_t size = 128;
6061 size_t originalSize = size;
6062 size = session->getSipCommandRegisterValues(command, true, size);
6063
6064 // For non-V5 version, size parameter should remain unchanged
6065 EXPECT_EQ(originalSize, size);
6066 }
6067
6068 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSipCommandRegisterValuesWhenWriteFalseThenReturnsSipCommandValuesAndFullSize) {
6069 NEO::SipCommandRegisterValues command = {{0}};
6070 command.sip_commandValues.command = 0x12345678;
6071 command.sip_commandValues.size = 0xABCD;
6072 command.sip_commandValues.offset = 0x9876;
6073
6074 size_t size = 0;
6075 size_t originalSize = size;
6076 size = session->getSipCommandRegisterValues(command, false, size);
6077
6078 // For non-V5 version, size parameter should remain unchanged
6079 EXPECT_EQ(originalSize, size);
6080 }
6081
6082 TEST_F(DebugSessionRegistersAccessTestV3, GivenCmdRegisterAccessHelperWhenWritingCommandThenCommandValuesArePreparedCorrectly) {
6083 // Setup the state save area to allow registersAccessHelper to work
6084 {
6085 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
6086 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
6087 pStateSaveAreaHeader->regHeaderV3.state_area_offset +
6088 pStateSaveAreaHeader->regHeaderV3.state_save_size * 16;
6089 session->stateSaveAreaHeader.resize(size);
6090 }
6091
6092 // Create command to write
6093 NEO::SipCommandRegisterValues command = {{0}};
6094 command.sip_commandValues.command = static_cast<uint32_t>(NEO::SipKernel::Command::resume);
6095 command.sip_commandValues.size = 0x100;
6096 command.sip_commandValues.offset = 0x200;
6097
6098 // Test getSipCommandRegisterValues for write mode
6099 size_t writeSize = 0;
6100 size_t originalWriteSize = writeSize;
6101 writeSize = session->getSipCommandRegisterValues(command, true, writeSize);
6102
6103 // For non-V5 version (< 5), size parameter should remain unchanged
6104 EXPECT_EQ(originalWriteSize, writeSize);
6105
6106 // Call cmdRegisterAccessHelper for write - should succeed or return expected error
6107 auto result = session->cmdRegisterAccessHelper(stoppedThreadId, command, true);
6108 EXPECT_TRUE(result == ZE_RESULT_SUCCESS || result == ZE_RESULT_ERROR_UNKNOWN);
6109 }
6110
6111 TEST_F(DebugSessionRegistersAccessTestV3, GivenCmdRegisterAccessHelperWhenReadingCommandThenCommandValuesArePreparedCorrectly) {
6112 // Setup the state save area
6113 {
6114 auto pStateSaveAreaHeader = session->getStateSaveAreaHeader();
6115 auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
6116 pStateSaveAreaHeader->regHeaderV3.state_area_offset +
6117 pStateSaveAreaHeader->regHeaderV3.state_save_size * 16;
6118 session->stateSaveAreaHeader.resize(size);
6119 }
6120
6121 // Create command to read
6122 NEO::SipCommandRegisterValues command = {{0}};
6123
6124 // Test getSipCommandRegisterValues for read mode
6125 size_t readSize = 0;
6126 size_t originalReadSize = readSize;
6127 readSize = session->getSipCommandRegisterValues(command, false, readSize);
6128
6129 // For non-V5 version (< 5), size parameter should remain unchanged
6130 EXPECT_EQ(originalReadSize, readSize);
6131
6132 // Call cmdRegisterAccessHelper for read
6133 auto result = session->cmdRegisterAccessHelper(stoppedThreadId, command, false);
6134 EXPECT_TRUE(result == ZE_RESULT_SUCCESS || result == ZE_RESULT_ERROR_UNKNOWN);
6135 }
6136
6137 TEST_F(DebugSessionRegistersAccessTestV3, GivenGetSipCommandRegisterValuesWhenDifferentCommandsUsedThenCorrectValuesReturned) {
6138 // Test multiple commands with different values
6139 std::vector<std::pair<uint32_t, const char *>> commandTests = {
6140 {static_cast<uint32_t>(NEO::SipKernel::Command::resume), "resume"},
6141 {static_cast<uint32_t>(NEO::SipKernel::Command::slmRead), "slmRead"},
6142 {static_cast<uint32_t>(NEO::SipKernel::Command::slmWrite), "slmWrite"},
6143 {0x12345678, "custom"}};
6144
6145 for (const auto &[cmdValue, cmdName] : commandTests) {
6146 NEO::SipCommandRegisterValues command = {{0}};
6147 command.sip_commandValues.command = cmdValue;
6148 command.sip_commandValues.size = 0x1000;
6149 command.sip_commandValues.offset = 0x2000;
6150
6151 // Test write mode
6152 size_t writeSize = 0;
6153 size_t originalWriteSize = writeSize;
6154 writeSize = session->getSipCommandRegisterValues(command, true, writeSize);
6155
6156 // For non-V5 version, size parameter should remain unchanged
6157 EXPECT_EQ(originalWriteSize, writeSize) << "Failed for command: " << cmdName;
6158
6159 // Test read mode
6160 size_t readSize = 0;
6161 size_t originalReadSize = readSize;
6162 readSize = session->getSipCommandRegisterValues(command, false, readSize);
6163
6164 // For non-V5 version, size parameter should remain unchanged
6165 EXPECT_EQ(originalReadSize, readSize) << "Failed for command: " << cmdName;
6166 }
6167 }
6168
6169 struct DebugSessionBarrierMemTest : public ::testing::Test {
6170 static constexpr uint64_t testMemoryHandle = 0xABCDEF00ULL;
6171 static constexpr uint64_t memDescAddress = 0x5372;
6172
6173 struct MockDebugSessionBarrierMem : public MockDebugSession {
6174 using DebugSessionImp::SipTransferAddr;
6175 using MockDebugSession::getBarrierAddresses;
6176 using MockDebugSession::getBarrierStartOffset;
6177 using MockDebugSession::readBarrierMemory;
6178
6179 uint64_t ctxSsaGpuVaReturn = 0x20000000;
6180 std::unique_ptr<MockSipExternalLib> mockSipExternalLib;
6181 std::optional<std::optional<SipTransferAddr>> forcedBarrierAddressResult;
6182
6183 MockDebugSessionBarrierMem(const zet_debug_config_t &config, L0::Device *device) : MockDebugSession(config, device),
6184 mockSipExternalLib(std::make_unique<MockSipExternalLib>()) {
6185 }
6186
6187 uint64_t getContextStateSaveAreaGpuVa(uint64_t memoryHandle) override {
6188 EXPECT_EQ(memoryHandle, testMemoryHandle);
6189 return ctxSsaGpuVaReturn;
6190 }
6191
6192 NEO::SipExternalLib *getSipExternalLibInterface() const override {
6193 return mockSipExternalLib ? mockSipExternalLib.get() : MockDebugSession::getSipExternalLibInterface();
6194 }
6195
6196 std::optional<SipTransferAddr> getBarrierAddresses(EuThread::ThreadId threadId, size_t size, const zet_debug_memory_space_desc_t *desc) override {
6197 return forcedBarrierAddressResult ? forcedBarrierAddressResult.value() : MockDebugSession::getBarrierAddresses(threadId, size, desc);
6198 }
6199
6200 struct ReadMemViaSipTransactionArgs {
6201 NEO::SipKernel::Command commandId;
6202 EuThread::ThreadId threadId;
6203 SipTransferAddr addrs;
6204 size_t size;
6205 void *buffer;
6206 };
6207 std::optional<ReadMemViaSipTransactionArgs> lastCalledReadMemViaSipTransactionArgs;
6208 ze_result_t readMemViaSipTransaction(NEO::SipKernel::Command commandId, EuThread::ThreadId threadId, const SipTransferAddr &addrs, size_t size, void *buffer) override {
6209 lastCalledReadMemViaSipTransactionArgs = ReadMemViaSipTransactionArgs{
6210 .commandId = commandId,
6211 .threadId = threadId,
6212 .addrs = addrs,
6213 .size = size,
6214 .buffer = buffer,
6215 };
6216 return ZE_RESULT_SUCCESS;
6217 }
6218 };
6219
6220 MockDeviceImp mockDevice;
6221 MockDebugSessionBarrierMem session;
6222 EuThread::ThreadId threadId;
6223
6224 DebugSessionBarrierMemTest() : mockDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(defaultHwInfo.get(), 0)),
6225 session(zet_debug_config_t{}, &mockDevice),
6226 threadId(0, 0, 0, 0, 0) {}
6227
6228 void SetUp() override {
6229 session.allThreads[threadId]->stopThread(testMemoryHandle);
6230 }
6231 };
6232
6233 TEST_F(DebugSessionBarrierMemTest, GivenGetBarrierStartOffsetFailsWhenGetBarrierAddressesIsCalledThenNulloptIsReturned) {
6234 session.mockSipExternalLib = std::make_unique<MockSipExternalLib>();
6235 session.mockSipExternalLib->getBarrierStartOffsetRetValue = false;
6236 zet_debug_memory_space_desc_t memDesc;
6237 const auto addrs = session.getBarrierAddresses(threadId, 8, &memDesc);
6238 EXPECT_EQ(addrs, std::nullopt);
6239 }
6240
6241 TEST_F(DebugSessionBarrierMemTest, GivenGetBarrierStartOffsetSucceedsWhenGetBarrierAddressesIsCalledThenCorrectValuesAreReturned) {
6242 session.mockSipExternalLib = std::make_unique<MockSipExternalLib>();
6243 session.mockSipExternalLib->getBarrierStartOffsetResult = 0x300000;
6244 zet_debug_memory_space_desc_t memDesc = {.address = 0xbee504ae};
6245 const auto addrs = session.getBarrierAddresses(threadId, 17, &memDesc);
6246 EXPECT_NE(addrs, std::nullopt);
6247 EXPECT_EQ(addrs->sipOffset, 21u);
6248 EXPECT_EQ(addrs->sipSize, 2u);
6249 EXPECT_EQ(addrs->gpuMemOffset, 0x203000a8u);
6250 }
6251
6252 TEST_F(DebugSessionBarrierMemTest, GivenSipExternalLibIsAvailableThenGetBarrierStartOffsetIsObtainedFromSipExternalLib) {
6253 session.mockSipExternalLib = std::make_unique<MockSipExternalLib>();
6254 session.mockSipExternalLib->getBarrierStartOffsetResult = 0x300000;
6255 uint32_t barrierStartOffset = 0;
6256 EXPECT_EQ(session.getBarrierStartOffset(0, threadId, &barrierStartOffset), true);
6257 EXPECT_EQ(barrierStartOffset, 0x300000u);
6258 }
6259
6260 TEST_F(DebugSessionBarrierMemTest, GivenGetBarrierAddressesFailsThenReadBarrierMemoryAlsoFails) {
6261 session.forcedBarrierAddressResult = std::optional<DebugSessionImp::SipTransferAddr>(std::nullopt);
6262 zet_debug_memory_space_desc_t memDesc;
6263 char buf[16];
6264 ze_result_t status = session.readBarrierMemory(threadId, &memDesc, sizeof(buf), buf);
6265 EXPECT_EQ(status, ZE_RESULT_ERROR_UNKNOWN);
6266 }
6267
6268 TEST_F(DebugSessionBarrierMemTest, GivenGetBarrierAddressesSucceedsThenReadMemViaSipTransactionIsCalledWithCorrectArgs) {
6269 session.forcedBarrierAddressResult = DebugSessionImp::SipTransferAddr{
6270 .sipOffset = 15,
6271 .sipSize = 8,
6272 .gpuMemOffset = 0x123456,
6273 };
6274 zet_debug_memory_space_desc_t memDesc;
6275 char buf[13];
6276 session.readBarrierMemory(threadId, &memDesc, sizeof(buf), buf);
6277 EXPECT_NE(session.lastCalledReadMemViaSipTransactionArgs, std::nullopt);
6278 const auto args = *session.lastCalledReadMemViaSipTransactionArgs;
6279 EXPECT_EQ(args.commandId, NEO::SipKernel::Command::barrierRead);
6280 EXPECT_EQ(args.threadId, threadId);
6281 EXPECT_EQ(args.addrs.sipOffset, 15u);
6282 EXPECT_EQ(args.addrs.sipSize, 8u);
6283 EXPECT_EQ(args.addrs.gpuMemOffset, 0x123456u);
6284 EXPECT_EQ(args.size, sizeof(buf));
6285 EXPECT_EQ(args.buffer, buf);
6286 }
6287
6288 } // namespace ult
6289 } // namespace L0