Revert "feature: Report correct GRF register count"

This reverts commit 8eb3fe222e.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>

level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper.h

@@ -10,7 +10,6 @@
 #include "shared/source/helpers/api_gfx_core_helper.h"
 #include "shared/source/helpers/heap_base_address_model.h"
 
-#include "level_zero/include/zet_intel_gpu_debug.h"
 #include "level_zero/tools/source/debug/eu_thread.h"
 #include <level_zero/ze_api.h>
 
@@ -79,7 +78,6 @@ class L0GfxCoreHelper : public NEO::ApiGfxCoreHelper {
     virtual NEO::HeapAddressModel getPlatformHeapAddressModel() const = 0;
     virtual std::vector<uint32_t> getSupportedNumGrfs() const = 0;
     virtual bool platformSupportsImmediateComputeFlushTask() const = 0;
-    virtual zet_debug_regset_type_intel_gpu_t getRegsetTypeForLargeGrfDetection() const = 0;
 
   protected:
     L0GfxCoreHelper() = default;
@@ -117,7 +115,6 @@ class L0GfxCoreHelperHw : public L0GfxCoreHelper {
     NEO::HeapAddressModel getPlatformHeapAddressModel() const override;
     std::vector<uint32_t> getSupportedNumGrfs() const override;
     bool platformSupportsImmediateComputeFlushTask() const override;
-    zet_debug_regset_type_intel_gpu_t getRegsetTypeForLargeGrfDetection() const override;
 
   protected:
     L0GfxCoreHelperHw() = default;

level_zero/core/source/gfx_core_helpers/l0_gfx_core_helper_base.inl

@@ -39,9 +39,4 @@ bool L0GfxCoreHelperHw<Family>::multiTileCapablePlatform() const {
     return false;
 }
 
-template <typename Family>
-zet_debug_regset_type_intel_gpu_t L0GfxCoreHelperHw<Family>::getRegsetTypeForLargeGrfDetection() const {
-    return ZET_DEBUG_REGSET_TYPE_INVALID_INTEL_GPU;
-}
-
 } // namespace L0

level_zero/core/source/xe_hp_core/l0_gfx_core_helper_xe_hp_core.cpp

@@ -42,11 +42,6 @@ bool L0GfxCoreHelperHw<Family>::platformSupportsRayTracing() const {
     return true;
 }
 
-template <>
-zet_debug_regset_type_intel_gpu_t L0GfxCoreHelperHw<Family>::getRegsetTypeForLargeGrfDetection() const {
-    return ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU;
-}
-
 template class L0GfxCoreHelperHw<Family>;
 
 } // namespace L0

level_zero/core/source/xe_hpc_core/l0_gfx_core_helper_xe_hpc_core.cpp

@@ -35,11 +35,6 @@ bool L0GfxCoreHelperHw<Family>::platformSupportsStateBaseAddressTracking() const
     return true;
 }
 
-template <>
-zet_debug_regset_type_intel_gpu_t L0GfxCoreHelperHw<Family>::getRegsetTypeForLargeGrfDetection() const {
-    return ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU;
-}
-
 template class L0GfxCoreHelperHw<Family>;
 
 } // namespace L0

level_zero/core/source/xe_hpg_core/l0_gfx_core_helper_xe_hpg_core.cpp

