feature: Add support for media freq domain on linux

mraghuwa · Compute-Runtime-Automation · commit 175ceb9bd1b4 · 2023-07-25T08:12:33.000+02:00
Related-To: LOCI-4552

Signed-off-by: Mayank Raghuwanshi &lt;mayank.raghuwanshi@intel.com&gt;
diff --git a/level_zero/sysman/source/frequency/linux/sysman_os_frequency_imp_prelim.cpp b/level_zero/sysman/source/frequency/linux/sysman_os_frequency_imp_prelim.cpp
@@ -422,7 +422,19 @@ OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uin
 }
 
 std::vector<zes_freq_domain_t> OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) {
-    std::vector<zes_freq_domain_t> freqDomains = {ZES_FREQ_DOMAIN_GPU};
+    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+    auto &productHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getHelper<NEO::ProductHelper>();
+    auto releaseHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getReleaseHelper();
+    std::vector<zes_freq_domain_t> freqDomains = {};
+    uint32_t mediaFreqTileIndex;
+    if (productHelper.getMediaFrequencyTileIndex(releaseHelper, mediaFreqTileIndex) == true) {
+        auto pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
+        const std::string baseDir = "gt/gt" + std::to_string(mediaFreqTileIndex) + "/";
+        if (pSysfsAccess->directoryExists(baseDir)) {
+            freqDomains.push_back(ZES_FREQ_DOMAIN_MEDIA);
+        }
+    }
+    freqDomains.push_back(ZES_FREQ_DOMAIN_GPU);
     return freqDomains;
 }
 
diff --git a/level_zero/sysman/source/sysman_device_imp.h b/level_zero/sysman/source/sysman_device_imp.h
@@ -32,6 +32,9 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
     const NEO::RootDeviceEnvironment &getRootDeviceEnvironment() const {
         return *executionEnvironment->rootDeviceEnvironments[rootDeviceIndex];
     }
+    NEO::RootDeviceEnvironment &getRootDeviceEnvironmentRef() const {
+        return *executionEnvironment->rootDeviceEnvironments[rootDeviceIndex];
+    }
     const NEO::HardwareInfo &getHardwareInfo() const override { return *getRootDeviceEnvironment().getHardwareInfo(); }
     PRODUCT_FAMILY getProductFamily() const { return getHardwareInfo().platform.eProductFamily; }
     NEO::ExecutionEnvironment *getExecutionEnvironment() const { return executionEnvironment; }
diff --git a/level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_prelim.h b/level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_prelim.h
@@ -7,6 +7,8 @@
 
 #pragma once
 
+#include "shared/source/os_interface/product_helper_hw.h"
+#include "shared/source/release_helper/release_helper.h"
 #include "shared/test/common/test_macros/mock_method_macros.h"
 
 #include "level_zero/sysman/source/frequency/linux/sysman_os_frequency_imp_prelim.h"
@@ -346,6 +348,15 @@ struct MockFrequencySysfsAccess : public L0::Sysman::SysfsAccess {
     ~MockFrequencySysfsAccess() override = default;
 };
 
+struct MockProductHelperFreq : NEO::ProductHelperHw<IGFX_UNKNOWN> {
+    MockProductHelperFreq() = default;
+    bool isMediaFreqDomainPresent = false;
+    bool getMediaFrequencyTileIndex(const NEO::ReleaseHelper *releaseHelper, uint32_t &tileIndex) const override {
+        tileIndex = 1;
+        return isMediaFreqDomainPresent;
+    }
+};
+
 class PublicLinuxFrequencyImp : public L0::Sysman::LinuxFrequencyImp {
   public:
     PublicLinuxFrequencyImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : L0::Sysman::LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {}
diff --git a/level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency_prelim.cpp b/level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency_prelim.cpp
@@ -31,6 +31,8 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
     L0::Sysman::SysmanDevice *device = nullptr;
     std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
     L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
+    std::unique_ptr<ProductHelper> pProductHelper;
+    std::unique_ptr<ProductHelper> pProductHelperOld;
     uint32_t numClocks = 0;
     double step = 0;
     PRODUCT_FAMILY productFamily{};
@@ -41,6 +43,9 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
         pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
         pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
         pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
+        pProductHelper = std::make_unique<MockProductHelperFreq>();
+        auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
+        std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
         productFamily = pLinuxSysmanImp->getProductFamily();
         if (productFamily >= IGFX_XE_HP_SDV) {
             step = 50.0;
@@ -62,11 +67,12 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
             delete handle;
         }
         pSysmanDeviceImp->pFrequencyHandleContext->handleList.clear();
-        getFreqHandles(0);
     }
 
     void TearDown() override {
         pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
+        auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
+        std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
         SysmanDeviceFixture::TearDown();
     }
 
