diff --git a/opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h b/opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h
index 41494130fb..420b7969fe 100644
--- a/opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h
+++ b/opencl/test/unit_test/offline_compiler/mock/mock_argument_helper.h
@@ -19,6 +19,7 @@
 
 class MockOclocArgHelper : public OclocArgHelper {
   public:
+    using OclocArgHelper::deviceProductTable;
     using OclocArgHelper::hasOutput;
     using OclocArgHelper::headers;
     using OclocArgHelper::inputs;
diff --git a/opencl/test/unit_test/offline_compiler/ocloc_validator_tests.cpp b/opencl/test/unit_test/offline_compiler/ocloc_validator_tests.cpp
index fdb8f10132..5eddedcaff 100644
--- a/opencl/test/unit_test/offline_compiler/ocloc_validator_tests.cpp
+++ b/opencl/test/unit_test/offline_compiler/ocloc_validator_tests.cpp
@@ -91,3 +91,26 @@ TEST(OclocValidate, WhenErrorsEmitedThenRedirectsThemToStdout) {
     EXPECT_EQ(static_cast<int>(NEO::DecodeError::InvalidBinary), res) << oclocStdout;
     EXPECT_NE(nullptr, strstr(oclocStdout.c_str(), "Validator detected errors :\nNEO::Yaml : Could not parse line : [1] : [kernels ] <-- parser position on error. Reason : Vector data type expects to have at least one value starting with -")) << oclocStdout;
 }
+
+TEST(OclocValidate, givenDeviceProductTableEveryProductMatchesProperPattern) {
+    MockOclocArgHelper::FilesMap files{{"src.gen", "01234567"}};
+    MockOclocArgHelper argHelper{files};
+    ASSERT_GE(argHelper.deviceProductTable.size(), 1u);
+    std::vector<std::string> genPatterns;
+    for (int j = 0; j < IGFX_MAX_PRODUCT; j++) {
+        if (NEO::hardwarePrefix[j] == nullptr)
+            continue;
+        genPatterns.push_back(NEO::hardwarePrefix[j]);
+    }
+    ASSERT_GE(genPatterns.size(), 1u);
+    if (argHelper.deviceProductTable.size() == 1 && argHelper.deviceProductTable[0].deviceId == 0) {
+        auto &deviceProductTable = const_cast<std::vector<DeviceProduct> &>(argHelper.deviceProductTable);
+        deviceProductTable[0].product = genPatterns[0];
+        deviceProductTable[0].deviceId = 0x123;
+        deviceProductTable.push_back(DeviceProduct{0, ""});
+    }
+    for (int i = 0; argHelper.deviceProductTable[i].deviceId != 0; i++) {
+        auto res = std::find(genPatterns.begin(), genPatterns.end(), argHelper.returnProductNameForDevice(argHelper.deviceProductTable[i].deviceId));
+        EXPECT_NE(res, genPatterns.end());
+    }
+}
\ No newline at end of file
diff --git a/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp b/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp
index 2d7e65305e..79e5f18b7e 100644
--- a/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp
+++ b/opencl/test/unit_test/offline_compiler/offline_compiler_tests.cpp
@@ -1028,11 +1028,10 @@ TEST_F(OfflineCompilerTests, GivenArgsWhenOfflineCompilerIsCreatedThenSuccessIsR
 }
 
 TEST_F(OfflineCompilerTests, givenDeviceIdHexValueWhenInitHwInfoThenItHasCorrectlySetValues) {
-    auto deviceAot = oclocArgHelperWithoutInput->productConfigHelper->getDeviceAotInfo();
-    if (deviceAot.empty()) {
+    auto deviceId = oclocArgHelperWithoutInput->deviceProductTable[0].deviceId;
+    if (oclocArgHelperWithoutInput->deviceProductTable.size() == 1 && deviceId == 0) {
         GTEST_SKIP();
     }
-    auto deviceId = deviceAot[0].deviceIds->front();
 
     MockOfflineCompiler mockOfflineCompiler;
     std::stringstream deviceString, productString;
@@ -1044,17 +1043,15 @@ TEST_F(OfflineCompilerTests, givenDeviceIdHexValueWhenInitHwInfoThenItHasCorrect
 }
 
 TEST_F(OfflineCompilerTests, givenProperDeviceIdHexAsDeviceArgumentThenSuccessIsReturned) {
-    auto deviceAotInfo = oclocArgHelperWithoutInput->productConfigHelper->getDeviceAotInfo();
-    if (deviceAotInfo.empty()) {
+    auto deviceId = oclocArgHelperWithoutInput->deviceProductTable[0].deviceId;
+    if (oclocArgHelperWithoutInput->deviceProductTable.size() == 1 && deviceId == 0) {
         GTEST_SKIP();
     }
 
     std::stringstream deviceString, productString;
-    AOT::PRODUCT_CONFIG config;
-    auto deviceId = deviceAotInfo[0].deviceIds->front();
+
     deviceString << "0x" << std::hex << deviceId;
-    config = static_cast<AOT::PRODUCT_CONFIG>(deviceAotInfo[0].aotConfig.ProductConfig);
-    productString << oclocArgHelperWithoutInput->productConfigHelper->getAcronymForProductConfig(config);
+    productString << oclocArgHelperWithoutInput->deviceProductTable[0].product;
 
     std::vector<std::string> argv = {
         "ocloc",
@@ -1092,7 +1089,7 @@ TEST_F(OfflineCompilerTests, givenIncorrectDeviceIdHexThenInvalidDeviceIsReturne
 
     auto output = testing::internal::GetCapturedStdout();
     EXPECT_EQ(nullptr, pOfflineCompiler);
-    EXPECT_STREQ(output.c_str(), "Could not determine device target: 0x0\nError: Cannot get HW Info for device 0x0.\n");
+    EXPECT_STREQ(output.c_str(), "Could not determine target based on device id: 0x0\nError: Cannot get HW Info for device 0x0.\n");
     EXPECT_EQ(CL_INVALID_DEVICE, retVal);
 }
 
@@ -1967,7 +1964,7 @@ TEST(OfflineCompilerTest, GivenUnsupportedDeviceConfigWhenInitHardwareInfoThenIn
     EXPECT_EQ(retVal, OclocErrorCode::INVALID_DEVICE);
 
     auto output = testing::internal::GetCapturedStdout();
-    resString << "Could not determine device target: " << deviceName << "\n";
+    resString << "Could not determine target based on product config: " << deviceName << "\n";
     EXPECT_STREQ(output.c_str(), resString.str().c_str());
 }
 
diff --git a/shared/offline_compiler/source/ocloc_arg_helper.cpp b/shared/offline_compiler/source/ocloc_arg_helper.cpp
index 8d88c70ee2..860c506217 100644
--- a/shared/offline_compiler/source/ocloc_arg_helper.cpp
+++ b/shared/offline_compiler/source/ocloc_arg_helper.cpp
@@ -57,7 +57,13 @@ OclocArgHelper::OclocArgHelper(const uint32_t numSources, const uint8_t **dataSo
                                uint64_t **lenOutputs, char ***nameOutputs)
     : numOutputs(numOutputs), nameOutputs(nameOutputs),
       dataOutputs(dataOutputs), lenOutputs(lenOutputs), hasOutput(numOutputs != nullptr),
-      messagePrinter(hasOutput) {
+      messagePrinter(hasOutput), deviceProductTable({
+#define NAMEDDEVICE(devId, product, ignored_devName) {devId, NEO::hardwarePrefix[NEO::product::hwInfo.platform.eProductFamily]},
+#define DEVICE(devId, product) {devId, NEO::hardwarePrefix[NEO::product::hwInfo.platform.eProductFamily]},
+#include "devices.inl"
+#undef DEVICE
+#undef NAMEDDEVICE
+                                     {0u, std::string("")}}) {
     for (uint32_t i = 0; i < numSources; ++i) {
         inputs.push_back(Source(dataSources[i], static_cast<size_t>(lenSources[i]), nameSources[i]));
     }
@@ -197,3 +203,24 @@ void OclocArgHelper::saveOutput(const std::string &filename, const std::ostream
 bool OclocArgHelper::areQuotesRequired(const std::string_view &argName) {
     return argName == "-options" || argName == "-internal_options";
 }
+
+bool OclocArgHelper::setAcronymForDeviceId(std::string &device) {
+    auto product = returnProductNameForDevice(std::stoi(device, 0, 16));
+    if (!product.empty()) {
+        printf("Auto-detected target based on %s device id: %s\n", device.c_str(), product.c_str());
+
+    } else {
+        printf("Could not determine target based on device id: %s\n", device.c_str());
+        return false;
+    }
+    device = std::move(product);
+    return true;
+}
+std::string OclocArgHelper::returnProductNameForDevice(unsigned short deviceId) {
+    for (int i = 0; deviceProductTable[i].deviceId != 0; i++) {
+        if (deviceProductTable[i].deviceId == deviceId) {
+            return deviceProductTable[i].product;
+        }
+    }
+    return "";
+}
\ No newline at end of file
diff --git a/shared/offline_compiler/source/ocloc_arg_helper.h b/shared/offline_compiler/source/ocloc_arg_helper.h
index eb9cbbd405..72ba4c4b63 100644
--- a/shared/offline_compiler/source/ocloc_arg_helper.h
+++ b/shared/offline_compiler/source/ocloc_arg_helper.h
@@ -41,6 +41,11 @@ struct Output {
     Output(const std::string &name, const void *data, const size_t &size);
 };
 
+struct DeviceProduct {
+    unsigned short deviceId;
+    std::string product;
+};
+
 class OclocArgHelper {
   protected:
     std::vector<Source> inputs, headers;
@@ -51,6 +56,7 @@ class OclocArgHelper {
     uint64_t **lenOutputs = nullptr;
     bool hasOutput = false;
     MessagePrinter messagePrinter;
+    const std::vector<DeviceProduct> deviceProductTable;
     void moveOutputs();
     Source *findSourceFile(const std::string &filename);
     bool sourceFileExists(const std::string &filename) const;
@@ -71,6 +77,7 @@ class OclocArgHelper {
     virtual ~OclocArgHelper();
     MOCKABLE_VIRTUAL bool fileExists(const std::string &filename) const;
     bool getHwInfoForProductConfig(uint32_t productConfig, NEO::HardwareInfo &hwInfo, uint64_t hwInfoConfig);
+    bool setAcronymForDeviceId(std::string &device);
     std::vector<std::string> headersToVectorOfStrings();
     MOCKABLE_VIRTUAL void readFileToVectorOfStrings(const std::string &filename, std::vector<std::string> &lines);
     MOCKABLE_VIRTUAL std::vector<char> readBinaryFile(const std::string &filename);
@@ -129,5 +136,6 @@ class OclocArgHelper {
     }
 
     bool areQuotesRequired(const std::string_view &argName);
+    std::string returnProductNameForDevice(unsigned short deviceId);
     std::unique_ptr<ProductConfigHelper> productConfigHelper;
 };
diff --git a/shared/offline_compiler/source/offline_compiler.cpp b/shared/offline_compiler/source/offline_compiler.cpp
index 2945297b9a..d7c1da8cc4 100644
--- a/shared/offline_compiler/source/offline_compiler.cpp
+++ b/shared/offline_compiler/source/offline_compiler.cpp
@@ -403,7 +403,7 @@ void OfflineCompiler::setFamilyType() {
     familyNameWithType.append(hwInfo.capabilityTable.platformType);
 }
 
-int OfflineCompiler::initHardwareInfoForDeprecatedAcronyms(std::string deviceName) {
+int OfflineCompiler::initHardwareInfoForDeprecatedAcronyms(std::string deviceName, int deviceId) {
     std::vector<PRODUCT_FAMILY> allSupportedProduct{ALL_SUPPORTED_PRODUCT_FAMILIES};
     std::transform(deviceName.begin(), deviceName.end(), deviceName.begin(), ::tolower);
 
@@ -413,7 +413,9 @@ int OfflineCompiler::initHardwareInfoForDeprecatedAcronyms(std::string deviceNam
             if (revisionId != -1) {
                 hwInfo.platform.usRevId = revisionId;
             }
-
+            if (deviceId != -1) {
+                hwInfo.platform.usDeviceID = deviceId;
+            }
             uint64_t config = hwInfoConfig ? hwInfoConfig : defaultHardwareInfoConfigTable[hwInfo.platform.eProductFamily];
             setHwInfoValuesFromConfig(config, hwInfo);
             hardwareInfoBaseSetup[hwInfo.platform.eProductFamily](&hwInfo, true);
@@ -429,36 +431,27 @@ int OfflineCompiler::initHardwareInfoForProductConfig(std::string deviceName) {
     AOT::PRODUCT_CONFIG productConfig = AOT::UNKNOWN_ISA;
     ProductConfigHelper::adjustDeviceName(deviceName);
 
-    const char hexPrefix = 2;
-    int deviceId = -1;
-
     if (deviceName.find(".") != std::string::npos) {
         productConfig = argHelper->productConfigHelper->getProductConfigForVersionValue(deviceName);
-    } else if (deviceName.substr(0, hexPrefix) == "0x" && std::all_of(deviceName.begin() + hexPrefix, deviceName.end(), (::isxdigit))) {
-        deviceId = std::stoi(deviceName, 0, 16);
-        productConfig = argHelper->productConfigHelper->getProductConfigForDeviceId(deviceId);
+        if (productConfig == AOT::UNKNOWN_ISA) {
+            argHelper->printf("Could not determine device target: %s\n", deviceName.c_str());
+        }
     } else if (argHelper->productConfigHelper->isProductConfig(deviceName)) {
         productConfig = ProductConfigHelper::getProductConfigForAcronym(deviceName);
-    } else {
-        return INVALID_DEVICE;
     }
 
-    if (argHelper->getHwInfoForProductConfig(productConfig, hwInfo, hwInfoConfig)) {
-        if (revisionId != -1) {
-            hwInfo.platform.usRevId = revisionId;
+    if (productConfig != AOT::UNKNOWN_ISA) {
+        if (argHelper->getHwInfoForProductConfig(productConfig, hwInfo, hwInfoConfig)) {
+            if (revisionId != -1) {
+                hwInfo.platform.usRevId = revisionId;
+            }
+            deviceConfig = productConfig;
+            setFamilyType();
+            return SUCCESS;
         }
-        if (deviceId != -1) {
-            auto product = argHelper->productConfigHelper->getAcronymForProductConfig(productConfig);
-            argHelper->printf("Auto-detected target based on %s device id: %s\n", deviceName.c_str(), product.c_str());
-            hwInfo.platform.usDeviceID = deviceId;
-        }
-        deviceConfig = productConfig;
-        setFamilyType();
-        return SUCCESS;
-    } else {
-        argHelper->printf("Could not determine device target: %s\n", deviceName.c_str());
-        return INVALID_DEVICE;
+        argHelper->printf("Could not determine target based on product config: %s\n", deviceName.c_str());
     }
+    return INVALID_DEVICE;
 }
 
 int OfflineCompiler::initHardwareInfo(std::string deviceName) {
@@ -469,12 +462,21 @@ int OfflineCompiler::initHardwareInfo(std::string deviceName) {
 
     overridePlatformName(deviceName);
 
+    const char hexPrefix = 2;
+    int deviceId = -1;
+
     retVal = initHardwareInfoForProductConfig(deviceName);
     if (retVal == SUCCESS) {
         return retVal;
     }
 
-    retVal = initHardwareInfoForDeprecatedAcronyms(deviceName);
+    if (deviceName.substr(0, hexPrefix) == "0x" && std::all_of(deviceName.begin() + hexPrefix, deviceName.end(), (::isxdigit))) {
+        deviceId = std::stoi(deviceName, 0, 16);
+        if (!argHelper->setAcronymForDeviceId(deviceName)) {
+            return retVal;
+        }
+    }
+    retVal = initHardwareInfoForDeprecatedAcronyms(deviceName, deviceId);
 
     return retVal;
 }
diff --git a/shared/offline_compiler/source/offline_compiler.h b/shared/offline_compiler/source/offline_compiler.h
index 6fd28c9b84..5f572e2901 100644
--- a/shared/offline_compiler/source/offline_compiler.h
+++ b/shared/offline_compiler/source/offline_compiler.h
@@ -100,7 +100,7 @@ All supported acronyms: %s.
     void setFamilyType();
     int initHardwareInfo(std::string deviceName);
     int initHardwareInfoForProductConfig(std::string deviceName);
-    int initHardwareInfoForDeprecatedAcronyms(std::string deviceName);
+    int initHardwareInfoForDeprecatedAcronyms(std::string deviceName, int deviceId);
 
     std::string getStringWithinDelimiters(const std::string &src);
     int initialize(size_t numArgs, const std::vector<std::string> &allArgs, bool dumpFiles);
diff --git a/shared/source/helpers/product_config_helper.cpp b/shared/source/helpers/product_config_helper.cpp
index c0ed45fd5d..df7194eb3b 100644
--- a/shared/source/helpers/product_config_helper.cpp
+++ b/shared/source/helpers/product_config_helper.cpp
@@ -34,15 +34,6 @@ bool ProductConfigHelper::compareConfigs(DeviceAotInfo deviceAotInfo0, DeviceAot
     return deviceAotInfo0.aotConfig.ProductConfig < deviceAotInfo1.aotConfig.ProductConfig;
 }
 
-AOT::PRODUCT_CONFIG ProductConfigHelper::getProductConfigForDeviceId(unsigned short deviceId) {
-    for (const auto &device : deviceAotInfo) {
-        if (std::find(device.deviceIds->begin(), device.deviceIds->end(), deviceId) != device.deviceIds->end()) {
-            return static_cast<AOT::PRODUCT_CONFIG>(device.aotConfig.ProductConfig);
-        }
-    }
-    return AOT::UNKNOWN_ISA;
-}
-
 std::vector<DeviceAotInfo> &ProductConfigHelper::getDeviceAotInfo() {
     return deviceAotInfo;
 }
@@ -70,14 +61,6 @@ NEO::ConstStringRef ProductConfigHelper::getAcronymForAFamily(AOT::FAMILY family
     return {};
 }
 
-const std::string ProductConfigHelper::getAcronymForProductConfig(AOT::PRODUCT_CONFIG config) {
-    auto it = std::find_if(deviceAotInfo.begin(), deviceAotInfo.end(), findProductConfig(config));
-    if (it == deviceAotInfo.end()) {
-        return {};
-    }
-    return it->acronyms.empty() ? parseMajorMinorRevisionValue(it->aotConfig) : it->acronyms.front().str();
-}
-
 AOT::RELEASE ProductConfigHelper::getReleaseForAcronym(const std::string &device) {
     auto it = std::find_if(AOT::releaseAcronyms.begin(), AOT::releaseAcronyms.end(), findMapAcronymWithoutDash(device));
     if (it == AOT::releaseAcronyms.end())
diff --git a/shared/source/helpers/product_config_helper.h b/shared/source/helpers/product_config_helper.h
index fafc3aea7f..43027f63ad 100644
--- a/shared/source/helpers/product_config_helper.h
+++ b/shared/source/helpers/product_config_helper.h
@@ -105,8 +105,6 @@ struct ProductConfigHelper {
     bool isRelease(const std::string &device);
     bool isProductConfig(const std::string &device);
 
-    AOT::PRODUCT_CONFIG getProductConfigForDeviceId(unsigned short deviceId);
-    const std::string getAcronymForProductConfig(AOT::PRODUCT_CONFIG config);
     std::vector<DeviceAotInfo> &getDeviceAotInfo();
     std::vector<NEO::ConstStringRef> getRepresentativeProductAcronyms();
     std::vector<NEO::ConstStringRef> getReleasesAcronyms();
diff --git a/shared/test/unit_test/helpers/product_config_helper_tests.cpp b/shared/test/unit_test/helpers/product_config_helper_tests.cpp
index 2a88f23e2b..94601a87c0 100644
--- a/shared/test/unit_test/helpers/product_config_helper_tests.cpp
+++ b/shared/test/unit_test/helpers/product_config_helper_tests.cpp
@@ -476,44 +476,3 @@ TEST_F(AotDeviceInfoTests, givenClearedProductAcronymWhenSearchInRepresentativeA
         }
     }
 }
-
-TEST_F(AotDeviceInfoTests, givenDeviceIdWhenSearchForProductConfigAndAcronymThenCorrectResultsAreReturned) {
-    auto deviceAot = productConfigHelper->getDeviceAotInfo();
-    if (deviceAot.empty()) {
-        GTEST_SKIP();
-    }
-
-    for (const auto &device : deviceAot) {
-        for (const auto &deviceId : *device.deviceIds) {
-            auto config = productConfigHelper->getProductConfigForDeviceId(deviceId);
-            EXPECT_NE(config, AOT::UNKNOWN_ISA);
-            auto name = productConfigHelper->getAcronymForProductConfig(config);
-            EXPECT_FALSE(name.empty());
-        }
-    }
-}
-
-TEST_F(AotDeviceInfoTests, givenInvalidDeviceIdWhenSearchForProductConfigAndAcronymThenUnknownIsaIsReturned) {
-    auto config = productConfigHelper->getProductConfigForDeviceId(0x0);
-    EXPECT_EQ(config, AOT::UNKNOWN_ISA);
-    auto name = productConfigHelper->getAcronymForProductConfig(config);
-    EXPECT_TRUE(name.empty());
-}
-
-TEST_F(AotDeviceInfoTests, givenDeviceIdsFromDevicesFileWhenGetProductConfigThenValueIsExpectedToBeFound) {
-    std::vector<unsigned short> deviceIds{
-#define NAMEDDEVICE(devId, ignored_product, ignored_devName) devId,
-#define DEVICE(devId, ignored_product) devId,
-#include "devices.inl"
-#undef DEVICE
-#undef NAMEDDEVICE
-    };
-
-    if (deviceIds.empty()) {
-        GTEST_SKIP();
-    }
-
-    for (const auto &deviceId : deviceIds) {
-        EXPECT_NE(productConfigHelper->getProductConfigForDeviceId(deviceId), AOT::UNKNOWN_ISA);
-    }
-}
\ No newline at end of file