test: add dedicated tests for release helpers

Related-To: NEO-7786
Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>

shared/test/unit_test/release_helper/CMakeLists.txt

@@ -0,0 +1,19 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(neo_shared_tests PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+)
+if(TESTS_XE_HPG_CORE)
+  target_sources(neo_shared_tests PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/release_helper_12_55_tests.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/release_helper_12_56_tests.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/release_helper_12_57_tests.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/release_helper_12_70_tests.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/release_helper_12_71_tests.cpp
+  )
+endif()
+add_subdirectories()

shared/test/unit_test/release_helper/release_helper_12_55_tests.cpp

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/release_helper/release_helper.h"
+
+#include "gtest/gtest.h"
+
+using namespace NEO;
+
+TEST(ReleaseHelperTest, givenReleaseHelper1255ThenCorrectPropertiesAreReturned) {
+    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);
+
+        EXPECT_FALSE(releaseHelper->isAdjustWalkOrderAvailable());
+        EXPECT_TRUE(releaseHelper->isMatrixMultiplyAccumulateSupported());
+        EXPECT_FALSE(releaseHelper->isPipeControlPriorToNonPipelinedStateCommandsWARequired());
+        EXPECT_EQ(revision < 4, releaseHelper->isPrefetchDisablingRequired());
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1255ThenMaxPreferredSlmSizeIsNotModified) {
+    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 < 10; i++) {
+            auto preferredEnumValue = i;
+            auto expectedEnumValue = i;
+            EXPECT_EQ(expectedEnumValue, releaseHelper->getProductMaxPreferredSlmSize(preferredEnumValue));
+        }
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1255ThenMediaFrequencyTileIndexIsNotReturned) {
+    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);
+
+        auto tileIndex = 0u;
+        auto expectedTileIndex = 0u;
+        EXPECT_FALSE(releaseHelper->getMediaFrequencyTileIndex(tileIndex));
+        EXPECT_EQ(expectedTileIndex, tileIndex);
+    }
+}

shared/test/unit_test/release_helper/release_helper_12_56_tests.cpp

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/release_helper/release_helper.h"
+
+#include "gtest/gtest.h"
+
+using namespace NEO;
+
+TEST(ReleaseHelperTest, givenReleaseHelper1256ThenCorrectPropertiesAreReturned) {
+    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);
+
+        EXPECT_FALSE(releaseHelper->isAdjustWalkOrderAvailable());
+        EXPECT_TRUE(releaseHelper->isMatrixMultiplyAccumulateSupported());
+        EXPECT_FALSE(releaseHelper->isPipeControlPriorToNonPipelinedStateCommandsWARequired());
+        EXPECT_FALSE(releaseHelper->isPrefetchDisablingRequired());
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1256ThenMaxPreferredSlmSizeIsNotModified) {
+    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 < 10; i++) {
+            auto preferredEnumValue = i;
+            auto expectedEnumValue = i;
+            EXPECT_EQ(expectedEnumValue, releaseHelper->getProductMaxPreferredSlmSize(preferredEnumValue));
+        }
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1256ThenMediaFrequencyTileIndexIsNotReturned) {
+    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);
+
+        auto tileIndex = 0u;
+        auto expectedTileIndex = 0u;
+        EXPECT_FALSE(releaseHelper->getMediaFrequencyTileIndex(tileIndex));
+        EXPECT_EQ(expectedTileIndex, tileIndex);
+    }
+}

shared/test/unit_test/release_helper/release_helper_12_57_tests.cpp

@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/release_helper/release_helper.h"
+
+#include "gtest/gtest.h"
+
+using namespace NEO;
+
+TEST(ReleaseHelperTest, givenReleaseHelper1257ThenCorrectPropertiesAreReturned) {
+    HardwareIpVersion ipVersion{};
+    ipVersion.architecture = 12;
+    ipVersion.release = 57;
+    for (auto &revision : {0}) {
+        ipVersion.revision = revision;
+        auto releaseHelper = ReleaseHelper::create(ipVersion);
+        ASSERT_NE(nullptr, releaseHelper);
+
+        EXPECT_FALSE(releaseHelper->isAdjustWalkOrderAvailable());
+        EXPECT_TRUE(releaseHelper->isMatrixMultiplyAccumulateSupported());
+        EXPECT_FALSE(releaseHelper->isPipeControlPriorToNonPipelinedStateCommandsWARequired());
+        EXPECT_FALSE(releaseHelper->isPrefetchDisablingRequired());
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1257ThenMaxPreferredSlmSizeIsNotModified) {
+    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 < 10; i++) {
+            auto preferredEnumValue = i;
+            auto expectedEnumValue = i;
+            EXPECT_EQ(expectedEnumValue, releaseHelper->getProductMaxPreferredSlmSize(preferredEnumValue));
+        }
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1257ThenMediaFrequencyTileIndexIsNotReturned) {
+    HardwareIpVersion ipVersion{};
+    ipVersion.architecture = 12;
+    ipVersion.release = 57;
+    for (auto &revision : {0}) {
+        ipVersion.revision = revision;
+        auto releaseHelper = ReleaseHelper::create(ipVersion);
+        ASSERT_NE(nullptr, releaseHelper);
+
+        auto tileIndex = 0u;
+        auto expectedTileIndex = 0u;
+        EXPECT_FALSE(releaseHelper->getMediaFrequencyTileIndex(tileIndex));
+        EXPECT_EQ(expectedTileIndex, tileIndex);
+    }
+}

