Allow override of default platform Hardware Info Config

New string debug variable HardwareInfoOverride is used to
specify new Hardware Info Config to be selected, for example 1x4x8.

Change-Id: I6d939608e6551e4a9102e5ab2e08255ee4982933

runtime/gen10/hw_cmds.h

@@ -46,7 +46,7 @@ struct CNL : public CNLFamily {
     static const uint32_t maxSlicesSupported = 4;
     static const uint32_t maxSubslicesSupported = 9;
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
 };
 class CNL_2x5x8 : public CNL {
   public:

runtime/gen10/hw_info_cnl.inl

@@ -205,5 +205,25 @@ void CNL_4x9x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
     gtSysInfo->IsDynamicallyPopulated = false;
 };
 const HardwareInfo CNL::hwInfo = CNL_2x5x8::hwInfo;
-void (*CNL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool) = CNL_2x5x8::setupHardwareInfo;
+
+void setupCNLHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+    if (hwInfoConfig == "1x2x8") {
+        CNL_1x2x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x3x8") {
+        CNL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "2x5x8") {
+        CNL_2x5x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "2x4x8") {
+        CNL_2x4x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "4x9x8") {
+        CNL_4x9x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "default") {
+        // Default config
+        CNL_2x5x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else {
+        UNRECOVERABLE_IF(true);
+    }
+}
+
+void (*CNL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupCNLHardwareInfoImpl;
 } // namespace OCLRT

runtime/gen8/hw_cmds_bdw.h

@@ -7,6 +7,7 @@
 
 #pragma once
 #include "runtime/gen8/hw_cmds_base.h"
