From 175ceb9bd1b49a783a408c56c35f8398713ee21a Mon Sep 17 00:00:00 2001 From: Mayank Raghuwanshi Date: Mon, 24 Jul 2023 14:35:07 +0000 Subject: [PATCH] feature: Add support for media freq domain on linux Related-To: LOCI-4552 Signed-off-by: Mayank Raghuwanshi --- .../linux/sysman_os_frequency_imp_prelim.cpp | 14 ++++- level_zero/sysman/source/sysman_device_imp.h | 3 + .../linux/mock_sysfs_frequency_prelim.h | 11 ++++ .../linux/test_zes_frequency_prelim.cpp | 62 ++++++++++++++++++- .../linux/os_frequency_imp_prelim.cpp | 15 ++++- .../linux/mock_sysfs_frequency_prelim.h | 11 ++++ .../linux/test_zes_frequency_prelim.cpp | 58 ++++++++++++++++- shared/source/os_interface/product_helper.h | 1 + shared/source/os_interface/product_helper.inl | 8 +++ .../source/os_interface/product_helper_hw.h | 1 + shared/source/release_helper/release_helper.h | 2 + .../release_helper/release_helper_1270.cpp | 6 ++ .../release_helper/release_helper_1271.cpp | 6 ++ .../release_helper/release_helper_base.inl | 5 ++ .../os_interface/product_helper_tests.cpp | 11 ++++ .../mtl/excludes_xe_hpg_core_mtl.cpp | 1 + .../mtl/product_helper_tests_mtl.cpp | 19 ++++++ 17 files changed, 229 insertions(+), 5 deletions(-) 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 index 406615098b..428256e160 100644 --- 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 OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) { - std::vector freqDomains = {ZES_FREQ_DOMAIN_GPU}; + LinuxSysmanImp *pLinuxSysmanImp = static_cast(pOsSysman); + auto &productHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getHelper(); + auto releaseHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getReleaseHelper(); + std::vector 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 index 4d1a5debdb..8bb5716f36 100644 --- 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 index 23802c691a..41544b52b3 100644 --- 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 { + 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 index c5af9726ae..59cbd9827c 100644 --- 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 pSysfsAccess; L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr; + std::unique_ptr pProductHelper; + std::unique_ptr 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(); pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get(); + pProductHelper = std::make_unique(); + 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(0UL)); } +TEST_F(SysmanDeviceFrequencyFixture, GivenComponentCountZeroWhenEnumeratingFrequencyHandlesAndMediaFreqDomainIsPresentThenNonZeroCountIsReturnedAndCallSucceds) { + auto mockProductHelper = std::make_unique(); + mockProductHelper->isMediaFreqDomainPresent = true; + std::unique_ptr 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(); + mockProductHelper->isMediaFreqDomainPresent = true; + std::unique_ptr 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,6 +909,7 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture { L0::Sysman::SysmanDevice *device = nullptr; std::unique_ptr pSysfsAccess; L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr; + std::unique_ptr pProductHelper; void SetUp() override { SysmanMultiDeviceFixture::SetUp(); @@ -864,6 +917,9 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture { pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess; pSysfsAccess = std::make_unique(); pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get(); + pProductHelper = std::make_unique(); + 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 index 35c5ed11e9..b9f03ac361 100644 --- 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 OsFrequency::getNumberOfFreqDomainsSupported(OsSysman *pOsSysman) { - std::vector freqDomains = {ZES_FREQ_DOMAIN_GPU}; + LinuxSysmanImp *pLinuxSysmanImp = static_cast(pOsSysman); + auto pDevice = Device::fromHandle(pLinuxSysmanImp->getSysmanDeviceImp()->hCoreDevice); + auto &productHelper = pDevice->getNEODevice()->getProductHelper(); + auto releaseHelper = pDevice->getNEODevice()->getReleaseHelper(); + std::vector 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 index 1574c7e5be..45fc39a85b 100644 --- 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 { + 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 index 57bb22ad12..3e4c261ecb 100644 --- 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 deviceHandles; std::unique_ptr pSysfsAccess; SysfsAccess *pSysfsAccessOld = nullptr; + std::unique_ptr pProductHelper; uint32_t numClocks = 0; double step = 0; @@ -54,6 +55,9 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture { pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess; pSysfsAccess = std::make_unique(); pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get(); + pProductHelper = std::make_unique(); + auto &rootDeviceEnvironment = neoDevice->getRootDeviceEnvironmentRef(); + std::swap(rootDeviceEnvironment.productHelper, pProductHelper); pSysfsAccess->setVal(minFreqFile, minFreq); pSysfsAccess->setVal(maxFreqFile, maxFreq); @@ -78,7 +82,6 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture { deviceHandles.resize(subDeviceCount, nullptr); Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data()); } - getFreqHandles(0); } void TearDown() override { @@ -86,6 +89,8 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture { 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(); + mockProductHelper->isMediaFreqDomainPresent = true; + std::unique_ptr 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(); + mockProductHelper->isMediaFreqDomainPresent = true; + std::unique_ptr 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(0UL); @@ -855,6 +905,7 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture { std::unique_ptr pSysfsAccess; SysfsAccess *pSysfsAccessOld = nullptr; std::vector deviceHandles; + std::unique_ptr pProductHelper; void SetUp() override { if (!sysmanUltsEnable) { @@ -865,6 +916,9 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture { pSysfsAccessOld = pLinuxSysmanImp->pSysfsAccess; pSysfsAccess = std::make_unique(); pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get(); + pProductHelper = std::make_unique(); + 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 index 873e42fd4c..5283c0c951 100644 --- 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 index 1f99c59131..a5aa1bb72e 100644 --- a/shared/source/os_interface/product_helper.inl +++ b/shared/source/os_interface/product_helper.inl @@ -752,6 +752,14 @@ bool ProductHelperHw::isDummyBlitWaRequired() const { return false; } +template +bool ProductHelperHw::getMediaFrequencyTileIndex(const ReleaseHelper *releaseHelper, uint32_t &tileIndex) const { + if (releaseHelper) { + return releaseHelper->getMediaFrequencyTileIndex(tileIndex); + } + return false; +} + template bool ProductHelperHw::is48bResourceNeededForRayTracing() const { return true; diff --git a/shared/source/os_interface/product_helper_hw.h b/shared/source/os_interface/product_helper_hw.h index 67640b2e0e..a9dfe392d9 100644 --- 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 index 54a311b296..95fef174f9 100644 --- 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 index 7dfe132ac2..6a445289ea 100644 --- a/shared/source/release_helper/release_helper_1270.cpp +++ b/shared/source/release_helper/release_helper_1270.cpp @@ -28,6 +28,12 @@ int ReleaseHelperHw::getProductMaxPreferredSlmSize(int preferredEnumVal return std::min(preferredEnumValue, static_cast(PREFERRED_SLM_ALLOCATION_SIZE::PREFERRED_SLM_ALLOCATION_SIZE_96K)); } +template <> +bool ReleaseHelperHw::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 index 3f666f46f2..dd6c98f926 100644 --- a/shared/source/release_helper/release_helper_1271.cpp +++ b/shared/source/release_helper/release_helper_1271.cpp @@ -28,6 +28,12 @@ int ReleaseHelperHw::getProductMaxPreferredSlmSize(int preferredEnumVal return std::min(preferredEnumValue, static_cast(PREFERRED_SLM_ALLOCATION_SIZE::PREFERRED_SLM_ALLOCATION_SIZE_96K)); } +template <> +bool ReleaseHelperHw::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_base.inl b/shared/source/release_helper/release_helper_base.inl index af6c59fd47..e39db3ff8d 100644 --- a/shared/source/release_helper/release_helper_base.inl +++ b/shared/source/release_helper/release_helper_base.inl @@ -33,4 +33,9 @@ int ReleaseHelperHw::getProductMaxPreferredSlmSize(int preferredEnu return preferredEnumValue; } +template +bool ReleaseHelperHw::getMediaFrequencyTileIndex(uint32_t &tileIndex) const { + return false; +} + } // namespace NEO diff --git a/shared/test/unit_test/os_interface/product_helper_tests.cpp b/shared/test/unit_test/os_interface/product_helper_tests.cpp index 3b8d50349c..c104090453 100644 --- a/shared/test/unit_test/os_interface/product_helper_tests.cpp +++ b/shared/test/unit_test/os_interface/product_helper_tests.cpp @@ -637,6 +637,17 @@ HWTEST_F(ProductHelperTest, givenProductHelperWhenIsAdjustWalkOrderAvailableCall EXPECT_FALSE(productHelper->isAdjustWalkOrderAvailable(releaseHelper)); } +HWTEST_F(ProductHelperTest, givenProductHelperWhenGetMediaFrequencyTileIndexCallThenFalseReturn) { + uint32_t tileIndex = 0; + EXPECT_FALSE(productHelper->getMediaFrequencyTileIndex(releaseHelper, tileIndex)); +} + +HWTEST_F(ProductHelperTest, givenProductHelperAndReleaseHelperNullptrWhenCallingGetMediaFrequencyTileIndexThenReturnFalse) { + uint32_t tileIndex = 0; + ReleaseHelper *releaseHelper = nullptr; + EXPECT_FALSE(productHelper->getMediaFrequencyTileIndex(releaseHelper, tileIndex)); +} + HWTEST_F(ProductHelperTest, givenProductHelperWhenIsPrefetcherDisablingInDirectSubmissionRequiredThenTrueIsReturned) { EXPECT_TRUE(productHelper->isPrefetcherDisablingInDirectSubmissionRequired()); } 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 index 3a221b9beb..b9b9e06260 100644 --- 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 @@ -27,3 +27,4 @@ HWTEST_EXCLUDE_PRODUCT(ProductHelperCommonTest, givenPatIndexAndAllocationTypeWh HWTEST_EXCLUDE_PRODUCT(CompilerProductHelperFixture, GivenXeHpAndLaterThenBFloat16ConversionIsSupported_IsAtLeastXeHpCore, IGFX_METEORLAKE); HWTEST_EXCLUDE_PRODUCT(CompilerProductHelperFixture, GivenXeHpAndLaterThenMatrixMultiplyAccumulateIsSupported_IsAtLeastXeHpCore, IGFX_METEORLAKE); HWTEST_EXCLUDE_PRODUCT(CompilerProductHelperFixture, GivenXeFamilyThenSplitMatrixMultiplyAccumulateIsSupported_IsWithinXeGfxFamily, IGFX_METEORLAKE); +HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenGetMediaFrequencyTileIndexCallThenFalseReturn, IGFX_METEORLAKE); 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 index 70a3f48cc1..dcc5ab8509 100644 --- 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 @@ -274,6 +274,25 @@ MTLTEST_F(MtlProductHelper, givenMtlWhenCallIsAdjustWalkOrderAvailableThenReturn } } +MTLTEST_F(MtlProductHelper, givenMtlWhenCallIsGetMediaFrequencyTileIndexThenReturnProperValue) { + VariableBackup backupHwInfo(defaultHwInfo.get()); + unsigned int gmdReleases[] = {70, 71}; + defaultHwInfo->ipVersion.architecture = 12; + + for (auto gmdRelease : gmdReleases) { + defaultHwInfo->ipVersion.release = gmdRelease; + refreshReleaseHelper(defaultHwInfo.get()); + uint32_t tileIndex = 0; + EXPECT_TRUE(productHelper->getMediaFrequencyTileIndex(releaseHelper, tileIndex)); + } +} + +MTLTEST_F(MtlProductHelper, givenMtlAndReleaseHelperNullptrWhenCallingGetMediaFrequencyTileIndexThenReturnFalse) { + uint32_t tileIndex = 0; + ReleaseHelper *releaseHelper = nullptr; + EXPECT_FALSE(productHelper->getMediaFrequencyTileIndex(releaseHelper, tileIndex)); +} + MTLTEST_F(MtlProductHelper, givenMtlAndReleaseHelperNullptrWhengetIsMatrixMultiplyAccumulateSupportedThenReturnsFalse) { auto &compilerProductHelper = this->executionEnvironment->rootDeviceEnvironments[0]->getHelper(); ReleaseHelper *releaseHelper = nullptr;