intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 01:04:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: add implementation for scratch related functions of DebugSessionImp

Browse Source 
Related-To: NEO-16649

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2025-12-15 17:49:37 +00:00
committed by Compute-Runtime-Automation
parent aa52b3aec5
commit c5e9eb3662
4 changed files with 384 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
level_zero/tools/source/debug/CMakeLists.txt
View File

@@ -13,8 +13,7 @@ target_sources(${L0_STATIC_LIB_NAME}
${CMAKE_CURRENT_SOURCE_DIR}/debug_handlers.h
${CMAKE_CURRENT_SOURCE_DIR}/debug_handlers.cpp
${CMAKE_CURRENT_SOURCE_DIR}/eu_thread.h
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}thread_scratch_helper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/thread_scratch_helper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}debug_session_sip_external_lib.cpp
${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}debug_session_sip_external_lib.h
)

102
level_zero/tools/source/debug/thread_scratch_helper.cpp
View File

@@ -5,24 +5,116 @@
*
*/
#include "shared/source/device/device.h"
#include "shared/source/gmm_helper/gmm_helper.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/source/helpers/hw_info.h"
#include "level_zero/core/source/device/device.h"
#include "level_zero/tools/source/debug/debug_session_imp.h"
#include "implicit_args.h"
namespace L0 {
ze_result_t DebugSessionImp::getScratchRenderSurfaceStateAddressV1(EuThread::ThreadId threadId, uint64_t *result) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
const NEO::HardwareInfo &hwInfo = connectedDevice->getHwInfo();
const uint32_t regSize = std::max(getRegisterSize(ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU), hwInfo.capabilityTable.grfSize);
std::vector<uint32_t> r0(regSize / sizeof(uint32_t));
ze_result_t ret = readRegistersImp(threadId, ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU, 0, 1, r0.data());
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
uint64_t implicitArgsGpuVaHigh = (static_cast<uint64_t>(r0[15]) << 32);
uint64_t implicitArgsGpuVaLow = static_cast<uint64_t>(r0[14]);
auto implicitArgsGpuVa = implicitArgsGpuVaLow | implicitArgsGpuVaHigh;
if (!implicitArgsGpuVa) {
return ZE_RESULT_SUCCESS;
}
NEO::ImplicitArgs implicitArgs;
ret = readGpuMemory(allThreads[threadId]->getMemoryHandle(), reinterpret_cast<char *>(&implicitArgs), sizeof(NEO::ImplicitArgs), implicitArgsGpuVa);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
if (implicitArgs.v0.header.structVersion != 1) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
*result = implicitArgs.v1.scratchPtr;
return ZE_RESULT_SUCCESS;
}
ze_result_t DebugSessionImp::getScratchRenderSurfaceStateAddressV2(EuThread::ThreadId threadId, uint64_t *result) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
const uint32_t regSize = getRegisterSize(ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU);
UNRECOVERABLE_IF(regSize != sizeof(uint32_t));
uint32_t s18and19[2] = {0};
ze_result_t ret = readRegistersImp(threadId, ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU, 18, 2, s18and19);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
*result = (static_cast<uint64_t>(s18and19[0]) << 32) | s18and19[1];
return ZE_RESULT_SUCCESS;
}
ze_result_t DebugSessionImp::getScratchRenderSurfaceStateAddress(EuThread::ThreadId threadId, uint64_t *result) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
if (getProductHelper().isScratchSpaceBasePointerInGrf()) {
return getScratchRenderSurfaceStateAddressV1(threadId, result);
} else {
return getScratchRenderSurfaceStateAddressV2(threadId, result);
}
}
ze_result_t DebugSessionImp::readThreadScratchRegisters(EuThread::ThreadId threadId, uint32_t start, uint32_t count, void *pRegisterValues) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
const SIP::regset_desc *threadScratchRegDesc = DebugSessionImp::getThreadScratchRegsetDesc();
if (start >= threadScratchRegDesc->num) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
if (start + count > threadScratchRegDesc->num) {
return ZE_RESULT_ERROR_INVALID_ARGUMENT;
}
const size_t size = count * threadScratchRegDesc->bytes;
memset(pRegisterValues, 0, size);
uint64_t renderSurfaceStateAddress = 0;
ze_result_t ret = getScratchRenderSurfaceStateAddress(threadId, &renderSurfaceStateAddress);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
if (renderSurfaceStateAddress == 0) {
return ZE_RESULT_SUCCESS;
}
const NEO::GfxCoreHelper &gfxCoreHelper = connectedDevice->getGfxCoreHelper();
const size_t renderSurfaceStateSize = gfxCoreHelper.getRenderSurfaceStateSize();
const size_t topScratchAreaToRead = (count == 2) || (start == 1) ? 2 : 1;
std::vector<char> renderSurfaceState(renderSurfaceStateSize * topScratchAreaToRead, 0);
ret = readGpuMemory(allThreads[threadId]->getMemoryHandle(), renderSurfaceState.data(), renderSurfaceStateSize * topScratchAreaToRead, renderSurfaceStateAddress);
if (ret != ZE_RESULT_SUCCESS) {
return ret;
}
std::vector<uint64_t> packed;
for (size_t i = 0; i < topScratchAreaToRead; i++) {
auto scratchSpacePTSize = gfxCoreHelper.getRenderSurfaceStatePitch(renderSurfaceState.data() + (i * renderSurfaceStateSize), connectedDevice->getProductHelper());
auto threadOffset = getPerThreadScratchOffset(scratchSpacePTSize, threadId);
auto gmmHelper = connectedDevice->getNEODevice()->getGmmHelper();
auto scratchAllocationBase = gmmHelper->decanonize(gfxCoreHelper.getRenderSurfaceStateBaseAddress(renderSurfaceState.data() + (i * renderSurfaceStateSize)));
auto scratchSpaceBaseAddress = threadOffset + scratchAllocationBase;
packed.push_back(scratchSpaceBaseAddress);
}
memcpy_s(pRegisterValues, size, &packed[start], size);
return ZE_RESULT_SUCCESS;
}
} // namespace L0
} // namespace L0

