Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: return error when cannot obtain debug surface size 

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
Show Stats 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;
if (neoDevice->getDebugger() || neoDevice->getPreemptionMode() == NEO::PreemptionMode::MidThread) {
if (neoDevice->getDebugger()) {
if (neoDevice->getCompilerInterface()) {
if (rootDeviceEnvironment.executionEnvironment.getDebuggingMode() == NEO::DebuggingMode::offline) {
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);
}
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) {
ze_result_t returnValue = ZE_RESULT_SUCCESS;
@ -353,46 +327,6 @@ TEST(L0DeviceTest, givenDeviceWithoutAnyCompilerLibraryThenInvalidDependencyIsNo
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) {
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
*
@ -28,12 +28,9 @@ HWTEST2_F(KernelDebugSurfaceDG2Test, givenDebuggerWhenPatchWithImplicitSurfaceCa
auto debugger = MockDebuggerL0Hw<FamilyType>::allocate(neoDevice);
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(
{device->getRootDeviceIndex(), true,
maxDbgSurfaceSize,
MemoryConstants::pageSize,
NEO::AllocationType::debugContextSaveArea,
false,
false,
@ -82,12 +79,9 @@ HWTEST2_F(KernelDebugSurfaceDG2Test, givenNoDebuggerWhenPatchWithImplicitSurface
auto debugger = MockDebuggerL0Hw<FamilyType>::allocate(neoDevice);
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(
{device->getRootDeviceIndex(), true,
maxDbgSurfaceSize,
MemoryConstants::pageSize,
NEO::AllocationType::debugContextSaveArea,
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
*
@ -28,15 +28,9 @@ void initStateSaveArea(std::vector<char> &stateSaveArea, SIP::version version, L
auto stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(version.major);
auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(stateSaveAreaHeader.data());
if (version.major >= 2) {
stateSaveArea.resize(
threadSlotOffset(pStateSaveAreaHeader, 0, 0, 0, 0) +
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);
}
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) + stateSaveSize);
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');
if (version.major < 2) {
auto &hwInfo = *NEO::defaultHwInfo.get();
const uint32_t numSlices = hwInfo.gtSystemInfo.SliceCount > 2 ? 2 : hwInfo.gtSystemInfo.SliceCount;
const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.SubSliceCount / hwInfo.gtSystemInfo.SliceCount;
const uint32_t numEusPerSubslice = hwInfo.gtSystemInfo.EUCount / hwInfo.gtSystemInfo.SubSliceCount;
const uint32_t numThreadsPerEu = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount;
const uint32_t numSlices = pStateSaveAreaHeader->regHeader.num_slices;
const uint32_t numSubslicesPerSlice = pStateSaveAreaHeader->regHeader.num_subslices_per_slice;
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 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->clientHandle = MockDebugSessionLinuxi915::mockClientHandle;
session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->contextsCreated[ctxHandle].vm = vmHandle;
auto &gfxCoreHelper = device->getGfxCoreHelper();
maxDbgSurfaceSize = gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
maxDbgSurfaceSize = MemoryConstants::pageSize;
session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->vmToContextStateSaveAreaBindInfo[vmHandle] = {stateSaveAreaGpuVa, maxDbgSurfaceSize};
session->allThreadsStopped = true;
session->allThreads[stoppedThreadId]->stopThread(1u);
@ -7355,10 +7354,11 @@ TEST_F(DebugApiRegistersAccessTest, givenReadRegistersCalledCorrectValuesRead) {
char grf[32] = {0};
char grfRef[32] = {0};
const uint32_t numSlices = hwInfo.gtSystemInfo.SliceCount > 2 ? 2 : hwInfo.gtSystemInfo.SliceCount;
const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.SubSliceCount / hwInfo.gtSystemInfo.SliceCount;
const uint32_t numEusPerSubslice = hwInfo.gtSystemInfo.EUCount / hwInfo.gtSystemInfo.SubSliceCount;
const uint32_t numThreadsPerEu = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount;
auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
const uint32_t numSlices = pStateSaveAreaHeader->regHeader.num_slices;
const uint32_t numSubslicesPerSlice = pStateSaveAreaHeader->regHeader.num_subslices_per_slice;
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 midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0;
@ -7467,10 +7467,11 @@ TEST_F(DebugApiRegistersAccessTest, givenWriteRegistersCalledCorrectValuesRead)
char grf[32] = {0};
char grfRef[32] = {0};
const uint32_t numSlices = hwInfo.gtSystemInfo.SliceCount > 2 ? 2 : hwInfo.gtSystemInfo.SliceCount;
const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.SubSliceCount / hwInfo.gtSystemInfo.SliceCount;
const uint32_t numEusPerSubslice = hwInfo.gtSystemInfo.EUCount / hwInfo.gtSystemInfo.SubSliceCount;
const uint32_t numThreadsPerEu = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount;
auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
const uint32_t numSlices = pStateSaveAreaHeader->regHeader.num_slices;
const uint32_t numSubslicesPerSlice = pStateSaveAreaHeader->regHeader.num_subslices_per_slice;
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 midSubslice = (numSubslicesPerSlice > 1) ? (numSubslicesPerSlice / 2) : 0;
@ -7719,9 +7720,7 @@ struct MockRenderSurfaceState {
static_assert(64 == sizeof(MockRenderSurfaceState));
void sbaInit(std::vector<char> &stateSaveArea, uint64_t stateSaveAreaGpuVa, SbaTrackedAddresses &sba, uint32_t r0[8], L0::Device *device) {
auto &hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = device->getGfxCoreHelper();
auto maxDbgSurfaceSize = gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo);
auto maxDbgSurfaceSize = MemoryConstants::pageSize;
uint64_t surfaceStateBaseAddress = stateSaveAreaGpuVa + maxDbgSurfaceSize + sizeof(SbaTrackedAddresses);
uint32_t renderSurfaceStateOffset = 256;
r0[4] = 0xAAAAAAAA;
@ -7843,10 +7842,11 @@ TEST_F(DebugApiRegistersAccessTest, GivenScratchPointerAndZeroAddressInSurfaceSt
session->vmHandle = 7;
session->clientHandleToConnection[MockDebugSessionLinuxi915::mockClientHandle]->vmToStateBaseAreaBindInfo[vmHandle] = {stateSaveAreaGpuVa + maxDbgSurfaceSize, sizeof(SbaTrackedAddresses)};
const uint32_t numSlices = hwInfo.gtSystemInfo.SliceCount > 2 ? 2 : hwInfo.gtSystemInfo.SliceCount;
const uint32_t numSubslicesPerSlice = hwInfo.gtSystemInfo.SubSliceCount / hwInfo.gtSystemInfo.SliceCount;
const uint32_t numEusPerSubslice = hwInfo.gtSystemInfo.EUCount / hwInfo.gtSystemInfo.SubSliceCount;
const uint32_t numThreadsPerEu = hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount;
auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
const uint32_t numSlices = pStateSaveAreaHeader->regHeader.num_slices;
const uint32_t numSubslicesPerSlice = pStateSaveAreaHeader->regHeader.num_subslices_per_slice;
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 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);
auto &commandStreamReceiver = cmdQ.getGpgpuCommandStreamReceiver();
auto &hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = pClDevice->getGfxCoreHelper();
cmdQ.getGpgpuCommandStreamReceiver().allocateDebugSurface(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo));
cmdQ.getGpgpuCommandStreamReceiver().allocateDebugSurface(MemoryConstants::pageSize);
cmdQ.setupDebugSurface(kernel.get());
auto debugSurface = commandStreamReceiver.getDebugSurfaceAllocation();
@ -1565,9 +1563,7 @@ HWTEST_F(CommandQueueCommandStreamTest, WhenSetupDebugSurfaceIsCalledThenDebugSu
const auto &systemThreadSurfaceAddress = kernel->getAllocatedKernelInfo()->kernelDescriptor.payloadMappings.implicitArgs.systemThreadSurfaceAddress.bindful;
kernel->setSshLocal(nullptr, sizeof(RENDER_SURFACE_STATE) + systemThreadSurfaceAddress);
auto &commandStreamReceiver = cmdQ.getGpgpuCommandStreamReceiver();
auto hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = pClDevice->getGfxCoreHelper();
commandStreamReceiver.allocateDebugSurface(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo));
commandStreamReceiver.allocateDebugSurface(MemoryConstants::pageSize);
auto debugSurface = commandStreamReceiver.getDebugSurfaceAllocation();
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 {
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();
if (stateSaveAreaHeader.empty()) {
return maxDbgSurfaceSize;
return 0u;
}
if (strcmp(stateSaveAreaHeader.data(), "tssarea")) {
return maxDbgSurfaceSize;
return 0u;
}
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(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, 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, 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")

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()) {
bool ret = SipKernel::initSipKernel(SipKernel::getSipKernelType(*this), *this);
UNRECOVERABLE_IF(!ret);
debugSurfaceSize = NEO::SipKernel::getSipKernel(*this, nullptr).getStateSaveAreaSize(this);
}
const bool isDebugSurfaceRequired = getL0Debugger();
if (isDebugSurfaceRequired) {
allocateDebugSurface(debugSurfaceSize);
const bool isDebugSurfaceRequired = getL0Debugger();
if (isDebugSurfaceRequired) {
auto debugSurfaceSize = NEO::SipKernel::getSipKernel(*this, nullptr).getStateSaveAreaSize(this);
if (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() &&

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

@ -122,7 +122,6 @@ class GfxCoreHelper {
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 getSipKernelMaxDbgSurfaceSize(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 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;
size_t getMaxFillPaternSizeForCopyEngine() const override;
size_t getSipKernelMaxDbgSurfaceSize(const HardwareInfo &hwInfo) const override;
bool isCpuImageTransferPreferred(const HardwareInfo &hwInfo) 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 {
}
template <typename GfxFamily>
size_t GfxCoreHelperHw<GfxFamily>::getSipKernelMaxDbgSurfaceSize(const HardwareInfo &hwInfo) const {
return 24 * MemoryConstants::megaByte;
}
template <typename GfxFamily>
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;
}
template <>
size_t GfxCoreHelperHw<Family>::getSipKernelMaxDbgSurfaceSize(const HardwareInfo &hwInfo) const {
return 40 * MemoryConstants::megaByte;
}
template <>
bool GfxCoreHelperHw<Family>::copyThroughLockedPtrEnabled(const HardwareInfo &hwInfo, const ProductHelper &productHelper) const {
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/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/ult_hw_config.h"
#include "shared/test/common/mocks/mock_sip.h"
#include "aubstream/aubstream.h"
@ -32,6 +33,8 @@ void BaseUltConfigListener::OnTestStart(const ::testing::TestInfo &) {
injectFcnSnapshot = debugManager.injectFcn;
referencedHwInfo = *defaultHwInfo;
stateSaveAreaHeaderSnapshot = MockSipData::mockSipKernel->getStateSaveAreaHeader();
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.capabilityTable == defaultHwInfo->capabilityTable);
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

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
*
@ -26,6 +26,7 @@ class BaseUltConfigListener : public ::testing::EmptyTestEventListener {
HardwareInfo referencedHwInfo;
std::chrono::steady_clock::time_point testStart{};
uint32_t maxOsContextCountBackup = 0;
std::vector<char> stateSaveAreaHeaderSnapshot{100};
};
} // namespace NEO

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

@ -449,7 +449,6 @@ int main(int argc, char **argv) {
MockSipData::useMockSip = true;
}
sipInitialized = true;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(1);
}
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
1, // num_slices
6, // num_subslices_per_slice
2, // num_subslices_per_slice
16, // num_eus_per_subslice
7, // num_threads_per_eu
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/helpers/hw_info.h"
@ -13,10 +13,10 @@
#include "shared/test/common/helpers/mock_file_io.h"
#include "shared/test/common/helpers/test_files.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 "cif/macros/enable.h"
#include "common/StateSaveAreaHeader.h"
#include "ocl_igc_interface/fcl_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;
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) {
return false;
@ -558,7 +565,7 @@ bool MockIgcOclDeviceCtx::GetSystemRoutine(IGC::SystemRoutineType::SystemRoutine
if (debugVars.stateSaveAreaHeaderToReturnSize > 0 && debugVars.stateSaveAreaHeaderToReturn != nullptr) {
stateSaveAreaHeaderInit->PushBackRawBytes(debugVars.stateSaveAreaHeaderToReturn, debugVars.stateSaveAreaHeaderToReturnSize);
} else {
stateSaveAreaHeaderInit->PushBackRawBytes(mockData2, 64);
stateSaveAreaHeaderInit->PushBackRawBytes(&mockSipStateSaveAreaHeaderV3, sizeof(mockSipStateSaveAreaHeaderV3));
}
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/test/common/helpers/test_files.h"
#include "common/StateSaveAreaHeader.h"
#include <fstream>
#include <map>
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();
}
MockSipKernel::MockSipKernel() : SipKernel(SipKernelType::csr, nullptr, {'s', 's', 'a', 'h'}) {
createMockSipAllocation();
MockSipKernel::MockSipKernel() : MockSipKernel(SipKernelType::csr, nullptr) {
}
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> tempSipMemoryAllocation;
std::vector<char> mockStateSaveAreaHeader = {'s', 's', 'a', 'h'};
std::vector<char> mockStateSaveAreaHeader;
MockExecutionEnvironment executionEnvironment;
};

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

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

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

@ -424,50 +424,35 @@ TEST_F(HexadecimalHeaderSipTest, whenInitHexadecimalArraySipKernelIsCalledTwiceT
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) {
DebugManagerStateRestore restore;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
MockSipData::useMockSip = true;
TEST_F(StateSaveAreaSipTest, givenEmptyStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenZeroSizeIsReturned) {
MockSipData::mockSipKernel->mockStateSaveAreaHeader.clear();
auto hwInfo = *NEO::defaultHwInfo.get();
auto &gfxCoreHelper = this->pDevice->getGfxCoreHelper();
EXPECT_EQ(gfxCoreHelper.getSipKernelMaxDbgSurfaceSize(hwInfo), SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
EXPECT_EQ(0u, SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
}
TEST_F(StateSaveAreaSipTest, givenCorruptedStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenMaxDbgSurfaceSizeIsReturned) {
DebugManagerStateRestore restore;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
MockSipData::useMockSip = true;
TEST_F(StateSaveAreaSipTest, givenCorruptedStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenZeroSizeIsReturned) {
MockSipData::mockSipKernel->mockStateSaveAreaHeader = {'g', 'a', 'r', 'b', 'a', 'g', 'e'};
auto hwInfo = *NEO::defaultHwInfo.get();
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));
EXPECT_EQ(0u, SipKernel::getSipKernel(*pDevice, nullptr).getStateSaveAreaSize(pDevice));
}
TEST_F(StateSaveAreaSipTest, givenCorrectStateSaveAreaHeaderWhenGetStateSaveAreaSizeCalledThenCorrectDbgSurfaceSizeIsReturned) {
MockSipData::useMockSip = true;
auto hwInfo = pDevice->getHardwareInfo();
auto numSlices = NEO::GfxCoreHelper::getHighestEnabledSlice(hwInfo);
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);
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) {
VariableBackup<bool> backupSipInitType(&MockSipData::useMockSip, true);
MockSipData::mockSipKernel->mockStateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(4);
auto header = reinterpret_cast<SIP::StateSaveAreaHeader *>(MockSipData::mockSipKernel->mockStateSaveAreaHeader.data());
header->versionHeader.version.major = 4u;
@ -969,4 +953,4 @@ TEST_F(DebugExternalLibSipTest, givenGetSipBinaryFromExternalLibRetunsTrueWhenGe
DebugManagerStateRestore restorer;
debugManager.flags.GetSipBinaryFromExternalLib.set(1);
EXPECT_EQ(nullptr, pDevice->getSipExternalLibInterface());
}
}

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) {
DebugManagerStateRestore stateRestore;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
auto mockAubManager = std::make_unique<MockAubManager>();
MockExecutionEnvironment executionEnvironment(defaultHwInfo.get());
@ -1004,7 +1001,6 @@ HWTEST_F(AubFileStreamTests, givenAndAubCommandStreamReceiverWhenCreateFullFileP
HWTEST_F(AubFileStreamTests, givenAubCommandStreamReceiverWithAubManagerWhenInitFileIsCalledThenCommentWithNonDefaultFlagsAreAdded) {
DebugManagerStateRestore stateRestore;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
debugManager.flags.MakeAllBuffersResident.set(1);
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());
}
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) {
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) {
DebugManagerStateRestore restorer;
debugManager.flags.OverrideSipKernelMaxDbgSurfaceSize.set(-1);
const std::unordered_map<std::string, int32_t> config = {
{"UseKmdMigration", 0},
{"SplitBcsSize", 256}};
@ -380,6 +377,7 @@ TEST(ExecutionEnvironment, givenNeoCalEnabledWhenCreateExecutionEnvironmentThenS
#undef DECLARE_DEBUG_SCOPED_V
#undef DECLARE_DEBUG_VARIABLE
DebugManagerStateRestore restorer;
debugManager.flags.NEO_CAL_ENABLED.set(1);
ExecutionEnvironment exeEnv;