refactor: adjust code for newer aot header

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

opencl/test/unit_test/offline_compiler/ocloc_fatbinary_tests.cpp

@@ -2141,7 +2141,7 @@ TEST_P(OclocFatbinaryPerProductTests, givenReleaseWhenGetTargetProductsForFarbin
     auto hasDeviceAcronym = std::any_of(aotInfos.begin(), aotInfos.end(), ProductConfigHelper::findDeviceAcronymForRelease(releaseValue));
 
     for (const auto &aotInfo : aotInfos) {
-        if (aotInfo.hwInfo->platform.eProductFamily == productFamily) {
+        if (aotInfo.hwInfo->platform.eProductFamily == productFamily && aotInfo.release == releaseValue) {
             if (hasDeviceAcronym) {
                 if (!aotInfo.deviceAcronyms.empty()) {
                     expected.push_back(aotInfo.deviceAcronyms.front());
@@ -2158,4 +2158,4 @@ TEST_P(OclocFatbinaryPerProductTests, givenReleaseWhenGetTargetProductsForFarbin
     EXPECT_EQ(got, expected);
 }
 
-} // namespace NEO
+} // namespace NEO

shared/source/dll/devices/product_config_base.inl

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2023 Intel Corporation
+ * Copyright (C) 2021-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -13,17 +13,17 @@ DEVICE_CONFIG(PVC_XT_A0, PvcHwConfig, pvcXtDeviceIds, XE_FAMILY, XE_HPC_RELEASE)
 DEVICE_CONFIG(PVC_XT_B0, PvcHwConfig, pvcXtDeviceIds, XE_FAMILY, XE_HPC_RELEASE)
 DEVICE_CONFIG(PVC_XT_B1, PvcHwConfig, pvcXtDeviceIds, XE_FAMILY, XE_HPC_RELEASE)
 DEVICE_CONFIG(PVC_XT_C0, PvcHwConfig, pvcXtDeviceIds, XE_FAMILY, XE_HPC_RELEASE)
-DEVICE_CONFIG(PVC_XT_C0_VG, PvcHwConfig, pvcXtVgDeviceIds, XE_FAMILY, XE_HPC_RELEASE)
+DEVICE_CONFIG(PVC_XT_C0_VG, PvcHwConfig, pvcXtVgDeviceIds, XE_FAMILY, XE_HPC_VG_RELEASE)
 
 #endif
 #endif
 
 #ifdef SUPPORT_XE_HPG_CORE
 #ifdef SUPPORT_MTL
-DEVICE_CONFIG(MTL_M_A0, MtlHwConfig, mtlmDeviceIds, XE_FAMILY, XE_LPG_RELEASE)
+DEVICE_CONFIG(MTL_U_A0, MtlHwConfig, mtlmDeviceIds, XE_FAMILY, XE_LPG_RELEASE)
-DEVICE_CONFIG(MTL_M_B0, MtlHwConfig, mtlmDeviceIds, XE_FAMILY, XE_LPG_RELEASE)
+DEVICE_CONFIG(MTL_U_B0, MtlHwConfig, mtlmDeviceIds, XE_FAMILY, XE_LPG_RELEASE)
-DEVICE_CONFIG(MTL_P_A0, MtlHwConfig, mtlpDeviceIds, XE_FAMILY, XE_LPG_RELEASE)
+DEVICE_CONFIG(MTL_H_A0, MtlHwConfig, mtlpDeviceIds, XE_FAMILY, XE_LPG_RELEASE)
-DEVICE_CONFIG(MTL_P_B0, MtlHwConfig, mtlpDeviceIds, XE_FAMILY, XE_LPG_RELEASE)
+DEVICE_CONFIG(MTL_H_B0, MtlHwConfig, mtlpDeviceIds, XE_FAMILY, XE_LPG_RELEASE)
 #endif
 #ifdef SUPPORT_DG2
 DEVICE_CONFIG(DG2_G10_A0, Dg2HwConfig, dg2G10DeviceIds, XE_FAMILY, XE_HPG_RELEASE)
@@ -36,29 +36,29 @@ DEVICE_CONFIG(DG2_G11_B1, Dg2HwConfig, dg2G11DeviceIds, XE_FAMILY, XE_HPG_RELEAS
 DEVICE_CONFIG(DG2_G12_A0, Dg2HwConfig, dg2G12DeviceIds, XE_FAMILY, XE_HPG_RELEASE)
 #endif
 #ifdef SUPPORT_ARL
-DEVICE_CONFIG(XE_LPGPLUS_A0, ArlHwConfig, arlDeviceIds, XE_FAMILY, XE_LPGPLUS_RELEASE)
+DEVICE_CONFIG(ARL_H_A0, ArlHwConfig, arlDeviceIds, XE_FAMILY, XE_LPGPLUS_RELEASE)
-DEVICE_CONFIG(XE_LPGPLUS_B0, ArlHwConfig, arlDeviceIds, XE_FAMILY, XE_LPGPLUS_RELEASE)
+DEVICE_CONFIG(ARL_H_B0, ArlHwConfig, arlDeviceIds, XE_FAMILY, XE_LPGPLUS_RELEASE)
 #endif
 #endif
 
 #ifdef SUPPORT_GEN12LP
 #ifdef SUPPORT_TGLLP
-DEVICE_CONFIG(TGL, TgllpHw1x6x16, tgllpDeviceIds, GEN12LP_FAMILY, GEN12LP_RELEASE)
+DEVICE_CONFIG(TGL, TgllpHw1x6x16, tgllpDeviceIds, XE_FAMILY, GEN12LP_RELEASE)
 #endif
 #ifdef SUPPORT_DG1
-DEVICE_CONFIG(DG1, Dg1HwConfig, dg1DeviceIds, GEN12LP_FAMILY, GEN12LP_RELEASE)
+DEVICE_CONFIG(DG1, Dg1HwConfig, dg1DeviceIds, XE_FAMILY, GEN12LP_RELEASE)
 #endif
 #ifdef SUPPORT_RKL
-DEVICE_CONFIG(RKL, RklHwConfig, rklDeviceIds, GEN12LP_FAMILY, GEN12LP_RELEASE)
+DEVICE_CONFIG(RKL, RklHwConfig, rklDeviceIds, XE_FAMILY, GEN12LP_RELEASE)
 #endif
 #ifdef SUPPORT_ADLS
-DEVICE_CONFIG(ADL_S, AdlsHwConfig, adlsDeviceIds, GEN12LP_FAMILY, GEN12LP_RELEASE)
+DEVICE_CONFIG(ADL_S, AdlsHwConfig, adlsDeviceIds, XE_FAMILY, GEN12LP_RELEASE)
 #endif
 #ifdef SUPPORT_ADLP
-DEVICE_CONFIG(ADL_P, AdlpHwConfig, adlpDeviceIds, GEN12LP_FAMILY, GEN12LP_RELEASE)
+DEVICE_CONFIG(ADL_P, AdlpHwConfig, adlpDeviceIds, XE_FAMILY, GEN12LP_RELEASE)
 #endif
 #ifdef SUPPORT_ADLN
-DEVICE_CONFIG(ADL_N, AdlnHwConfig, adlnDeviceIds, GEN12LP_FAMILY, GEN12LP_RELEASE)
+DEVICE_CONFIG(ADL_N, AdlnHwConfig, adlnDeviceIds, XE_FAMILY, GEN12LP_RELEASE)
 #endif
 #endif
 

shared/source/release_helper/release_helper_1270.cpp

@@ -19,12 +19,12 @@ constexpr auto release = ReleaseType::release1270;
 
 template <>
 bool ReleaseHelperHw<release>::isPipeControlPriorToNonPipelinedStateCommandsWARequired() const {
-    return hardwareIpVersion.value == AOT::MTL_M_A0;
+    return hardwareIpVersion.value == AOT::MTL_U_A0;
 }
 
 template <>
 bool ReleaseHelperHw<release>::isProgramAllStateComputeCommandFieldsWARequired() const {
-    return hardwareIpVersion.value == AOT::MTL_M_A0;
+    return hardwareIpVersion.value == AOT::MTL_U_A0;
 }
 
 template <>

shared/source/release_helper/release_helper_1271.cpp

@@ -19,12 +19,12 @@ constexpr auto release = ReleaseType::release1271;
 
 template <>
 bool ReleaseHelperHw<release>::isPipeControlPriorToNonPipelinedStateCommandsWARequired() const {
-    return hardwareIpVersion.value == AOT::MTL_P_A0;
+    return hardwareIpVersion.value == AOT::MTL_H_A0;
 }
 
 template <>
 bool ReleaseHelperHw<release>::isProgramAllStateComputeCommandFieldsWARequired() const {
-    return hardwareIpVersion.value == AOT::MTL_P_A0;
+    return hardwareIpVersion.value == AOT::MTL_H_A0;
 }
 
 template <>

shared/source/xe_hpg_core/enable_compiler_product_helper_arl.cpp

@@ -14,7 +14,7 @@ constexpr auto gfxProduct = IGFX_ARROWLAKE;
 namespace NEO {
 template <>
 uint32_t CompilerProductHelperHw<gfxProduct>::getDefaultHwIpVersion() const {
-    return AOT::XE_LPGPLUS_B0;
+    return AOT::ARL_H_B0;
 }
 
 template <>
@@ -27,10 +27,10 @@ uint32_t CompilerProductHelperHw<gfxProduct>::getProductConfigFromHwInfo(const H
     case 0x7D41: {
         switch (hwInfo.platform.usRevId) {
         case 0x0:
-            return AOT::MTL_M_A0;
+            return AOT::MTL_U_A0;
         case 0x3:
         case 0x6:
-            return AOT::MTL_M_B0;
+            return AOT::MTL_U_B0;
         }
         break;
     }
@@ -39,9 +39,9 @@ uint32_t CompilerProductHelperHw<gfxProduct>::getProductConfigFromHwInfo(const H
         switch (hwInfo.platform.usRevId) {
         case 0x0:
         case 0x3:
-            return AOT::XE_LPGPLUS_A0;
+            return AOT::ARL_H_A0;
         case 0x6:
-            return AOT::XE_LPGPLUS_B0;
+            return AOT::ARL_H_B0;
         }
         break;
     }

shared/source/xe_hpg_core/enable_compiler_product_helper_mtl.cpp

@@ -14,7 +14,7 @@ constexpr auto gfxProduct = IGFX_METEORLAKE;
 namespace NEO {
 template <>
 uint32_t CompilerProductHelperHw<gfxProduct>::getDefaultHwIpVersion() const {
-    return AOT::MTL_M_B0;
+    return AOT::MTL_U_B0;
 }
 
 template <>
@@ -28,10 +28,10 @@ uint32_t CompilerProductHelperHw<gfxProduct>::getProductConfigFromHwInfo(const H
         switch (hwInfo.platform.usRevId) {
         case 0x0:
         case 0x2:
-            return AOT::MTL_M_A0;
+            return AOT::MTL_U_A0;
         case 0x3:
         case 0x8:
-            return AOT::MTL_M_B0;
+            return AOT::MTL_U_B0;
         }
         break;
     }
@@ -40,19 +40,19 @@ uint32_t CompilerProductHelperHw<gfxProduct>::getProductConfigFromHwInfo(const H
         switch (hwInfo.platform.usRevId) {
         case 0x0:
         case 0x2:
-            return AOT::MTL_P_A0;
+            return AOT::MTL_H_A0;
         case 0x3:
         case 0x8:
-            return AOT::MTL_P_B0;
+            return AOT::MTL_H_B0;
         }
         break;
     }
     case 0x7D60: {
         switch (hwInfo.platform.usRevId) {
         case 0x0:
-            return AOT::MTL_M_A0;
+            return AOT::MTL_U_A0;
         case 0x2:
-            return AOT::MTL_M_B0;
+            return AOT::MTL_U_B0;
         }
         break;
     }

shared/test/common/xe_hpg_core/arl/product_configs_arl.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -10,7 +10,7 @@
 
 namespace AOT_ARL {
 inline constexpr AOT::PRODUCT_CONFIG productConfigs[] = {
-    AOT::MTL_M_B0,
+    AOT::MTL_U_B0,
-    AOT::XE_LPGPLUS_A0,
+    AOT::ARL_H_A0,
-    AOT::XE_LPGPLUS_B0};
+    AOT::ARL_H_B0};
 }

shared/test/common/xe_hpg_core/mtl/product_configs_mtl.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -10,8 +10,8 @@
 
 namespace AOT_MTL {
 inline constexpr AOT::PRODUCT_CONFIG productConfigs[] = {
-    AOT::MTL_M_A0,
+    AOT::MTL_U_A0,
-    AOT::MTL_M_B0,
+    AOT::MTL_U_B0,
-    AOT::MTL_P_A0,
+    AOT::MTL_H_A0,
-    AOT::MTL_P_B0};
+    AOT::MTL_H_B0};
 }

shared/test/unit_test/helpers/product_config_helper_tests.cpp

@@ -10,7 +10,7 @@
 #include "shared/source/helpers/hw_info.h"
 #include "shared/source/utilities/const_stringref.h"
 #include "shared/test/common/helpers/default_hw_info.h"
-#include "shared/test/common/test_macros/test.h"
+#include "shared/test/common/test_macros/hw_test.h"
 
 #include "platforms.h"
 
@@ -103,7 +103,7 @@ TEST_F(ProductConfigHelperTests, givenFamilyAcronymWhenAdjustDeviceNameThenNothi
     }
 }
 
-TEST_F(AotDeviceInfoTests, givenGen12lpFamilyAcronymWhenAdjustClosedRangeDeviceNamesThenProperReleaseAcronymsAreAssigned) {
+HWTEST2_F(AotDeviceInfoTests, givenGen12lpFamilyAcronymWhenAdjustClosedRangeDeviceNamesThenProperReleaseAcronymsAreAssigned, IsGen12LP) {
     bool isGen12lpFamilyEnabled = productConfigHelper->getFamilyFromDeviceName("gen12lp") != AOT::UNKNOWN_FAMILY;
     if (productConfigHelper->getReleasesAcronyms().size() < 2 || isGen12lpFamilyEnabled) {
         GTEST_SKIP();

shared/test/unit_test/xe_hpg_core/arl/product_helper_tests_arl.cpp

@@ -30,12 +30,12 @@ ARLTEST_F(ArlProductHelper, givenArlWithoutHwIpVersionInHwInfoWhenGettingIpVersi
         for (auto &revision : {0}) {
             hwInfo.platform.usRevId = revision;
 
-            EXPECT_EQ(AOT::MTL_M_A0, compilerProductHelper->getHwIpVersion(hwInfo));
+            EXPECT_EQ(AOT::MTL_U_A0, compilerProductHelper->getHwIpVersion(hwInfo));
         }
         for (auto &revision : {3, 6}) {
             hwInfo.platform.usRevId = revision;
 
-            EXPECT_EQ(AOT::MTL_M_B0, compilerProductHelper->getHwIpVersion(hwInfo));
+            EXPECT_EQ(AOT::MTL_U_B0, compilerProductHelper->getHwIpVersion(hwInfo));
         }
         hwInfo.platform.usRevId = 0xdead;
 
@@ -47,12 +47,12 @@ ARLTEST_F(ArlProductHelper, givenArlWithoutHwIpVersionInHwInfoWhenGettingIpVersi
         for (auto &revision : {0, 3}) {
             hwInfo.platform.usRevId = revision;
 
-            EXPECT_EQ(AOT::XE_LPGPLUS_A0, compilerProductHelper->getHwIpVersion(hwInfo));
+            EXPECT_EQ(AOT::ARL_H_A0, compilerProductHelper->getHwIpVersion(hwInfo));
         }
         for (auto &revision : {6}) {
             hwInfo.platform.usRevId = revision;
 
-            EXPECT_EQ(AOT::XE_LPGPLUS_B0, compilerProductHelper->getHwIpVersion(hwInfo));
+            EXPECT_EQ(AOT::ARL_H_B0, compilerProductHelper->getHwIpVersion(hwInfo));
         }
         hwInfo.platform.usRevId = 0xdead;
 

shared/test/unit_test/xe_hpg_core/command_encoder_tests_xe_hpg_core.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -107,7 +107,7 @@ void testProgrammingStateComputeModeXeLpgWithDisabledWa(ExecutionEnvironment &ex
 using CommandEncoderXeHpgTests = ::testing::Test;
 
 HWTEST2_F(CommandEncoderXeHpgTests, whenProgrammingStateComputeModeThenProperFieldsAreSet, IsXeLpg) {
-    AOT::PRODUCT_CONFIG ipReleases[] = {AOT::MTL_M_A0, AOT::MTL_M_B0, AOT::MTL_P_A0, AOT::MTL_P_B0, AOT::XE_LPGPLUS_A0, AOT::XE_LPGPLUS_B0};
+    AOT::PRODUCT_CONFIG ipReleases[] = {AOT::MTL_U_A0, AOT::MTL_U_B0, AOT::MTL_H_A0, AOT::MTL_H_B0, AOT::ARL_H_A0, AOT::ARL_H_B0};
     for (auto &ipRelease : ipReleases) {
 
         MockExecutionEnvironment executionEnvironment{};

shared/test/unit_test/xe_hpg_core/mtl/product_config_helper_tests_mtl.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -36,7 +36,7 @@ MTLTEST_F(ProductConfigHelperMtlTests, givenVariousVariantsOfXeLpgAcronymsWhenGe
 
 MTLTEST_F(ProductConfigHelperMtlTests, givenMtlConfigsWhenSearchForDeviceAcronymsThenObjectIsFound) {
     auto productConfigHelper = std::make_unique<ProductConfigHelper>();
-    std::vector<AOT::PRODUCT_CONFIG> mtlConfigs = {AOT::MTL_M_B0, AOT::MTL_P_B0};
+    std::vector<AOT::PRODUCT_CONFIG> mtlConfigs = {AOT::MTL_U_B0, AOT::MTL_H_B0};
     auto deviceAcronyms = productConfigHelper->getDeviceAcronyms();
     for (const auto &config : mtlConfigs) {
         auto acronym = productConfigHelper->getAcronymForProductConfig(config);

shared/test/unit_test/xe_hpg_core/mtl/product_helper_tests_mtl.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -35,11 +35,11 @@ MTLTEST_F(MtlProductHelper, givenMtlWithoutHwIpVersionInHwInfoWhenGettingIpVersi
     hwInfo.platform.usDeviceID = 0x7D60;
     hwInfo.platform.usRevId = 0;
 
-    EXPECT_EQ(AOT::MTL_M_A0, compilerProductHelper->getHwIpVersion(hwInfo));
+    EXPECT_EQ(AOT::MTL_U_A0, compilerProductHelper->getHwIpVersion(hwInfo));
 
     hwInfo.platform.usRevId = 2;
 
-    EXPECT_EQ(AOT::MTL_M_B0, compilerProductHelper->getHwIpVersion(hwInfo));
+    EXPECT_EQ(AOT::MTL_U_B0, compilerProductHelper->getHwIpVersion(hwInfo));
 
     hwInfo.platform.usRevId = 0xdead;
 
@@ -50,12 +50,12 @@ MTLTEST_F(MtlProductHelper, givenMtlWithoutHwIpVersionInHwInfoWhenGettingIpVersi
         for (auto &revision : {0, 2}) {
             hwInfo.platform.usRevId = revision;
 
-            EXPECT_EQ(AOT::MTL_M_A0, compilerProductHelper->getHwIpVersion(hwInfo));
+            EXPECT_EQ(AOT::MTL_U_A0, compilerProductHelper->getHwIpVersion(hwInfo));
         }
         for (auto &revision : {3, 8}) {
             hwInfo.platform.usRevId = revision;
 
-            EXPECT_EQ(AOT::MTL_M_B0, compilerProductHelper->getHwIpVersion(hwInfo));
+            EXPECT_EQ(AOT::MTL_U_B0, compilerProductHelper->getHwIpVersion(hwInfo));
         }
         hwInfo.platform.usRevId = 0xdead;
 
@@ -67,12 +67,12 @@ MTLTEST_F(MtlProductHelper, givenMtlWithoutHwIpVersionInHwInfoWhenGettingIpVersi
         for (auto &revision : {0, 2}) {
             hwInfo.platform.usRevId = revision;
 
-            EXPECT_EQ(AOT::MTL_P_A0, compilerProductHelper->getHwIpVersion(hwInfo));
+            EXPECT_EQ(AOT::MTL_H_A0, compilerProductHelper->getHwIpVersion(hwInfo));
         }
         for (auto &revision : {3, 8}) {
             hwInfo.platform.usRevId = revision;
 
-            EXPECT_EQ(AOT::MTL_P_B0, compilerProductHelper->getHwIpVersion(hwInfo));
+            EXPECT_EQ(AOT::MTL_H_B0, compilerProductHelper->getHwIpVersion(hwInfo));
         }
         hwInfo.platform.usRevId = 0xdead;
 

shared/test/unit_test/xe_hpg_core/os_agnostic_product_helper_xe_lpg_tests.cpp

@@ -271,7 +271,7 @@ HWTEST2_F(XeLpgProductHelperTests, givenHwIpVersionWhenIsPipeControlPriorToNonPi
     HardwareInfo hwInfo = *defaultHwInfo;
     auto isRcs = false;
 
-    AOT::PRODUCT_CONFIG ipReleases[] = {AOT::MTL_M_A0, AOT::MTL_M_B0, AOT::MTL_P_A0, AOT::MTL_P_B0, AOT::XE_LPGPLUS_A0, AOT::XE_LPGPLUS_B0};
+    AOT::PRODUCT_CONFIG ipReleases[] = {AOT::MTL_U_A0, AOT::MTL_U_B0, AOT::MTL_H_A0, AOT::MTL_H_B0, AOT::ARL_H_A0, AOT::ARL_H_B0};
     for (auto &ipRelease : ipReleases) {
         hwInfo.ipVersion.value = ipRelease;
         auto releaseHelper = ReleaseHelper::create(ipRelease);
@@ -327,9 +327,9 @@ HWTEST2_F(XeLpgProductHelperTests, givenCompilerProductHelperWhenGetDefaultHwIpV
     HardwareInfo hwInfo = *defaultHwInfo;
     auto compilerProductHelper = CompilerProductHelper::create(hwInfo.platform.eProductFamily);
     if (hwInfo.platform.eProductFamily == IGFX_ARROWLAKE) {
-        EXPECT_EQ(AOT::XE_LPGPLUS_B0, compilerProductHelper->getDefaultHwIpVersion());
+        EXPECT_EQ(AOT::ARL_H_B0, compilerProductHelper->getDefaultHwIpVersion());
     } else {
-        EXPECT_EQ(AOT::MTL_M_B0, compilerProductHelper->getDefaultHwIpVersion());
+        EXPECT_EQ(AOT::MTL_U_B0, compilerProductHelper->getDefaultHwIpVersion());
     }
 }
 
@@ -372,4 +372,4 @@ HWTEST2_F(XeLpgProductHelperTests, givenPatIndexWhenCheckIsCoherentAllocationThe
     for (auto patIndex : listOfNonCoherentPatIndexes) {
         EXPECT_FALSE(productHelper->isCoherentAllocation(patIndex).value());
     }
-}
+}

third_party/aot_config_headers/.version

@@ -0,0 +1 @@
+git_revision: 8b7b40b8e55db14765852563adc3ee0ab0e33e32

third_party/aot_config_headers/platforms.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2023 Intel Corporation
+ * Copyright (C) 2021-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -29,11 +29,11 @@ enum PRODUCT_CONFIG : uint32_t {
     EHL = 0x02c08000,
     TGL = 0x03000000,
     RKL = 0x03004000,
-    RPL_S = 0x03008000,
     ADL_S = 0x03008000,
     ADL_P = 0x0300c000,
     ADL_N = 0x03010000,
     DG1 = 0x03028000,
+    XEHP_SDV = 0x030c8004,
     DG2_G10_A0 = 0x030dc000,
     DG2_G10_A1 = 0x030dc001,
     DG2_G10_B0 = 0x030dc004,
@@ -49,13 +49,19 @@ enum PRODUCT_CONFIG : uint32_t {
     PVC_XT_B1 = 0x030f0006,
     PVC_XT_C0 = 0x030f0007,
     PVC_XT_C0_VG = 0x030f4007,
-    MTL_M_A0 = 0x03118000,
+    MTL_U_A0 = 0x03118000,
-    MTL_M_B0 = 0x03118004,
+    MTL_U_B0 = 0x03118004,
-    MTL_P_A0 = 0x0311c000,
+    MTL_H_A0 = 0x0311c000,
-    MTL_P_B0 = 0x0311c004,
+    MTL_H_B0 = 0x0311c004,
-    XE_LPGPLUS_A0 = 0x03128000,
+    ARL_H_A0 = 0x03128000,
-    XE_LPGPLUS_B0 = 0x03128004,
+    ARL_H_B0 = 0x03128004,
-    CONFIG_MAX_PLATFORM,
+    BMG_G21_A0 = 0x05004000,
+    BMG_G21_A1 = 0x05004001,
+    BMG_G21_B0 = 0x05004004,
+    LNL_A0 = 0x05010000,
+    LNL_A1 = 0x05010001,
+    LNL_B0 = 0x05010004,
+    CONFIG_MAX_PLATFORM
 };
 
 enum RELEASE : uint32_t {
@@ -63,12 +69,17 @@ enum RELEASE : uint32_t {
     GEN8_RELEASE,
     GEN9_RELEASE,
     GEN11_RELEASE,
-    GEN12LP_RELEASE,
+    XE_LP_RELEASE,
+    GEN12LP_RELEASE = XE_LP_RELEASE,
+    XE_HP_RELEASE,
     XE_HPG_RELEASE,
     XE_HPC_RELEASE,
+    XE_HPC_VG_RELEASE,
     XE_LPG_RELEASE,
     XE_LPGPLUS_RELEASE,
-    RELEASE_MAX,
+    XE2_HPG_RELEASE,
+    XE2_LPG_RELEASE,
+    RELEASE_MAX
 };
 
 enum FAMILY : uint32_t {
@@ -76,130 +87,199 @@ enum FAMILY : uint32_t {
     GEN8_FAMILY,
     GEN9_FAMILY,
     GEN11_FAMILY,
-    GEN12LP_FAMILY,
     XE_FAMILY,
-    FAMILY_MAX,
+    XE2_FAMILY,
+    FAMILY_MAX
 };
 
 inline const std::map<std::string, FAMILY> familyAcronyms = {
-#ifdef SUPPORT_GEN8
+#ifdef SUPPORT_AOT_GEN8
     {"gen8", GEN8_FAMILY},
 #endif
-#ifdef SUPPORT_GEN9
+#ifdef SUPPORT_AOT_GEN9
     {"gen9", GEN9_FAMILY},
 #endif
-#ifdef SUPPORT_GEN11
+#ifdef SUPPORT_AOT_GEN11
     {"gen11", GEN11_FAMILY},
 #endif
-#ifdef SUPPORT_GEN12LP
+#ifdef SUPPORT_AOT_XE
-    {"gen12lp", GEN12LP_FAMILY},
-#endif
-#if defined(SUPPORT_XE_HPC_CORE) || defined(SUPPORT_XE_HPG_CORE)
     {"xe", XE_FAMILY},
 #endif
+#ifdef SUPPORT_AOT_XE2
+    {"xe2", XE2_FAMILY},
+#endif
 };
 
 inline const std::map<std::string, RELEASE> releaseAcronyms = {
-#ifdef SUPPORT_GEN8
+#ifdef SUPPORT_AOT_GEN8
     {"gen8", GEN8_RELEASE},
 #endif
-#ifdef SUPPORT_GEN9
+#ifdef SUPPORT_AOT_GEN9
     {"gen9", GEN9_RELEASE},
 #endif
-#ifdef SUPPORT_GEN11
+#ifdef SUPPORT_AOT_GEN11
     {"gen11", GEN11_RELEASE},
 #endif
-#ifdef SUPPORT_GEN12LP
+#ifdef SUPPORT_AOT_XE_LP
-    {"gen12lp", GEN12LP_RELEASE},
+    {"xe-lp", XE_LP_RELEASE},
+    {"gen12lp", XE_LP_RELEASE},
 #endif
-#if defined(SUPPORT_XE_HPG_CORE) && defined(SUPPORT_DG2)
+#ifdef SUPPORT_AOT_XE_HP
+    {"xe-hp", XE_HP_RELEASE},
+#endif
+#ifdef SUPPORT_AOT_XE_HPG
     {"xe-hpg", XE_HPG_RELEASE},
 #endif
-#ifdef SUPPORT_XE_HPC_CORE
+#ifdef SUPPORT_AOT_XE_HPC
     {"xe-hpc", XE_HPC_RELEASE},
 #endif
-#if defined(SUPPORT_XE_HPG_CORE) && defined(SUPPORT_MTL)
+#ifdef SUPPORT_AOT_XE_HPC_VG
+    {"xe-hpc-vg", XE_HPC_VG_RELEASE},
+#endif
+#ifdef SUPPORT_AOT_XE_LPG
     {"xe-lpg", XE_LPG_RELEASE},
 #endif
-#if defined(SUPPORT_XE_HPG_CORE) && defined(SUPPORT_ARL)
+#ifdef SUPPORT_AOT_XE_LPGPLUS
     {"xe-lpgplus", XE_LPGPLUS_RELEASE},
 #endif
+#ifdef SUPPORT_AOT_XE2_HPG
+    {"xe2-hpg", XE2_HPG_RELEASE},
+#endif
+#ifdef SUPPORT_AOT_XE2_LPG
+    {"xe2-lpg", XE2_LPG_RELEASE},
+#endif
 };
 
-inline const std::map<std::string, AOT::PRODUCT_CONFIG> deviceAcronyms = {
+inline const std::map<std::string, PRODUCT_CONFIG> deviceAcronyms = {
-#ifdef SUPPORT_BDW
+#ifdef SUPPORT_AOT_BDW
-    {"bdw", BDW},
+  {"bdw", BDW},
 #endif
-#ifdef SUPPORT_SKL
+#ifdef SUPPORT_AOT_SKL
-    {"skl", SKL},
+  {"skl", SKL},
 #endif
-#ifdef SUPPORT_KBL
+#ifdef SUPPORT_AOT_KBL
-    {"kbl", KBL},
+  {"kbl", KBL},
-    {"aml", AML},
 #endif
-#ifdef SUPPORT_CFL
+#ifdef SUPPORT_AOT_CFL
-    {"cfl", CFL},
+  {"cfl", CFL},
-    {"cml", CML},
-    {"whl", WHL},
 #endif
-#ifdef SUPPORT_BXT
+#ifdef SUPPORT_AOT_BXT
-    {"apl", APL},
+  {"apl", APL},
-    {"bxt", APL},
+  {"bxt", APL},
 #endif
-#ifdef SUPPORT_GLK
+#ifdef SUPPORT_AOT_GLK
-    {"glk", GLK},
+  {"glk", GLK},
 #endif
-#ifdef SUPPORT_ICLLP
+#ifdef SUPPORT_AOT_WHL
-    {"icllp", ICL},
+  {"whl", WHL},
 #endif
-#ifdef SUPPORT_LKF
+#ifdef SUPPORT_AOT_AML
-    {"lkf", LKF},
+  {"aml", AML},
 #endif
-#ifdef SUPPORT_EHL
+#ifdef SUPPORT_AOT_CML
-    {"ehl", EHL},
+  {"cml", CML},
-    {"jsl", EHL},
 #endif
-#ifdef SUPPORT_TGLLP
+#ifdef SUPPORT_AOT_ICLLP
-    {"tgllp", TGL},
+  {"icllp", ICL},
+  {"icl", ICL},
 #endif
-#ifdef SUPPORT_RKL
+#ifdef SUPPORT_AOT_LKF1
-    {"rkl", RKL},
+  {"lkf", LKF},
 #endif
-#ifdef SUPPORT_ADLS
+#ifdef SUPPORT_AOT_JSL
-    {"adl-s", ADL_S},
+  {"ehl", EHL},
+  {"jsl", EHL},
 #endif
-#ifdef SUPPORT_ADLP
+#ifdef SUPPORT_AOT_TGLLP
-    {"adl-p", ADL_P},
+  {"tgllp", TGL},
+  {"tgl", TGL},
 #endif
-#ifdef SUPPORT_ADLN
+#ifdef SUPPORT_AOT_RKLC
-    {"adl-n", ADL_N},
+  {"rkl", RKL},
 #endif
-#ifdef SUPPORT_DG1
+#ifdef SUPPORT_AOT_ADLS
-    {"dg1", DG1},
+  {"adl-s", ADL_S},
+  {"rpl-s", ADL_S},
 #endif
-#ifdef SUPPORT_DG2
+#ifdef SUPPORT_AOT_ADL
-    {"acm-g10", DG2_G10_C0},
+  {"adl-p", ADL_P},
-    {"dg2-g10", DG2_G10_C0},
+  {"rpl-p", ADL_P},
-    {"ats-m150", DG2_G10_C0},
+  {"adl-n", ADL_N},
-    {"acm-g11", DG2_G11_B1},
-    {"dg2-g11", DG2_G11_B1},
-    {"ats-m75", DG2_G11_B1},
-    {"acm-g12", DG2_G12_A0},
-    {"dg2-g12", DG2_G12_A0},
 #endif
-#ifdef SUPPORT_PVC
+#ifdef SUPPORT_AOT_DG1
-    {"pvc-sdv", PVC_XL_A0P},
+  {"dg1", DG1},
-    {"pvc", PVC_XT_C0},
+#endif
+#ifdef SUPPORT_AOT_DG2
+  {"acm-g10", DG2_G10_C0},
+  {"dg2-g10", DG2_G10_C0},
+  {"ats-m150", DG2_G10_C0},
+  {"acm-g11", DG2_G11_B1},
+  {"dg2-g11", DG2_G11_B1},
+  {"ats-m75", DG2_G11_B1},
+  {"acm-g12", DG2_G12_A0},
+  {"dg2-g12", DG2_G12_A0},
+#endif
+#ifdef SUPPORT_AOT_PVC
+  {"pvc-sdv", PVC_XL_A0P},
+  {"pvc", PVC_XT_C0},
+  {"pvc-vg", PVC_XT_C0_VG},
+#endif
+#ifdef SUPPORT_AOT_MTL
+  {"mtl-u", MTL_U_B0},
+  {"arl-u", MTL_U_B0},
+  {"arl-s", MTL_U_B0},
+  {"mtl-h", MTL_H_B0},
+#endif
+#ifdef SUPPORT_AOT_ARL
+  {"arl-h", ARL_H_B0},
+#endif
+#ifdef SUPPORT_AOT_BMG
+  {"bmg-g21", BMG_G21_B0},
+#endif
+#ifdef SUPPORT_AOT_LNL
+  {"lnl-m", LNL_B0},
+#endif
+};
+
+inline const std::map<std::string, PRODUCT_CONFIG> rtlIdAcronyms = {
+#ifdef SUPPORT_AOT_DG2
+    {"dg2-g10-a0", DG2_G10_A0},
+    {"dg2-g10-a1", DG2_G10_A1},
+    {"dg2-g10-b0", DG2_G10_B0},
+    {"dg2-g10-c0", DG2_G10_C0},
+    {"dg2-g11-a0", DG2_G11_A0},
+    {"dg2-g11-b0", DG2_G11_B0},
+    {"dg2-g11-b1", DG2_G11_B1},
+    {"dg2-g12-a0", DG2_G12_A0},
+#endif
+#ifdef SUPPORT_AOT_PVC
+    {"pvc-xl-a0", PVC_XL_A0},
+    {"pvc-xl-a0p", PVC_XL_A0P},
+    {"pvc-xt-a0", PVC_XT_A0},
+    {"pvc-xt-b0", PVC_XT_B0},
+    {"pvc-xt-b1", PVC_XT_B1},
+    {"pvc-xt-c0", PVC_XT_C0},
     {"pvc-xt-c0-vg", PVC_XT_C0_VG},
 #endif
-#ifdef SUPPORT_MTL
+#ifdef SUPPORT_AOT_MTL
-    {"mtl-s", MTL_M_B0},
+    {"mtl-u-a0", MTL_U_A0},
-    {"mtl-m", MTL_M_B0},
+    {"mtl-u-b0", MTL_U_B0},
-    {"mtl-p", MTL_P_B0},
+    {"mtl-h-a0", MTL_H_A0},
+    {"mtl-h-b0", MTL_H_B0},
 #endif
-#ifdef SUPPORT_ARL
+#ifdef SUPPORT_AOT_ARL
-    {"xe-lpgplus-a0", XE_LPGPLUS_A0},
+    {"arl-h-a0", ARL_H_A0},
-    {"xe-lpgplus-b0", XE_LPGPLUS_B0},
+    {"arl-h-b0", ARL_H_B0},
+#endif
+#ifdef SUPPORT_AOT_BMG
+    {"bmg-g21-a0", BMG_G21_A0},
+    {"bmg-g21-a1", BMG_G21_A1},
+    {"bmg-g21-b0", BMG_G21_B0},
+#endif
+#ifdef SUPPORT_AOT_LNL
+    {"lnl-a0", LNL_A0},
+    {"lnl-a1", LNL_A1},
+    {"lnl-b0", LNL_B0},
 #endif
 };
 } // namespace AOT