+#include <string>
 
 namespace OCLRT {
 
@@ -18,7 +19,7 @@ struct BDW : public BDWFamily {
     static const uint32_t maxSlicesSupported = 2;
     static const uint32_t maxSubslicesSupported = 6;
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
 };
 class BDW_1x2x6 : public BDW {
   public:

runtime/gen8/hw_info_bdw.inl

@@ -182,5 +182,23 @@ void BDW_2x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
 };
 
 const HardwareInfo BDW::hwInfo = BDW_1x3x8::hwInfo;
-void (*BDW::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool) = BDW_1x3x8::setupHardwareInfo;
+
+void setupBDWHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+    if (hwInfoConfig == "2x3x8") {
+        BDW_2x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x3x8") {
+        BDW_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x3x6") {
+        BDW_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x2x6") {
+        BDW_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "default") {
+        // Default config
+        BDW_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else {
+        UNRECOVERABLE_IF(true);
+    }
+}
+
+void (*BDW::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupBDWHardwareInfoImpl;
 } // namespace OCLRT

runtime/gen9/hw_cmds_bxt.h

@@ -20,7 +20,7 @@ struct BXT : public SKLFamily {
     static const uint32_t maxSubslicesSupported = 3;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
 };
 
 class BXT_1x2x6 : public BXT {

runtime/gen9/hw_cmds_cfl.h

@@ -20,7 +20,7 @@ struct CFL : public SKLFamily {
     static const uint32_t maxSubslicesSupported = 9;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
 };
 
 class CFL_1x2x6 : public CFL {

runtime/gen9/hw_cmds_glk.h

@@ -20,7 +20,7 @@ struct GLK : public SKLFamily {
     static const uint32_t maxSubslicesSupported = 3;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
 };
 
 class GLK_1x3x6 : public GLK {

runtime/gen9/hw_cmds_kbl.h

@@ -20,7 +20,7 @@ struct KBL : public SKLFamily {
     static const uint32_t maxSubslicesSupported = 9;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
 };
 
 class KBL_1x2x6 : public KBL {

runtime/gen9/hw_cmds_skl.h

@@ -20,7 +20,7 @@ struct SKL : public SKLFamily {
     static const uint32_t maxSubslicesSupported = 9;
 
     static const RuntimeCapabilityTable capabilityTable;
-    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable);
+    static void (*setupHardwareInfo)(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
 };
 
 class SKL_1x2x6 : public SKL {

runtime/gen9/hw_info_bxt.inl

@@ -121,5 +121,19 @@ void BXT_1x3x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
 };
 
 const HardwareInfo BXT::hwInfo = BXT_1x3x6::hwInfo;
-void (*BXT::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool) = BXT_1x3x6::setupHardwareInfo;
+
+void setupBXTHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+    if (hwInfoConfig == "1x2x6") {
+        BXT_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x3x6") {
+        BXT_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "default") {
+        // Default config
+        BXT_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else {
+        UNRECOVERABLE_IF(true);
+    }
+}
+
+void (*BXT::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupBXTHardwareInfoImpl;
 } // namespace OCLRT

runtime/gen9/hw_info_cfl.inl

@@ -203,5 +203,25 @@ void CFL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
 };
 
 const HardwareInfo CFL::hwInfo = CFL_1x3x6::hwInfo;
-void (*CFL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool) = CFL_1x3x6::setupHardwareInfo;
+
+void setupCFLHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+    if (hwInfoConfig == "1x3x8") {
+        CFL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "2x3x8") {
+        CFL_2x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "3x3x8") {
+        CFL_3x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x2x6") {
+        CFL_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x3x6") {
+        CFL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "default") {
+        // Default config
+        CFL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else {
+        UNRECOVERABLE_IF(true);
+    }
+}
+
+void (*CFL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupCFLHardwareInfoImpl;
 } // namespace OCLRT

runtime/gen9/hw_info_glk.inl

@@ -116,5 +116,19 @@ void GLK_1x2x6::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
 };
 
 const HardwareInfo GLK::hwInfo = GLK_1x3x6::hwInfo;
-void (*GLK::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool) = GLK_1x3x6::setupHardwareInfo;
+
+void setupGLKHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+    if (hwInfoConfig == "1x2x6") {
+        GLK_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x3x6") {
+        GLK_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "default") {
+        // Default config
+        GLK_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else {
+        UNRECOVERABLE_IF(true);
+    }
+}
+
+void (*GLK::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupGLKHardwareInfoImpl;
 } // namespace OCLRT

runtime/gen9/hw_info_kbl.inl

@@ -203,5 +203,25 @@ void KBL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
 };
 
 const HardwareInfo KBL::hwInfo = KBL_1x3x6::hwInfo;
-void (*KBL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool) = KBL_1x3x6::setupHardwareInfo;
+
+void setupKBLHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+    if (hwInfoConfig == "1x3x8") {
+        KBL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "2x3x8") {
+        KBL_2x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "3x3x8") {
+        KBL_3x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x2x6") {
+        KBL_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x3x6") {
+        KBL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "default") {
+        // Default config
+        KBL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else {
+        UNRECOVERABLE_IF(true);
+    }
+}
+
+void (*KBL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupKBLHardwareInfoImpl;
 } // namespace OCLRT

runtime/gen9/hw_info_skl.inl

@@ -211,5 +211,25 @@ void SKL_3x3x8::setupHardwareInfo(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featu
 };
 
 const HardwareInfo SKL::hwInfo = SKL_1x3x8::hwInfo;
-void (*SKL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool) = SKL_1x3x8::setupHardwareInfo;
+
+void setupSKLHardwareInfoImpl(GT_SYSTEM_INFO *gtSysInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig) {
+    if (hwInfoConfig == "1x3x8") {
+        SKL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "2x3x8") {
+        SKL_2x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "3x3x8") {
+        SKL_3x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x2x6") {
+        SKL_1x2x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "1x3x6") {
+        SKL_1x3x6::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else if (hwInfoConfig == "default") {
+        // Default config
+        SKL_1x3x8::setupHardwareInfo(gtSysInfo, featureTable, setupFeatureTable);
+    } else {
+        UNRECOVERABLE_IF(true);
+    }
+}
+
+void (*SKL::setupHardwareInfo)(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = setupSKLHardwareInfoImpl;
 } // namespace OCLRT

runtime/helpers/hw_info.cpp

@@ -16,7 +16,7 @@ HardwareInfo::HardwareInfo(const PLATFORM *platform, const FeatureTable *skuTabl
 }
 
 const HardwareInfo *hardwareInfoTable[IGFX_MAX_PRODUCT] = {};
-void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(GT_SYSTEM_INFO *, FeatureTable *, bool) = {
+void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(GT_SYSTEM_INFO *, FeatureTable *, bool, const std::string &) = {
     nullptr,
 };
 

runtime/helpers/hw_info.h

@@ -13,6 +13,7 @@
 #include "runtime/helpers/engine_node.h"
 #include "runtime/helpers/kmd_notify_properties.h"
 #include <cstddef>
+#include <string>
 
 namespace OCLRT {
 
@@ -101,7 +102,7 @@ extern bool familyEnabled[IGFX_MAX_CORE];
 extern const char *familyName[IGFX_MAX_CORE];
 extern const char *hardwarePrefix[];
 extern const HardwareInfo *hardwareInfoTable[IGFX_MAX_PRODUCT];
-extern void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(GT_SYSTEM_INFO *gtSystemInfo, FeatureTable *featureTable, bool setupFeatureTable);
+extern void (*hardwareInfoSetup[IGFX_MAX_PRODUCT])(GT_SYSTEM_INFO *gtSystemInfo, FeatureTable *featureTable, bool setupFeatureTable, const std::string &hwInfoConfig);
 
 template <GFXCORE_FAMILY gfxFamily>
 struct EnableGfxFamilyHw {

runtime/os_interface/DebugVariables_base.inl

@@ -9,6 +9,7 @@
 /*SIMULATION FLAGS*/
 DECLARE_DEBUG_VARIABLE(std::string, TbxServer, std::string("127.0.0.1"), "TCP-IP address of TBX server")
 DECLARE_DEBUG_VARIABLE(std::string, ProductFamilyOverride, std::string("unk"), "Specify product for use in AUB/TBX")
+DECLARE_DEBUG_VARIABLE(std::string, HardwareInfoOverride, std::string("default"), "Specify hardware info config, i.e 1x4x8, for use in AUB/TBX")
 DECLARE_DEBUG_VARIABLE(std::string, ForceCompilerUsePlatform, std::string("unk"), "Specify product for use in compiler interface")
 DECLARE_DEBUG_VARIABLE(std::string, AUBDumpCaptureFileName, std::string("unk"), "Name of file to save AUB capture into")
 DECLARE_DEBUG_VARIABLE(std::string, AUBDumpFilterKernelName, std::string("unk"), "Name of kernel to AUB capture")

runtime/os_interface/debug_settings_manager.cpp

@@ -59,6 +59,17 @@ DebugSettingsManager<DebugLevel>::~DebugSettingsManager() {
     }
 }
 
+template <DebugFunctionalityLevel DebugLevel>
+void DebugSettingsManager<DebugLevel>::getHardwareInfoOverride(std::string &hwInfoConfig) {
+    std::string str = flags.HardwareInfoOverride.get();
+    if (str[0] == '\"') {
+        str.pop_back();
+        hwInfoConfig = str.substr(1, std::string::npos);
+    } else {
+        hwInfoConfig = str;
+    }
+}
+
 template <DebugFunctionalityLevel DebugLevel>
 void DebugSettingsManager<DebugLevel>::dumpKernel(const std::string &name, const std::string &src) {
     if (false == debugKernelDumpingAvailable()) {

runtime/os_interface/debug_settings_manager.h

@@ -102,6 +102,7 @@ class DebugSettingsManager {
         return DebugLevel == DebugFunctionalityLevel::None;
     }
 
+    void getHardwareInfoOverride(std::string &hwInfoConfig);
     void dumpKernel(const std::string &name, const std::string &src);
     void logApiCall(const char *function, bool enter, int32_t errorCode);
     size_t getInput(const size_t *input, int32_t index);

runtime/os_interface/device_factory.cpp

@@ -21,6 +21,8 @@ bool DeviceFactory::getDevicesForProductFamilyOverride(HardwareInfo **pHWInfos,
     getHwInfoForPlatformString(productFamily.c_str(), hwInfoConst);
     std::unique_ptr<HardwareInfo[]> tempHwInfos(new HardwareInfo[totalDeviceCount]);
     numDevices = 0;
+    std::string hwInfoConfig;
+    DebugManager.getHardwareInfoOverride(hwInfoConfig);
     while (numDevices < totalDeviceCount) {
         tempHwInfos[numDevices].pPlatform = new PLATFORM(*hwInfoConst->pPlatform);
         tempHwInfos[numDevices].pSkuTable = new FeatureTable(*hwInfoConst->pSkuTable);
@@ -28,7 +30,8 @@ bool DeviceFactory::getDevicesForProductFamilyOverride(HardwareInfo **pHWInfos,
         tempHwInfos[numDevices].pSysInfo = new GT_SYSTEM_INFO(*hwInfoConst->pSysInfo);
         tempHwInfos[numDevices].capabilityTable = hwInfoConst->capabilityTable;
         hardwareInfoSetup[hwInfoConst->pPlatform->eProductFamily](const_cast<GT_SYSTEM_INFO *>(tempHwInfos[numDevices].pSysInfo),
-                                                                  const_cast<FeatureTable *>(tempHwInfos[numDevices].pSkuTable), true);
+                                                                  const_cast<FeatureTable *>(tempHwInfos[numDevices].pSkuTable),
+                                                                  true, hwInfoConfig);
         numDevices++;
     }
     *pHWInfos = tempHwInfos.get();

unit_tests/gen10/CMakeLists.txt

@@ -19,6 +19,7 @@ if(TESTS_GEN10)
     ${CMAKE_CURRENT_SOURCE_DIR}/scheduler_source_tests_gen10.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_gen10.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_device_queue_hw_gen10.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_cnl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_platform_caps_gen10.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_preamble_gen10.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_preemption_gen10.cpp

unit_tests/gen10/test_hw_info_config_cnl.cpp

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+using namespace OCLRT;
+
+TEST(CnlHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorrect) {
+    if (IGFX_CANNONLAKE != productFamily) {
+        return;
+    }
+    GT_SYSTEM_INFO gInfo;
+    FeatureTable fTable;
+    std::string strConfig = "1x2x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 2u);
+    EXPECT_EQ(gInfo.EUCount, 15u);
+
+    strConfig = "1x3x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 23u);
+
+    strConfig = "2x4x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 2u);
+    EXPECT_EQ(gInfo.SubSliceCount, 4u);
+    EXPECT_EQ(gInfo.EUCount, 31u);
+
+    strConfig = "2x5x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 2u);
+    EXPECT_EQ(gInfo.SubSliceCount, 5u);
+    EXPECT_EQ(gInfo.EUCount, 39u);
+
+    strConfig = "4x9x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 4u);
+    EXPECT_EQ(gInfo.SubSliceCount, 9u);
+    EXPECT_EQ(gInfo.EUCount, 71u);
+
+    strConfig = "default";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 2u);
+    EXPECT_EQ(gInfo.SubSliceCount, 5u);
+    EXPECT_EQ(gInfo.EUCount, 39u);
+
+    strConfig = "erroneous";
+    gInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
+    EXPECT_EQ(gInfo.SliceCount, 0u);
+    EXPECT_EQ(gInfo.SubSliceCount, 0u);
+    EXPECT_EQ(gInfo.EUCount, 0u);
+}

unit_tests/gen8/bdw/CMakeLists.txt

@@ -9,6 +9,7 @@ if(TESTS_BDW)
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/device_tests_bdw.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_bdw.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_bdw.cpp
   )
   target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen8_bdw})
   add_subdirectories()

unit_tests/gen8/bdw/test_hw_info_config_bdw.cpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+using namespace OCLRT;
+
+TEST(BdwHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorrect) {
+    if (IGFX_BROADWELL != productFamily) {
+        return;
+    }
+    GT_SYSTEM_INFO gInfo = {0};
+    FeatureTable fTable;
+    std::string strConfig = "1x3x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 23u);
+
+    strConfig = "2x3x8";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 2u);
+    EXPECT_EQ(gInfo.SubSliceCount, 6u);
+    EXPECT_EQ(gInfo.EUCount, 47u);
+
+    strConfig = "1x2x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 2u);
+    EXPECT_EQ(gInfo.EUCount, 12u);
+
+    strConfig = "1x3x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 18u);
+
+    strConfig = "default";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 23u);
+
+    strConfig = "erroneous";
+    gInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
+    EXPECT_EQ(gInfo.SliceCount, 0u);
+    EXPECT_EQ(gInfo.SubSliceCount, 0u);
+    EXPECT_EQ(gInfo.EUCount, 0u);
+}

unit_tests/gen9/bxt/CMakeLists.txt

@@ -9,6 +9,7 @@ if(TESTS_BXT)
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/device_tests_bxt.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_bxt.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_bxt.cpp
   )
   target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_bxt})
   add_subdirectories()