1
level_zero/tools/test/unit_tests/sources/debug/CMakeLists.txt
View File

@@ -15,6 +15,7 @@ target_sources(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/debug_session_common.cpp
${CMAKE_CURRENT_SOURCE_DIR}/debug_session_registers_access.cpp
${CMAKE_CURRENT_SOURCE_DIR}/debug_session_registers_access.h
${CMAKE_CURRENT_SOURCE_DIR}/debug_session_scratch_reg_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}/test_debug_external_sip.cpp
)
if(SUPPORT_XE3_AND_LATER)

285
level_zero/tools/test/unit_tests/sources/debug/debug_session_scratch_reg_tests.cpp Normal file
View File

@@ -0,0 +1,285 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/test/common/mocks/mock_device.h"
#include "shared/test/common/mocks/mock_gmm_helper.h"
#include "shared/test/common/mocks/mock_sip.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h"
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "level_zero/core/test/unit_tests/mocks/mock_built_ins.h"
#include "level_zero/core/test/unit_tests/mocks/mock_device.h"
#include "level_zero/tools/source/debug/debug_session_imp.h"
#include "level_zero/tools/test/unit_tests/sources/debug/debug_session_common.h"
#include "level_zero/tools/test/unit_tests/sources/debug/debug_session_registers_access.h"
#include "level_zero/tools/test/unit_tests/sources/debug/mock_debug_session.h"
#include "level_zero/zet_intel_gpu_debug.h"
#include "implicit_args.h"
namespace L0 {
namespace ult {
using DebugApiTest = Test<DebugApiFixture>;
TEST_F(DebugApiTest, givenReadThreadScratchRegisterCalledThenSuccessReturned) {
zet_debug_config_t config = {};
config.pid = 0x1234;
neoDevice->executionEnvironment->rootDeviceEnvironments[0]->osInterface.reset(new OsInterfaceWithDebugAttach);
setIsScratchInGrf(neoDevice, true);
L0::DeviceImp *deviceImp = static_cast<DeviceImp *>(device);
auto session = new MockDebugSession(config, device, true);
session->initialize();
deviceImp->setDebugSession(session);
SIP::version version = {3, 0, 0};
initStateSaveArea(session->stateSaveAreaHeader, version, device);
ze_device_thread_t stoppedThread = {0, 0, 0, 0};
EuThread::ThreadId stoppedThreadId{0, stoppedThread};
session->allThreads[stoppedThreadId]->stopThread(1u);
session->allThreads[stoppedThreadId]->reportAsStopped();
session->readThreadScratchRegistersResult = ZE_RESULT_SUCCESS;
EXPECT_EQ(ZE_RESULT_SUCCESS, zetDebugReadRegisters(session->toHandle(), {0, 0, 0, 0}, ZET_DEBUG_REGSET_TYPE_THREAD_SCRATCH_INTEL_GPU, 0, 1, nullptr));
}
using DebugSessionRegistersAccessTestScratchV3 = Test<DebugSessionRegistersAccessScratchV3>;
TEST_F(DebugSessionRegistersAccessTestScratchV3, WhenReadingThreadScratchRegThenErrorsAreHandled) {
{
auto pStateSaveAreaHeader = reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
pStateSaveAreaHeader->regHeaderV3.state_area_offset +
pStateSaveAreaHeader->regHeaderV3.state_save_size * 16;
session->stateSaveAreaHeader.resize(size);
}
auto threadScratchRegDesc = DebugSessionImp::getThreadScratchRegsetDesc();
ze_device_thread_t thread = {0, 0, 0, 0};
EuThread::ThreadId threadId(0, thread);
uint64_t scratch[2];
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, session->readThreadScratchRegisters(threadId, 0, threadScratchRegDesc->num + 1, scratch));
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, session->readThreadScratchRegisters(threadId, threadScratchRegDesc->num, 1, scratch));
session->readRegistersResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->readThreadScratchRegisters(threadId, 0, 1, scratch));
session->readRegistersResult = ZE_RESULT_FORCE_UINT32;
dumpRegisterState();
auto threadSlotOffset = session->calculateThreadSlotOffset(threadId);
auto stateSaveAreaHeader = reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
auto grfOffset = threadSlotOffset + stateSaveAreaHeader->regHeaderV3.grf.offset;
uint32_t *r0Thread0 = reinterpret_cast<uint32_t *>(ptrOffset(session->stateSaveAreaHeader.data(), grfOffset));
r0Thread0[15] = 0u;
r0Thread0[14] = 0u;
// implictArgsGpuVa == 0
EXPECT_EQ(ZE_RESULT_SUCCESS, session->readThreadScratchRegisters(threadId, 0, 2, scratch));
EXPECT_EQ(0u, scratch[0]);
EXPECT_EQ(0u, scratch[1]);
r0Thread0[15] = 0x1111;
r0Thread0[14] = 0x1111;
// read implicit args from gpu mem fails
session->readGpuMemoryCallCount = 0;
session->forcereadGpuMemoryFailOnCount = 2;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->readThreadScratchRegisters(threadId, 0, 1, scratch));
// scratchPtr == 0
session->readGpuMemoryCallCount = 0;
session->forcereadGpuMemoryFailOnCount = 0;
session->readMemoryBuffer.assign(sizeof(NEO::ImplicitArgs), 5);
NEO::ImplicitArgsV1 args1 = {};
args1.header.structVersion = 1;
args1.header.structSize = NEO::ImplicitArgsV1::getSize();
args1.scratchPtr = 0u;
memcpy_s(session->readMemoryBuffer.data(), sizeof(args1), &args1, sizeof(args1));
r0Thread0[15] = static_cast<uint32_t>((reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()) >> 32) & 0xffffffff);
r0Thread0[14] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()) & 0xffffffff);
EXPECT_EQ(ZE_RESULT_SUCCESS, session->readThreadScratchRegisters(threadId, 0, 2, scratch));
EXPECT_EQ(0u, scratch[0]);
EXPECT_EQ(0u, scratch[1]);
// read render surface fails
args1.scratchPtr = 0x1234u;
memcpy_s(session->readMemoryBuffer.data(), sizeof(args1), &args1, sizeof(args1));
session->readGpuMemoryCallCount = 0;
session->forcereadGpuMemoryFailOnCount = 3;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session->readThreadScratchRegisters(threadId, 0, 1, scratch));
// Unsupported structVersion
NEO::ImplicitArgsV0 args = {};
args.header.structVersion = 0;
args.header.structSize = NEO::ImplicitArgsV0::getSize();
memcpy_s(session->readMemoryBuffer.data(), sizeof(args), &args, sizeof(args));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, session->readThreadScratchRegisters(threadId, 0, 1, scratch));
NEO::ImplicitArgsV2 args2 = {};
args2.header.structVersion = 2;
memcpy_s(session->readMemoryBuffer.data(), sizeof(args2), &args2, sizeof(args2));
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, session->readThreadScratchRegisters(threadId, 0, 1, scratch));
}
TEST_F(DebugSessionRegistersAccessTestScratchV3, WhenReadingThreadScratchRegistersThenCorrectAddressesAreReturned) {
{
auto pStateSaveAreaHeader = reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
pStateSaveAreaHeader->regHeaderV3.state_area_offset +
pStateSaveAreaHeader->regHeaderV3.state_save_size * 16;
session->stateSaveAreaHeader.resize(size);
}
auto &gfxCoreHelper = neoDevice->getGfxCoreHelper();
ze_device_thread_t thread = {0, 0, 0, 0};
EuThread::ThreadId threadId(0, thread);
session->allThreads[threadId]->stopThread(1u);
dumpRegisterState();
auto threadSlotOffset = session->calculateThreadSlotOffset(threadId);
auto stateSaveAreaHeader = reinterpret_cast<NEO::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
auto grfOffset = threadSlotOffset + stateSaveAreaHeader->regHeaderV3.grf.offset;
uint32_t *r0Thread0 = reinterpret_cast<uint32_t *>(ptrOffset(session->stateSaveAreaHeader.data(), grfOffset));
uint64_t scratch[2];
uint64_t scratchExpected[2] = {0xdeadbeef, 0xbeefdead};
constexpr auto implicitArgsAlignedSize = NEO::ImplicitArgsV1::getAlignedSize();
session->readMemoryBuffer.assign(4 * gfxCoreHelper.getRenderSurfaceStateSize() + implicitArgsAlignedSize, 5);
NEO::ImplicitArgsV1 args = {};
args.header.structVersion = 1;
args.header.structSize = NEO::ImplicitArgsV1::getSize();
args.scratchPtr = reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()) + implicitArgsAlignedSize;
memcpy_s(session->readMemoryBuffer.data(), sizeof(args), &args, sizeof(args));
r0Thread0[15] = static_cast<uint32_t>((reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()) >> 32) & 0xffffffff);
r0Thread0[14] = static_cast<uint32_t>(reinterpret_cast<uint64_t>(session->readMemoryBuffer.data()) & 0xffffffff);
const uint32_t ptss = 128;
gfxCoreHelper.setRenderSurfaceStateForScratchResource(neoDevice->getRootDeviceEnvironment(),
&session->readMemoryBuffer[implicitArgsAlignedSize], 1, scratchExpected[0], 0,
ptss, nullptr, false, 6, false, true);
gfxCoreHelper.setRenderSurfaceStateForScratchResource(neoDevice->getRootDeviceEnvironment(),
&session->readMemoryBuffer[implicitArgsAlignedSize + gfxCoreHelper.getRenderSurfaceStateSize()], 1, scratchExpected[1], 0,
ptss, nullptr, false, 6, false, true);
EXPECT_EQ(ZE_RESULT_SUCCESS, session->readThreadScratchRegisters(threadId, 0, 2, scratch));
EXPECT_EQ(scratchExpected[0], scratch[0]);
EXPECT_EQ(scratchExpected[1], scratch[1]);
scratch[0] = 0;
scratch[1] = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, session->readThreadScratchRegisters(threadId, 0, 1, scratch));
EXPECT_EQ(scratchExpected[0], scratch[0]);
EXPECT_EQ(ZE_RESULT_SUCCESS, session->readThreadScratchRegisters(threadId, 1, 1, &scratch[1]));
EXPECT_EQ(scratchExpected[1], scratch[1]);
}
struct DebugSessionScratchRegistersTestV2 : public ::testing::Test {
struct MockDebugSessionScratch : public MockDebugSession {
using MockDebugSession::getScratchRenderSurfaceStateAddress;
using MockDebugSession::MockDebugSession;
uint32_t getRegisterSize(uint32_t type) override {
EXPECT_EQ(ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU, type);
return sizeof(uint32_t);
}
struct ReadRegistersParams {
EuThread::ThreadId thread;
uint32_t type, start, count;
void *pRegisters;
};
std::optional<ReadRegistersParams> lastReadRegistersParams;
std::vector<uint8_t> readRegistersData;
ze_result_t readRegistersResult = ZE_RESULT_SUCCESS;
ze_result_t readRegistersImp(EuThread::ThreadId thread, uint32_t type, uint32_t start, uint32_t count, void *pRegisters) override {
lastReadRegistersParams = {.thread = thread, .type = type, .start = start, .count = count, .pRegisters = pRegisters};
if (readRegistersResult == ZE_RESULT_SUCCESS) {
size_t sizeToCopy = std::min(readRegistersData.size(), static_cast<size_t>(count * getRegisterSize(type)));
memcpy(pRegisters, readRegistersData.data(), sizeToCopy);
}
return readRegistersResult;
}
std::optional<EuThread::ThreadId> lastGetRssAddressThread;
std::optional<uint64_t> getScratchRenderSurfaceStateAddressV2Result;
std::optional<ze_result_t> getScratchRenderSurfaceStateAddressV2Return;
ze_result_t getScratchRenderSurfaceStateAddressV2(EuThread::ThreadId thread, uint64_t *result) override {
lastGetRssAddressThread = thread;
if (getScratchRenderSurfaceStateAddressV2Return.has_value()) {
if (getScratchRenderSurfaceStateAddressV2Result.has_value()) {
*result = getScratchRenderSurfaceStateAddressV2Result.value();
}
return getScratchRenderSurfaceStateAddressV2Return.value();
}
return MockDebugSession::getScratchRenderSurfaceStateAddressV2(thread, result);
}
};
static constexpr uint64_t testMemoryHandle = 0xABCDEF00ULL;
DebugSessionScratchRegistersTestV2() : neoDevice(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(defaultHwInfo.get(), 0)),
deviceImp(std::make_unique<MockDeviceImp>(neoDevice)),
session(zet_debug_config_t{}, static_cast<L0::DeviceImp *>(deviceImp.get())),
threadId(5, 7, 9, 3, 1) {
session.allThreads[threadId] = std::make_unique<EuThread>(threadId);
session.allThreads[threadId]->stopThread(testMemoryHandle);
setIsScratchInGrf(neoDevice, false);
}
NEO::MockDevice *neoDevice; // deviceImp takes ownership of neoDevice
std::unique_ptr<MockDeviceImp> deviceImp;
MockDebugSessionScratch session;
EuThread::ThreadId threadId;
};
TEST_F(DebugSessionScratchRegistersTestV2, WhenCallingGetRenderSurfaceStateAddressThenV2IsCalled) {
uint64_t rssAddress = 0x123456780ULL;
session.getScratchRenderSurfaceStateAddressV2Result = rssAddress;
session.getScratchRenderSurfaceStateAddressV2Return = ZE_RESULT_SUCCESS;
uint64_t result = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, session.getScratchRenderSurfaceStateAddress(threadId, &result));
EXPECT_EQ(rssAddress, result);
EXPECT_EQ(threadId, session.lastGetRssAddressThread.value());
}
TEST_F(DebugSessionScratchRegistersTestV2, WhenGetRenderSurfaceStateAddressV2ReturnsErrorThenErrorIsPropagated) {
session.getScratchRenderSurfaceStateAddressV2Return = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
uint64_t result = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, session.getScratchRenderSurfaceStateAddress(threadId, &result));
EXPECT_EQ(threadId, session.lastGetRssAddressThread.value());
}
TEST_F(DebugSessionScratchRegistersTestV2, WhenReadRegistersImpReturnsErrorThenGetRenderSurfaceStateAddressV2ReturnsError) {
session.readRegistersResult = ZE_RESULT_ERROR_UNKNOWN;
uint64_t result = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, session.getScratchRenderSurfaceStateAddress(threadId, &result));
EXPECT_EQ(threadId, session.lastReadRegistersParams->thread);
}
TEST_F(DebugSessionScratchRegistersTestV2, WhenGetRenderSurfaceStateAddressV2IsCalledThenCorrectResultIsReturned) {
session.readRegistersData.assign({0x0a, 0xbc, 0xde, 0xf0, 0x0d, 0xbe, 0xad, 0xde});
uint64_t result = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, session.getScratchRenderSurfaceStateAddress(threadId, &result));
EXPECT_EQ(0xf0debc0adeadbe0d, result);
EXPECT_EQ(threadId, session.lastReadRegistersParams->thread);
EXPECT_EQ(ZET_DEBUG_REGSET_TYPE_SCALAR_INTEL_GPU, session.lastReadRegistersParams->type);
EXPECT_EQ(18u, session.lastReadRegistersParams->start);
EXPECT_EQ(2u, session.lastReadRegistersParams->count);
}
} // namespace ult
} // namespace L0