shared/test/unit_test/release_helper/release_helper_12_70_tests.cpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/release_helper/release_helper.h"
+#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
+
+#include "gtest/gtest.h"
+
+using namespace NEO;
+
+TEST(ReleaseHelperTest, givenReleaseHelper1270ThenCorrectPropertiesAreReturned) {
+    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);
+
+        EXPECT_FALSE(releaseHelper->isAdjustWalkOrderAvailable());
+        EXPECT_FALSE(releaseHelper->isMatrixMultiplyAccumulateSupported());
+        EXPECT_EQ(revision == 0, releaseHelper->isPipeControlPriorToNonPipelinedStateCommandsWARequired());
+        EXPECT_FALSE(releaseHelper->isPrefetchDisablingRequired());
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1270ThenMaxPreferredSlmSizeIsLimitedBy96K) {
+    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);
+
+        using PREFERRED_SLM_ALLOCATION_SIZE = typename XeHpgCoreFamily::INTERFACE_DESCRIPTOR_DATA::PREFERRED_SLM_ALLOCATION_SIZE;
+        auto maxValue = static_cast<int>(PREFERRED_SLM_ALLOCATION_SIZE::PREFERRED_SLM_ALLOCATION_SIZE_96K);
+
+        for (auto i = 0; i < maxValue; i++) {
+            auto preferredEnumValue = i;
+            auto expectedEnumValue = i;
+            EXPECT_EQ(expectedEnumValue, releaseHelper->getProductMaxPreferredSlmSize(preferredEnumValue));
+        }
+
+        for (auto i = maxValue + 1; i < maxValue + 10; i++) {
+            auto preferredEnumValue = i;
+            auto expectedEnumValue = maxValue;
+            EXPECT_EQ(expectedEnumValue, releaseHelper->getProductMaxPreferredSlmSize(preferredEnumValue));
+        }
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1270ThenCorrectMediaFrequencyTileIndexIsReturned) {
+    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);
+
+        auto tileIndex = 0u;
+        auto expectedTileIndex = 1u;
+        EXPECT_TRUE(releaseHelper->getMediaFrequencyTileIndex(tileIndex));
+        EXPECT_EQ(expectedTileIndex, tileIndex);
+    }
+}

shared/test/unit_test/release_helper/release_helper_12_71_tests.cpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/release_helper/release_helper.h"
+#include "shared/source/xe_hpg_core/hw_cmds_xe_hpg_core_base.h"
+
+#include "gtest/gtest.h"
+
+using namespace NEO;
+
+TEST(ReleaseHelperTest, givenReleaseHelper1271ThenCorrectPropertiesAreReturned) {
+    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);
+
+        EXPECT_FALSE(releaseHelper->isAdjustWalkOrderAvailable());
+        EXPECT_FALSE(releaseHelper->isMatrixMultiplyAccumulateSupported());
+        EXPECT_EQ(revision == 0, releaseHelper->isPipeControlPriorToNonPipelinedStateCommandsWARequired());
+        EXPECT_FALSE(releaseHelper->isPrefetchDisablingRequired());
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1271ThenMaxPreferredSlmSizeIsLimitedBy96K) {
+    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);
+
+        using PREFERRED_SLM_ALLOCATION_SIZE = typename XeHpgCoreFamily::INTERFACE_DESCRIPTOR_DATA::PREFERRED_SLM_ALLOCATION_SIZE;
+        auto maxValue = static_cast<int>(PREFERRED_SLM_ALLOCATION_SIZE::PREFERRED_SLM_ALLOCATION_SIZE_96K);
+
+        for (auto i = 0; i < maxValue; i++) {
+            auto preferredEnumValue = i;
+            auto expectedEnumValue = i;
+            EXPECT_EQ(expectedEnumValue, releaseHelper->getProductMaxPreferredSlmSize(preferredEnumValue));
+        }
+
+        for (auto i = maxValue + 1; i < maxValue + 10; i++) {
+            auto preferredEnumValue = i;
+            auto expectedEnumValue = maxValue;
+            EXPECT_EQ(expectedEnumValue, releaseHelper->getProductMaxPreferredSlmSize(preferredEnumValue));
+        }
+    }
+}
+
+TEST(ReleaseHelperTest, givenReleaseHelper1271ThenCorrectMediaFrequencyTileIndexIsReturned) {
+    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);
+
+        auto tileIndex = 0u;
+        auto expectedTileIndex = 1u;
+        EXPECT_TRUE(releaseHelper->getMediaFrequencyTileIndex(tileIndex));
+        EXPECT_EQ(expectedTileIndex, tileIndex);
+    }
+}