unit_tests/gen9/bxt/test_hw_info_config_bxt.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+using namespace OCLRT;
+
+TEST(BxtHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorrect) {
+    if (IGFX_BROXTON != productFamily) {
+        return;
+    }
+    GT_SYSTEM_INFO gInfo = {0};
+    FeatureTable fTable;
+    std::string strConfig = "1x2x6";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 2u);
+    EXPECT_EQ(gInfo.EUCount, 12u);
+
+    strConfig = "1x3x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 18u);
+
+    strConfig = "default";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 18u);
+
+    strConfig = "erroneous";
+    gInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
+    EXPECT_EQ(gInfo.SliceCount, 0u);
+    EXPECT_EQ(gInfo.SubSliceCount, 0u);
+    EXPECT_EQ(gInfo.EUCount, 0u);
+}

unit_tests/gen9/cfl/CMakeLists.txt

@@ -8,6 +8,7 @@ if(TESTS_CFL)
   set(IGDRCL_SRCS_tests_gen9_cfl
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_cfl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_cfl.cpp
   )
   target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_cfl})
   add_subdirectories()

unit_tests/gen9/cfl/test_hw_info_config_cfl.cpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+using namespace OCLRT;
+
+TEST(CflHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorrect) {
+    if (IGFX_COFFEELAKE != productFamily) {
+        return;
+    }
+    GT_SYSTEM_INFO gInfo = {0};
+    FeatureTable fTable;
+    std::string strConfig = "1x3x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 23u);
+
+    strConfig = "2x3x8";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 2u);
+    EXPECT_EQ(gInfo.SubSliceCount, 6u);
+    EXPECT_EQ(gInfo.EUCount, 47u);
+
+    strConfig = "3x3x8";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 3u);
+    EXPECT_EQ(gInfo.SubSliceCount, 9u);
+    EXPECT_EQ(gInfo.EUCount, 71u);
+
+    strConfig = "1x2x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 2u);
+    EXPECT_EQ(gInfo.EUCount, 11u);
+
+    strConfig = "1x3x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 17u);
+
+    strConfig = "default";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 17u);
+
+    strConfig = "erroneous";
+    gInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
+    EXPECT_EQ(gInfo.SliceCount, 0u);
+    EXPECT_EQ(gInfo.SubSliceCount, 0u);
+    EXPECT_EQ(gInfo.EUCount, 0u);
+}