@@ -153,6 +159,51 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroAndValidPtrWhenEnume
     EXPECT_EQ(handle, static_cast<zes_freq_handle_t>(0UL));
 }
 
+TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaFreqDomainIsPresentThenNonZeroCountIsReturnedAndCallSucceds) {
+    auto mockProductHelper = std::make_unique<MockProductHelperFreq>();
+    mockProductHelper->isMediaFreqDomainPresent = true;
+    std::unique_ptr<ProductHelper> productHelper = std::move(mockProductHelper);
+    auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
+    std::swap(rootDeviceEnvironment.productHelper, productHelper);
+    uint32_t count = 0U;
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
+    EXPECT_EQ(count, 2U);
+
+    uint32_t testCount = count + 1;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
+    EXPECT_EQ(count, testCount);
+
+    auto handles = getFreqHandles(count);
+    for (auto handle : handles) {
+        EXPECT_NE(handle, nullptr);
+    }
+    std::swap(rootDeviceEnvironment.productHelper, productHelper);
+}
+
+TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaDomainIsAbsentThenNonZeroCountIsReturnedAndCallSucceds) {
+    pSysfsAccess->directoryExistsResult = false;
+    auto mockProductHelper = std::make_unique<MockProductHelperFreq>();
+    mockProductHelper->isMediaFreqDomainPresent = true;
+    std::unique_ptr<ProductHelper> productHelper = std::move(mockProductHelper);
+    auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
+    std::swap(rootDeviceEnvironment.productHelper, productHelper);
+    uint32_t count = 0U;
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
+    EXPECT_EQ(count, 1U);
+
+    uint32_t testCount = count + 1;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
+    EXPECT_EQ(count, testCount);
+
+    auto handles = getFreqHandles(count);
+    for (auto handle : handles) {
+        EXPECT_NE(handle, nullptr);
+    }
+    std::swap(rootDeviceEnvironment.productHelper, productHelper);
+}
+
 TEST_F(SysmanDeviceFrequencyFixture, GivenActualComponentCountTwoWhenTryingToGetOneComponentOnlyThenOneComponentIsReturnedAndCountUpdated) {
     auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
     ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
@@ -174,7 +225,8 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenValidFrequencyHandleWhenCallingzesFreq
         zes_freq_properties_t properties;
         EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(handle, &properties));
         EXPECT_EQ(nullptr, properties.pNext);
-        EXPECT_EQ(ZES_FREQ_DOMAIN_GPU, properties.type);
+        EXPECT_GE(properties.type, ZES_FREQ_DOMAIN_GPU);
+        EXPECT_LE(properties.type, ZES_FREQ_DOMAIN_MEDIA);
         EXPECT_FALSE(properties.onSubdevice);
         EXPECT_DOUBLE_EQ(maxFreq, properties.max);
         EXPECT_DOUBLE_EQ(minFreq, properties.min);
@@ -857,13 +909,17 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
     L0::Sysman::SysmanDevice *device = nullptr;
     std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
     L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
