Revert "fix: correct calculating max subslice space"

This reverts commit 67f2500c03.

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

shared/source/helpers/gfx_core_helper.cpp

@@ -94,7 +94,7 @@ uint32_t GfxCoreHelper::getHighestEnabledSlice(const HardwareInfo &hwInfo) {
     return highestEnabledSlice;
 }
 
-uint32_t GfxCoreHelper::getHighestEnabledSubSlice(const HardwareInfo &hwInfo) {
+uint32_t getHighestEnabledSubSlice(const HardwareInfo &hwInfo) {
     uint32_t numSubSlicesPerSlice = hwInfo.gtSystemInfo.MaxSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported;
     uint32_t highestEnabledSliceIdx = GfxCoreHelper::getHighestEnabledSlice(hwInfo) - 1;
     uint32_t highestSubSlice = (highestEnabledSliceIdx + 1) * numSubSlicesPerSlice;

shared/source/helpers/gfx_core_helper.h

@@ -76,7 +76,6 @@ class GfxCoreHelper {
     static bool cacheFlushAfterWalkerSupported(const HardwareInfo &hwInfo);
     static uint32_t getHighestEnabledSlice(const HardwareInfo &hwInfo);
     static uint32_t getHighestEnabledDualSubSlice(const HardwareInfo &hwInfo);
-    static uint32_t getHighestEnabledSubSlice(const HardwareInfo &hwInfo);
     virtual bool timestampPacketWriteSupported() const = 0;
     virtual bool isTimestampWaitSupportedForQueues() const = 0;
     virtual bool isUpdateTaskCountFromWaitSupported() const = 0;

shared/source/helpers/gfx_core_helper_xehp_and_later.inl

@@ -26,8 +26,9 @@ uint32_t GfxCoreHelperHw<GfxFamily>::getComputeUnitsUsedForScratch(const RootDev
         return static_cast<uint32_t>(debugManager.flags.OverrideNumComputeUnitsForScratch.get());
     }
 
+    auto &productHelper = rootDeviceEnvironment.getHelper<ProductHelper>();
     auto hwInfo = rootDeviceEnvironment.getHardwareInfo();
-    auto maxSubSlice = GfxCoreHelper::getHighestEnabledSubSlice(*hwInfo);
+    auto maxSubSlice = productHelper.computeMaxNeededSubSliceSpace(*hwInfo);
     // XeHP and later products return physical threads
     return maxSubSlice * hwInfo->gtSystemInfo.MaxEuPerSubSlice * (hwInfo->gtSystemInfo.ThreadCount / hwInfo->gtSystemInfo.EUCount);
 }

shared/source/os_interface/product_helper.h

@@ -134,6 +134,7 @@ class ProductHelper {
     virtual bool isDcFlushMitigated() const = 0;
     virtual bool overridePatAndUsageForDcFlushMitigation(AllocationType allocationType) const = 0;
     virtual bool overrideCacheableForDcFlushMitigation(AllocationType allocationType) const = 0;
+    virtual uint32_t computeMaxNeededSubSliceSpace(const HardwareInfo &hwInfo) const = 0;
     virtual bool getUuid(NEO::DriverModel *driverModel, const uint32_t subDeviceCount, const uint32_t deviceIndex, std::array<uint8_t, ProductHelper::uuidSize> &uuid) const = 0;
     virtual bool isFlushTaskAllowed() const = 0;
     virtual bool isSystolicModeConfigurable(const HardwareInfo &hwInfo) const = 0;

shared/source/os_interface/product_helper.inl

@@ -433,6 +433,11 @@ bool ProductHelperHw<gfxProduct>::overrideCacheableForDcFlushMitigation(Allocati
             allocationType == AllocationType::printfSurface);
 }
 
+template <PRODUCT_FAMILY gfxProduct>
+uint32_t ProductHelperHw<gfxProduct>::computeMaxNeededSubSliceSpace(const HardwareInfo &hwInfo) const {
+    return hwInfo.gtSystemInfo.MaxSubSlicesSupported;
+}
+
 template <PRODUCT_FAMILY gfxProduct>
 bool ProductHelperHw<gfxProduct>::getUuid(NEO::DriverModel *driverModel, const uint32_t subDeviceCount, const uint32_t deviceIndex, std::array<uint8_t, ProductHelper::uuidSize> &uuid) const {
     return false;

shared/source/os_interface/product_helper_hw.h

@@ -78,6 +78,7 @@ class ProductHelperHw : public ProductHelper {
     bool isDcFlushMitigated() const override;
     bool overridePatAndUsageForDcFlushMitigation(AllocationType allocationType) const override;
     bool overrideCacheableForDcFlushMitigation(AllocationType allocationType) const override;
+    uint32_t computeMaxNeededSubSliceSpace(const HardwareInfo &hwInfo) const override;
     bool getUuid(NEO::DriverModel *driverModel, uint32_t subDeviceCount, uint32_t deviceIndex, std::array<uint8_t, ProductHelper::uuidSize> &uuid) const override;
     bool isFlushTaskAllowed() const override;
     bool isSystolicModeConfigurable(const HardwareInfo &hwInfo) const override;

shared/source/xe_hpc_core/gfx_core_helper_xe_hpc_core.cpp

@@ -354,7 +354,7 @@ uint32_t GfxCoreHelperHw<Family>::getComputeUnitsUsedForScratch(const RootDevice
     auto hwInfo = rootDeviceEnvironment.getHardwareInfo();
     uint32_t threadEuRatio = helper.getThreadEuRatioForScratch(*hwInfo);
 
-    return getHighestEnabledSubSlice(*hwInfo) * hwInfo->gtSystemInfo.MaxEuPerSubSlice * threadEuRatio;
+    return hwInfo->gtSystemInfo.MaxSubSlicesSupported * hwInfo->gtSystemInfo.MaxEuPerSubSlice * threadEuRatio;
 }
 
 template <>

shared/source/xe_hpg_core/dg2/os_agnostic_product_helper_dg2.inl

@@ -162,6 +162,18 @@ bool ProductHelperHw<gfxProduct>::isTile64With3DSurfaceOnBCSSupported(const Hard
     return true;
 }
 
+template <>
+uint32_t ProductHelperHw<gfxProduct>::computeMaxNeededSubSliceSpace(const HardwareInfo &hwInfo) const {
+    const uint32_t highestEnabledSlice = NEO::GfxCoreHelper::getHighestEnabledSlice(hwInfo);
+
+    UNRECOVERABLE_IF(highestEnabledSlice == 0);
+    UNRECOVERABLE_IF(hwInfo.gtSystemInfo.MaxSlicesSupported == 0);
+    auto subSlicesPerSlice = hwInfo.gtSystemInfo.MaxSubSlicesSupported / hwInfo.gtSystemInfo.MaxSlicesSupported;
+    auto maxSubSlice = std::max(highestEnabledSlice * subSlicesPerSlice, hwInfo.gtSystemInfo.MaxSubSlicesSupported);
+
+    return maxSubSlice;
+}
+
 template <>
 bool ProductHelperHw<gfxProduct>::isCpuCopyNecessary(const void *ptr, MemoryManager *memoryManager) const {
     if (memoryManager) {

shared/test/common/mocks/mock_product_helper.cpp

@@ -291,6 +291,11 @@ bool ProductHelperHw<IGFX_UNKNOWN>::overrideCacheableForDcFlushMitigation(Alloca
     return false;
 }
 
+template <>
+uint32_t ProductHelperHw<IGFX_UNKNOWN>::computeMaxNeededSubSliceSpace(const HardwareInfo &hwInfo) const {
+    return hwInfo.gtSystemInfo.MaxSubSlicesSupported;
+}
+
 template <>
 bool ProductHelperHw<IGFX_UNKNOWN>::getUuid(NEO::DriverModel *driverModel, const uint32_t subDeviceCount, const uint32_t deviceIndex, std::array<uint8_t, ProductHelper::uuidSize> &uuid) const {
     return false;

shared/test/unit_test/device/neo_device_tests.cpp

@@ -1106,7 +1106,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, DeviceTest, givenHwInfoWhenRequestedComputeUnitsUse
     const uint32_t multiplyFactor = productHelper.getThreadEuRatioForScratch(hwInfo) / 8u;
     const uint32_t numThreadsPerEu = (hwInfo.gtSystemInfo.ThreadCount / hwInfo.gtSystemInfo.EUCount) * multiplyFactor;
 
-    uint32_t expectedValue = GfxCoreHelper::getHighestEnabledSubSlice(hwInfo) * hwInfo.gtSystemInfo.MaxEuPerSubSlice * numThreadsPerEu;
+    uint32_t expectedValue = productHelper.computeMaxNeededSubSliceSpace(hwInfo) * hwInfo.gtSystemInfo.MaxEuPerSubSlice * numThreadsPerEu;
 
     EXPECT_EQ(expectedValue, gfxCoreHelper.getComputeUnitsUsedForScratch(pDevice->getRootDeviceEnvironment()));
     EXPECT_EQ(expectedValue, pDevice->getDeviceInfo().computeUnitsUsedForScratch);

shared/test/unit_test/os_interface/product_helper_tests.cpp

@@ -992,6 +992,26 @@ HWTEST2_F(ProductHelperTest, givenProductHelperWhenItsXe2PlusThenCacheLineSizeIs
     EXPECT_EQ(productHelper->getCacheLineSize(), 256u);
 }
 
+TEST_F(ProductHelperTest, whenGettingMaxSubSliceSpaceThenValueIsNotSmallerThanMaxSubSliceCount) {
+    constexpr auto maxSupportedSubSlices = 128u;
+    auto hwInfo = *defaultHwInfo;
+    auto &gtSystemInfo = hwInfo.gtSystemInfo;
+    gtSystemInfo.SliceCount = 1;
+    gtSystemInfo.SubSliceCount = 2;
+    gtSystemInfo.DualSubSliceCount = 2;
+
+    gtSystemInfo.MaxSlicesSupported = 2;
+    gtSystemInfo.MaxSlicesSupported = 2;
+    gtSystemInfo.MaxSubSlicesSupported = maxSupportedSubSlices;
+    gtSystemInfo.MaxDualSubSlicesSupported = maxSupportedSubSlices;
+
+    gtSystemInfo.IsDynamicallyPopulated = true;
+    for (uint32_t slice = 0; slice < GT_MAX_SLICE; slice++) {
+        gtSystemInfo.SliceInfo[slice].Enabled = slice < gtSystemInfo.SliceCount;
+    }
+    EXPECT_EQ(maxSupportedSubSlices, productHelper->computeMaxNeededSubSliceSpace(hwInfo));
+}
+
 HWTEST_F(ProductHelperTest, givenDefaultProductHelperWhenQuery2DBlockLoadThenReturnFalse) {
 
     EXPECT_FALSE(productHelper->supports2DBlockLoad());

shared/test/unit_test/xe_hpc_core/pvc/gfx_core_helper_tests_pvc.cpp

@@ -78,9 +78,7 @@ PVCTEST_F(GfxCoreHelperTestsPvc, givenRevisionIdWhenGetComputeUnitsUsedForScratc
     auto &hwInfo = *pDevice->getRootDeviceEnvironment().getMutableHardwareInfo();
     hwInfo.gtSystemInfo.EUCount *= 2;
 
-    auto highestEnabledSubSlice = GfxCoreHelper::getHighestEnabledSubSlice(hwInfo);
+    uint32_t expectedValue = hwInfo.gtSystemInfo.MaxSubSlicesSupported * hwInfo.gtSystemInfo.MaxEuPerSubSlice;
-
-    uint32_t expectedValue = highestEnabledSubSlice * hwInfo.gtSystemInfo.MaxEuPerSubSlice;
 
     struct {
         unsigned short revId;

shared/test/unit_test/xe_hpg_core/dg2/product_config_helper_tests_dg2.cpp

@@ -695,6 +695,17 @@ DG2TEST_F(ProductHelperTestDg2, givenEnabledSliceInNonStandardConfigWhenComputeU
     EXPECT_EQ(expectedCalculation, gfxCoreHelper.getComputeUnitsUsedForScratch(*executionEnvironment->rootDeviceEnvironments[0]));
 }
 
+DG2TEST_F(ProductHelperTestDg2, givenNotEnabledSliceWhenComputeUnitsUsedForScratchThenThrowUnrecoverableIf) {
+    HardwareInfo &hwInfo = *executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo();
+    GT_SYSTEM_INFO &testSysInfo = hwInfo.gtSystemInfo;
+    testSysInfo.IsDynamicallyPopulated = false;
+    testSysInfo.MaxSlicesSupported = 0;
+
+    auto &gfxCoreHelper = executionEnvironment->rootDeviceEnvironments[0]->getHelper<GfxCoreHelper>();
+
+    EXPECT_THROW(gfxCoreHelper.getComputeUnitsUsedForScratch(*executionEnvironment->rootDeviceEnvironments[0]), std::exception);
+}
+
 DG2TEST_F(ProductHelperTestDg2, givenDG2WhenCheckingIsTimestampWaitSupportedForEventsThenReturnTrue) {
 
     EXPECT_TRUE(productHelper->isTimestampWaitSupportedForEvents());