refactor: add wrapper for max product enum value

JablonskiMateusz · Compute-Runtime-Automation · commit 8db92240fc3f · 2025-11-20T08:04:57.000+01:00
Signed-off-by: Mateusz Jablonski &lt;mateusz.jablonski@intel.com&gt;
diff --git a/level_zero/core/source/cmdlist/cmdlist_imp.cpp b/level_zero/core/source/cmdlist/cmdlist_imp.cpp
@@ -39,8 +39,8 @@ void CommandList::setPatchingPreamble(bool patching, bool saveWait) {
     }
 }
 
-CommandListAllocatorFn commandListFactory[IGFX_MAX_PRODUCT] = {};
-CommandListAllocatorFn commandListFactoryImmediate[IGFX_MAX_PRODUCT] = {};
+CommandListAllocatorFn commandListFactory[NEO::maxProductEnumValue] = {};
+CommandListAllocatorFn commandListFactoryImmediate[NEO::maxProductEnumValue] = {};
 
 ze_result_t CommandListImp::destroy() {
     if (this->isBcsSplitNeeded) {
@@ -104,7 +104,7 @@ CommandList *CommandList::create(uint32_t productFamily, Device *device, NEO::En
                                  ze_command_list_flags_t flags, ze_result_t &returnValue,
                                  bool internalUsage) {
     CommandListAllocatorFn allocator = nullptr;
-    if (productFamily < IGFX_MAX_PRODUCT) {
+    if (productFamily < NEO::maxProductEnumValue) {
         allocator = commandListFactory[productFamily];
     }
 
@@ -170,7 +170,7 @@ CommandList *CommandList::createImmediate(uint32_t productFamily, Device *device
         cmdQdesc.mode = static_cast<ze_command_queue_mode_t>(overrideImmediateCmdListSyncMode);
     }
     CommandListAllocatorFn allocator = nullptr;
-    if (productFamily < IGFX_MAX_PRODUCT) {
+    if (productFamily < NEO::maxProductEnumValue) {
         allocator = commandListFactoryImmediate[productFamily];
     }
 
diff --git a/level_zero/core/source/cmdqueue/cmdqueue.cpp b/level_zero/core/source/cmdqueue/cmdqueue.cpp
@@ -33,7 +33,7 @@
 
 namespace L0 {
 
-CommandQueueAllocatorFn commandQueueFactory[IGFX_MAX_PRODUCT] = {};
+CommandQueueAllocatorFn commandQueueFactory[NEO::maxProductEnumValue] = {};
 
 bool CommandQueue::frontEndTrackingEnabled() const {
     return NEO::debugManager.flags.AllowPatchingVfeStateInCommandLists.get() || this->frontEndStateTracking;
@@ -234,7 +234,7 @@ void CommandQueueImp::postSyncOperations(bool hangDetected) {
 CommandQueue *CommandQueue::create(uint32_t productFamily, Device *device, NEO::CommandStreamReceiver *csr,
                                    const ze_command_queue_desc_t *desc, bool isCopyOnly, bool isInternal, bool immediateCmdListQueue, ze_result_t &returnValue) {
     CommandQueueAllocatorFn allocator = nullptr;
-    if (productFamily < IGFX_MAX_PRODUCT) {
+    if (productFamily < NEO::maxProductEnumValue) {
         allocator = commandQueueFactory[productFamily];
     }
 
diff --git a/level_zero/core/source/image/image_imp.cpp b/level_zero/core/source/image/image_imp.cpp
@@ -25,7 +25,7 @@
 #include "neo_igfxfmid.h"
 
 namespace L0 {
-ImageAllocatorFn imageFactory[IGFX_MAX_PRODUCT] = {};
+ImageAllocatorFn imageFactory[NEO::maxProductEnumValue] = {};
 
 bool isImportedWin32Handle(const ze_image_desc_t *imgDesc) {
     const ze_base_desc_t *extendedDesc = reinterpret_cast<const ze_base_desc_t *>(imgDesc->pNext);
@@ -178,7 +178,7 @@ NEO::SurfaceStateInHeapInfo *ImageImp::getBindlessSlot() {
 ze_result_t Image::create(uint32_t productFamily, Device *device, const ze_image_desc_t *desc, Image **pImage) {
     ze_result_t result = ZE_RESULT_SUCCESS;
     ImageAllocatorFn allocator = nullptr;
-    if (productFamily < IGFX_MAX_PRODUCT) {
+    if (productFamily < NEO::maxProductEnumValue) {
         allocator = imageFactory[productFamily];
     }
 
diff --git a/level_zero/core/source/kernel/kernel.cpp b/level_zero/core/source/kernel/kernel.cpp
@@ -11,6 +11,6 @@
 
 namespace L0 {
 
-KernelAllocatorFn kernelFactory[IGFX_MAX_PRODUCT] = {};
+KernelAllocatorFn kernelFactory[NEO::maxProductEnumValue] = {};
 
 } // namespace L0
diff --git a/level_zero/core/source/kernel/kernel_imp.cpp b/level_zero/core/source/kernel/kernel_imp.cpp
@@ -1457,7 +1457,7 @@ void KernelImp::patchGlobalOffset() {
 
 Kernel *Kernel::create(uint32_t productFamily, Module *module,
                        const ze_kernel_desc_t *desc, ze_result_t *res) {
-    UNRECOVERABLE_IF(productFamily >= IGFX_MAX_PRODUCT);
+    UNRECOVERABLE_IF(productFamily >= NEO::maxProductEnumValue);
     KernelAllocatorFn allocator = kernelFactory[productFamily];
     auto kernel = static_cast<KernelImp *>(allocator(module));
     *res = kernel->initialize(desc);
diff --git a/level_zero/core/source/mutable_cmdlist/mutable_cmdlist_imp.cpp b/level_zero/core/source/mutable_cmdlist/mutable_cmdlist_imp.cpp
@@ -82,7 +82,7 @@ void MutableResidencyAllocations::cleanResidencyContainer() {
     immutableResidencySize = 0;
 }
 
-MutableCommandListAllocFn mutableCommandListFactory[IGFX_MAX_PRODUCT] = {};
+MutableCommandListAllocFn mutableCommandListFactory[NEO::maxProductEnumValue] = {};
 
 MutableCommandList *MutableCommandList::fromHandle(ze_command_list_handle_t handle) {
     return static_cast<MutableCommandList *>(L0::CommandList::fromHandle(handle)->asMutable());
@@ -91,7 +91,7 @@ MutableCommandList *MutableCommandList::fromHandle(ze_command_list_handle_t hand
 CommandList *MutableCommandList::create(uint32_t productFamily, Device *device, NEO::EngineGroupType engineGroupType,
                                         ze_command_list_flags_t flags, ze_result_t &resultValue, bool useInternalEngineType) {
     MutableCommandListAllocFn allocator = nullptr;
-    if (productFamily < IGFX_MAX_PRODUCT) {
+    if (productFamily < NEO::maxProductEnumValue) {
         allocator = mutableCommandListFactory[productFamily];
     }
     if (allocator == nullptr) {
diff --git a/level_zero/core/source/sampler/sampler_imp.cpp b/level_zero/core/source/sampler/sampler_imp.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,7 +11,7 @@
 
 namespace L0 {
 
-SamplerAllocatorFn samplerFactory[IGFX_MAX_PRODUCT] = {};
+SamplerAllocatorFn samplerFactory[NEO::maxProductEnumValue] = {};
 
 ze_result_t SamplerImp::destroy() {
     delete this;
@@ -25,7 +25,7 @@ ze_result_t SamplerImp::initialize(Device *device, const ze_sampler_desc_t *desc
 
 Sampler *Sampler::create(uint32_t productFamily, Device *device, const ze_sampler_desc_t *desc) {
     SamplerAllocatorFn allocator = nullptr;
-    if (productFamily < IGFX_MAX_PRODUCT) {
+    if (productFamily < NEO::maxProductEnumValue) {
         allocator = samplerFactory[productFamily];
     }
 
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp
@@ -125,7 +125,7 @@ TEST_F(DefaultDescriptorWithoutBlitterTest, givenDeviceWithoutBlitterSupportWhen
 
 TEST_F(CommandListCreateTests, whenCommandListIsCreatedWithInvalidProductFamilyThenFailureIsReturned) {
     ze_result_t returnValue;
-    std::unique_ptr<L0::CommandList> commandList(CommandList::create(PRODUCT_FAMILY::IGFX_MAX_PRODUCT, device, NEO::EngineGroupType::renderCompute, 0u, returnValue, false));
+    std::unique_ptr<L0::CommandList> commandList(CommandList::create(NEO::maxProductEnumValue, device, NEO::EngineGroupType::renderCompute, 0u, returnValue, false));
     EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, returnValue);
     ASSERT_EQ(nullptr, commandList);
 }
@@ -134,7 +134,7 @@ TEST_F(CommandListCreateTests, whenCommandListImmediateIsCreatedWithInvalidProdu
     ze_result_t returnValue;
     const ze_command_queue_desc_t desc = {};
     bool internalEngine = true;
-    std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(PRODUCT_FAMILY::IGFX_MAX_PRODUCT,
+    std::unique_ptr<L0::CommandList> commandList(CommandList::createImmediate(NEO::maxProductEnumValue,
                                                                               device,
                                                                               &desc,
                                                                               internalEngine,
diff --git a/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_1.cpp b/level_zero/core/test/unit_tests/sources/cmdqueue/test_cmdqueue_1.cpp
@@ -291,7 +291,7 @@ TEST_F(CommandQueueCreate, whenCreatingCommandQueueWithInvalidProductFamilyThenF
     ze_result_t returnValue;
     auto csr = std::unique_ptr<NEO::CommandStreamReceiver>(neoDevice->createCommandStreamReceiver());
     csr->setupContext(*neoDevice->getDefaultEngine().osContext);
-    L0::CommandQueue *commandQueue = CommandQueue::create(PRODUCT_FAMILY::IGFX_MAX_PRODUCT,
+    L0::CommandQueue *commandQueue = CommandQueue::create(NEO::maxProductEnumValue,
                                                           device,
                                                           csr.get(),
                                                           &desc,
diff --git a/level_zero/core/test/unit_tests/sources/mutable_cmdlist/tests/mutable_cmdlist_tests.cpp b/level_zero/core/test/unit_tests/sources/mutable_cmdlist/tests/mutable_cmdlist_tests.cpp
@@ -30,7 +30,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE,
             givenInvalidProductWhenCreatingCommandListThenNoObjectCreated) {
     ze_result_t returnValue;
 
-    auto mcl = MutableCommandList::create(IGFX_MAX_PRODUCT, device, this->engineGroupType, 0, returnValue, false);
+    auto mcl = MutableCommandList::create(NEO::maxProductEnumValue, device, this->engineGroupType, 0, returnValue, false);
     EXPECT_EQ(nullptr, mcl);
     EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, returnValue);
 }
diff --git a/level_zero/core/test/unit_tests/sources/sampler/test_sampler.cpp b/level_zero/core/test/unit_tests/sources/sampler/test_sampler.cpp
@@ -184,7 +184,7 @@ HWTEST2_F(ContextCreateSamplerTest, givenInvalidHardwareFamilyThenSamplerIsNotCr
     desc.filterMode = filterMode;
     desc.isNormalized = isNormalized;
 
-    L0::Sampler *sampler = Sampler::create(IGFX_MAX_PRODUCT, device, &desc);
+    L0::Sampler *sampler = Sampler::create(NEO::maxProductEnumValue, device, &desc);
 
     EXPECT_EQ(nullptr, sampler);
 }
diff --git a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.cpp b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -10,7 +10,7 @@
 namespace L0 {
 namespace Sysman {
 
-SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[IGFX_MAX_PRODUCT] = {};
+SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[NEO::maxProductEnumValue] = {};
 
 }
 } // namespace L0
diff --git a/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h b/level_zero/sysman/source/shared/linux/product_helper/sysman_product_helper.h
@@ -35,7 +35,7 @@ enum class RasInterfaceType;
 enum class SysfsValueUnit;
 
 using SysmanProductHelperCreateFunctionType = std::unique_ptr<SysmanProductHelper> (*)();
-extern SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[IGFX_MAX_PRODUCT];
+extern SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[NEO::maxProductEnumValue];
 
 class SysmanProductHelper {
   public:
diff --git a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.cpp b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -10,7 +10,7 @@
 namespace L0 {
 namespace Sysman {
 
-SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[IGFX_MAX_PRODUCT] = {};
+SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[NEO::maxProductEnumValue] = {};
 
 }
 } // namespace L0
diff --git a/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h b/level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper.h
@@ -29,7 +29,7 @@ class SysmanProductHelper;
 class WddmSysmanImp;
 
 using SysmanProductHelperCreateFunctionType = std::unique_ptr<SysmanProductHelper> (*)();
-extern SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[IGFX_MAX_PRODUCT];
+extern SysmanProductHelperCreateFunctionType sysmanProductHelperFactory[NEO::maxProductEnumValue];
 static const std::map<zes_power_domain_t, KmdSysman::PowerDomainsType> powerGroupToDomainTypeMap = {
     {ZES_POWER_DOMAIN_CARD, KmdSysman::PowerDomainsType::powerDomainCard},
     {ZES_POWER_DOMAIN_PACKAGE, KmdSysman::PowerDomainsType::powerDomainPackage},
diff --git a/opencl/test/unit_test/offline_compiler/decoder/iga_wrapper_tests.cpp b/opencl/test/unit_test/offline_compiler/decoder/iga_wrapper_tests.cpp
@@ -307,7 +307,7 @@ TEST_F(IgaWrapperTest, GivenIgcWrapperWhenCallingSetGfxCoreMultipleTimesThenFirs
 
 TEST_F(IgaWrapperTest, GivenIgcWrapperWhenCallingSetProductFamilyMultipleTimesThenFirstValidProductFamilyIsPreserved) {
     ASSERT_FALSE(testedIgaWrapper.isKnownPlatform());
-    constexpr auto invalidProductFamily = IGFX_MAX_PRODUCT;
+    constexpr auto invalidProductFamily = NEO::maxProductEnumValue;
 
     testedIgaWrapper.setProductFamily(invalidProductFamily);
     EXPECT_FALSE(testedIgaWrapper.isKnownPlatform());
diff --git a/opencl/test/unit_test/offline_compiler/main.cpp b/opencl/test/unit_test/offline_compiler/main.cpp
@@ -136,7 +136,7 @@ int main(int argc, char **argv) {
     }
 
     uint16_t revision = 0;
-    for (unsigned int productId = 0; productId < IGFX_MAX_PRODUCT; ++productId) {
+    for (unsigned int productId = 0; productId < NEO::maxProductEnumValue; ++productId) {
         if (NEO::hardwarePrefix[productId] && (0 == strcmp(devicePrefix.c_str(), NEO::hardwarePrefix[productId]))) {
             if (NEO::hardwareInfoTable[productId]) {
                 renderCoreFamily = NEO::hardwareInfoTable[productId]->platform.eRenderCoreFamily;
diff --git a/shared/offline_compiler/source/decoder/helper.cpp b/shared/offline_compiler/source/decoder/helper.cpp
@@ -92,7 +92,7 @@ size_t findPos(const std::vector<std::string> &lines, const std::string &whatToF
 }
 
 PRODUCT_FAMILY getProductFamilyFromDeviceName(const std::string &deviceName) {
-    for (unsigned int productId = 0; productId < IGFX_MAX_PRODUCT; ++productId) {
+    for (unsigned int productId = 0; productId < NEO::maxProductEnumValue; ++productId) {
         if (NEO::hardwarePrefix[productId] != nullptr &&
             deviceName == NEO::hardwarePrefix[productId]) {
             return static_cast<PRODUCT_FAMILY>(productId);
diff --git a/shared/source/ail/ail_configuration.h b/shared/source/ail/ail_configuration.h
@@ -51,7 +51,7 @@ enum class AILEnumeration : uint32_t {
 
 class AILConfiguration;
 using AILConfigurationCreateFunctionType = std::unique_ptr<AILConfiguration> (*)();
-extern AILConfigurationCreateFunctionType ailConfigurationFactory[IGFX_MAX_PRODUCT];
+extern AILConfigurationCreateFunctionType ailConfigurationFactory[NEO::maxProductEnumValue];
 
 class AILConfiguration {
   public:
diff --git a/shared/source/ail/ail_configuration_extra.cpp b/shared/source/ail/ail_configuration_extra.cpp
@@ -46,7 +46,7 @@ const std::set<std::string_view> applicationsMicrosecontResolutionAdjustment = {
 
 const uint32_t microsecondAdjustment = 1000;
 
-AILConfigurationCreateFunctionType ailConfigurationFactory[IGFX_MAX_PRODUCT];
+AILConfigurationCreateFunctionType ailConfigurationFactory[NEO::maxProductEnumValue];
 
 void AILConfiguration::apply(HardwareInfo &hwInfo) {
     auto search = applicationMap.find(processName);
diff --git a/shared/source/gmm_helper/igfxfmid_wrapper/neo_igfxfmid.h b/shared/source/gmm_helper/igfxfmid_wrapper/neo_igfxfmid.h
@@ -11,4 +11,5 @@
 
 namespace NEO {
 constexpr GFXCORE_FAMILY xe3pCoreEnumValue = static_cast<GFXCORE_FAMILY>(0x2300); // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange), NEO-16649
-}
+constexpr PRODUCT_FAMILY maxProductEnumValue = IGFX_MAX_PRODUCT;
+} // namespace NEO
diff --git a/shared/source/helpers/compiler_product_helper.cpp b/shared/source/helpers/compiler_product_helper.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2023 Intel Corporation
+ * Copyright (C) 2021-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,7 +11,7 @@
 
 namespace NEO {
 
-CompilerProductHelperCreateFunctionType compilerProductHelperFactory[IGFX_MAX_PRODUCT] = {};
+CompilerProductHelperCreateFunctionType compilerProductHelperFactory[NEO::maxProductEnumValue] = {};
 
 uint32_t CompilerProductHelper::getHwIpVersion(const HardwareInfo &hwInfo) const {
     if (debugManager.flags.OverrideHwIpVersion.get() != -1) {
diff --git a/shared/source/helpers/compiler_product_helper.h b/shared/source/helpers/compiler_product_helper.h
@@ -41,7 +41,7 @@ constexpr bool operator>=(OclCVersion lhs, OclCVersion rhs) {
 }
 
 using CompilerProductHelperCreateFunctionType = std::unique_ptr<CompilerProductHelper> (*)();
-extern CompilerProductHelperCreateFunctionType compilerProductHelperFactory[IGFX_MAX_PRODUCT];
+extern CompilerProductHelperCreateFunctionType compilerProductHelperFactory[NEO::maxProductEnumValue];
 
 class CompilerProductHelper {
   public:
diff --git a/shared/source/helpers/hw_info.cpp b/shared/source/helpers/hw_info.cpp
@@ -22,7 +22,7 @@ HardwareInfo::HardwareInfo(const PLATFORM *platform, const FeatureTable *feature
 }
 
 // Global table of hardware prefixes
-const char *hardwarePrefix[IGFX_MAX_PRODUCT] = {
+const char *hardwarePrefix[NEO::maxProductEnumValue] = {
     nullptr,
 };
 
@@ -31,12 +31,12 @@ bool familyEnabled[IGFX_MAX_CORE] = {
     false,
 };
 
-const HardwareInfo *hardwareInfoTable[IGFX_MAX_PRODUCT] = {};
-void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(HardwareInfo *, bool, uint64_t, const ReleaseHelper *) = {
+const HardwareInfo *hardwareInfoTable[NEO::maxProductEnumValue] = {};
+void (*hardwareInfoSetup[NEO::maxProductEnumValue])(HardwareInfo *, bool, uint64_t, const ReleaseHelper *) = {
     0x0,
 };
 
-void (*hardwareInfoBaseSetup[IGFX_MAX_PRODUCT])(HardwareInfo *, bool, const ReleaseHelper *) = {
+void (*hardwareInfoBaseSetup[NEO::maxProductEnumValue])(HardwareInfo *, bool, const ReleaseHelper *) = {
     0x0,
 };
 
@@ -47,7 +47,7 @@ bool getHwInfoForPlatformString(std::string &platform, const HardwareInfo *&hwIn
         return true;
     }
     bool ret = false;
-    for (int j = 0; j < IGFX_MAX_PRODUCT; j++) {
+    for (int j = 0; j < NEO::maxProductEnumValue; j++) {
         if (hardwarePrefix[j] == nullptr) {
             continue;
         }
diff --git a/shared/source/helpers/hw_info.h b/shared/source/helpers/hw_info.h
@@ -71,10 +71,10 @@ struct HardwareInfo { // NOLINT(clang-analyzer-optin.performance.Padding)
 
 // Global table of hardware prefixes
 extern bool familyEnabled[IGFX_MAX_CORE];
-extern const char *hardwarePrefix[IGFX_MAX_PRODUCT];
-extern const HardwareInfo *hardwareInfoTable[IGFX_MAX_PRODUCT];
-extern void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, uint64_t hwInfoConfig, const ReleaseHelper *releaseHelper);
-extern void (*hardwareInfoBaseSetup[IGFX_MAX_PRODUCT])(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const ReleaseHelper *releaseHelper);
+extern const char *hardwarePrefix[NEO::maxProductEnumValue];
+extern const HardwareInfo *hardwareInfoTable[NEO::maxProductEnumValue];
+extern void (*hardwareInfoSetup[NEO::maxProductEnumValue])(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, uint64_t hwInfoConfig, const ReleaseHelper *releaseHelper);
+extern void (*hardwareInfoBaseSetup[NEO::maxProductEnumValue])(HardwareInfo *hwInfo, bool setupFeatureTableAndWorkaroundTable, const ReleaseHelper *releaseHelper);
 
 template <GFXCORE_FAMILY gfxFamily>
 struct EnableGfxFamilyHw {
diff --git a/shared/source/helpers/product_config_helper.cpp b/shared/source/helpers/product_config_helper.cpp
@@ -251,7 +251,7 @@ PRODUCT_FAMILY ProductConfigHelper::getProductFamilyFromDeviceName(const std::st
 
 std::vector<NEO::ConstStringRef> ProductConfigHelper::getDeprecatedAcronyms() {
     std::vector<NEO::ConstStringRef> prefixes{}, deprecatedAcronyms{};
-    for (int j = 0; j < IGFX_MAX_PRODUCT; j++) {
+    for (int j = 0; j < NEO::maxProductEnumValue; j++) {
         if (NEO::hardwarePrefix[j] == nullptr) {
             continue;
         }
diff --git a/shared/source/os_interface/linux/ioctl_helper.cpp b/shared/source/os_interface/linux/ioctl_helper.cpp
@@ -28,7 +28,7 @@
 
 namespace NEO {
 
-std::optional<std::function<std::unique_ptr<IoctlHelper>(Drm &drm)>> ioctlHelperFactory[IGFX_MAX_PRODUCT] = {};
+std::optional<std::function<std::unique_ptr<IoctlHelper>(Drm &drm)>> ioctlHelperFactory[NEO::maxProductEnumValue] = {};
 void IoctlHelper::setExternalContext(ExternalCtx *ctx) {
     externalCtx = ctx;
 }
diff --git a/shared/source/os_interface/linux/ioctl_helper.h b/shared/source/os_interface/linux/ioctl_helper.h
@@ -475,5 +475,5 @@ class IoctlHelperPrelim20 : public IoctlHelperI915 {
     uint64_t uuid = 0;
 };
 
-extern std::optional<std::function<std::unique_ptr<IoctlHelper>(Drm &drm)>> ioctlHelperFactory[IGFX_MAX_PRODUCT];
+extern std::optional<std::function<std::unique_ptr<IoctlHelper>(Drm &drm)>> ioctlHelperFactory[NEO::maxProductEnumValue];
 } // namespace NEO
diff --git a/shared/source/os_interface/product_helper.cpp b/shared/source/os_interface/product_helper.cpp
@@ -18,7 +18,7 @@
 
 namespace NEO {
 
-ProductHelperCreateFunctionType productHelperFactory[IGFX_MAX_PRODUCT] = {};
+ProductHelperCreateFunctionType productHelperFactory[NEO::maxProductEnumValue] = {};
 
 void ProductHelper::setupPreemptionSurfaceSize(HardwareInfo &hwInfo, const RootDeviceEnvironment &rootDeviceEnvironment) {
     if (debugManager.flags.OverridePreemptionSurfaceSizeInMb.get() >= 0) {
diff --git a/shared/source/os_interface/product_helper.h b/shared/source/os_interface/product_helper.h
diff --git a/shared/test/common/common_main.cpp b/shared/test/common/common_main.cpp
diff --git a/shared/test/common/helpers/raii_product_helper.h b/shared/test/common/helpers/raii_product_helper.h
diff --git a/shared/test/common/test_macros/hw_test_base.h b/shared/test/common/test_macros/hw_test_base.h
diff --git a/shared/test/unit_test/command_stream/get_devices_tests.cpp b/shared/test/unit_test/command_stream/get_devices_tests.cpp
diff --git a/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp b/shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,8 @@ void CommandList::setPatchingPreamble(bool patching, bool saveWait) {`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`-CommandListAllocatorFn commandListFactory[IGFX_MAX_PRODUCT] = {};`
`43`		`-CommandListAllocatorFn commandListFactoryImmediate[IGFX_MAX_PRODUCT] = {};`
	`42`	`+CommandListAllocatorFn commandListFactory[NEO::maxProductEnumValue] = {};`
	`43`	`+CommandListAllocatorFn commandListFactoryImmediate[NEO::maxProductEnumValue] = {};`
`44`	`44`
`45`	`45`	`ze_result_t CommandListImp::destroy() {`
`46`	`46`	`if (this->isBcsSplitNeeded) {`
`@@ -104,7 +104,7 @@ CommandList CommandList::create(uint32_t productFamily, Device device, NEO::En`
`104`	`104`	`ze_command_list_flags_t flags, ze_result_t &returnValue,`
`105`	`105`	`bool internalUsage) {`
`106`	`106`	`CommandListAllocatorFn allocator = nullptr;`
`107`		`- if (productFamily < IGFX_MAX_PRODUCT) {`
	`107`	`+ if (productFamily < NEO::maxProductEnumValue) {`
`108`	`108`	`allocator = commandListFactory[productFamily];`
`109`	`109`	`}`
`110`	`110`
`@@ -170,7 +170,7 @@ CommandList CommandList::createImmediate(uint32_t productFamily, Device device`
`170`	`170`	`cmdQdesc.mode = static_cast<ze_command_queue_mode_t>(overrideImmediateCmdListSyncMode);`
`171`	`171`	`}`
`172`	`172`	`CommandListAllocatorFn allocator = nullptr;`
`173`		`- if (productFamily < IGFX_MAX_PRODUCT) {`
	`173`	`+ if (productFamily < NEO::maxProductEnumValue) {`
`174`	`174`	`allocator = commandListFactoryImmediate[productFamily];`
`175`	`175`	`}`
`176`	`176`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2020-2021 Intel Corporation`
	`2`	`+ * Copyright (C) 2020-2025 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -11,7 +11,7 @@`
`11`	`11`
`12`	`12`	`namespace L0 {`
`13`	`13`
`14`		`-SamplerAllocatorFn samplerFactory[IGFX_MAX_PRODUCT] = {};`
	`14`	`+SamplerAllocatorFn samplerFactory[NEO::maxProductEnumValue] = {};`
`15`	`15`
`16`	`16`	`ze_result_t SamplerImp::destroy() {`
`17`	`17`	`delete this;`
`@@ -25,7 +25,7 @@ ze_result_t SamplerImp::initialize(Device device, const ze_sampler_desc_t desc`
`25`	`25`
`26`	`26`	`Sampler Sampler::create(uint32_t productFamily, Device device, const ze_sampler_desc_t *desc) {`
`27`	`27`	`SamplerAllocatorFn allocator = nullptr;`
`28`		`- if (productFamily < IGFX_MAX_PRODUCT) {`
	`28`	`+ if (productFamily < NEO::maxProductEnumValue) {`
`29`	`29`	`allocator = samplerFactory[productFamily];`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE,`
`30`	`30`	`givenInvalidProductWhenCreatingCommandListThenNoObjectCreated) {`
`31`	`31`	`ze_result_t returnValue;`
`32`	`32`
`33`		`- auto mcl = MutableCommandList::create(IGFX_MAX_PRODUCT, device, this->engineGroupType, 0, returnValue, false);`
	`33`	`+ auto mcl = MutableCommandList::create(NEO::maxProductEnumValue, device, this->engineGroupType, 0, returnValue, false);`
`34`	`34`	`EXPECT_EQ(nullptr, mcl);`
`35`	`35`	`EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, returnValue);`
`36`	`36`	`}`