+    std::unique_ptr<ProductHelper> pProductHelper;
 
     void SetUp() override {
         SysmanMultiDeviceFixture::SetUp();
         device = pSysmanDevice;
         pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
         pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
         pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
+        pProductHelper = std::make_unique<MockProductHelperFreq>();
+        auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
+        std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
         // delete handles created in initial SysmanDeviceHandleContext::init() call
         for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
             delete handle;
@@ -874,6 +930,8 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
 
     void TearDown() override {
         pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
+        auto &rootDeviceEnvironment = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironmentRef();
+        std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
         SysmanMultiDeviceFixture::TearDown();
     }
 
diff --git a/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp_prelim.cpp b/level_zero/tools/source/sysman/frequency/linux/os_frequency_imp_prelim.cpp
@@ -427,7 +427,20 @@ OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uin
 }
 
 std::vector<zes_freq_domain_t> OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) {
-    std::vector<zes_freq_domain_t> freqDomains = {ZES_FREQ_DOMAIN_GPU};
+    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+    auto pDevice = Device::fromHandle(pLinuxSysmanImp->getSysmanDeviceImp()->hCoreDevice);
+    auto &productHelper = pDevice->getNEODevice()->getProductHelper();
+    auto releaseHelper = pDevice->getNEODevice()->getReleaseHelper();
+    std::vector<zes_freq_domain_t> freqDomains = {};
+    uint32_t mediaFreqTileIndex;
+    if (productHelper.getMediaFrequencyTileIndex(releaseHelper, mediaFreqTileIndex) == true) {
+        auto pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
+        const std::string baseDir = "gt/gt" + std::to_string(mediaFreqTileIndex) + "/";
+        if (pSysfsAccess->directoryExists(baseDir)) {
+            freqDomains.push_back(ZES_FREQ_DOMAIN_MEDIA);
+        }
+    }
+    freqDomains.push_back(ZES_FREQ_DOMAIN_GPU);
     return freqDomains;
 }
 
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency_prelim.h b/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/mock_sysfs_frequency_prelim.h
@@ -6,6 +6,8 @@
  */
 
 #pragma once
+#include "shared/source/os_interface/product_helper_hw.h"
+#include "shared/source/release_helper/release_helper.h"
 #include "shared/test/common/test_macros/mock_method_macros.h"
 
 #include "level_zero/tools/source/sysman/frequency/linux/os_frequency_imp_prelim.h"
@@ -341,6 +343,15 @@ struct MockFrequencySysfsAccess : public SysfsAccess {
     ~MockFrequencySysfsAccess() override = default;
 };
 
+struct MockProductHelperFreq : NEO::ProductHelperHw<IGFX_UNKNOWN> {
+    MockProductHelperFreq() = default;
+    bool isMediaFreqDomainPresent = false;
+    bool getMediaFrequencyTileIndex(const NEO::ReleaseHelper *releaseHelper, uint32_t &tileIndex) const override {
+        tileIndex = 1;
+        return isMediaFreqDomainPresent;
+    }
+};
+
 class PublicLinuxFrequencyImp : public L0::LinuxFrequencyImp {
   public:
     PublicLinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type) : LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, type) {}
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_zes_frequency_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/frequency/linux/test_zes_frequency_prelim.cpp
@@ -36,6 +36,7 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
     std::vector<ze_device_handle_t> deviceHandles;
     std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
     SysfsAccess *pSysfsAccessOld = nullptr;
+    std::unique_ptr<ProductHelper> pProductHelper;
     uint32_t numClocks = 0;
     double step = 0;
 
@@ -54,6 +55,9 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
         pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
         pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
         pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
+        pProductHelper = std::make_unique<MockProductHelperFreq>();
+        auto &rootDeviceEnvironment = neoDevice->getRootDeviceEnvironmentRef();
+        std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
 
         pSysfsAccess->setVal(minFreqFile, minFreq);
         pSysfsAccess->setVal(maxFreqFile, maxFreq);
@@ -78,14 +82,15 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
             deviceHandles.resize(subDeviceCount, nullptr);
             Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
         }
-        getFreqHandles(0);
     }
 
     void TearDown() override {
         if (!sysmanUltsEnable) {
             GTEST_SKIP();
         }
         pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
+        auto &rootDeviceEnvironment = neoDevice->getRootDeviceEnvironmentRef();
+        std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
         SysmanDeviceFixture::TearDown();
     }
 
@@ -163,6 +168,51 @@ TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequ
     }
 }
 
+TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaFreqDomainIsPresentThenNonZeroCountIsReturnedAndCallSucceds) {
+    auto mockProductHelper = std::make_unique<MockProductHelperFreq>();
+    mockProductHelper->isMediaFreqDomainPresent = true;
+    std::unique_ptr<ProductHelper> productHelper = std::move(mockProductHelper);
+    auto &rootDeviceEnvironment = neoDevice->getRootDeviceEnvironmentRef();
+    std::swap(rootDeviceEnvironment.productHelper, productHelper);
+    uint32_t count = 0U;
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
+    EXPECT_EQ(count, 2U);
+
+    uint32_t testCount = count + 1;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
+    EXPECT_EQ(count, testCount);
+
+    auto handles = getFreqHandles(count);
+    for (auto handle : handles) {
+        EXPECT_NE(handle, nullptr);
+    }
+    std::swap(rootDeviceEnvironment.productHelper, productHelper);
+}
+
+TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaDomainIsAbsentThenNonZeroCountIsReturnedAndCallSucceds) {
+    pSysfsAccess->directoryExistsResult = false;
+    auto mockProductHelper = std::make_unique<MockProductHelperFreq>();
+    mockProductHelper->isMediaFreqDomainPresent = true;
+    std::unique_ptr<ProductHelper> productHelper = std::move(mockProductHelper);
+    auto &rootDeviceEnvironment = neoDevice->getRootDeviceEnvironmentRef();
+    std::swap(rootDeviceEnvironment.productHelper, productHelper);
+    uint32_t count = 0U;
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &count, nullptr));
+    EXPECT_EQ(count, 1U);
+
+    uint32_t testCount = count + 1;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(device->toHandle(), &testCount, nullptr));
+    EXPECT_EQ(count, testCount);
+
+    auto handles = getFreqHandles(count);
+    for (auto handle : handles) {
+        EXPECT_NE(handle, nullptr);
+    }
+    std::swap(rootDeviceEnvironment.productHelper, productHelper);
+}
+
 TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroAndValidPtrWhenEnumeratingFrequencyHandlesThenNonZeroCountAndNoHandlesAreReturnedAndCallSucceds) {
     uint32_t count = 0U;
     zes_freq_handle_t handle = static_cast<zes_freq_handle_t>(0UL);
@@ -855,6 +905,7 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
     std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
     SysfsAccess *pSysfsAccessOld = nullptr;
     std::vector<ze_device_handle_t> deviceHandles;
+    std::unique_ptr<ProductHelper> pProductHelper;
 
     void SetUp() override {
         if (!sysmanUltsEnable) {
@@ -865,6 +916,9 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
         pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess;
         pSysfsAccess = std::make_unique<MockFrequencySysfsAccess>();
         pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
+        pProductHelper = std::make_unique<MockProductHelperFreq>();
+        auto &rootDeviceEnvironment = neoDevice->getRootDeviceEnvironmentRef();
+        std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
         // delete handles created in initial SysmanDeviceHandleContext::init() call
         for (auto handle : pSysmanDeviceImp->pFrequencyHandleContext->handleList) {
             delete handle;
@@ -887,6 +941,8 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
             GTEST_SKIP();
         }
         pLinuxSysmanImp->pSysfsAccess = pSysfsAccessOld;
+        auto &rootDeviceEnvironment = neoDevice->getRootDeviceEnvironmentRef();
+        std::swap(rootDeviceEnvironment.productHelper, pProductHelper);
         SysmanMultiDeviceFixture::TearDown();
     }
 
diff --git a/shared/source/os_interface/product_helper.h b/shared/source/os_interface/product_helper.h
@@ -208,6 +208,7 @@ class ProductHelper {
     virtual bool disableL3CacheForDebug(const HardwareInfo &hwInfo) const = 0;
     virtual bool isCachingOnCpuAvailable() const = 0;
     virtual bool isSkippingStatefulInformationRequired(const KernelDescriptor &kernelDescriptor) const = 0;
+    virtual bool getMediaFrequencyTileIndex(const ReleaseHelper *releaseHelper, uint32_t &tileIndex) const = 0;
 
     virtual ~ProductHelper() = default;
 
diff --git a/shared/source/os_interface/product_helper.inl b/shared/source/os_interface/product_helper.inl
@@ -752,6 +752,14 @@ bool ProductHelperHw<gfxProduct>::isDummyBlitWaRequired() const {
     return false;
 }
 
+template <PRODUCT_FAMILY gfxProduct>
+bool ProductHelperHw<gfxProduct>::getMediaFrequencyTileIndex(const ReleaseHelper *releaseHelper, uint32_t &tileIndex) const {
+    if (releaseHelper) {
+        return releaseHelper->getMediaFrequencyTileIndex(tileIndex);
+    }
+    return false;
+}
+
 template <PRODUCT_FAMILY gfxProduct>
 bool ProductHelperHw<gfxProduct>::is48bResourceNeededForRayTracing() const {
     return true;
diff --git a/shared/source/os_interface/product_helper_hw.h b/shared/source/os_interface/product_helper_hw.h
@@ -160,6 +160,7 @@ class ProductHelperHw : public ProductHelper {
     bool disableL3CacheForDebug(const HardwareInfo &hwInfo) const override;
     bool isCachingOnCpuAvailable() const override;
     bool isSkippingStatefulInformationRequired(const KernelDescriptor &kernelDescriptor) const override;
+    bool getMediaFrequencyTileIndex(const ReleaseHelper *releaseHelper, uint32_t &tileIndex) const override;
 
     ~ProductHelperHw() override = default;
 
diff --git a/shared/source/release_helper/release_helper.h b/shared/source/release_helper/release_helper.h
@@ -29,6 +29,7 @@ class ReleaseHelper {
     virtual bool isPipeControlPriorToNonPipelinedStateCommandsWARequired() const = 0;
     virtual bool isPrefetchDisablingRequired() const = 0;
     virtual int getProductMaxPreferredSlmSize(int preferredEnumValue) const = 0;
+    virtual bool getMediaFrequencyTileIndex(uint32_t &tileIndex) const = 0;
 
   protected:
     ReleaseHelper(HardwareIpVersion hardwareIpVersion) : hardwareIpVersion(hardwareIpVersion) {}
@@ -47,6 +48,7 @@ class ReleaseHelperHw : public ReleaseHelper {
     bool isPipeControlPriorToNonPipelinedStateCommandsWARequired() const override;
     bool isPrefetchDisablingRequired() const override;
     int getProductMaxPreferredSlmSize(int preferredEnumValue) const override;
+    bool getMediaFrequencyTileIndex(uint32_t &tileIndex) const override;
 
   private:
     ReleaseHelperHw(HardwareIpVersion hardwareIpVersion) : ReleaseHelper(hardwareIpVersion) {}
diff --git a/shared/source/release_helper/release_helper_1270.cpp b/shared/source/release_helper/release_helper_1270.cpp
@@ -28,6 +28,12 @@ int ReleaseHelperHw<release>::getProductMaxPreferredSlmSize(int preferredEnumVal
     return std::min(preferredEnumValue, static_cast<int>(PREFERRED_SLM_ALLOCATION_SIZE::PREFERRED_SLM_ALLOCATION_SIZE_96K));
 }
 
+template <>
+bool ReleaseHelperHw<release>::getMediaFrequencyTileIndex(uint32_t &tileIndex) const {
+    tileIndex = 1;
+    return true;
+}
+
 } // namespace NEO
 #include "shared/source/release_helper/release_helper_common_xe_lpg.inl"
 
diff --git a/shared/source/release_helper/release_helper_1271.cpp b/shared/source/release_helper/release_helper_1271.cpp
diff --git a/shared/source/release_helper/release_helper_base.inl b/shared/source/release_helper/release_helper_base.inl
diff --git a/shared/test/unit_test/os_interface/product_helper_tests.cpp b/shared/test/unit_test/os_interface/product_helper_tests.cpp
diff --git a/shared/test/unit_test/xe_hpg_core/mtl/excludes_xe_hpg_core_mtl.cpp b/shared/test/unit_test/xe_hpg_core/mtl/excludes_xe_hpg_core_mtl.cpp
diff --git a/shared/test/unit_test/xe_hpg_core/mtl/product_helper_tests_mtl.cpp b/shared/test/unit_test/xe_hpg_core/mtl/product_helper_tests_mtl.cpp