unit_tests/gen9/glk/CMakeLists.txt

@@ -8,6 +8,7 @@ if(TESTS_GLK)
   set(IGDRCL_SRCS_tests_gen9_glk
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_glk.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_glk.cpp
   )
   target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_glk})
   add_subdirectories()

unit_tests/gen9/glk/test_hw_info_config_glk.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+using namespace OCLRT;
+
+TEST(GlkHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorrect) {
+    if (IGFX_GEMINILAKE != productFamily) {
+        return;
+    }
+    GT_SYSTEM_INFO gInfo = {0};
+    FeatureTable fTable;
+    std::string strConfig = "1x2x6";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 2u);
+    EXPECT_EQ(gInfo.EUCount, 12u);
+
+    strConfig = "1x3x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 18u);
+
+    strConfig = "default";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 18u);
+
+    strConfig = "erroneous";
+    gInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
+    EXPECT_EQ(gInfo.SliceCount, 0u);
+    EXPECT_EQ(gInfo.SubSliceCount, 0u);
+    EXPECT_EQ(gInfo.EUCount, 0u);
+}

unit_tests/gen9/kbl/CMakeLists.txt

@@ -8,6 +8,7 @@ if(TESTS_KBL)
   set(IGDRCL_SRCS_tests_gen9_kbl
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_kbl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_kbl.cpp
   )
   target_sources(igdrcl_tests PRIVATE ${IGDRCL_SRCS_tests_gen9_kbl})
   add_subdirectories()

