intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-20 00:24:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: define preferred allocation method per hw release

Browse Source 
Related-To: HSD-18033144631
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
2023-09-11 09:05:49 +00:00
committed by Compute-Runtime-Automation
parent 1579c69316
commit aa6b837a67
15 changed files with 126 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
shared/source/os_interface/product_helper.h
View File

@@ -43,9 +43,6 @@ enum class DriverModelType;
using ProductHelperCreateFunctionType = std::unique_ptr<ProductHelper> (*)();
extern ProductHelperCreateFunctionType productHelperFactory[IGFX_MAX_PRODUCT];
enum class GfxMemoryAllocationMethod : uint32_t;
enum class AllocationType;
enum class UsmAccessCapabilities {
Host = 0,
Device,
@@ -210,7 +207,6 @@ class ProductHelper {
virtual bool isSkippingStatefulInformationRequired(const KernelDescriptor &kernelDescriptor) const = 0;
virtual bool getMediaFrequencyTileIndex(const ReleaseHelper *releaseHelper, uint32_t &tileIndex) const = 0;
virtual bool isResolvingSubDeviceIDNeeded(const ReleaseHelper *releaseHelper) const = 0;
virtual std::optional<GfxMemoryAllocationMethod> getPreferredAllocationMethod(AllocationType allocationType) const = 0;
virtual uint64_t overridePatIndex(bool isUncachedType, uint64_t patIndex) const = 0;
virtual ~ProductHelper() = default;

5
shared/source/os_interface/product_helper.inl
View File

@@ -803,11 +803,6 @@ bool ProductHelperHw<gfxProduct>::isSkippingStatefulInformationRequired(const Ke
return false;
}
template <PRODUCT_FAMILY gfxProduct>
std::optional<GfxMemoryAllocationMethod> ProductHelperHw<gfxProduct>::getPreferredAllocationMethod(AllocationType allocationType) const {
return {};
}
template <PRODUCT_FAMILY gfxProduct>
bool ProductHelperHw<gfxProduct>::isResolvingSubDeviceIDNeeded(const ReleaseHelper *releaseHelper) const {
if (releaseHelper) {

1
shared/source/os_interface/product_helper_hw.h
View File

@@ -160,7 +160,6 @@ class ProductHelperHw : public ProductHelper {
bool isSkippingStatefulInformationRequired(const KernelDescriptor &kernelDescriptor) const override;
bool getMediaFrequencyTileIndex(const ReleaseHelper *releaseHelper, uint32_t &tileIndex) const override;
bool isResolvingSubDeviceIDNeeded(const ReleaseHelper *releaseHelper) const override;
std::optional<GfxMemoryAllocationMethod> getPreferredAllocationMethod(AllocationType allocationType) const override;
uint64_t overridePatIndex(bool isUncachedType, uint64_t patIndex) const override;
~ProductHelperHw() override = default;

5
shared/source/os_interface/windows/wddm_memory_manager.cpp
View File

@@ -40,6 +40,7 @@
#include "shared/source/os_interface/windows/wddm_allocation.h"
#include "shared/source/os_interface/windows/wddm_residency_allocations_container.h"
#include "shared/source/os_interface/windows/wddm_residency_controller.h"
#include "shared/source/release_helper/release_helper.h"
#include <algorithm>
#include <emmintrin.h>
@@ -78,8 +79,8 @@ GfxMemoryAllocationMethod WddmMemoryManager::getPreferredAllocationMethod(const
}
auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[allocationProperties.rootDeviceIndex].get();
UNRECOVERABLE_IF(!rootDeviceEnvironment);
auto &productHelper = rootDeviceEnvironment->getHelper<ProductHelper>();
auto preference = productHelper.getPreferredAllocationMethod(allocationProperties.allocationType);
auto releaseHelper = rootDeviceEnvironment->releaseHelper.get();
auto preference = releaseHelper ? releaseHelper->getPreferredAllocationMethod(allocationProperties.allocationType) : std::nullopt;
if (preference) {
return *preference;
}

5
shared/source/release_helper/release_helper.h
View File

@@ -10,10 +10,13 @@
#include "shared/source/helpers/hw_ip_version.h"
#include <memory>
#include <optional>
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);
@@ -34,6 +37,7 @@ class ReleaseHelper {
virtual int getProductMaxPreferredSlmSize(int preferredEnumValue) const = 0;
virtual bool getMediaFrequencyTileIndex(uint32_t &tileIndex) const = 0;
virtual bool isResolvingSubDeviceIDNeeded() const = 0;
virtual std::optional<GfxMemoryAllocationMethod> getPreferredAllocationMethod(AllocationType allocationType) const = 0;
protected:
ReleaseHelper(HardwareIpVersion hardwareIpVersion) : hardwareIpVersion(hardwareIpVersion) {}
@@ -57,6 +61,7 @@ class ReleaseHelperHw : public ReleaseHelper {
int getProductMaxPreferredSlmSize(int preferredEnumValue) const override;
bool getMediaFrequencyTileIndex(uint32_t &tileIndex) const override;
bool isResolvingSubDeviceIDNeeded() const override;
std::optional<GfxMemoryAllocationMethod> getPreferredAllocationMethod(AllocationType allocationType) const override;
private:
ReleaseHelperHw(HardwareIpVersion hardwareIpVersion) : ReleaseHelper(hardwareIpVersion) {}

5
shared/source/release_helper/release_helper_base.inl
View File

@@ -57,4 +57,9 @@ template <ReleaseType releaseType>
bool ReleaseHelperHw<releaseType>::isResolvingSubDeviceIDNeeded() const {
return true;
}
template <ReleaseType releaseType>
std::optional<GfxMemoryAllocationMethod> ReleaseHelperHw<releaseType>::getPreferredAllocationMethod(AllocationType allocationType) const {
return {};
}
} // namespace NEO

12
shared/source/release_helper/release_helper_common_xe_lpg.inl
View File

@@ -5,6 +5,7 @@
*
*/
#include "shared/source/memory_manager/allocation_type.h"
#include "shared/source/release_helper/release_helper.h"
namespace NEO {
@@ -14,4 +15,15 @@ bool ReleaseHelperHw<release>::isMatrixMultiplyAccumulateSupported() const {
return false;
}
template <>
std::optional<GfxMemoryAllocationMethod> ReleaseHelperHw<release>::getPreferredAllocationMethod(AllocationType allocationType) const {
switch (allocationType) {
case AllocationType::TAG_BUFFER:
case AllocationType::TIMESTAMP_PACKET_TAG_BUFFER:
return {};
default:
return GfxMemoryAllocationMethod::AllocateByKmd;
}
}
} // namespace NEO

11
shared/source/xe_hpg_core/xe_lpg/os_agnostic_product_helper_xe_lpg.inl
View File

@@ -18,17 +18,6 @@
namespace NEO {
template <>
std::optional<GfxMemoryAllocationMethod> ProductHelperHw<gfxProduct>::getPreferredAllocationMethod(AllocationType allocationType) const {
switch (allocationType) {
case AllocationType::TAG_BUFFER:
case AllocationType::TIMESTAMP_PACKET_TAG_BUFFER:
return {};
default:
return GfxMemoryAllocationMethod::AllocateByKmd;
}
}
template <>
uint64_t ProductHelperHw<gfxProduct>::getHostMemCapabilitiesValue() const {
return (UNIFIED_SHARED_MEMORY_ACCESS | UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS);

7
shared/test/unit_test/os_interface/windows/wddm_memory_manager_tests.cpp
View File

@@ -12,6 +12,7 @@
#include "shared/source/os_interface/windows/dxgi_wrapper.h"
#include "shared/source/os_interface/windows/wddm/um_km_data_translator.h"
#include "shared/source/os_interface/windows/windows_wrapper.h"
#include "shared/source/release_helper/release_helper.h"
#include "shared/source/utilities/tag_allocator.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/execution_environment_helper.h"
@@ -516,11 +517,11 @@ TEST_F(WddmMemoryManagerTests, givenTypeWhenCallIsStatelessAccessRequiredThenPro
}
TEST_F(WddmMemoryManagerTests, givenForcePreferredAllocationMethodFlagSetWhenGettingPreferredAllocationMethodThenValueFlagIsReturned) {
auto &productHelper = executionEnvironment->rootDeviceEnvironments[0]->getProductHelper();
auto releaseHelper = executionEnvironment->rootDeviceEnvironments[0]->releaseHelper.get();
for (auto i = 0; i < static_cast<int>(AllocationType::COUNT); i++) {
AllocationProperties allocationProperties{0u, 0u, static_cast<AllocationType>(i), {}};
if (productHelper.getPreferredAllocationMethod(allocationProperties.allocationType)) {
EXPECT_EQ(*productHelper.getPreferredAllocationMethod(allocationProperties.allocationType), memoryManager->getPreferredAllocationMethod(allocationProperties));
if (releaseHelper && releaseHelper->getPreferredAllocationMethod(allocationProperties.allocationType)) {
EXPECT_EQ(*releaseHelper->getPreferredAllocationMethod(allocationProperties.allocationType), memoryManager->getPreferredAllocationMethod(allocationProperties));
} else {
EXPECT_EQ(preferredAllocationMethod, memoryManager->getPreferredAllocationMethod(allocationProperties));
}

17
shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "shared/source/memory_manager/allocation_type.h"
#include "shared/source/release_helper/release_helper.h"
#include "gtest/gtest.h"
@@ -63,3 +64,19 @@ TEST(ReleaseHelperTest, givenReleaseHelper1255ThenMediaFrequencyTileIndexIsNotRe
EXPECT_EQ(expectedTileIndex, tileIndex);
}
}
TEST(ReleaseHelperTest, givenReleaseHelper1255WhenCheckPreferredAllocationMethodThenNoPreferenceIsReturned) {
HardwareIpVersion ipVersion{};
ipVersion.architecture = 12;
ipVersion.release = 55;
for (auto &revision : {0, 1, 4, 8}) {
ipVersion.revision = revision;
auto releaseHelper = ReleaseHelper::create(ipVersion);
ASSERT_NE(nullptr, releaseHelper);
for (auto i = 0; i < static_cast<int>(AllocationType::COUNT); i++) {
auto allocationType = static_cast<AllocationType>(i);
auto preferredAllocationMethod = releaseHelper->getPreferredAllocationMethod(allocationType);
EXPECT_FALSE(preferredAllocationMethod.has_value());
}
}
}

17
shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "shared/source/memory_manager/allocation_type.h"
#include "shared/source/release_helper/release_helper.h"
#include "gtest/gtest.h"
@@ -63,3 +64,19 @@ TEST(ReleaseHelperTest, givenReleaseHelper1256ThenMediaFrequencyTileIndexIsNotRe
EXPECT_EQ(expectedTileIndex, tileIndex);
}
}
TEST(ReleaseHelperTest, givenReleaseHelper1256WhenCheckPreferredAllocationMethodThenNoPreferenceIsReturned) {
HardwareIpVersion ipVersion{};
ipVersion.architecture = 12;
ipVersion.release = 56;
for (auto &revision : {0, 4, 5}) {
ipVersion.revision = revision;
auto releaseHelper = ReleaseHelper::create(ipVersion);
ASSERT_NE(nullptr, releaseHelper);
for (auto i = 0; i < static_cast<int>(AllocationType::COUNT); i++) {
auto allocationType = static_cast<AllocationType>(i);
auto preferredAllocationMethod = releaseHelper->getPreferredAllocationMethod(allocationType);
EXPECT_FALSE(preferredAllocationMethod.has_value());
}
}
}

17
shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "shared/source/memory_manager/allocation_type.h"
#include "shared/source/release_helper/release_helper.h"
#include "gtest/gtest.h"
@@ -63,3 +64,19 @@ TEST(ReleaseHelperTest, givenReleaseHelper1257ThenMediaFrequencyTileIndexIsNotRe
EXPECT_EQ(expectedTileIndex, tileIndex);
}
}
TEST(ReleaseHelperTest, givenReleaseHelper1257WhenCheckPreferredAllocationMethodThenNoPreferenceIsReturned) {
HardwareIpVersion ipVersion{};
ipVersion.architecture = 12;
ipVersion.release = 57;
for (auto &revision : {0}) {
ipVersion.revision = revision;
auto releaseHelper = ReleaseHelper::create(ipVersion);
ASSERT_NE(nullptr, releaseHelper);
for (auto i = 0; i < static_cast<int>(AllocationType::COUNT); i++) {
auto allocationType = static_cast<AllocationType>(i);
auto preferredAllocationMethod = releaseHelper->getPreferredAllocationMethod(allocationType);
EXPECT_FALSE(preferredAllocationMethod.has_value());
}
}
}

23
shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "shared/source/memory_manager/allocation_type.h"
#include "shared/source/release_helper/release_helper.h"
#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
@@ -72,3 +73,25 @@ TEST(ReleaseHelperTest, givenReleaseHelper1270ThenCorrectMediaFrequencyTileIndex
EXPECT_EQ(expectedTileIndex, tileIndex);
}
}
TEST(ReleaseHelperTest, givenReleaseHelper1270WhenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestapPacketTagBuffer) {
HardwareIpVersion ipVersion{};
ipVersion.architecture = 12;
ipVersion.release = 70;
for (auto &revision : {0, 4}) {
ipVersion.revision = revision;
auto releaseHelper = ReleaseHelper::create(ipVersion);
ASSERT_NE(nullptr, releaseHelper);
for (auto i = 0; i < static_cast<int>(AllocationType::COUNT); i++) {
auto allocationType = static_cast<AllocationType>(i);
auto preferredAllocationMethod = releaseHelper->getPreferredAllocationMethod(allocationType);
if (allocationType == AllocationType::TAG_BUFFER ||
allocationType == AllocationType::TIMESTAMP_PACKET_TAG_BUFFER) {
EXPECT_FALSE(preferredAllocationMethod.has_value());
} else {
EXPECT_TRUE(preferredAllocationMethod.has_value());
EXPECT_EQ(GfxMemoryAllocationMethod::AllocateByKmd, preferredAllocationMethod.value());
}
}
}
}

23
shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp
View File

@@ -5,6 +5,7 @@
*
*/
#include "shared/source/memory_manager/allocation_type.h"
#include "shared/source/release_helper/release_helper.h"
#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
@@ -73,3 +74,25 @@ TEST(ReleaseHelperTest, givenReleaseHelper1271ThenCorrectMediaFrequencyTileIndex
EXPECT_EQ(expectedTileIndex, tileIndex);
}
}
TEST(ReleaseHelperTest, givenReleaseHelper1271WhenCheckPreferredAllocationMethodThenAllocateByKmdIsReturnedExceptTagBufferAndTimestapPacketTagBuffer) {
HardwareIpVersion ipVersion{};
ipVersion.architecture = 12;
ipVersion.release = 71;
for (auto &revision : {0, 4}) {
ipVersion.revision = revision;
auto releaseHelper = ReleaseHelper::create(ipVersion);
ASSERT_NE(nullptr, releaseHelper);
for (auto i = 0; i < static_cast<int>(AllocationType::COUNT); i++) {
auto allocationType = static_cast<AllocationType>(i);
auto preferredAllocationMethod = releaseHelper->getPreferredAllocationMethod(allocationType);
if (allocationType == AllocationType::TAG_BUFFER ||
allocationType == AllocationType::TIMESTAMP_PACKET_TAG_BUFFER) {
EXPECT_FALSE(preferredAllocationMethod.has_value());
} else {
EXPECT_TRUE(preferredAllocationMethod.has_value());
EXPECT_EQ(GfxMemoryAllocationMethod::AllocateByKmd, preferredAllocationMethod.value());
}
}
}
}

14
shared/test/unit_test/xe_hpg_core/os_agnostic_product_helper_xe_lpg_tests.cpp
View File

@@ -171,20 +171,6 @@ HWTEST2_F(XeLpgHwInfoTests, GivenEmptyHwInfoForUnitTestsWhenSetupHardwareInfoIsC
}
}
HWTEST2_F(XeLpgProductHelperTests, whenCheckPreferredAllocationMethodThenAllocateByKmdIsReturned, IsXeLpg) {
for (auto i = 0; i < static_cast<int>(AllocationType::COUNT); i++) {
auto allocationType = static_cast<AllocationType>(i);
auto preferredAllocationMethod = productHelper->getPreferredAllocationMethod(allocationType);
if (allocationType == AllocationType::TAG_BUFFER ||
allocationType == AllocationType::TIMESTAMP_PACKET_TAG_BUFFER) {
EXPECT_FALSE(preferredAllocationMethod.has_value());
} else {
EXPECT_TRUE(preferredAllocationMethod.has_value());
EXPECT_EQ(GfxMemoryAllocationMethod::AllocateByKmd, preferredAllocationMethod.value());
}
}
}
HWTEST2_F(XeLpgProductHelperTests, givenBooleanUncachedWhenCallOverridePatIndexThenProperPatIndexIsReturned, IsXeLpg) {
uint64_t patIndex = 1u;
bool isUncached = true;