From eec01e500a009a195082c30ca9ae21b7278a3ea2 Mon Sep 17 00:00:00 2001 From: Katarzyna Cencelewska Date: Thu, 25 Jan 2024 17:07:26 +0000 Subject: [PATCH] fix: non-coherency issue on arl Resolves: HSD-15015200338 Signed-off-by: Katarzyna Cencelewska --- .../gmm_helper/cache_settings_helper.cpp | 6 ++-- shared/source/os_interface/product_helper.h | 4 +++ shared/source/os_interface/product_helper.inl | 10 ++++++ .../source/os_interface/product_helper_hw.h | 2 ++ .../windows/wddm_memory_manager.cpp | 4 +-- shared/source/release_helper/release_helper.h | 8 +---- .../release_helper/release_helper_base.inl | 12 +------ .../release_helper_common_xe_lpg.inl | 18 +--------- .../os_agnostic_product_helper_xe_lpg.inl | 16 +++++++++ .../test/common/mocks/mock_release_helper.h | 4 +-- .../test/unit_test/gmm_helper/gmm_tests.cpp | 15 ++++---- .../os_interface/product_helper_tests.cpp | 8 +++++ .../windows/wddm_memory_manager_tests.cpp | 14 +++----- .../release_helper_12_55_tests.cpp | 7 +--- .../release_helper_12_56_tests.cpp | 7 +--- .../release_helper_12_57_tests.cpp | 7 +--- .../release_helper_12_60_tests.cpp | 3 +- .../release_helper_12_61_tests.cpp | 1 - .../release_helper_12_70_tests.cpp | 7 +--- .../release_helper_12_71_tests.cpp | 7 +--- .../release_helper_12_74_tests.cpp | 7 +--- .../release_helper_tests_base.cpp | 34 +------------------ .../release_helper_tests_base.h | 4 +-- .../arl/excludes_xe_hpg_core_arl.cpp | 3 +- .../mtl/excludes_xe_hpg_core_mtl.cpp | 3 +- ...s_agnostic_product_helper_xe_lpg_tests.cpp | 20 ++++++++++- 26 files changed, 92 insertions(+), 139 deletions(-) diff --git a/shared/source/gmm_helper/cache_settings_helper.cpp b/shared/source/gmm_helper/cache_settings_helper.cpp index dae50f0973..2d4e0d8a16 100644 --- 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 index 7f59d5e012..14bbfa20a8 100644 --- 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 (*)(); extern ProductHelperCreateFunctionType productHelperFactory[IGFX_MAX_PRODUCT]; @@ -215,6 +217,8 @@ class ProductHelper { virtual std::vector getSupportedNumGrfs(const ReleaseHelper *releaseHelper) const = 0; virtual aub_stream::EngineType getDefaultCopyEngine() const = 0; virtual void adjustEngineGroupType(EngineGroupType &engineGroupType) const = 0; + virtual std::optional 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 index 8b43c63aad..d40a2e58f9 100644 --- a/shared/source/os_interface/product_helper.inl +++ b/shared/source/os_interface/product_helper.inl @@ -839,4 +839,14 @@ aub_stream::EngineType ProductHelperHw::getDefaultCopyEngine() const template void ProductHelperHw::adjustEngineGroupType(EngineGroupType &engineGroupType) const {} +template +std::optional ProductHelperHw::getPreferredAllocationMethod(AllocationType allocationType) const { + return {}; +} + +template +bool ProductHelperHw::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 index e9d86cacf3..f4e6b902b6 100644 --- 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 getSupportedNumGrfs(const ReleaseHelper *releaseHelper) const override; aub_stream::EngineType getDefaultCopyEngine() const override; void adjustEngineGroupType(EngineGroupType &engineGroupType) const override; + std::optional 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 index 8b013722ee..18667aaf98 100644 --- 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(); + 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 index 6bb9aec9b8..9d77764b4f 100644 --- 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 (*)(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 getPreferredAllocationMethod(AllocationType allocationType) const = 0; virtual std::vector 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 getPreferredAllocationMethod(AllocationType allocationType) const override; std::vector 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 index 2d9c852bea..3aa720abef 100644 --- 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::isResolvingSubDeviceIDNeeded() const { return true; } -template -bool ReleaseHelperHw::isCachingOnCpuAvailable() const { - return true; -} - -template -std::optional ReleaseHelperHw::getPreferredAllocationMethod(AllocationType allocationType) const { - return {}; -} - template bool ReleaseHelperHw::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 index 44a935047c..4ff73ea1c7 100644 --- 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::isMatrixMultiplyAccumulateSupported() const { return false; } -template <> -std::optional ReleaseHelperHw::getPreferredAllocationMethod(AllocationType allocationType) const { - switch (allocationType) { - case AllocationType::tagBuffer: - case AllocationType::timestampPacketTagBuffer: - return {}; - default: - return GfxMemoryAllocationMethod::allocateByKmd; - } -} - -template <> -bool ReleaseHelperHw::isCachingOnCpuAvailable() const { - return false; -} - template <> bool ReleaseHelperHw::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 index 59daecd635..b0e8c75701 100644 --- 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::getInternalHeapsPreallocated() const { return 1u; } +template <> +std::optional ProductHelperHw::getPreferredAllocationMethod(AllocationType allocationType) const { + switch (allocationType) { + case AllocationType::tagBuffer: + case AllocationType::timestampPacketTagBuffer: + return {}; + default: + return GfxMemoryAllocationMethod::allocateByKmd; + } +} + +template <> +bool ProductHelperHw::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 index b8229dcea4..dae7d2f533 100644 --- 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, std::nullopt, (AllocationType allocationType)); ADDMETHOD_CONST_NOBASE(getSupportedNumGrfs, std::vector, {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 index 0f66161c79..23dad65a24 100644 --- 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(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(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 index 6a70488aa9..d5400da1d0 100644 --- 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(AllocationType::count); i++) { + auto allocationType = static_cast(i); + auto preferredAllocationMethod = productHelper->getPreferredAllocationMethod(allocationType); + EXPECT_FALSE(preferredAllocationMethod.has_value()); + } } \ No newline at end of file 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 index 8e47ca0531..8c95be4ca5 100644 --- 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(AllocationType::count); i++) { AllocationProperties allocationProperties{0u, 0u, static_cast(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 index 671da96864..0e0130a752 100644 --- 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 index 4657f28a47..0e3808922a 100644 --- 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 index 36292277ee..1993927e41 100644 --- 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 index 824278607a..6c95f03473 100644 --- 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 index dabc452467..430615b194 100644 --- 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 index d218364d11..e4d873207f 100644 --- 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -34,7 +34,6 @@ TEST_F(ReleaseHelper1270Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe EXPECT_FALSE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported()); EXPECT_FALSE(releaseHelper->isBFloat16ConversionSupported()); EXPECT_TRUE(releaseHelper->isResolvingSubDeviceIDNeeded()); - EXPECT_FALSE(releaseHelper->isCachingOnCpuAvailable()); EXPECT_TRUE(releaseHelper->isDirectSubmissionSupported()); EXPECT_TRUE(releaseHelper->isAuxSurfaceModeOverrideRequired()); EXPECT_FALSE(releaseHelper->isRcsExposureDisabled()); @@ -69,10 +68,6 @@ TEST_F(ReleaseHelper1270Tests, whenGettingMediaFrequencyTileIndexThenOneIsReturn whenGettingMediaFrequencyTileIndexThenOneIsReturned(); } -TEST_F(ReleaseHelper1270Tests, whenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestampPacketTagBuffer) { - whenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestampPacketTagBuffer(); -} - TEST_F(ReleaseHelper1270Tests, whenGettingSupportedNumGrfsThenCorrectValuesAreReturned) { whenGettingSupportedNumGrfsThenValues128And256Returned(); } 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 index 3dc4f66723..2ecdad288b 100644 --- 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -34,7 +34,6 @@ TEST_F(ReleaseHelper1271Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe EXPECT_FALSE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported()); EXPECT_FALSE(releaseHelper->isBFloat16ConversionSupported()); EXPECT_TRUE(releaseHelper->isResolvingSubDeviceIDNeeded()); - EXPECT_FALSE(releaseHelper->isCachingOnCpuAvailable()); EXPECT_TRUE(releaseHelper->isDirectSubmissionSupported()); EXPECT_TRUE(releaseHelper->isAuxSurfaceModeOverrideRequired()); EXPECT_FALSE(releaseHelper->isRcsExposureDisabled()); @@ -70,10 +69,6 @@ TEST_F(ReleaseHelper1271Tests, whenGettingMediaFrequencyTileIndexThenOneIsReturn whenGettingMediaFrequencyTileIndexThenOneIsReturned(); } -TEST_F(ReleaseHelper1271Tests, whenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestampPacketTagBuffer) { - whenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestampPacketTagBuffer(); -} - TEST_F(ReleaseHelper1271Tests, whenGettingSupportedNumGrfsThenCorrectValuesAreReturned) { whenGettingSupportedNumGrfsThenValues128And256Returned(); } 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 index 8a1c2ee9e2..b5713b7fb2 100644 --- 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 @@ -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(ReleaseHelper1274Tests, whenGettingCapabilitiesThenCorrectPropertiesAreRe EXPECT_TRUE(releaseHelper->isSplitMatrixMultiplyAccumulateSupported()); EXPECT_TRUE(releaseHelper->isBFloat16ConversionSupported()); EXPECT_TRUE(releaseHelper->isResolvingSubDeviceIDNeeded()); - EXPECT_TRUE(releaseHelper->isCachingOnCpuAvailable()); EXPECT_FALSE(releaseHelper->isDirectSubmissionSupported()); EXPECT_FALSE(releaseHelper->isAuxSurfaceModeOverrideRequired()); EXPECT_FALSE(releaseHelper->isRcsExposureDisabled()); @@ -50,10 +49,6 @@ TEST_F(ReleaseHelper1274Tests, whenGettingMediaFrequencyTileIndexThenOneIsReturn whenGettingMediaFrequencyTileIndexThenOneIsReturned(); } -TEST_F(ReleaseHelper1274Tests, whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned) { - whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned(); -} - TEST_F(ReleaseHelper1274Tests, whenShouldAdjustCalledThenFalseReturned) { whenShouldAdjustCalledThenFalseReturned(); } 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 index 6ca94cf551..82ccdf724c 100644 --- a/shared/test/unit_test/release_helper/release_helper_tests_base.cpp +++ b/shared/test/unit_test/release_helper/release_helper_tests_base.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -42,19 +42,6 @@ void ReleaseHelperTestsBase::whenGettingMediaFrequencyTileIndexThenFalseIsReturn } } -void ReleaseHelperTestsBase::whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned() { - for (auto &revision : getRevisions()) { - ipVersion.revision = revision; - releaseHelper = ReleaseHelper::create(ipVersion); - ASSERT_NE(nullptr, releaseHelper); - for (auto i = 0; i < static_cast(AllocationType::count); i++) { - auto allocationType = static_cast(i); - auto preferredAllocationMethod = releaseHelper->getPreferredAllocationMethod(allocationType); - EXPECT_FALSE(preferredAllocationMethod.has_value()); - } - } -} - void ReleaseHelperTestsBase::whenGettingMediaFrequencyTileIndexThenOneIsReturned() { for (auto &revision : getRevisions()) { ipVersion.revision = revision; @@ -68,25 +55,6 @@ void ReleaseHelperTestsBase::whenGettingMediaFrequencyTileIndexThenOneIsReturned } } -void ReleaseHelperTestsBase::whenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestampPacketTagBuffer() { - for (auto &revision : getRevisions()) { - ipVersion.revision = revision; - releaseHelper = ReleaseHelper::create(ipVersion); - ASSERT_NE(nullptr, releaseHelper); - for (auto i = 0; i < static_cast(AllocationType::count); i++) { - auto allocationType = static_cast(i); - auto preferredAllocationMethod = releaseHelper->getPreferredAllocationMethod(allocationType); - if (allocationType == AllocationType::tagBuffer || - allocationType == AllocationType::timestampPacketTagBuffer) { - EXPECT_FALSE(preferredAllocationMethod.has_value()); - } else { - EXPECT_TRUE(preferredAllocationMethod.has_value()); - EXPECT_EQ(GfxMemoryAllocationMethod::allocateByKmd, preferredAllocationMethod.value()); - } - } - } -} - void ReleaseHelperTestsBase::whenShouldAdjustCalledThenTrueReturned() { for (auto &revision : getRevisions()) { ipVersion.revision = revision; 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 index a0cae80d58..958fb88293 100644 --- a/shared/test/unit_test/release_helper/release_helper_tests_base.h +++ b/shared/test/unit_test/release_helper/release_helper_tests_base.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -22,10 +22,8 @@ struct ReleaseHelperTestsBase : public ::testing::Test { ReleaseHelperTestsBase(); ~ReleaseHelperTestsBase() override; void whenGettingMediaFrequencyTileIndexThenFalseIsReturned(); - void whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned(); void whenGettingMaxPreferredSlmSizeThenSizeIsNotModified(); void whenGettingMediaFrequencyTileIndexThenOneIsReturned(); - void whenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestampPacketTagBuffer(); void whenShouldAdjustCalledThenTrueReturned(); void whenShouldAdjustCalledThenFalseReturned(); void whenGettingSupportedNumGrfsThenValues128And256Returned(); 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 index 5f45daf5fe..4ecedf40e5 100644 --- 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -26,3 +26,4 @@ HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenIsAdjustWalkOrde HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenGetMediaFrequencyTileIndexCallThenFalseReturn, IGFX_ARROWLAKE); HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenBooleanUncachedWhenCallOverridePatIndexThenProperPatIndexIsReturned, IGFX_ARROWLAKE); HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenCheckBlitEnqueueAllowedThenReturnTrue, IGFX_ARROWLAKE); +HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned, IGFX_ARROWLAKE); 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 baf3ea0043..5f9c4b10fa 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2023 Intel Corporation + * Copyright (C) 2022-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -21,3 +21,4 @@ HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenAskedIfPatIndexP HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenIsAdjustWalkOrderAvailableCallThenFalseReturn, IGFX_METEORLAKE); HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenBooleanUncachedWhenCallOverridePatIndexThenProperPatIndexIsReturned, IGFX_METEORLAKE); HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, givenProductHelperWhenCheckBlitEnqueueAllowedThenReturnTrue, IGFX_METEORLAKE); +HWTEST_EXCLUDE_PRODUCT(ProductHelperTest, whenGettingPreferredAllocationMethodThenNoPreferenceIsReturned, IGFX_METEORLAKE); 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 index 6c3cf0c200..c7ef88e7c8 100644 --- 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -338,3 +338,21 @@ HWTEST2_F(XeLpgProductHelperTests, givenCompilerProductHelperWhenGetDefaultHwIpV HWTEST2_F(XeLpgProductHelperTests, whenCheckDirectSubmissionSupportedThenValueFromReleaseHelperIsReturned, IsXeLpg) { EXPECT_EQ(productHelper->isDirectSubmissionSupported(releaseHelper), releaseHelper->isDirectSubmissionSupported()); } + +HWTEST2_F(XeLpgProductHelperTests, whenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestampPacketTagBuffer, IsXeLpg) { + for (auto i = 0; i < static_cast(AllocationType::count); i++) { + auto allocationType = static_cast(i); + auto preferredAllocationMethod = productHelper->getPreferredAllocationMethod(allocationType); + if (allocationType == AllocationType::tagBuffer || + allocationType == AllocationType::timestampPacketTagBuffer) { + EXPECT_FALSE(preferredAllocationMethod.has_value()); + } else { + EXPECT_TRUE(preferredAllocationMethod.has_value()); + EXPECT_EQ(GfxMemoryAllocationMethod::allocateByKmd, preferredAllocationMethod.value()); + } + } +} + +HWTEST2_F(XeLpgProductHelperTests, givenProductHelperWhenCallIsCachingOnCpuAvailableThenFalseIsReturned, IsXeLpg) { + EXPECT_FALSE(productHelper->isCachingOnCpuAvailable()); +} \ No newline at end of file