unit_tests/gen9/kbl/test_hw_info_config_kbl.cpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+using namespace OCLRT;
+
+TEST(KblHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorrect) {
+    if (IGFX_KABYLAKE != productFamily) {
+        return;
+    }
+    GT_SYSTEM_INFO gInfo = {0};
+    FeatureTable fTable;
+    std::string strConfig = "1x3x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 23u);
+
+    strConfig = "2x3x8";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 2u);
+    EXPECT_EQ(gInfo.SubSliceCount, 6u);
+    EXPECT_EQ(gInfo.EUCount, 47u);
+
+    strConfig = "3x3x8";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 3u);
+    EXPECT_EQ(gInfo.SubSliceCount, 9u);
+    EXPECT_EQ(gInfo.EUCount, 71u);
+
+    strConfig = "1x2x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 2u);
+    EXPECT_EQ(gInfo.EUCount, 11u);
+
+    strConfig = "1x3x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 17u);
+
+    strConfig = "default";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 17u);
+
+    strConfig = "erroneous";
+    gInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
+    EXPECT_EQ(gInfo.SliceCount, 0u);
+    EXPECT_EQ(gInfo.SubSliceCount, 0u);
+    EXPECT_EQ(gInfo.EUCount, 0u);
+}

unit_tests/gen9/skl/CMakeLists.txt

@@ -9,6 +9,7 @@ if(TESTS_SKL)
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
     ${CMAKE_CURRENT_SOURCE_DIR}/device_tests_skl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_device_caps_skl.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config_skl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_preamble_skl.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test_sample_skl.cpp
   )

