fix: non-coherency issue on arl

kcencele · Compute-Runtime-Automation · commit eec01e500a00 · 2024-01-26T10:26:33.000+01:00
Resolves: HSD-15015200338
Signed-off-by: Katarzyna Cencelewska &lt;katarzyna.cencelewska@intel.com&gt;
diff --git a/shared/source/gmm_helper/cache_settings_helper.cpp b/shared/source/gmm_helper/cache_settings_helper.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -39,8 +39,8 @@ bool CacheSettingsHelper::preferNoCpuAccess(GMM_RESOURCE_USAGE_TYPE_ENUM gmmReso
     if (rootDeviceEnvironment.isWddmOnLinux()) {
         return false;
     }
-    auto releaseHelper = rootDeviceEnvironment.getReleaseHelper();
-    if (!releaseHelper || releaseHelper->isCachingOnCpuAvailable()) {
+    auto &productHelper = rootDeviceEnvironment.getProductHelper();
+    if (productHelper.isCachingOnCpuAvailable()) {
         return false;
     }
     return (gmmResourceUsageType != GMM_RESOURCE_USAGE_OCL_SYSTEM_MEMORY_BUFFER);
diff --git a/shared/source/os_interface/product_helper.h b/shared/source/os_interface/product_helper.h
@@ -43,6 +43,8 @@ class OSInterface;
 class DriverModel;
 enum class DriverModelType;
 enum class EngineGroupType : uint32_t;
+enum class GfxMemoryAllocationMethod : uint32_t;
+enum class AllocationType;
 
 using ProductHelperCreateFunctionType = std::unique_ptr<ProductHelper> (*)();
 extern ProductHelperCreateFunctionType productHelperFactory[IGFX_MAX_PRODUCT];
@@ -215,6 +217,8 @@ class ProductHelper {
     virtual std::vector<uint32_t> getSupportedNumGrfs(const ReleaseHelper *releaseHelper) const = 0;
     virtual aub_stream::EngineType getDefaultCopyEngine() const = 0;
     virtual void adjustEngineGroupType(EngineGroupType &engineGroupType) const = 0;
+    virtual std::optional<GfxMemoryAllocationMethod> getPreferredAllocationMethod(AllocationType allocationType) const = 0;
+    virtual bool isCachingOnCpuAvailable() const = 0;
 
     virtual ~ProductHelper() = default;
 
diff --git a/shared/source/os_interface/product_helper.inl b/shared/source/os_interface/product_helper.inl
@@ -839,4 +839,14 @@ aub_stream::EngineType ProductHelperHw<gfxProduct>::getDefaultCopyEngine() const
 template <PRODUCT_FAMILY gfxProduct>
 void ProductHelperHw<gfxProduct>::adjustEngineGroupType(EngineGroupType &engineGroupType) const {}
 
+template <PRODUCT_FAMILY gfxProduct>
+std::optional<GfxMemoryAllocationMethod> ProductHelperHw<gfxProduct>::getPreferredAllocationMethod(AllocationType allocationType) const {
+    return {};
+}
+
+template <PRODUCT_FAMILY gfxProduct>
+bool ProductHelperHw<gfxProduct>::isCachingOnCpuAvailable() const {
+    return true;
+}
+
 } // namespace NEO
diff --git a/shared/source/os_interface/product_helper_hw.h b/shared/source/os_interface/product_helper_hw.h
@@ -164,6 +164,8 @@ class ProductHelperHw : public ProductHelper {
     std::vector<uint32_t> getSupportedNumGrfs(const ReleaseHelper *releaseHelper) const override;
     aub_stream::EngineType getDefaultCopyEngine() const override;
     void adjustEngineGroupType(EngineGroupType &engineGroupType) const override;
+    std::optional<GfxMemoryAllocationMethod> getPreferredAllocationMethod(AllocationType allocationType) const override;
+    bool isCachingOnCpuAvailable() const override;
 
     ~ProductHelperHw() override = default;
 
diff --git a/shared/source/os_interface/windows/wddm_memory_manager.cpp b/shared/source/os_interface/windows/wddm_memory_manager.cpp
@@ -79,8 +79,8 @@ GfxMemoryAllocationMethod WddmMemoryManager::getPreferredAllocationMethod(const
     }
     auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[allocationProperties.rootDeviceIndex].get();
     UNRECOVERABLE_IF(!rootDeviceEnvironment);
-    auto releaseHelper = rootDeviceEnvironment->releaseHelper.get();
-    auto preference = releaseHelper ? releaseHelper->getPreferredAllocationMethod(allocationProperties.allocationType) : std::nullopt;
+    auto &productHelper = rootDeviceEnvironment->getHelper<ProductHelper>();
+    auto preference = productHelper.getPreferredAllocationMethod(allocationProperties.allocationType);
     if (preference) {
         return *preference;
     }
diff --git a/shared/source/release_helper/release_helper.h b/shared/source/release_helper/release_helper.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -18,8 +18,6 @@ namespace NEO {
 
 class ReleaseHelper;
 enum class ReleaseType;
-enum class GfxMemoryAllocationMethod : uint32_t;
-enum class AllocationType;
 
 inline constexpr uint32_t maxArchitecture = 64;
 using createReleaseHelperFunctionType = std::unique_ptr<ReleaseHelper> (*)(HardwareIpVersion hardwareIpVersion);
@@ -45,11 +43,9 @@ class ReleaseHelper {
     virtual int getProductMaxPreferredSlmSize(int preferredEnumValue) const = 0;
     virtual bool getMediaFrequencyTileIndex(uint32_t &tileIndex) const = 0;
     virtual bool isResolvingSubDeviceIDNeeded() const = 0;
-    virtual bool isCachingOnCpuAvailable() const = 0;
     virtual bool shouldAdjustDepth() const = 0;
     virtual bool isDirectSubmissionSupported() const = 0;
     virtual bool isRcsExposureDisabled() const = 0;
-    virtual std::optional<GfxMemoryAllocationMethod> getPreferredAllocationMethod(AllocationType allocationType) const = 0;
     virtual std::vector<uint32_t> getSupportedNumGrfs() const = 0;
     virtual bool isBindlessAddressingDisabled() const = 0;
     virtual uint32_t getNumThreadsPerEu() const = 0;
@@ -80,11 +76,9 @@ class ReleaseHelperHw : public ReleaseHelper {
     int getProductMaxPreferredSlmSize(int preferredEnumValue) const override;
     bool getMediaFrequencyTileIndex(uint32_t &tileIndex) const override;
     bool isResolvingSubDeviceIDNeeded() const override;
-    bool isCachingOnCpuAvailable() const override;
     bool shouldAdjustDepth() const override;
     bool isDirectSubmissionSupported() const override;
     bool isRcsExposureDisabled() const override;
-    std::optional<GfxMemoryAllocationMethod> getPreferredAllocationMethod(AllocationType allocationType) const override;
     std::vector<uint32_t> getSupportedNumGrfs() const override;
     bool isBindlessAddressingDisabled() const override;
     uint32_t getNumThreadsPerEu() const override;
diff --git a/shared/source/release_helper/release_helper_base.inl b/shared/source/release_helper/release_helper_base.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -72,16 +72,6 @@ bool ReleaseHelperHw<releaseType>::isResolvingSubDeviceIDNeeded() const {
     return true;
 }
 
-template <ReleaseType releaseType>
-bool ReleaseHelperHw<releaseType>::isCachingOnCpuAvailable() const {
-    return true;
-}
-
-template <ReleaseType releaseType>
-std::optional<GfxMemoryAllocationMethod> ReleaseHelperHw<releaseType>::getPreferredAllocationMethod(AllocationType allocationType) const {
-    return {};
-}
-
 template <ReleaseType releaseType>
 bool ReleaseHelperHw<releaseType>::shouldAdjustDepth() const {
     return false;
diff --git a/shared/source/release_helper/release_helper_common_xe_lpg.inl b/shared/source/release_helper/release_helper_common_xe_lpg.inl
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -15,22 +15,6 @@ bool ReleaseHelperHw<release>::isMatrixMultiplyAccumulateSupported() const {
     return false;
 }
 
-template <>
-std::optional<GfxMemoryAllocationMethod> ReleaseHelperHw<release>::getPreferredAllocationMethod(AllocationType allocationType) const {
-    switch (allocationType) {
-    case AllocationType::tagBuffer:
-    case AllocationType::timestampPacketTagBuffer:
-        return {};
-    default:
-        return GfxMemoryAllocationMethod::allocateByKmd;
-    }
-}
-
-template <>
-bool ReleaseHelperHw<release>::isCachingOnCpuAvailable() const {
-    return false;
-}
-
 template <>
 bool ReleaseHelperHw<release>::isDirectSubmissionSupported() const {
     return true;
diff --git a/shared/source/xe_hpg_core/xe_lpg/os_agnostic_product_helper_xe_lpg.inl b/shared/source/xe_hpg_core/xe_lpg/os_agnostic_product_helper_xe_lpg.inl
@@ -105,4 +105,20 @@ uint32_t ProductHelperHw<gfxProduct>::getInternalHeapsPreallocated() const {
     return 1u;
 }
 
+template <>
+std::optional<GfxMemoryAllocationMethod> ProductHelperHw<gfxProduct>::getPreferredAllocationMethod(AllocationType allocationType) const {
+    switch (allocationType) {
+    case AllocationType::tagBuffer:
+    case AllocationType::timestampPacketTagBuffer:
+        return {};
+    default:
+        return GfxMemoryAllocationMethod::allocateByKmd;
+    }
+}
+
+template <>
+bool ProductHelperHw<gfxProduct>::isCachingOnCpuAvailable() const {
+    return false;
+}
+
 } // namespace NEO
diff --git a/shared/test/common/mocks/mock_release_helper.h b/shared/test/common/mocks/mock_release_helper.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -26,11 +26,9 @@ class MockReleaseHelper : public ReleaseHelper {
     ADDMETHOD_CONST_NOBASE(getProductMaxPreferredSlmSize, int, 0, (int preferredEnumValue));
     ADDMETHOD_CONST_NOBASE(getMediaFrequencyTileIndex, bool, false, (uint32_t & tileIndex));
     ADDMETHOD_CONST_NOBASE(isResolvingSubDeviceIDNeeded, bool, false, ());
-    ADDMETHOD_CONST_NOBASE(isCachingOnCpuAvailable, bool, false, ());
     ADDMETHOD_CONST_NOBASE(shouldAdjustDepth, bool, false, ());
     ADDMETHOD_CONST_NOBASE(isDirectSubmissionSupported, bool, false, ());
     ADDMETHOD_CONST_NOBASE(isRcsExposureDisabled, bool, false, ());
-    ADDMETHOD_CONST_NOBASE(getPreferredAllocationMethod, std::optional<GfxMemoryAllocationMethod>, std::nullopt, (AllocationType allocationType));
     ADDMETHOD_CONST_NOBASE(getSupportedNumGrfs, std::vector<uint32_t>, {128}, ());
     ADDMETHOD_CONST_NOBASE(isBindlessAddressingDisabled, bool, true, ());
     ADDMETHOD_CONST_NOBASE(getNumThreadsPerEu, uint32_t, 8u, ());
diff --git a/shared/test/unit_test/gmm_helper/gmm_tests.cpp b/shared/test/unit_test/gmm_helper/gmm_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -38,7 +38,7 @@ TEST_F(GmmTests, givenResourceUsageTypesCacheableWhenCreateGmmAndFlagEnableCpuCa
     DebugManagerStateRestore restore;
     debugManager.flags.EnableCpuCacheForResources.set(0);
     StorageInfo storageInfo{};
-    auto releaseHelper = getGmmHelper()->getRootDeviceEnvironment().getReleaseHelper();
+    auto &productHelper = getGmmHelper()->getRootDeviceEnvironment().getProductHelper();
     GmmRequirements gmmRequirements{};
     gmmRequirements.allowLargePages = false;
     gmmRequirements.preferCompressed = false;
@@ -47,7 +47,7 @@ TEST_F(GmmTests, givenResourceUsageTypesCacheableWhenCreateGmmAndFlagEnableCpuCa
                                    GMM_RESOURCE_USAGE_OCL_BUFFER_CONST,
                                    GMM_RESOURCE_USAGE_OCL_BUFFER}) {
         auto gmm = std::make_unique<Gmm>(getGmmHelper(), nullptr, 0, 0, resourceUsageType, storageInfo, gmmRequirements);
-        bool noCpuAccessPreference = releaseHelper ? !releaseHelper->isCachingOnCpuAvailable() : false;
+        bool noCpuAccessPreference = !productHelper.isCachingOnCpuAvailable();
         EXPECT_EQ(noCpuAccessPreference, CacheSettingsHelper::preferNoCpuAccess(resourceUsageType, getGmmHelper()->getRootDeviceEnvironment()));
         EXPECT_EQ(noCpuAccessPreference, gmm->getPreferNoCpuAccess());
     }
@@ -91,7 +91,7 @@ HWTEST_F(GmmTests, givenVariousResourceUsageTypeWhenCreateGmmThenFlagCacheableIs
     DebugManagerStateRestore restore;
     debugManager.flags.EnableCpuCacheForResources.set(false);
     StorageInfo storageInfo{};
-    auto releaseHelper = executionEnvironment->rootDeviceEnvironments[0]->getReleaseHelper();
+    auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
     GmmRequirements gmmRequirements{};
     gmmRequirements.allowLargePages = false;
     gmmRequirements.preferCompressed = false;
@@ -101,11 +101,8 @@ HWTEST_F(GmmTests, givenVariousResourceUsageTypeWhenCreateGmmThenFlagCacheableIs
                                           GMM_RESOURCE_USAGE_OCL_BUFFER_CONST,
                                           GMM_RESOURCE_USAGE_OCL_BUFFER}) {
         auto gmm = std::make_unique<Gmm>(getGmmHelper(), nullptr, 0, 0, regularResourceUsageType, storageInfo, gmmRequirements);
-        if (!releaseHelper) {
-            EXPECT_TRUE(gmm->resourceParams.Flags.Info.Cacheable);
-        } else {
-            EXPECT_EQ(releaseHelper->isCachingOnCpuAvailable(), gmm->resourceParams.Flags.Info.Cacheable);
-        }
+
+        EXPECT_EQ(productHelper.isCachingOnCpuAvailable(), gmm->resourceParams.Flags.Info.Cacheable);
     }
 
     for (auto cpuAccessibleResourceUsageType : {GMM_RESOURCE_USAGE_OCL_SYSTEM_MEMORY_BUFFER}) {
diff --git a/shared/test/unit_test/os_interface/product_helper_tests.cpp b/shared/test/unit_test/os_interface/product_helper_tests.cpp
@@ -867,4 +867,12 @@ HWTEST_F(ProductHelperTest, givenProductHelperWhenAdjustingEnginesGroupThenDoNot
         productHelper->adjustEngineGroupType(engineGroupType);
         EXPECT_EQ(engineGroupTypeUnchanged, engineGroupType);
     }
+}
+
+HWTEST_F(ProductHelperTest, whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned) {
+    for (auto i = 0; i < static_cast<int>(AllocationType::count); i++) {
+        auto allocationType = static_cast<AllocationType>(i);
+        auto preferredAllocationMethod = productHelper->getPreferredAllocationMethod(allocationType);
+        EXPECT_FALSE(preferredAllocationMethod.has_value());
+    }
 }
diff --git a/shared/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp b/shared/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp
@@ -582,11 +582,11 @@ TEST_F(WddmMemoryManagerTests, givenTypeWhenCallIsStatelessAccessRequiredThenPro
 }
 
 TEST_F(WddmMemoryManagerTests, givenForcePreferredAllocationMethodFlagSetWhenGettingPreferredAllocationMethodThenValueFlagIsReturned) {
-    auto releaseHelper = executionEnvironment->rootDeviceEnvironments[0]->releaseHelper.get();
+    auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
     for (auto i = 0; i < static_cast<int>(AllocationType::count); i++) {
         AllocationProperties allocationProperties{0u, 0u, static_cast<AllocationType>(i), {}};
-        if (releaseHelper && releaseHelper->getPreferredAllocationMethod(allocationProperties.allocationType)) {
-            EXPECT_EQ(*releaseHelper->getPreferredAllocationMethod(allocationProperties.allocationType), memoryManager->getPreferredAllocationMethod(allocationProperties));
+        if (productHelper.getPreferredAllocationMethod(allocationProperties.allocationType)) {
+            EXPECT_EQ(productHelper.getPreferredAllocationMethod(allocationProperties.allocationType), memoryManager->getPreferredAllocationMethod(allocationProperties));
         } else {
             EXPECT_EQ(preferredAllocationMethod, memoryManager->getPreferredAllocationMethod(allocationProperties));
         }
@@ -3442,12 +3442,8 @@ HWTEST_F(MockWddmMemoryManagerTest, givenEnabled64kbPagesWhenAllocationIsCreated
     EXPECT_EQ(MemoryConstants::pageSize64k, graphicsAllocation->getUnderlyingBufferSize());
     EXPECT_NE(0llu, graphicsAllocation->getGpuAddress());
     EXPECT_NE(nullptr, graphicsAllocation->getUnderlyingBuffer());
-    auto releaseHelper = executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getReleaseHelper();
-    if (releaseHelper) {
-        EXPECT_EQ(releaseHelper->isCachingOnCpuAvailable(), graphicsAllocation->getDefaultGmm()->resourceParams.Flags.Info.Cacheable);
-    } else {
-        EXPECT_TRUE(graphicsAllocation->getDefaultGmm()->resourceParams.Flags.Info.Cacheable);
-    }
+    auto &productHelper = executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getProductHelper();
+    EXPECT_EQ(productHelper.isCachingOnCpuAvailable(), graphicsAllocation->getDefaultGmm()->resourceParams.Flags.Info.Cacheable);
 
     memoryManager.freeGraphicsMemory(graphicsAllocation);
 }
diff --git a/shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,7 +33,6 @@ TEST_F(ReleaseHelper1255Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
         EXPECT_TRUE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported());
         EXPECT_TRUE(releaseHelper->isBFloat16ConversionSupported());
         EXPECT_TRUE(releaseHelper->isResolvingSubDeviceIDNeeded());
-        EXPECT_TRUE(releaseHelper->isCachingOnCpuAvailable());
         EXPECT_TRUE(releaseHelper->isDirectSubmissionSupported());
         EXPECT_FALSE(releaseHelper->isAuxSurfaceModeOverrideRequired());
         EXPECT_TRUE(releaseHelper->isRcsExposureDisabled());
@@ -50,10 +49,6 @@ TEST_F(ReleaseHelper1255Tests, whenGettingMediaFrequencyTileIndexThenFalseIsRetu
     whenGettingMediaFrequencyTileIndexThenFalseIsReturned();
 }
 
-TEST_F(ReleaseHelper1255Tests, whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned) {
-    whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned();
-}
-
 TEST_F(ReleaseHelper1255Tests, whenShouldAdjustCalledThenFalseReturned) {
     whenShouldAdjustCalledThenFalseReturned();
 }
diff --git a/shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,7 +33,6 @@ TEST_F(ReleaseHelper1256Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
         EXPECT_TRUE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported());
         EXPECT_TRUE(releaseHelper->isBFloat16ConversionSupported());
         EXPECT_TRUE(releaseHelper->isResolvingSubDeviceIDNeeded());
-        EXPECT_TRUE(releaseHelper->isCachingOnCpuAvailable());
         EXPECT_TRUE(releaseHelper->isDirectSubmissionSupported());
         EXPECT_FALSE(releaseHelper->isAuxSurfaceModeOverrideRequired());
         EXPECT_TRUE(releaseHelper->isRcsExposureDisabled());
@@ -50,10 +49,6 @@ TEST_F(ReleaseHelper1256Tests, whenGettingMediaFrequencyTileIndexThenFalseIsRetu
     whenGettingMediaFrequencyTileIndexThenFalseIsReturned();
 }
 
-TEST_F(ReleaseHelper1256Tests, whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned) {
-    whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned();
-}
-
 TEST_F(ReleaseHelper1256Tests, whenShouldAdjustCalledThenFalseReturned) {
     whenShouldAdjustCalledThenFalseReturned();
 }
diff --git a/shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,7 +33,6 @@ TEST_F(ReleaseHelper1257Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
         EXPECT_TRUE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported());
         EXPECT_TRUE(releaseHelper->isBFloat16ConversionSupported());
         EXPECT_TRUE(releaseHelper->isResolvingSubDeviceIDNeeded());
-        EXPECT_TRUE(releaseHelper->isCachingOnCpuAvailable());
         EXPECT_TRUE(releaseHelper->isDirectSubmissionSupported());
         EXPECT_FALSE(releaseHelper->isAuxSurfaceModeOverrideRequired());
         EXPECT_TRUE(releaseHelper->isRcsExposureDisabled());
@@ -50,10 +49,6 @@ TEST_F(ReleaseHelper1257Tests, whenGettingMediaFrequencyTileIndexThenFalseIsRetu
     whenGettingMediaFrequencyTileIndexThenFalseIsReturned();
 }
 
-TEST_F(ReleaseHelper1257Tests, whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned) {
-    whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned();
-}
-
 TEST_F(ReleaseHelper1257Tests, whenShouldAdjustCalledThenFalseReturned) {
     whenShouldAdjustCalledThenFalseReturned();
 }
diff --git a/shared/test/unit_test/release_helper/release_helper_12_60_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_60_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,7 +33,6 @@ TEST_F(ReleaseHelper1260Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
         EXPECT_FALSE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported());
         EXPECT_FALSE(releaseHelper->isBFloat16ConversionSupported());
         EXPECT_TRUE(releaseHelper->isResolvingSubDeviceIDNeeded());
-        EXPECT_TRUE(releaseHelper->isCachingOnCpuAvailable());
         EXPECT_TRUE(releaseHelper->isRcsExposureDisabled());
         EXPECT_TRUE(releaseHelper->isBindlessAddressingDisabled());
         EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
diff --git a/shared/test/unit_test/release_helper/release_helper_12_61_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_61_tests.cpp
@@ -32,7 +32,6 @@ TEST_F(ReleaseHelper1261Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe
         EXPECT_FALSE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported());
         EXPECT_FALSE(releaseHelper->isBFloat16ConversionSupported());
         EXPECT_TRUE(releaseHelper->isResolvingSubDeviceIDNeeded());
-        EXPECT_TRUE(releaseHelper->isCachingOnCpuAvailable());
         EXPECT_TRUE(releaseHelper->isRcsExposureDisabled());
         EXPECT_TRUE(releaseHelper->isBindlessAddressingDisabled());
         EXPECT_EQ(8u, releaseHelper->getNumThreadsPerEu());
diff --git a/shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp
diff --git a/shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp
diff --git a/shared/test/unit_test/release_helper/release_helper_12_74_tests.cpp b/shared/test/unit_test/release_helper/release_helper_12_74_tests.cpp
diff --git a/shared/test/unit_test/release_helper/release_helper_tests_base.cpp b/shared/test/unit_test/release_helper/release_helper_tests_base.cpp
diff --git a/shared/test/unit_test/release_helper/release_helper_tests_base.h b/shared/test/unit_test/release_helper/release_helper_tests_base.h
diff --git a/shared/test/unit_test/xe_hpg_core/arl/excludes_xe_hpg_core_arl.cpp b/shared/test/unit_test/xe_hpg_core/arl/excludes_xe_hpg_core_arl.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/os_agnostic_product_helper_xe_lpg_tests.cpp b/shared/test/unit_test/xe_hpg_core/os_agnostic_product_helper_xe_lpg_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2022-2023 Intel Corporation`
	`2`	`+ * Copyright (C) 2022-2024 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -39,8 +39,8 @@ bool CacheSettingsHelper::preferNoCpuAccess(GMM_RESOURCE_USAGE_TYPE_ENUM gmmReso`
`39`	`39`	`if (rootDeviceEnvironment.isWddmOnLinux()) {`
`40`	`40`	`return false;`
`41`	`41`	`}`
`42`		`- auto releaseHelper = rootDeviceEnvironment.getReleaseHelper();`
`43`		`- if (!releaseHelper \|\| releaseHelper->isCachingOnCpuAvailable()) {`
	`42`	`+ auto &productHelper = rootDeviceEnvironment.getProductHelper();`
	`43`	`+ if (productHelper.isCachingOnCpuAvailable()) {`
`44`	`44`	`return false;`
`45`	`45`	`}`
`46`	`46`	`return (gmmResourceUsageType != GMM_RESOURCE_USAGE_OCL_SYSTEM_MEMORY_BUFFER);`
Original file line number	Diff line number	Diff line change
`@@ -79,8 +79,8 @@ GfxMemoryAllocationMethod WddmMemoryManager::getPreferredAllocationMethod(const`
`79`	`79`	`}`
`80`	`80`	`auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[allocationProperties.rootDeviceIndex].get();`
`81`	`81`	`UNRECOVERABLE_IF(!rootDeviceEnvironment);`
`82`		`- auto releaseHelper = rootDeviceEnvironment->releaseHelper.get();`
`83`		`- auto preference = releaseHelper ? releaseHelper->getPreferredAllocationMethod(allocationProperties.allocationType) : std::nullopt;`
	`82`	`+ auto &productHelper = rootDeviceEnvironment->getHelper<ProductHelper>();`
	`83`	`+ auto preference = productHelper.getPreferredAllocationMethod(allocationProperties.allocationType);`
`84`	`84`	`if (preference) {`
`85`	`85`	`return *preference;`
`86`	`86`	`}`