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

fix: return error when cannot obtain debug surface size

Browse Source 
remove default max debug surface size
check state save area size only for debug scenarios
reduce state save area size in unit tests - rely on values from mock

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2025-05-22 09:43:25 +00:00
committed by Compute-Runtime-Automation
parent efbf505744
commit 98bf872fdd
24 changed files with 108 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/source/device/device_imp.cpp
View File

@@ -1534,7 +1534,7 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, bool
std::vector<char> stateSaveAreaHeader; std::vector<char> stateSaveAreaHeader;
if (neoDevice->getDebugger() || neoDevice->getPreemptionMode() == NEO::PreemptionMode::MidThread) { if (neoDevice->getDebugger()) {
if (neoDevice->getCompilerInterface()) { if (neoDevice->getCompilerInterface()) {
if (rootDeviceEnvironment.executionEnvironment.getDebuggingMode() == NEO::DebuggingMode::offline) { if (rootDeviceEnvironment.executionEnvironment.getDebuggingMode() == NEO::DebuggingMode::offline) {
if (NEO::SipKernel::getSipKernel(*neoDevice, nullptr).getCtxOffset() == 0) { if (NEO::SipKernel::getSipKernel(*neoDevice, nullptr).getCtxOffset() == 0) {

66
level_zero/core/test/unit_tests/sources/device/test_l0_device.cpp
View File

@@ -292,32 +292,6 @@ TEST(L0DeviceTest, givenDisabledPreemptionWhenCreatingDeviceThenSipKernelIsNotIn
EXPECT_FALSE(NEO::MockSipData::called); EXPECT_FALSE(NEO::MockSipData::called);
} }
TEST(L0DeviceTest, givenMidThreadPreemptionAndIncorrectStateSaveAreaHeaderWhenCreatingL0DeviceThenErrorIsReturned) {
VariableBackup<bool> mockSipCalled(&NEO::MockSipData::called, false);
VariableBackup<NEO::SipKernelType> mockSipCalledType(&NEO::MockSipData::calledType, NEO::SipKernelType::count);
VariableBackup<bool> backupSipInitType(&MockSipData::useMockSip, true);
NonCopyableVariableBackup<std::unique_ptr<MockSipKernel>> backupSipKernel(&MockSipData::mockSipKernel, std::make_unique<MockSipKernel>());
MockSipData::mockSipKernel->mockStateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(1);
auto header = reinterpret_cast<SIP::StateSaveAreaHeader *>(MockSipData::mockSipKernel->mockStateSaveAreaHeader.data());
header->versionHeader.version.major = 5u;
std::unique_ptr<DriverHandleImp> driverHandle(new DriverHandleImp);
auto hwInfo = *NEO::defaultHwInfo;
hwInfo.capabilityTable.defaultPreemptionMode = NEO::PreemptionMode::MidThread;
auto neoDevice = std::unique_ptr<NEO::Device>(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
ze_result_t returnValue = ZE_RESULT_SUCCESS;
auto device = std::unique_ptr<L0::Device>(Device::create(driverHandle.get(), neoDevice.release(), false, &returnValue));
EXPECT_NE(nullptr, device);
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, returnValue);
EXPECT_EQ(NEO::SipKernelType::csr, NEO::MockSipData::calledType);
EXPECT_TRUE(NEO::MockSipData::called);
}
TEST(L0DeviceTest, givenDeviceWithoutIGCCompilerLibraryThenInvalidDependencyIsNotReturned) { TEST(L0DeviceTest, givenDeviceWithoutIGCCompilerLibraryThenInvalidDependencyIsNotReturned) {
ze_result_t returnValue = ZE_RESULT_SUCCESS; ze_result_t returnValue = ZE_RESULT_SUCCESS;
@@ -353,46 +327,6 @@ TEST(L0DeviceTest, givenDeviceWithoutAnyCompilerLibraryThenInvalidDependencyIsNo
EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS); EXPECT_EQ(returnValue, ZE_RESULT_SUCCESS);
} }
TEST(L0DeviceTest, givenDeviceWithoutIGCCompilerLibraryAndMidThreadPreemptionThenInvalidDependencyIsReturned) {
DebugManagerStateRestore restore{};
debugManager.flags.ForcePreemptionMode.set(PreemptionMode::MidThread);
ze_result_t returnValue = ZE_RESULT_SUCCESS;
std::unique_ptr<DriverHandleImp> driverHandle(new DriverHandleImp);
auto hwInfo = *NEO::defaultHwInfo;
auto igcNameGuard = NEO::pushIgcDllName("_invalidIGC");
auto neoDevice = std::unique_ptr<NEO::Device>(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
auto mockDevice = reinterpret_cast<NEO::MockDevice *>(neoDevice.get());
mockDevice->setPreemptionMode(NEO::PreemptionMode::MidThread);
auto device = std::unique_ptr<L0::Device>(Device::create(driverHandle.get(), neoDevice.release(), false, &returnValue));
ASSERT_NE(nullptr, device);
EXPECT_EQ(returnValue, ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
}
TEST(L0DeviceTest, givenDeviceWithoutAnyCompilerLibraryAndMidThreadPreemptionThenInvalidDependencyIsReturned) {
DebugManagerStateRestore restore{};
debugManager.flags.ForcePreemptionMode.set(PreemptionMode::MidThread);
ze_result_t returnValue = ZE_RESULT_SUCCESS;
std::unique_ptr<DriverHandleImp> driverHandle(new DriverHandleImp);
auto hwInfo = *NEO::defaultHwInfo;
auto oldFclDllName = Os::frontEndDllName;
Os::frontEndDllName = "_invalidFCL";
auto igcNameGuard = NEO::pushIgcDllName("_invalidIGC");
auto neoDevice = std::unique_ptr<NEO::Device>(NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0));
auto mockDevice = reinterpret_cast<NEO::MockDevice *>(neoDevice.get());
mockDevice->setPreemptionMode(NEO::PreemptionMode::MidThread);
auto device = std::unique_ptr<L0::Device>(Device::create(driverHandle.get(), neoDevice.release(), false, &returnValue));
ASSERT_NE(nullptr, device);
EXPECT_EQ(returnValue, ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
Os::frontEndDllName = oldFclDllName;
}
TEST(L0DeviceTest, givenFilledTopologyWhenGettingApiSliceThenCorrectSliceIdIsReturned) { TEST(L0DeviceTest, givenFilledTopologyWhenGettingApiSliceThenCorrectSliceIdIsReturned) {
std::unique_ptr<DriverHandleImp> driverHandle(new DriverHandleImp); std::unique_ptr<DriverHandleImp> driverHandle(new DriverHandleImp);

12
level_zero/core/test/unit_tests/xe_hpg_core/dg2/test_module_dg2.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2022-2024 Intel Corporation * Copyright (C) 2022-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -28,12 +28,9 @@ HWTEST2_F(KernelDebugSurfaceDG2Test, givenDebuggerWhenPatchWithImplicitSurfaceCa
auto debugger = MockDebuggerL0Hw<FamilyType>::allocate(neoDevice); auto debugger = MockDebuggerL0Hw<FamilyType>::allocate(neoDevice);
neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->debugger.reset(debugger); neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->debugger.reset(debugger);
auto &hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = neoDevice->getGfxCoreHelper();
auto maxDbgSurfaceSize = gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
auto debugSurface = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties( auto debugSurface = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(
{device->getRootDeviceIndex(), true, {device->getRootDeviceIndex(), true,
maxDbgSurfaceSize, MemoryConstants::pageSize,
NEO::AllocationType::debugContextSaveArea, NEO::AllocationType::debugContextSaveArea,
false, false,
false, false,
@@ -82,12 +79,9 @@ HWTEST2_F(KernelDebugSurfaceDG2Test, givenNoDebuggerWhenPatchWithImplicitSurface
auto debugger = MockDebuggerL0Hw<FamilyType>::allocate(neoDevice); auto debugger = MockDebuggerL0Hw<FamilyType>::allocate(neoDevice);
neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->debugger.reset(debugger); neoDevice->getExecutionEnvironment()->rootDeviceEnvironments[0]->debugger.reset(debugger);
auto &hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = neoDevice->getGfxCoreHelper();
auto maxDbgSurfaceSize = gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
auto debugSurface = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties( auto debugSurface = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(
{device->getRootDeviceIndex(), true, {device->getRootDeviceIndex(), true,
maxDbgSurfaceSize, MemoryConstants::pageSize,
NEO::AllocationType::debugContextSaveArea, NEO::AllocationType::debugContextSaveArea,
false, false,
false, false,

23
level_zero/tools/test/unit_tests/sources/debug/debug_session_common.cpp
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2022-2024 Intel Corporation * Copyright (C) 2022-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -28,15 +28,9 @@ void initStateSaveArea(std::vector<char> &stateSaveArea, SIP::version version, L
auto stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(version.major); auto stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(version.major);
auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(stateSaveAreaHeader.data()); auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(stateSaveAreaHeader.data());
if (version.major >= 2) { auto stateSaveSize = pStateSaveAreaHeader->regHeader.num_subslices_per_slice * pStateSaveAreaHeader->regHeader.num_eus_per_subslice * pStateSaveAreaHeader->regHeader.num_threads_per_eu * pStateSaveAreaHeader->regHeader.state_save_size;
stateSaveArea.resize(
threadSlotOffset(pStateSaveAreaHeader, 0, 0, 0, 0) + stateSaveArea.resize(threadSlotOffset(pStateSaveAreaHeader, 0, 0, 0, 0) + stateSaveSize);
pStateSaveAreaHeader->regHeader.num_subslices_per_slice * pStateSaveAreaHeader->regHeader.num_eus_per_subslice * pStateSaveAreaHeader->regHeader.num_threads_per_eu * pStateSaveAreaHeader->regHeader.state_save_size);
} else {
auto &hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = device->getGfxCoreHelper();
stateSaveArea.resize(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo) + MemoryConstants::pageSize);
}
memcpy_s(stateSaveArea.data(), stateSaveArea.size(), pStateSaveAreaHeader, stateSaveAreaHeader.size()); memcpy_s(stateSaveArea.data(), stateSaveArea.size(), pStateSaveAreaHeader, stateSaveAreaHeader.size());
@@ -63,11 +57,10 @@ void initStateSaveArea(std::vector<char> &stateSaveArea, SIP::version version, L
fillRegsetForThread(&pStateSaveAreaHeader->regHeader.grf, 0, 0, 4, 0, 'a'); fillRegsetForThread(&pStateSaveAreaHeader->regHeader.grf, 0, 0, 4, 0, 'a');
if (version.major < 2) { if (version.major < 2) {
auto &hwInfo = *NEO::defaultHwInfo.get(); const uint32_t numSlices = pStateSaveAreaHeader->regHeader.num_slices;
const uint32_t numSlices = hwInfo.gtSystemInfo.SliceCount > 2 ? 2 : hwInfo.gtSystemInfo.SliceCount; const uint32_t numSubslicesPerSlice = pStateSaveAreaHeader->regHeader.num_subslices_per_slice;
const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.SubSliceCount / hwInfo.gtSystemInfo.SliceCount; const uint32_t numEusPerSubslice = pStateSaveAreaHeader->regHeader.num_eus_per_subslice;
const uint32_t numEusPerSubslice = hwInfo.gtSystemInfo.EUCount / hwInfo.gtSystemInfo.SubSliceCount; const uint32_t numThreadsPerEu = pStateSaveAreaHeader->regHeader.num_threads_per_eu;
const uint32_t numThreadsPerEu = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount;
const uint32_t midSlice = (numSlices > 1) ? (numSlices / 2) : 0; const uint32_t midSlice = (numSlices > 1) ? (numSlices / 2) : 0;
const uint32_t midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0; const uint32_t midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0;

34
level_zero/tools/test/unit_tests/sources/debug/linux/prelim/test_debug_api_linux.cpp
View File

@@ -7247,8 +7247,7 @@ struct DebugApiRegistersAccessFixture : public DebugApiLinuxPrelimFixture {
session = std::make_unique<MockDebugSessionLinuxi915>(zet_debug_config_t{}, device, 0); session = std::make_unique<MockDebugSessionLinuxi915>(zet_debug_config_t{}, device, 0);
session->clientHandle = MockDebugSessionLinuxi915::mockClientHandle; session->clientHandle = MockDebugSessionLinuxi915::mockClientHandle;
session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->contextsCreated[ctxHandle].vm = vmHandle; session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->contextsCreated[ctxHandle].vm = vmHandle;
auto &gfxCoreHelper = device->getGfxCoreHelper(); maxDbgSurfaceSize = MemoryConstants::pageSize;
maxDbgSurfaceSize = gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->vmToContextStateSaveAreaBindInfo[vmHandle] = {stateSaveAreaGpuVa, maxDbgSurfaceSize}; session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->vmToContextStateSaveAreaBindInfo[vmHandle] = {stateSaveAreaGpuVa, maxDbgSurfaceSize};
session->allThreadsStopped = true; session->allThreadsStopped = true;
session->allThreads[stoppedThreadId]->stopThread(1u); session->allThreads[stoppedThreadId]->stopThread(1u);
@@ -7355,10 +7354,11 @@ TEST_F(DebugApiRegistersAccessTest, givenReadRegistersCalledCorrectValuesRead) {
char grf[32] = {0}; char grf[32] = {0};
char grfRef[32] = {0}; char grfRef[32] = {0};
const uint32_t numSlices = hwInfo.gtSystemInfo.SliceCount > 2 ? 2 : hwInfo.gtSystemInfo.SliceCount; auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.SubSliceCount / hwInfo.gtSystemInfo.SliceCount; const uint32_t numSlices = pStateSaveAreaHeader->regHeader.num_slices;
const uint32_t numEusPerSubslice = hwInfo.gtSystemInfo.EUCount / hwInfo.gtSystemInfo.SubSliceCount; const uint32_t numSubslicesPerSlice = pStateSaveAreaHeader->regHeader.num_subslices_per_slice;
const uint32_t numThreadsPerEu = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount; const uint32_t numEusPerSubslice = pStateSaveAreaHeader->regHeader.num_eus_per_subslice;
const uint32_t numThreadsPerEu = pStateSaveAreaHeader->regHeader.num_threads_per_eu;
const uint32_t midSlice = (numSlices > 1) ? (numSlices / 2) : 0; const uint32_t midSlice = (numSlices > 1) ? (numSlices / 2) : 0;
const uint32_t midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0; const uint32_t midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0;
@@ -7467,10 +7467,11 @@ TEST_F(DebugApiRegistersAccessTest, givenWriteRegistersCalledCorrectValuesRead)
char grf[32] = {0}; char grf[32] = {0};
char grfRef[32] = {0}; char grfRef[32] = {0};
const uint32_t numSlices = hwInfo.gtSystemInfo.SliceCount > 2 ? 2 : hwInfo.gtSystemInfo.SliceCount; auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.SubSliceCount / hwInfo.gtSystemInfo.SliceCount; const uint32_t numSlices = pStateSaveAreaHeader->regHeader.num_slices;
const uint32_t numEusPerSubslice = hwInfo.gtSystemInfo.EUCount / hwInfo.gtSystemInfo.SubSliceCount; const uint32_t numSubslicesPerSlice = pStateSaveAreaHeader->regHeader.num_subslices_per_slice;
const uint32_t numThreadsPerEu = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount; const uint32_t numEusPerSubslice = pStateSaveAreaHeader->regHeader.num_eus_per_subslice;
const uint32_t numThreadsPerEu = pStateSaveAreaHeader->regHeader.num_threads_per_eu;
const uint32_t midSlice = (numSlices > 1) ? (numSlices / 2) : 0; const uint32_t midSlice = (numSlices > 1) ? (numSlices / 2) : 0;
const uint32_t midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0; const uint32_t midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0;
@@ -7719,9 +7720,7 @@ struct MockRenderSurfaceState {
static_assert(64 == sizeof(MockRenderSurfaceState)); static_assert(64 == sizeof(MockRenderSurfaceState));
void sbaInit(std::vector<char> &stateSaveArea, uint64_t stateSaveAreaGpuVa, SbaTrackedAddresses &sba, uint32_t r0[8], L0::Device *device) { void sbaInit(std::vector<char> &stateSaveArea, uint64_t stateSaveAreaGpuVa, SbaTrackedAddresses &sba, uint32_t r0[8], L0::Device *device) {
auto &hwInfo = *NEO::defaultHwInfo.get(); auto maxDbgSurfaceSize = MemoryConstants::pageSize;
auto &gfxCoreHelper = device->getGfxCoreHelper();
auto maxDbgSurfaceSize = gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
uint64_t surfaceStateBaseAddress = stateSaveAreaGpuVa + maxDbgSurfaceSize + sizeof(SbaTrackedAddresses); uint64_t surfaceStateBaseAddress = stateSaveAreaGpuVa + maxDbgSurfaceSize + sizeof(SbaTrackedAddresses);
uint32_t renderSurfaceStateOffset = 256; uint32_t renderSurfaceStateOffset = 256;
r0[4] = 0xAAAAAAAA; r0[4] = 0xAAAAAAAA;
@@ -7843,10 +7842,11 @@ TEST_F(DebugApiRegistersAccessTest, GivenScratchPointerAndZeroAddressInSurfaceSt
session->vmHandle = 7; session->vmHandle = 7;
session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->vmToStateBaseAreaBindInfo[vmHandle] = {stateSaveAreaGpuVa + maxDbgSurfaceSize, sizeof(SbaTrackedAddresses)}; session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->vmToStateBaseAreaBindInfo[vmHandle] = {stateSaveAreaGpuVa + maxDbgSurfaceSize, sizeof(SbaTrackedAddresses)};
const uint32_t numSlices = hwInfo.gtSystemInfo.SliceCount > 2 ? 2 : hwInfo.gtSystemInfo.SliceCount; auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.SubSliceCount / hwInfo.gtSystemInfo.SliceCount; const uint32_t numSlices = pStateSaveAreaHeader->regHeader.num_slices;
const uint32_t numEusPerSubslice = hwInfo.gtSystemInfo.EUCount / hwInfo.gtSystemInfo.SubSliceCount; const uint32_t numSubslicesPerSlice = pStateSaveAreaHeader->regHeader.num_subslices_per_slice;
const uint32_t numThreadsPerEu = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount; const uint32_t numEusPerSubslice = pStateSaveAreaHeader->regHeader.num_eus_per_subslice;
const uint32_t numThreadsPerEu = pStateSaveAreaHeader->regHeader.num_threads_per_eu;
const uint32_t midSlice = (numSlices > 1) ? (numSlices / 2) : 0; const uint32_t midSlice = (numSlices > 1) ? (numSlices / 2) : 0;
const uint32_t midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0; const uint32_t midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0;

8
opencl/test/unit_test/command_queue/command_queue_tests.cpp
View File

@@ -1545,9 +1545,7 @@ HWTEST_F(CommandQueueCommandStreamTest, WhenSetupDebugSurfaceIsCalledThenSurface
kernel->setSshLocal(nullptr, sizeof(RENDER_SURFACE_STATE) + systemThreadSurfaceAddress); kernel->setSshLocal(nullptr, sizeof(RENDER_SURFACE_STATE) + systemThreadSurfaceAddress);
auto &commandStreamReceiver = cmdQ.getGpgpuCommandStreamReceiver(); auto &commandStreamReceiver = cmdQ.getGpgpuCommandStreamReceiver();
auto &hwInfo = *NEO::defaultHwInfo.get(); cmdQ.getGpgpuCommandStreamReceiver().allocateDebugSurface(MemoryConstants::pageSize);
auto &gfxCoreHelper = pClDevice->getGfxCoreHelper();
cmdQ.getGpgpuCommandStreamReceiver().allocateDebugSurface(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo));
cmdQ.setupDebugSurface(kernel.get()); cmdQ.setupDebugSurface(kernel.get());
auto debugSurface = commandStreamReceiver.getDebugSurfaceAllocation(); auto debugSurface = commandStreamReceiver.getDebugSurfaceAllocation();
@@ -1565,9 +1563,7 @@ HWTEST_F(CommandQueueCommandStreamTest, WhenSetupDebugSurfaceIsCalledThenDebugSu
const auto &systemThreadSurfaceAddress = kernel->getAllocatedKernelInfo()->kernelDescriptor.payloadMappings.implicitArgs.systemThreadSurfaceAddress.bindful; const auto &systemThreadSurfaceAddress = kernel->getAllocatedKernelInfo()->kernelDescriptor.payloadMappings.implicitArgs.systemThreadSurfaceAddress.bindful;
kernel->setSshLocal(nullptr, sizeof(RENDER_SURFACE_STATE) + systemThreadSurfaceAddress); kernel->setSshLocal(nullptr, sizeof(RENDER_SURFACE_STATE) + systemThreadSurfaceAddress);
auto &commandStreamReceiver = cmdQ.getGpgpuCommandStreamReceiver(); auto &commandStreamReceiver = cmdQ.getGpgpuCommandStreamReceiver();
auto hwInfo = *NEO::defaultHwInfo.get(); commandStreamReceiver.allocateDebugSurface(MemoryConstants::pageSize);
auto &gfxCoreHelper = pClDevice->getGfxCoreHelper();
commandStreamReceiver.allocateDebugSurface(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo));
auto debugSurface = commandStreamReceiver.getDebugSurfaceAllocation(); auto debugSurface = commandStreamReceiver.getDebugSurfaceAllocation();
ASSERT_NE(nullptr, debugSurface); ASSERT_NE(nullptr, debugSurface);

9
shared/source/built_ins/sip.cpp
View File

@@ -86,18 +86,13 @@ const std::vector<char> &SipKernel::getBinary() const {
size_t SipKernel::getStateSaveAreaSize(Device *device) const { size_t SipKernel::getStateSaveAreaSize(Device *device) const {
auto &hwInfo = device->getHardwareInfo(); auto &hwInfo = device->getHardwareInfo();
auto &gfxCoreHelper = device->getGfxCoreHelper();
auto maxDbgSurfaceSize = gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
if (debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.get() != -1) {
maxDbgSurfaceSize = static_cast<size_t>(debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.get());
}
const auto &stateSaveAreaHeader = getStateSaveAreaHeader(); const auto &stateSaveAreaHeader = getStateSaveAreaHeader();
if (stateSaveAreaHeader.empty()) { if (stateSaveAreaHeader.empty()) {
return maxDbgSurfaceSize; return 0u;
} }
if (strcmp(stateSaveAreaHeader.data(), "tssarea")) { if (strcmp(stateSaveAreaHeader.data(), "tssarea")) {
return maxDbgSurfaceSize; return 0u;
} }
auto hdr = reinterpret_cast<const NEO::StateSaveAreaHeader *>(stateSaveAreaHeader.data()); auto hdr = reinterpret_cast<const NEO::StateSaveAreaHeader *>(stateSaveAreaHeader.data());

1
shared/source/debug_settings/debug_variables_base.inl
View File

@@ -155,7 +155,6 @@ DECLARE_DEBUG_VARIABLE(int32_t, DebuggerForceSbaTrackingMode, -1, "-1: default,
DECLARE_DEBUG_VARIABLE(bool, DisableSupportForL0Debugger, 0, "0: default setting for product, 1: disable l0 debugger") DECLARE_DEBUG_VARIABLE(bool, DisableSupportForL0Debugger, 0, "0: default setting for product, 1: disable l0 debugger")
DECLARE_DEBUG_VARIABLE(int32_t, DebugApiUsed, 0, "0: default L0 Debug API not used, 1: L0 Debug API used") DECLARE_DEBUG_VARIABLE(int32_t, DebugApiUsed, 0, "0: default L0 Debug API not used, 1: L0 Debug API used")
DECLARE_DEBUG_VARIABLE(int32_t, OverrideCsrAllocationSize, -1, "-1: default, >0: use value for size of CSR allocation") DECLARE_DEBUG_VARIABLE(int32_t, OverrideCsrAllocationSize, -1, "-1: default, >0: use value for size of CSR allocation")
DECLARE_DEBUG_VARIABLE(int32_t, OverrideSipKernelMaxDbgSurfaceSize, -1, "-1: default, >0: use value as max debug surface size for sip kernel")
DECLARE_DEBUG_VARIABLE(int32_t, ComputeOverdispatchDisable, -1, "Set Compute Overdispatch Disable field, -1: do not set.") DECLARE_DEBUG_VARIABLE(int32_t, ComputeOverdispatchDisable, -1, "Set Compute Overdispatch Disable field, -1: do not set.")
DECLARE_DEBUG_VARIABLE(int32_t, CFEWeightedDispatchModeDisable, -1, "Set Weighted Dispatch Mode Disable field in CFE_STATE on XEHP, -1: do not set.") DECLARE_DEBUG_VARIABLE(int32_t, CFEWeightedDispatchModeDisable, -1, "Set Weighted Dispatch Mode Disable field in CFE_STATE on XEHP, -1: do not set.")
DECLARE_DEBUG_VARIABLE(int32_t, CFESingleSliceDispatchCCSMode, -1, "Set Single Slice Dispatch CCS Mode in CFE_STATE on XEHP, -1 - do not set") DECLARE_DEBUG_VARIABLE(int32_t, CFESingleSliceDispatchCCSMode, -1, "Set Single Slice Dispatch CCS Mode in CFE_STATE on XEHP, -1 - do not set")

19
shared/source/device/device.cpp
View File

@@ -192,18 +192,19 @@ bool Device::initializeCommonResources() {
} }
} }
auto &hwInfo = getHardwareInfo();
auto &gfxCoreHelper = getGfxCoreHelper();
auto debugSurfaceSize = gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
if (this->isStateSipRequired()) { if (this->isStateSipRequired()) {
bool ret = SipKernel::initSipKernel(SipKernel::getSipKernelType(*this), *this); bool ret = SipKernel::initSipKernel(SipKernel::getSipKernelType(*this), *this);
UNRECOVERABLE_IF(!ret); UNRECOVERABLE_IF(!ret);
debugSurfaceSize = NEO::SipKernel::getSipKernel(*this, nullptr).getStateSaveAreaSize(this); const bool isDebugSurfaceRequired = getL0Debugger();
} if (isDebugSurfaceRequired) {
auto debugSurfaceSize = NEO::SipKernel::getSipKernel(*this, nullptr).getStateSaveAreaSize(this);
const bool isDebugSurfaceRequired = getL0Debugger(); if (debugSurfaceSize) {
if (isDebugSurfaceRequired) { allocateDebugSurface(debugSurfaceSize);
allocateDebugSurface(debugSurfaceSize); } else {
NEO::printDebugString(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "Unable to determine debug surface size.\n");
return false;
}
}
} }
bool usmPoolManagerEnabled = ApiSpecificConfig::isDeviceUsmPoolingEnabled() && bool usmPoolManagerEnabled = ApiSpecificConfig::isDeviceUsmPoolingEnabled() &&

3
shared/source/helpers/gfx_core_helper.h
View File

@@ -122,7 +122,6 @@ class GfxCoreHelper {
const RootDeviceEnvironment &rootDeviceEnvironment) const = 0; const RootDeviceEnvironment &rootDeviceEnvironment) const = 0;
virtual uint32_t adjustMaxWorkGroupSize(const uint32_t grfCount, const uint32_t simd, bool isHwLocalGeneration, const uint32_t defaultMaxGroupSize, const RootDeviceEnvironment &rootDeviceEnvironment) const = 0; virtual uint32_t adjustMaxWorkGroupSize(const uint32_t grfCount, const uint32_t simd, bool isHwLocalGeneration, const uint32_t defaultMaxGroupSize, const RootDeviceEnvironment &rootDeviceEnvironment) const = 0;
virtual size_t getMaxFillPaternSizeForCopyEngine() const = 0; virtual size_t getMaxFillPaternSizeForCopyEngine() const = 0;
virtual size_t getSipKernelMaxDbgSurfaceSize(const HardwareInfo &hwInfo) const = 0;
virtual bool isCpuImageTransferPreferred(const HardwareInfo &hwInfo) const = 0; virtual bool isCpuImageTransferPreferred(const HardwareInfo &hwInfo) const = 0;
virtual aub_stream::MMIOList getExtraMmioList(const HardwareInfo &hwInfo, const GmmHelper &gmmHelper) const = 0; virtual aub_stream::MMIOList getExtraMmioList(const HardwareInfo &hwInfo, const GmmHelper &gmmHelper) const = 0;
virtual bool isSubDeviceEngineSupported(const RootDeviceEnvironment &rootDeviceEnvironment, const DeviceBitfield &deviceBitfield, aub_stream::EngineType engineType) const = 0; virtual bool isSubDeviceEngineSupported(const RootDeviceEnvironment &rootDeviceEnvironment, const DeviceBitfield &deviceBitfield, aub_stream::EngineType engineType) const = 0;
@@ -366,8 +365,6 @@ class GfxCoreHelperHw : public GfxCoreHelper {
uint32_t adjustMaxWorkGroupSize(const uint32_t grfCount, const uint32_t simd, bool isHwLocalGeneration, const uint32_t defaultMaxGroupSize, const RootDeviceEnvironment &rootDeviceEnvironment) const override; uint32_t adjustMaxWorkGroupSize(const uint32_t grfCount, const uint32_t simd, bool isHwLocalGeneration, const uint32_t defaultMaxGroupSize, const RootDeviceEnvironment &rootDeviceEnvironment) const override;
size_t getMaxFillPaternSizeForCopyEngine() const override; size_t getMaxFillPaternSizeForCopyEngine() const override;
size_t getSipKernelMaxDbgSurfaceSize(const HardwareInfo &hwInfo) const override;
bool isCpuImageTransferPreferred(const HardwareInfo &hwInfo) const override; bool isCpuImageTransferPreferred(const HardwareInfo &hwInfo) const override;
aub_stream::MMIOList getExtraMmioList(const HardwareInfo &hwInfo, const GmmHelper &gmmHelper) const override; aub_stream::MMIOList getExtraMmioList(const HardwareInfo &hwInfo, const GmmHelper &gmmHelper) const override;

5
shared/source/helpers/gfx_core_helper_base.inl
View File

@@ -592,11 +592,6 @@ template <typename GfxFamily>
void GfxCoreHelperHw<GfxFamily>::setSipKernelData(uint32_t *&sipKernelBinary, size_t &kernelBinarySize, const RootDeviceEnvironment &rootDeviceEnvironment) const { void GfxCoreHelperHw<GfxFamily>::setSipKernelData(uint32_t *&sipKernelBinary, size_t &kernelBinarySize, const RootDeviceEnvironment &rootDeviceEnvironment) const {
} }
template <typename GfxFamily>
size_t GfxCoreHelperHw<GfxFamily>::getSipKernelMaxDbgSurfaceSize(const HardwareInfo &hwInfo) const {
return 24 * MemoryConstants::megaByte;
}
template <typename GfxFamily> template <typename GfxFamily>
void GfxCoreHelperHw<GfxFamily>::adjustPreemptionSurfaceSize(size_t &csrSize, const RootDeviceEnvironment &rootDeviceEnvironment) const { void GfxCoreHelperHw<GfxFamily>::adjustPreemptionSurfaceSize(size_t &csrSize, const RootDeviceEnvironment &rootDeviceEnvironment) const {
} }

5
shared/source/xe_hpc_core/gfx_core_helper_xe_hpc_core.cpp
View File

@@ -280,11 +280,6 @@ uint32_t GfxCoreHelperHw<Family>::getComputeUnitsUsedForScratch(const RootDevice
return hwInfo->gtSystemInfo.MaxSubSlicesSupported * hwInfo->gtSystemInfo.MaxEuPerSubSlice * threadEuRatio; return hwInfo->gtSystemInfo.MaxSubSlicesSupported * hwInfo->gtSystemInfo.MaxEuPerSubSlice * threadEuRatio;
} }
template <>
size_t GfxCoreHelperHw<Family>::getSipKernelMaxDbgSurfaceSize(const HardwareInfo &hwInfo) const {
return 40 * MemoryConstants::megaByte;
}
template <> template <>
bool GfxCoreHelperHw<Family>::copyThroughLockedPtrEnabled(const HardwareInfo &hwInfo, const ProductHelper &productHelper) const { bool GfxCoreHelperHw<Family>::copyThroughLockedPtrEnabled(const HardwareInfo &hwInfo, const ProductHelper &productHelper) const {
if (debugManager.flags.ExperimentalCopyThroughLock.get() != -1) { if (debugManager.flags.ExperimentalCopyThroughLock.get() != -1) {

6
shared/test/common/base_ult_config_listener.cpp
View File

@@ -11,6 +11,7 @@
#include "shared/source/utilities/wait_util.h" #include "shared/source/utilities/wait_util.h"
#include "shared/test/common/helpers/default_hw_info.h" #include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/ult_hw_config.h" #include "shared/test/common/helpers/ult_hw_config.h"
#include "shared/test/common/mocks/mock_sip.h"
#include "aubstream/aubstream.h" #include "aubstream/aubstream.h"
@@ -32,6 +33,8 @@ void BaseUltConfigListener::OnTestStart(const ::testing::TestInfo &) {
injectFcnSnapshot = debugManager.injectFcn; injectFcnSnapshot = debugManager.injectFcn;
referencedHwInfo = *defaultHwInfo; referencedHwInfo = *defaultHwInfo;
stateSaveAreaHeaderSnapshot = MockSipData::mockSipKernel->getStateSaveAreaHeader();
testStart = std::chrono::steady_clock::now(); testStart = std::chrono::steady_clock::now();
} }
@@ -66,5 +69,8 @@ void BaseUltConfigListener::OnTestEnd(const ::testing::TestInfo &) {
EXPECT_EQ(1, referencedHwInfo.workaroundTable.asHash() == defaultHwInfo->workaroundTable.asHash()); EXPECT_EQ(1, referencedHwInfo.workaroundTable.asHash() == defaultHwInfo->workaroundTable.asHash());
EXPECT_EQ(1, referencedHwInfo.capabilityTable == defaultHwInfo->capabilityTable); EXPECT_EQ(1, referencedHwInfo.capabilityTable == defaultHwInfo->capabilityTable);
MemoryManager::maxOsContextCount = maxOsContextCountBackup; MemoryManager::maxOsContextCount = maxOsContextCountBackup;
EXPECT_EQ(stateSaveAreaHeaderSnapshot.size(), MockSipData::mockSipKernel->getStateSaveAreaHeader().size());
EXPECT_EQ(0, memcmp(stateSaveAreaHeaderSnapshot.data(), MockSipData::mockSipKernel->getStateSaveAreaHeader().data(), stateSaveAreaHeaderSnapshot.size()));
} }
} // namespace NEO } // namespace NEO

3
shared/test/common/base_ult_config_listener.h
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020-2024 Intel Corporation * Copyright (C) 2020-2025 Intel Corporation
* *
* SPDX-License-Identifier: MIT * SPDX-License-Identifier: MIT
* *
@@ -26,6 +26,7 @@ class BaseUltConfigListener : public ::testing::EmptyTestEventListener {
HardwareInfo referencedHwInfo; HardwareInfo referencedHwInfo;
std::chrono::steady_clock::time_point testStart{}; std::chrono::steady_clock::time_point testStart{};
uint32_t maxOsContextCountBackup = 0; uint32_t maxOsContextCountBackup = 0;
std::vector<char> stateSaveAreaHeaderSnapshot{100};
}; };
} // namespace NEO } // namespace NEO

1
shared/test/common/common_main.cpp
View File

@@ -449,7 +449,6 @@ int main(int argc, char **argv) {
MockSipData::useMockSip = true; MockSipData::useMockSip = true;
} }
sipInitialized = true; sipInitialized = true;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(1);
} }
Device::createPerformanceCountersFunc = [](Device *) -> std::unique_ptr<NEO::PerformanceCounters> { return {}; }; Device::createPerformanceCountersFunc = [](Device *) -> std::unique_ptr<NEO::PerformanceCounters> { return {}; };

2
shared/test/common/helpers/sip_init.cpp
View File

@@ -55,7 +55,7 @@ std::vector<char> createStateSaveAreaHeader(uint32_t version, uint16_t grfNum, u
{ {
// regHeader // regHeader
1, // num_slices 1, // num_slices
6, // num_subslices_per_slice 2, // num_subslices_per_slice
16, // num_eus_per_subslice 16, // num_eus_per_subslice
7, // num_threads_per_eu 7, // num_threads_per_eu
0, // state_area_offset 0, // state_area_offset

15
shared/test/common/mocks/mock_compilers.cpp
View File

@@ -5,7 +5,7 @@
* *
*/ */
#include "mock_compilers.h" #include "shared/test/common/mocks/mock_compilers.h"
#include "shared/source/compiler_interface/compiler_options.h" #include "shared/source/compiler_interface/compiler_options.h"
#include "shared/source/helpers/hw_info.h" #include "shared/source/helpers/hw_info.h"
@@ -13,10 +13,10 @@
#include "shared/test/common/helpers/mock_file_io.h" #include "shared/test/common/helpers/mock_file_io.h"
#include "shared/test/common/helpers/test_files.h" #include "shared/test/common/helpers/test_files.h"
#include "shared/test/common/mocks/mock_compiler_interface.h" #include "shared/test/common/mocks/mock_compiler_interface.h"
#include "shared/test/common/mocks/mock_compilers.h"
#include "shared/test/common/mocks/mock_sip.h" #include "shared/test/common/mocks/mock_sip.h"
#include "cif/macros/enable.h" #include "cif/macros/enable.h"
#include "common/StateSaveAreaHeader.h"
#include "ocl_igc_interface/fcl_ocl_device_ctx.h" #include "ocl_igc_interface/fcl_ocl_device_ctx.h"
#include "ocl_igc_interface/igc_ocl_device_ctx.h" #include "ocl_igc_interface/igc_ocl_device_ctx.h"
@@ -543,7 +543,14 @@ bool MockIgcOclDeviceCtx::GetSystemRoutine(IGC::SystemRoutineType::SystemRoutine
debugVars.receivedSipAddressingType = bindless ? MockCompilerDebugVars::SipAddressingType::bindless : MockCompilerDebugVars::SipAddressingType::bindful; debugVars.receivedSipAddressingType = bindless ? MockCompilerDebugVars::SipAddressingType::bindless : MockCompilerDebugVars::SipAddressingType::bindful;
const char mockData1[64] = {'C', 'T', 'N', 'I'}; const char mockData1[64] = {'C', 'T', 'N', 'I'};
const char mockData2[64] = {'S', 'S', 'A', 'H'}; const SIP::StateSaveAreaHeaderV3 mockSipStateSaveAreaHeaderV3 = {
.versionHeader{
.magic = "tssarea",
.reserved1 = 0,
.version = {3, 0, 0},
.size = static_cast<uint8_t>(sizeof(SIP::StateSaveArea)),
.reserved2 = {0, 0, 0}},
.regHeader{}};
if (debugVars.forceBuildFailure || typeOfSystemRoutine == IGC::SystemRoutineType::undefined) { if (debugVars.forceBuildFailure || typeOfSystemRoutine == IGC::SystemRoutineType::undefined) {
return false; return false;
@@ -558,7 +565,7 @@ bool MockIgcOclDeviceCtx::GetSystemRoutine(IGC::SystemRoutineType::SystemRoutine
if (debugVars.stateSaveAreaHeaderToReturnSize > 0 && debugVars.stateSaveAreaHeaderToReturn != nullptr) { if (debugVars.stateSaveAreaHeaderToReturnSize > 0 && debugVars.stateSaveAreaHeaderToReturn != nullptr) {
stateSaveAreaHeaderInit->PushBackRawBytes(debugVars.stateSaveAreaHeaderToReturn, debugVars.stateSaveAreaHeaderToReturnSize); stateSaveAreaHeaderInit->PushBackRawBytes(debugVars.stateSaveAreaHeaderToReturn, debugVars.stateSaveAreaHeaderToReturnSize);
} else { } else {
stateSaveAreaHeaderInit->PushBackRawBytes(mockData2, 64); stateSaveAreaHeaderInit->PushBackRawBytes(&mockSipStateSaveAreaHeaderV3, sizeof(mockSipStateSaveAreaHeaderV3));
} }
return true; return true;
} }

19
shared/test/common/mocks/mock_sip.cpp
View File

@@ -10,16 +10,29 @@
#include "shared/source/memory_manager/memory_allocation.h" #include "shared/source/memory_manager/memory_allocation.h"
#include "shared/test/common/helpers/test_files.h" #include "shared/test/common/helpers/test_files.h"
#include "common/StateSaveAreaHeader.h"
#include <fstream> #include <fstream>
#include <map> #include <map>
namespace NEO { namespace NEO {
MockSipKernel::MockSipKernel(SipKernelType type, GraphicsAllocation *sipAlloc) : SipKernel(type, sipAlloc, {'s', 's', 'a', 'h'}) {
static constexpr SIP::StateSaveAreaHeaderV3 mockSipStateSaveAreaHeaderV3 = {
.versionHeader{
.magic = "tssarea",
.reserved1 = 0,
.version = {3, 0, 0},
.size = static_cast<uint8_t>(sizeof(SIP::StateSaveArea)),
.reserved2 = {0, 0, 0}},
.regHeader{}};
MockSipKernel::MockSipKernel(SipKernelType type, GraphicsAllocation *sipAlloc) : SipKernel(type, sipAlloc, {}) {
this->mockStateSaveAreaHeader.resize(sizeof(mockSipStateSaveAreaHeaderV3));
memcpy_s(this->mockStateSaveAreaHeader.data(), sizeof(mockSipStateSaveAreaHeaderV3), &mockSipStateSaveAreaHeaderV3, sizeof(mockSipStateSaveAreaHeaderV3));
createMockSipAllocation(); createMockSipAllocation();
} }
MockSipKernel::MockSipKernel() : SipKernel(SipKernelType::csr, nullptr, {'s', 's', 'a', 'h'}) { MockSipKernel::MockSipKernel() : MockSipKernel(SipKernelType::csr, nullptr) {
createMockSipAllocation();
} }
MockSipKernel::~MockSipKernel() = default; MockSipKernel::~MockSipKernel() = default;

2
shared/test/common/mocks/mock_sip.h
View File

@@ -36,7 +36,7 @@ class MockSipKernel : public SipKernel {
std::unique_ptr<MemoryAllocation> mockSipMemoryAllocation; std::unique_ptr<MemoryAllocation> mockSipMemoryAllocation;
std::unique_ptr<MemoryAllocation> tempSipMemoryAllocation; std::unique_ptr<MemoryAllocation> tempSipMemoryAllocation;
std::vector<char> mockStateSaveAreaHeader = {'s', 's', 'a', 'h'}; std::vector<char> mockStateSaveAreaHeader;
MockExecutionEnvironment executionEnvironment; MockExecutionEnvironment executionEnvironment;
}; };

1
shared/test/common/test_files/igdrcl.config
View File

@@ -47,7 +47,6 @@ DumpSipHeaderFile = unk
InjectInternalBuildOptions = unk InjectInternalBuildOptions = unk
InjectApiBuildOptions = unk InjectApiBuildOptions = unk
OverrideCsrAllocationSize = -1 OverrideCsrAllocationSize = -1
OverrideSipKernelMaxDbgSurfaceSize = -1
AbortHostSyncOnNonHostVisibleEvent = 0 AbortHostSyncOnNonHostVisibleEvent = 0
IgnoreProductSpecificIoctlHelper = 0 IgnoreProductSpecificIoctlHelper = 0
ForceL1Caching = -1 ForceL1Caching = -1

52
shared/test/unit_test/built_ins/sip_tests.cpp
View File

@@ -424,50 +424,35 @@ TEST_F(HexadecimalHeaderSipTest, whenInitHexadecimalArraySipKernelIsCalledTwiceT
EXPECT_EQ(sipAllocation, sipAllocation2); EXPECT_EQ(sipAllocation, sipAllocation2);
} }
using StateSaveAreaSipTest = Test<RawBinarySipFixture>; struct StateSaveAreaSipTest : Test<RawBinarySipFixture> {
void SetUp() override {
RawBinarySipFixture::setUp();
MockSipData::useMockSip = true;
stateSaveAreaHeaderBackup = MockSipData::mockSipKernel->mockStateSaveAreaHeader;
}
void TearDown() override {
MockSipData::mockSipKernel->mockStateSaveAreaHeader = std::move(stateSaveAreaHeaderBackup);
RawBinarySipFixture::tearDown();
}
VariableBackup<bool> backupSipInitType{&MockSipData::useMockSip};
std::vector<char> stateSaveAreaHeaderBackup;
};
TEST_F(StateSaveAreaSipTest, givenEmptyStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenMaxDbgSurfaceSizeIsReturned) { TEST_F(StateSaveAreaSipTest, givenEmptyStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenZeroSizeIsReturned) {
DebugManagerStateRestore restore;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
MockSipData::useMockSip = true;
MockSipData::mockSipKernel->mockStateSaveAreaHeader.clear(); MockSipData::mockSipKernel->mockStateSaveAreaHeader.clear();
auto hwInfo = *NEO::defaultHwInfo.get(); EXPECT_EQ(0u, SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
auto &gfxCoreHelper = this->pDevice->getGfxCoreHelper();
EXPECT_EQ(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo), SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
} }
TEST_F(StateSaveAreaSipTest, givenCorruptedStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenMaxDbgSurfaceSizeIsReturned) { TEST_F(StateSaveAreaSipTest, givenCorruptedStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenZeroSizeIsReturned) {
DebugManagerStateRestore restore;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
MockSipData::useMockSip = true;
MockSipData::mockSipKernel->mockStateSaveAreaHeader = {'g', 'a', 'r', 'b', 'a', 'g', 'e'}; MockSipData::mockSipKernel->mockStateSaveAreaHeader = {'g', 'a', 'r', 'b', 'a', 'g', 'e'};
auto hwInfo = *NEO::defaultHwInfo.get(); EXPECT_EQ(0u, SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
auto &gfxCoreHelper = this->pDevice->getGfxCoreHelper();
EXPECT_EQ(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo), SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
}
TEST_F(StateSaveAreaSipTest, givenOverrideSipKernelMaxDebugSurfaceSizeFlagSetWhenGettingStateSaveAreaSizeForInvalidInputThenValueOfDebugFlagIsReturned) {
DebugManagerStateRestore restore;
auto expectedValue = MemoryConstants::pageSize2M;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(static_cast<int32_t>(expectedValue));
MockSipData::useMockSip = true;
MockSipData::mockSipKernel->mockStateSaveAreaHeader = {'g', 'a', 'r', 'b', 'a', 'g', 'e'};
auto hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = this->pDevice->getGfxCoreHelper();
EXPECT_NE(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo), expectedValue);
EXPECT_EQ(expectedValue, SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
MockSipData::mockSipKernel->mockStateSaveAreaHeader.clear();
EXPECT_EQ(expectedValue, SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
} }
TEST_F(StateSaveAreaSipTest, givenCorrectStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenCorrectDbgSurfaceSizeIsReturned) { TEST_F(StateSaveAreaSipTest, givenCorrectStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenCorrectDbgSurfaceSizeIsReturned) {
MockSipData::useMockSip = true;
auto hwInfo = pDevice->getHardwareInfo(); auto hwInfo = pDevice->getHardwareInfo();
auto numSlices = NEO::GfxCoreHelper::getHighestEnabledSlice(hwInfo); auto numSlices = NEO::GfxCoreHelper::getHighestEnabledSlice(hwInfo);
MockSipData::mockSipKernel->mockStateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(1); MockSipData::mockSipKernel->mockStateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(1);
EXPECT_EQ(0x1800u * numSlices * 6 * 16 * 7 + alignUp(sizeof(SIP::StateSaveAreaHeader), MemoryConstants::pageSize), SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice)); EXPECT_EQ(0x1800u * numSlices * 2 * 16 * 7 + alignUp(sizeof(SIP::StateSaveAreaHeader), MemoryConstants::pageSize), SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
MockSipData::mockSipKernel->mockStateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2); MockSipData::mockSipKernel->mockStateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2);
EXPECT_EQ(0x1800u * numSlices * 8 * 7 + alignUp(sizeof(SIP::StateSaveAreaHeader), MemoryConstants::pageSize), SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice)); EXPECT_EQ(0x1800u * numSlices * 8 * 7 + alignUp(sizeof(SIP::StateSaveAreaHeader), MemoryConstants::pageSize), SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
@@ -479,7 +464,6 @@ TEST_F(StateSaveAreaSipTest, givenCorrectStateSaveAreaHeaderWhenGetStateSaveArea
} }
TEST_F(StateSaveAreaSipTest, givenStateSaveAreaHeaderVersion4WhenGetStateSaveAreaSizeCalledThenTotalWmtpDataSizeIsReturned) { TEST_F(StateSaveAreaSipTest, givenStateSaveAreaHeaderVersion4WhenGetStateSaveAreaSizeCalledThenTotalWmtpDataSizeIsReturned) {
VariableBackup<bool> backupSipInitType(&MockSipData::useMockSip, true);
MockSipData::mockSipKernel->mockStateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(4); MockSipData::mockSipKernel->mockStateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(4);
auto header = reinterpret_cast<SIP::StateSaveAreaHeader *>(MockSipData::mockSipKernel->mockStateSaveAreaHeader.data()); auto header = reinterpret_cast<SIP::StateSaveAreaHeader *>(MockSipData::mockSipKernel->mockStateSaveAreaHeader.data());
header->versionHeader.version.major = 4u; header->versionHeader.version.major = 4u;

4
shared/test/unit_test/command_stream/aub_file_stream_tests.cpp
View File

@@ -734,9 +734,6 @@ HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWhenInitializeEngineIs
} }
HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithAubManagerWhenInitFileIsCalledThenMemTraceCommentWithDriverVersionIsPutIntoAubStream) { HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithAubManagerWhenInitFileIsCalledThenMemTraceCommentWithDriverVersionIsPutIntoAubStream) {
DebugManagerStateRestore stateRestore;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
auto mockAubManager = std::make_unique<MockAubManager>(); auto mockAubManager = std::make_unique<MockAubManager>();
MockExecutionEnvironment executionEnvironment(defaultHwInfo.get()); MockExecutionEnvironment executionEnvironment(defaultHwInfo.get());
@@ -1004,7 +1001,6 @@ HWTEST_F(AubFileStreamTests, givenAndAubCommandStreamReceiverWhenCreateFullFileP
HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithAubManagerWhenInitFileIsCalledThenCommentWithNonDefaultFlagsAreAdded) { HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithAubManagerWhenInitFileIsCalledThenCommentWithNonDefaultFlagsAreAdded) {
DebugManagerStateRestore stateRestore; DebugManagerStateRestore stateRestore;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
debugManager.flags.MakeAllBuffersResident.set(1); debugManager.flags.MakeAllBuffersResident.set(1);
debugManager.flags.ZE_AFFINITY_MASK.set("non-default"); debugManager.flags.ZE_AFFINITY_MASK.set("non-default");

8
shared/test/unit_test/device/neo_device_tests.cpp
View File

@@ -2244,6 +2244,14 @@ TEST_F(DeviceTests, GivenDebuggingEnabledWhenDeviceIsInitializedThenL0DebuggerIs
EXPECT_NE(nullptr, device->getL0Debugger()); EXPECT_NE(nullptr, device->getL0Debugger());
} }
TEST_F(DeviceTests, GivenDebuggingEnabledAndInvalidStateSaveAreaHeaderWhenDeviceIsInitializedThenFailureIsReturned) {
auto executionEnvironment = MockDevice::prepareExecutionEnvironment(defaultHwInfo.get(), 0u);
executionEnvironment->setDebuggingMode(NEO::DebuggingMode::online);
VariableBackup<char> backupStateSaveAreaHeader{MockSipData::mockSipKernel->mockStateSaveAreaHeader.data(), '\0'};
auto device = std::unique_ptr<MockDevice>(MockDevice::createWithExecutionEnvironment<MockDevice>(defaultHwInfo.get(), executionEnvironment, 0u));
EXPECT_EQ(nullptr, device);
}
TEST_F(DeviceTests, givenDebuggerRequestedByUserAndNotAvailableWhenDeviceIsInitializedThenDeviceIsNullAndErrorIsPrinted) { TEST_F(DeviceTests, givenDebuggerRequestedByUserAndNotAvailableWhenDeviceIsInitializedThenDeviceIsNullAndErrorIsPrinted) {
extern bool forceCreateNullptrDebugger; extern bool forceCreateNullptrDebugger;

4
shared/test/unit_test/execution_environment/execution_environment_tests.cpp
View File

@@ -362,9 +362,6 @@ TEST(ExecutionEnvironment, givenExperimentalUSMAllocationReuseCleanerSetAndNotEn
} }
TEST(ExecutionEnvironment, givenNeoCalEnabledWhenCreateExecutionEnvironmentThenSetDebugVariables) { TEST(ExecutionEnvironment, givenNeoCalEnabledWhenCreateExecutionEnvironmentThenSetDebugVariables) {
DebugManagerStateRestore restorer;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
const std::unordered_map<std::string, int32_t> config = { const std::unordered_map<std::string, int32_t> config = {
{"UseKmdMigration", 0}, {"UseKmdMigration", 0},
{"SplitBcsSize", 256}}; {"SplitBcsSize", 256}};
@@ -380,6 +377,7 @@ TEST(ExecutionEnvironment, givenNeoCalEnabledWhenCreateExecutionEnvironmentThenS
#undef DECLARE_DEBUG_SCOPED_V #undef DECLARE_DEBUG_SCOPED_V
#undef DECLARE_DEBUG_VARIABLE #undef DECLARE_DEBUG_VARIABLE
DebugManagerStateRestore restorer;
debugManager.flags.NEO_CAL_ENABLED.set(1); debugManager.flags.NEO_CAL_ENABLED.set(1);
ExecutionEnvironment exeEnv; ExecutionEnvironment exeEnv;