unit_tests/gen9/skl/test_hw_info_config_skl.cpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2018 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+using namespace OCLRT;
+
+TEST(SklHwInfoConfig, givenHwInfoConfigStringThenAfterSetupResultingHwInfoIsCorrect) {
+    if (IGFX_SKYLAKE != productFamily) {
+        return;
+    }
+    GT_SYSTEM_INFO gInfo = {0};
+    FeatureTable fTable;
+    std::string strConfig = "1x3x8";
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 23u);
+
+    strConfig = "2x3x8";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 2u);
+    EXPECT_EQ(gInfo.SubSliceCount, 6u);
+    EXPECT_EQ(gInfo.EUCount, 47u);
+
+    strConfig = "3x3x8";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 3u);
+    EXPECT_EQ(gInfo.SubSliceCount, 9u);
+    EXPECT_EQ(gInfo.EUCount, 71u);
+
+    strConfig = "1x2x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 2u);
+    EXPECT_EQ(gInfo.EUCount, 11u);
+
+    strConfig = "1x3x6";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 17u);
+
+    strConfig = "default";
+    gInfo = {0};
+    hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig);
+    EXPECT_EQ(gInfo.SliceCount, 1u);
+    EXPECT_EQ(gInfo.SubSliceCount, 3u);
+    EXPECT_EQ(gInfo.EUCount, 23u);
+
+    strConfig = "erroneous";
+    gInfo = {0};
+    EXPECT_ANY_THROW(hardwareInfoSetup[productFamily](&gInfo, &fTable, false, strConfig));
+    EXPECT_EQ(gInfo.SliceCount, 0u);
+    EXPECT_EQ(gInfo.SubSliceCount, 0u);
+    EXPECT_EQ(gInfo.EUCount, 0u);
+}

unit_tests/main.cpp

@@ -287,7 +287,8 @@ int main(int argc, char **argv) {
     platform.usRevId = (uint16_t)revisionId;
 
     // set Gt and FeatureTable to initial state
-    hardwareInfoSetup[productFamily](&gtSystemInfo, &featureTable, setupFeatureTable);
+    std::string hwInfoConfig = "default";
+    hardwareInfoSetup[productFamily](&gtSystemInfo, &featureTable, setupFeatureTable, hwInfoConfig);
     // and adjust dynamic values if not secified
     sliceCount = sliceCount > 0 ? sliceCount : gtSystemInfo.SliceCount;
     subSliceCount = subSliceCount > 0 ? subSliceCount : gtSystemInfo.SubSliceCount;

unit_tests/os_interface/debug_settings_manager_tests.cpp

@@ -921,3 +921,22 @@ TEST(DebugSettingsManager, whenOnlyRegKeysAreEnabledThenAllOtherDebugFunctionali
     static_assert(false == debugManager.kernelArgDumpingAvailable(), "");
     static_assert(debugManager.registryReadAvailable(), "");
 }
+
+TEST(DebugSettingsManager, givenTwoPossibleVariantsOfHardwareInfoOverrideStringThenOutputStringIsTheSame) {
+    FullyEnabledTestDebugManager debugManager;
+    std::string hwInfoConfig;
+
+    // Set HardwareInfoOverride as regular string (i.e. as in Windows Registry)
+    std::string str1 = "1x4x8";
+    debugManager.flags.HardwareInfoOverride.set(str1);
+    debugManager.getHardwareInfoOverride(hwInfoConfig);
+    EXPECT_EQ(str1, hwInfoConfig);
+
+    // Set HardwareInfoOverride as quoted string (i.e. as in igdrcl.config file)
+    std::string str2 = "\"1x4x8\"";
+    debugManager.flags.HardwareInfoOverride.set(str2);
+    hwInfoConfig = debugManager.flags.HardwareInfoOverride.get();
+    EXPECT_EQ(str2, hwInfoConfig);
+    debugManager.getHardwareInfoOverride(hwInfoConfig);
+    EXPECT_EQ(str1, hwInfoConfig);
+}

unit_tests/test_files/igdrcl.config

@@ -48,6 +48,7 @@ OverrideDelayQuickKmdSleepForSporadicWaitsMicroseconds = -1
 Enable64kbpages = -1
 NodeOrdinal = -1
 ProductFamilyOverride = unk
+HardwareInfoOverride = default
 EnableDebugBreak = true
 EnableComputeWorkSizeND = true
 EventsDebugEnable = false