@@ -18,11 +18,6 @@ namespace L0 {
 using Family = NEO::XeHpgCoreFamily;
 static auto gfxCore = IGFX_XE_HPG_CORE;
 
-template <>
-zet_debug_regset_type_intel_gpu_t L0GfxCoreHelperHw<Family>::getRegsetTypeForLargeGrfDetection() const {
-    return ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU;
-}
-
 #include "level_zero/core/source/helpers/l0_gfx_core_helper_factory_init.inl"
 
 template class L0GfxCoreHelperHw<Family>;

level_zero/core/test/unit_tests/gen12lp/test_l0_gfx_core_helper_gen12lp.cpp

@@ -23,11 +23,6 @@ HWTEST_EXCLUDE_PRODUCT(L0GfxCoreHelperTest, givenBitmaskWithAttentionBitsForHalf
 
 using L0GfxCoreHelperTestGen12Lp = Test<DeviceFixture>;
 
-GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenGetRegsetTypeForLargeGrfDetectionIsCalledThenInvalidRegsetTypeIsRetuned) {
-    auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
-    EXPECT_EQ(ZET_DEBUG_REGSET_TYPE_INVALID_INTEL_GPU, l0GfxCoreHelper.getRegsetTypeForLargeGrfDetection());
-}
-
 GEN12LPTEST_F(L0GfxCoreHelperTestGen12Lp, GivenGen12LpWhenCheckingL0HelperForCmdListHeapSharingSupportThenReturnFalse) {
     auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
 

level_zero/core/test/unit_tests/xe_hpc_core/test_l0_gfx_core_helper_xe_hpc_core.cpp

@@ -74,10 +74,5 @@ XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenCheckingL0HelperForPla
     EXPECT_TRUE(l0GfxCoreHelper.platformSupportsImmediateComputeFlushTask());
 }
 
-XE_HPC_CORETEST_F(L0GfxCoreHelperTestXeHpc, GivenXeHpcWhenGetRegsetTypeForLargeGrfDetectionIsCalledThenCrRegsetTypeIsRetuned) {
-    auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
-    EXPECT_EQ(ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, l0GfxCoreHelper.getRegsetTypeForLargeGrfDetection());
-}
-
 } // namespace ult
 } // namespace L0

level_zero/core/test/unit_tests/xe_hpg_core/test_l0_gfx_core_helper_xe_hpg_core.cpp

@@ -31,11 +31,6 @@ XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenCheckingL0HelperForMul
     EXPECT_FALSE(l0GfxCoreHelper.multiTileCapablePlatform());
 }
 
-XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenGetRegsetTypeForLargeGrfDetectionIsCalledThenCrRegsetTypeIsRetuned) {
-    auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
-    EXPECT_EQ(ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU, l0GfxCoreHelper.getRegsetTypeForLargeGrfDetection());
-}
-
 XE_HPG_CORETEST_F(L0GfxCoreHelperTestXeHpg, GivenXeHpgWhenCheckingL0HelperForCmdListHeapSharingSupportThenReturnTrue) {
     auto &l0GfxCoreHelper = getHelper<L0GfxCoreHelper>();
     EXPECT_TRUE(l0GfxCoreHelper.platformSupportsCmdListHeapSharing());

level_zero/tools/source/debug/debug_session.h

@@ -110,9 +110,6 @@ struct DebugSession : _zet_debug_session_handle_t {
   protected:
     DebugSession(const zet_debug_config_t &config, Device *device);
     void createEuThreads();
-    void updateGrfRegisterSetProperties(EuThread::ThreadId thread, uint32_t *pCount, zet_debug_regset_properties_t *pRegisterSetProperties);
-    virtual uint32_t getRegisterSize(uint32_t type) = 0;
-    virtual ze_result_t readRegistersImp(EuThread::ThreadId thread, uint32_t type, uint32_t start, uint32_t count, void *pRegisterValues) = 0;
 
     virtual void startAsyncThread() = 0;
 

level_zero/tools/source/debug/debug_session_imp.cpp

@@ -1160,40 +1160,6 @@ ze_result_t DebugSessionImp::readSbaRegisters(EuThread::ThreadId threadId, uint3
     return ZE_RESULT_SUCCESS;
 }
 
-void DebugSession::updateGrfRegisterSetProperties(EuThread::ThreadId thread, uint32_t *pCount, zet_debug_regset_properties_t *pRegisterSetProperties) {
-    if (pRegisterSetProperties == nullptr) {
-        return;
-    }
-
-    auto &gfxCoreHelper = this->connectedDevice->getGfxCoreHelper();
-    if (!gfxCoreHelper.largeGrfModeSupported()) {
-        return;
-    }
-
-    // update GRF, if large GRF is enabled
-    auto &l0GfxCoreHelper = connectedDevice->getNEODevice()->getRootDeviceEnvironment().getHelper<L0GfxCoreHelper>();
-    auto regsetType = l0GfxCoreHelper.getRegsetTypeForLargeGrfDetection();
-    bool largeGrfModeEnabled = false;
-    const auto regSize = std::max(getRegisterSize(regsetType), 64u);
-    auto reg = std::make_unique<uint32_t[]>(regSize / sizeof(uint32_t));
-    memset(reg.get(), 0, regSize);
-    readRegistersImp(thread, regsetType, 0, 1, reg.get());
-    auto regPtr = reg.get();
-    if (regsetType == ZET_DEBUG_REGSET_TYPE_CR_INTEL_GPU) {
-        largeGrfModeEnabled = regPtr[0] & 0x2000;
-    } else if (regsetType == ZET_DEBUG_REGSET_TYPE_SR_INTEL_GPU) {
-        largeGrfModeEnabled = regPtr[1] & 0x6000;
-    }
-
-    if (!largeGrfModeEnabled) {
-        for (uint32_t i = 0; i < *pCount; i++) {
-            if (pRegisterSetProperties[i].type == ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU) {
-                pRegisterSetProperties[i].count = 128;
-            }
-        }
-    }
-}
-
 ze_result_t DebugSession::getThreadRegisterSetProperties(ze_device_thread_t thread, uint32_t *pCount, zet_debug_regset_properties_t *pRegisterSetProperties) {
     if (!isSingleThread(thread)) {
         return ZE_RESULT_ERROR_NOT_AVAILABLE;
@@ -1204,13 +1170,7 @@ ze_result_t DebugSession::getThreadRegisterSetProperties(ze_device_thread_t thre
         return ZE_RESULT_ERROR_NOT_AVAILABLE;
     }
 
-    auto ret = getRegisterSetProperties(this->connectedDevice, pCount, pRegisterSetProperties);
+    return getRegisterSetProperties(this->connectedDevice, pCount, pRegisterSetProperties);
-    if (ret != ZE_RESULT_SUCCESS) {
-        return ret;
-    }
-
-    updateGrfRegisterSetProperties(threadId, pCount, pRegisterSetProperties);
-    return ret;
 }
 
 ze_result_t DebugSession::getRegisterSetProperties(Device *device, uint32_t *pCount, zet_debug_regset_properties_t *pRegisterSetProperties) {
@@ -1233,6 +1193,7 @@ ze_result_t DebugSession::getRegisterSetProperties(Device *device, uint32_t *pCo
     auto parseRegsetDesc = [&](const SIP::regset_desc &regsetDesc, zet_debug_regset_type_intel_gpu_t regsetType) {
         if (regsetDesc.num) {
             if (totalRegsetNum < *pCount) {
+                uint16_t num = (regsetType == ZET_DEBUG_REGSET_TYPE_GRF_INTEL_GPU) ? 128 : regsetDesc.num;
                 zet_debug_regset_properties_t regsetProps = {
                     ZET_STRUCTURE_TYPE_DEBUG_REGSET_PROPERTIES,
                     nullptr,
@@ -1240,7 +1201,7 @@ ze_result_t DebugSession::getRegisterSetProperties(Device *device, uint32_t *pCo
                     0,
                     DebugSessionImp::typeToRegsetFlags(regsetType),
                     0,
-                    regsetDesc.num,
+                    num,
                     regsetDesc.bits,
                     regsetDesc.bytes,
                 };

level_zero/tools/source/debug/debug_session_imp.h

@@ -71,7 +71,7 @@ struct DebugSessionImp : DebugSession {
     using ApiEventQueue = std::queue<zet_debug_event_t>;
 
   protected:
-    ze_result_t readRegistersImp(EuThread::ThreadId thread, uint32_t type, uint32_t start, uint32_t count, void *pRegisterValues) override;
+    MOCKABLE_VIRTUAL ze_result_t readRegistersImp(EuThread::ThreadId thread, uint32_t type, uint32_t start, uint32_t count, void *pRegisterValues);
     MOCKABLE_VIRTUAL ze_result_t writeRegistersImp(EuThread::ThreadId thread, uint32_t type, uint32_t start, uint32_t count, void *pRegisterValues);
     Error resumeThreadsWithinDevice(uint32_t deviceIndex, ze_device_thread_t physicalThread);
     MOCKABLE_VIRTUAL bool writeResumeCommand(const std::vector<EuThread::ThreadId> &threadIds);
@@ -120,7 +120,7 @@ struct DebugSessionImp : DebugSession {
     MOCKABLE_VIRTUAL ze_result_t waitForCmdReady(EuThread::ThreadId threadId, uint16_t retryCount);
 
     const SIP::regset_desc *typeToRegsetDesc(uint32_t type);
-    uint32_t getRegisterSize(uint32_t type) override;
+    uint32_t getRegisterSize(uint32_t type);
 
     size_t calculateThreadSlotOffset(EuThread::ThreadId threadId);
     size_t calculateRegisterOffsetInThreadSlot(const SIP::regset_desc *const regdesc, uint32_t start);

level_zero/tools/test/unit_tests/sources/debug/CMakeLists.txt

@@ -13,7 +13,6 @@ target_sources(${TARGET_NAME} PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/test_debug_api.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/debug_session_common.h
                ${CMAKE_CURRENT_SOURCE_DIR}/debug_session_common.cpp
-               ${CMAKE_CURRENT_SOURCE_DIR}/debug_session_registers_access.h
 )
 
 add_subdirectories()

level_zero/tools/test/unit_tests/sources/debug/debug_session_registers_access.h

@@ -1,61 +0,0 @@
-/*
- * Copyright (C) 2022-2023 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
-#include "level_zero/tools/test/unit_tests/sources/debug/mock_debug_session.h"
-
-#include "common/StateSaveAreaHeader.h"
-
-namespace L0 {
-namespace ult {
-
-struct DebugSessionRegistersAccess {
-    void setUp() {
-        zet_debug_config_t config = {};
-        config.pid = 0x1234;
-        auto hwInfo = *NEO::defaultHwInfo.get();
-
-        neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0);
-        deviceImp = std::make_unique<Mock<L0::DeviceImp>>(neoDevice, neoDevice->getExecutionEnvironment());
-
-        session = std::make_unique<MockDebugSession>(config, deviceImp.get());
-
-        session->allThreads[stoppedThreadId]->stopThread(1u);
-        session->allThreads[stoppedThreadId]->reportAsStopped();
-    }
-
-    void tearDown() {
-    }
-
-    void dumpRegisterState() {
-        if (session->stateSaveAreaHeader.size() == 0) {
-            return;
-        }
-        auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
-
-        for (uint32_t thread = 0; thread < pStateSaveAreaHeader->regHeader.num_threads_per_eu; thread++) {
-            EuThread::ThreadId threadId(0, 0, 0, 0, thread);
-            auto threadSlotOffset = session->calculateThreadSlotOffset(threadId);
-
-            auto srMagicOffset = threadSlotOffset + pStateSaveAreaHeader->regHeader.sr_magic_offset;
-            SIP::sr_ident srMagic;
-            srMagic.count = 1;
-            srMagic.version.major = pStateSaveAreaHeader->versionHeader.version.major;
-
-            session->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(pStateSaveAreaHeader) + srMagicOffset);
-        }
-    }
-
-    ze_device_thread_t stoppedThread = {0, 0, 0, 0};
-    EuThread::ThreadId stoppedThreadId{0, stoppedThread};
-    std::unique_ptr<MockDebugSession> session;
-    std::unique_ptr<Mock<L0::DeviceImp>> deviceImp;
-    NEO::MockDevice *neoDevice = nullptr;
-};
-
-} // namespace ult
-} // namespace L0

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

@@ -20,7 +20,7 @@
 #include "level_zero/core/test/unit_tests/mocks/mock_device.h"
 #include "level_zero/include/zet_intel_gpu_debug.h"
 #include "level_zero/tools/source/debug/debug_session_imp.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 "common/StateSaveAreaHeader.h"
 #include "encode_surface_state_args.h"
@@ -2228,6 +2228,50 @@ TEST_F(MultiTileDebugSessionTest, GivenMultitileDeviceWhenCallingAreRequestedThr
     EXPECT_TRUE(stopped);
 }
 
+struct DebugSessionRegistersAccess {
+    void setUp() {
+        zet_debug_config_t config = {};
+        config.pid = 0x1234;
+        auto hwInfo = *NEO::defaultHwInfo.get();
+
+        neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(&hwInfo, 0);
+        deviceImp = std::make_unique<Mock<L0::DeviceImp>>(neoDevice, neoDevice->getExecutionEnvironment());
+
+        session = std::make_unique<MockDebugSession>(config, deviceImp.get());
+
+        session->allThreads[stoppedThreadId]->stopThread(1u);
+        session->allThreads[stoppedThreadId]->reportAsStopped();
+    }
+
+    void tearDown() {
+    }
+
+    void dumpRegisterState() {
+        if (session->stateSaveAreaHeader.size() == 0) {
+            return;
+        }
+        auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
+
+        for (uint32_t thread = 0; thread < pStateSaveAreaHeader->regHeader.num_threads_per_eu; thread++) {
+            EuThread::ThreadId threadId(0, 0, 0, 0, thread);
+            auto threadSlotOffset = session->calculateThreadSlotOffset(threadId);
+
+            auto srMagicOffset = threadSlotOffset + pStateSaveAreaHeader->regHeader.sr_magic_offset;
+            SIP::sr_ident srMagic;
+            srMagic.count = 1;
+            srMagic.version.major = pStateSaveAreaHeader->versionHeader.version.major;
+
+            session->writeGpuMemory(0, reinterpret_cast<char *>(&srMagic), sizeof(srMagic), reinterpret_cast<uint64_t>(pStateSaveAreaHeader) + srMagicOffset);
+        }
+    }
+
+    ze_device_thread_t stoppedThread = {0, 0, 0, 0};
+    EuThread::ThreadId stoppedThreadId{0, stoppedThread};
+    std::unique_ptr<MockDebugSession> session;
+    std::unique_ptr<Mock<L0::DeviceImp>> deviceImp;
+    NEO::MockDevice *neoDevice = nullptr;
+};
+
 using DebugSessionRegistersAccessTest = Test<DebugSessionRegistersAccess>;
 
 TEST_F(DebugSessionRegistersAccessTest, givenTypeToRegsetDescCalledThenCorrectRegdescIsReturned) {
@@ -2275,72 +2319,6 @@ TEST_F(DebugSessionRegistersAccessTest, givenGetThreadRegisterSetPropertiesCalle
     EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, zetDebugGetThreadRegisterSetProperties(session->toHandle(), stoppedThread, &threadCount, nullptr));
 }
 
-TEST_F(DebugSessionRegistersAccessTest,
-       givenNonZeroCountAndNullRegsetPointerWhenGetThreadRegisterSetPropertiesCalledTheniInvalidNullPointerIsReturned) {
-    uint32_t threadCount = 10;
-    ze_device_thread_t thread = stoppedThread;
-    EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_POINTER,
-              zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, nullptr));
-}
-
-HWTEST2_F(DebugSessionRegistersAccessTest,
-          givenGetThreadRegisterSetPropertiesCalledWhenLargeGrfIsSetThen256GrfRegisterCountIsReported,
-          IsXeHpOrXeHpcOrXeHpgCore) {
-    auto mockBuiltins = new MockBuiltins();
-    mockBuiltins->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2, 256);
-    neoDevice->executionEnvironment->rootDeviceEnvironments[0]->builtins.reset(mockBuiltins);
-
-    {
-        auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
-        auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
-                    pStateSaveAreaHeader->regHeader.state_area_offset +
-                    pStateSaveAreaHeader->regHeader.state_save_size * 16;
-        session->stateSaveAreaHeader.resize(size);
-    }
-
-    ze_device_thread_t thread = stoppedThread;
-
-    auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.cr;
-    uint32_t cr0[8] = {0, 0, 0, 0, 0, 0, 0, 0};
-    cr0[0] = 0x80002000;
-    session->registersAccessHelper(session->allThreads[stoppedThreadId].get(), regdesc, 0, 1, cr0, true);
-
-    uint32_t threadCount = 0;
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, nullptr));
-    std::vector<zet_debug_regset_properties_t> threadRegsetProps(threadCount);
-    ASSERT_EQ(ZE_RESULT_SUCCESS, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, threadRegsetProps.data()));
-    EXPECT_EQ(256u, threadRegsetProps[0].count);
-}
-
-HWTEST2_F(DebugSessionRegistersAccessTest,
-          givenGetThreadRegisterSetPropertiesCalledWhenLargeGrfIsNotSetThen128GrfRegisterCountIsReported,
-          IsXeHpOrXeHpcOrXeHpgCore) {
-    auto mockBuiltins = new MockBuiltins();
-    mockBuiltins->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2, 256);
-    neoDevice->executionEnvironment->rootDeviceEnvironments[0]->builtins.reset(mockBuiltins);
-
-    {
-        auto pStateSaveAreaHeader = reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data());
-        auto size = pStateSaveAreaHeader->versionHeader.size * 8 +
-                    pStateSaveAreaHeader->regHeader.state_area_offset +
-                    pStateSaveAreaHeader->regHeader.state_save_size * 16;
-        session->stateSaveAreaHeader.resize(size);
-    }
-
-    ze_device_thread_t thread = stoppedThread;
-
-    auto *regdesc = &(reinterpret_cast<SIP::StateSaveAreaHeader *>(session->stateSaveAreaHeader.data()))->regHeader.cr;
-    uint32_t cr0[8] = {0, 0, 0, 0, 0, 0, 0, 0};
-    cr0[0] = 0x80000000;
-    session->registersAccessHelper(session->allThreads[stoppedThreadId].get(), regdesc, 0, 1, cr0, true);
-
-    uint32_t threadCount = 0;
-    EXPECT_EQ(ZE_RESULT_SUCCESS, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, nullptr));
-    std::vector<zet_debug_regset_properties_t> threadRegsetProps(threadCount);
-    ASSERT_EQ(ZE_RESULT_SUCCESS, zetDebugGetThreadRegisterSetProperties(session->toHandle(), thread, &threadCount, threadRegsetProps.data()));
-    EXPECT_EQ(128u, threadRegsetProps[0].count);
-}
-
 TEST_F(DebugSessionRegistersAccessTest, givenGetThreadRegisterSetPropertiesCalledPropertieAreTheSameAsgetRegisterSetProperties) {
 
     auto mockBuiltins = new MockBuiltins();

level_zero/tools/test/unit_tests/sources/debug/mock_debug_session.h

@@ -116,14 +116,6 @@ struct DebugSessionMock : public L0::DebugSession {
         return true;
     }
 
-    ze_result_t readRegistersImp(EuThread::ThreadId thread, uint32_t type, uint32_t start, uint32_t count, void *pRegisterValues) override {
-        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
-
-    uint32_t getRegisterSize(uint32_t type) override {
-        return 0;
-    }
-
     void detachTileDebugSession(DebugSession *tileSession) override {}
     bool areAllTileDebugSessionDetached() override { return true; }
 

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

@@ -334,6 +334,21 @@ TEST_F(DebugApiTest, givenSIPHeaderHasZeroSizeMMEThenNotExposedAsRegset) {
     }
 }
 
+TEST_F(DebugApiTest, givenSIPHeaderGRFCountNotEqualTo128ThenGetRegisterSetPropertiesReturns128) {
+    mockBuiltins = new MockBuiltins();
+    mockBuiltins->stateSaveAreaHeader = MockSipData::createStateSaveAreaHeader(2, 256);
+    neoDevice->executionEnvironment->rootDeviceEnvironments[0]->builtins.reset(mockBuiltins);
+    uint32_t count = 0;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zetDebugGetRegisterSetProperties(device->toHandle(), &count, nullptr));
+    EXPECT_EQ(13u, count);
+
+    std::vector<zet_debug_regset_properties_t> regsetProps(count);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zetDebugGetRegisterSetProperties(device->toHandle(), &count, regsetProps.data()));
+
+    EXPECT_EQ(13u, count);
+    EXPECT_EQ(128u, regsetProps[0].count);
+}
+
 TEST_F(DebugApiTest, givenGetRegisterSetPropertiesCalledCorrectPropertiesReturned) {
     uint32_t count = 0;
     EXPECT_EQ(ZE_RESULT_SUCCESS, zetDebugGetRegisterSetProperties(device->toHandle(), &count, nullptr));

shared/source/helpers/gfx_core_helper.h

@@ -96,7 +96,6 @@ class GfxCoreHelper {
     virtual uint8_t getBarriersCountFromHasBarriers(uint8_t hasBarriers) const = 0;
     virtual uint32_t calculateAvailableThreadCount(const HardwareInfo &hwInfo, uint32_t grfCount) const = 0;
     virtual uint32_t calculateMaxWorkGroupSize(const KernelDescriptor &kernelDescriptor, uint32_t defaultMaxGroupSize) const = 0;
-    virtual bool largeGrfModeSupported() const = 0;
     virtual uint32_t alignSlmSize(uint32_t slmSize) const = 0;
     virtual uint32_t computeSlmValues(const HardwareInfo &hwInfo, uint32_t slmSize) const = 0;
 
@@ -274,7 +273,6 @@ class GfxCoreHelperHw : public GfxCoreHelper {
     uint32_t calculateAvailableThreadCount(const HardwareInfo &hwInfo, uint32_t grfCount) const override;
 
     uint32_t calculateMaxWorkGroupSize(const KernelDescriptor &kernelDescriptor, uint32_t defaultMaxGroupSize) const override;
-    bool largeGrfModeSupported() const override;
 
     uint32_t alignSlmSize(uint32_t slmSize) const override;
 

shared/source/helpers/gfx_core_helper_base.inl

@@ -664,11 +664,6 @@ bool GfxCoreHelperHw<gfxProduct>::isChipsetUniqueUUIDSupported() const {
     return false;
 }
 
-template <typename gfxProduct>
-bool GfxCoreHelperHw<gfxProduct>::largeGrfModeSupported() const {
-    return false;
-}
-
 template <typename gfxProduct>
 bool GfxCoreHelperHw<gfxProduct>::isTimestampShiftRequired() const {
     return true;

shared/source/helpers/gfx_core_helper_xehp_and_later.inl

@@ -232,9 +232,4 @@ bool GfxCoreHelperHw<Family>::isChipsetUniqueUUIDSupported() const {
     return true;
 }
 
-template <>
-bool GfxCoreHelperHw<Family>::largeGrfModeSupported() const {
-    return true;
-}
-
 } // namespace NEO

shared/test/common/helpers/sip_init.cpp

@@ -33,7 +33,7 @@ std::vector<char> createStateSaveAreaHeader(uint32_t version) {
 }
 
 std::vector<char> createStateSaveAreaHeader(uint32_t version, uint16_t grfNum) {
-    return createStateSaveAreaHeader(version, grfNum, 1);
+    return createStateSaveAreaHeader(version, 128, 1);
 }
 
 std::vector<char> createStateSaveAreaHeader(uint32_t version, uint16_t grfNum, uint16_t mmeNum) {

shared/test/common/test_macros/header/common_matchers.h

@@ -44,7 +44,6 @@ using IsAtMostXeHpcCore = IsAtMostGfxCore<IGFX_XE_HPC_CORE>;
 using IsXeHpOrXeHpgCore = IsAnyGfxCores<IGFX_XE_HP_CORE, IGFX_XE_HPG_CORE>;
 using IsXeHpOrXeHpcCore = IsAnyGfxCores<IGFX_XE_HP_CORE, IGFX_XE_HPC_CORE>;
 using IsXeHpcOrXeHpgCore = IsAnyGfxCores<IGFX_XE_HPC_CORE, IGFX_XE_HPG_CORE>;
-using IsXeHpOrXeHpcOrXeHpgCore = IsAnyGfxCores<IGFX_XE_HP_CORE, IGFX_XE_HPC_CORE, IGFX_XE_HPG_CORE>;
 
 using IsNotXeHpOrXeHpgCore = IsNotAnyGfxCores<IGFX_XE_HP_CORE, IGFX_XE_HPG_CORE>;
 using IsNotXeHpOrXeHpcCore = IsNotAnyGfxCores<IGFX_XE_HP_CORE, IGFX_XE_HPC_CORE>;

shared/test/unit_test/gen12lp/dg1/gfx_core_helper_tests_dg1.cpp

@@ -19,11 +19,6 @@
 
 using GfxCoreHelperTestDg1 = GfxCoreHelperTest;
 
-DG1TEST_F(GfxCoreHelperTestDg1, givenDg1SteppingWhenLargeGrfModeSupportedIsQueriedThenFalseIsReturned) {
-    auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
-    EXPECT_FALSE(gfxCoreHelper.largeGrfModeSupported());
-}
-
 DG1TEST_F(GfxCoreHelperTestDg1, givenDg1SteppingA0WhenAdjustDefaultEngineTypeCalledThenRcsIsReturned) {
     auto &gfxCoreHelper = getHelper<GfxCoreHelper>();
     const auto &productHelper = getHelper<ProductHelper>();