refactor: Store AIL in root device environment

Instead of storing AIL configurations in global table, store it
in root device environment.
This also prevents potential scenario with accessing deleted memory due
to symbol collision when application uses both OCL/L0 libraries.
- AIL is now stored in root device environment, and gets initialized
with other helpers
- Minor: corrected naming in ULTs

Signed-off-by: Kacper Nowak <kacper.nowak@intel.com>
Related-To: NEO-9240

opencl/source/program/create.inl

@@ -6,6 +6,7 @@
  */
 
 #include "shared/source/ail/ail_configuration.h"
+#include "shared/source/execution_environment/root_device_environment.h"
 #include "shared/source/helpers/hw_info.h"
 #include "shared/source/helpers/string_helpers.h"
 
@@ -71,8 +72,7 @@ T *Program::create(
 
     if (CL_SUCCESS == retVal) {
 
-        auto &hwInfo = pContext->getDevice(0)->getHardwareInfo();
+        auto ail = pContext->getDevice(0)->getRootDeviceEnvironment().getAILConfigurationHelper();
-        auto ail = AILConfiguration::get(hwInfo.platform.eProductFamily);
         if (ail) {
             ail->modifyKernelIfRequired(combinedString);
         }

opencl/test/unit_test/program/program_tests.cpp

@@ -680,10 +680,10 @@ void MinimumProgramFixture::TearDown() {
     NEO::PlatformFixture::tearDown();
 }
 
-TEST_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSourcesDoNotChange) {
+HWTEST2_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSourcesDoNotChange, IsDG2) {
-
+    auto pDevice = pContext->getDevice(0);
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    auto rootDeviceEnvironment = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex].get();
-    ailConfigurationTable[productFamily] = nullptr;
+    rootDeviceEnvironment->ailConfiguration.reset(nullptr);
     const char *sources[] = {"kernel() {}"};
     size_t knownSourceSize = strlen(sources[0]);
 
@@ -701,9 +701,10 @@ TEST_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSourc
     pProgram->release();
 }
 
-HWTEST_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesAndWithDummyKernelThenDoNotMarkApplicationContextAsNonZebin) {
+HWTEST2_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesAndWithDummyKernelThenDoNotMarkApplicationContextAsNonZebin, IsAtLeastSkl) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    auto pDevice = pContext->getDevice(0);
-    ailConfigurationTable[productFamily] = nullptr;
+    auto rootDeviceEnvironment = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex].get();
+    rootDeviceEnvironment->ailConfiguration.reset(nullptr);
     const char *dummyKernelSources[] = {"kernel void _(){}"}; // if detected - should trigger fallback to CTNI
     size_t knownSourceSize = strlen(dummyKernelSources[0]);
 
@@ -754,10 +755,10 @@ HWTEST2_F(MinimumProgramFixture, givenAILReturningTrueForFallbackRequirementWhen
             return true;
         }
     };
-    VariableBackup<AILConfiguration *> ailConfiguration(&ailConfigurationTable[productFamily]);
+    auto pDevice = pContext->getDevice(0);
+    auto rootDeviceEnvironment = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex].get();
+    rootDeviceEnvironment->ailConfiguration.reset(new MockAIL());
 
-    MockAIL mockAIL;
-    ailConfigurationTable[productFamily] = &mockAIL;
     ASSERT_FALSE(pContext->checkIfContextIsNonZebin());
 
     const char *kernelSources[] = {"some source code"};

shared/source/ail/ail_configuration.h

@@ -10,6 +10,7 @@
 #include "igfxfmid.h"
 
 #include <cstdint>
+#include <memory>
 #include <set>
 #include <string>
 
@@ -43,14 +44,24 @@ enum class AILEnumeration : uint32_t {
     AIL_MAX_OPTIONS_COUNT
 };
 
+class AILConfiguration;
+using AILConfigurationCreateFunctionType = std::unique_ptr<AILConfiguration> (*)();
+extern AILConfigurationCreateFunctionType ailConfigurationFactory[IGFX_MAX_PRODUCT];
+
 class AILConfiguration {
   public:
+    static std::unique_ptr<AILConfiguration> create(PRODUCT_FAMILY product) {
+        auto ailConfigurationCreateFunction = ailConfigurationFactory[product];
+        if (ailConfigurationCreateFunction == nullptr) {
+            return nullptr;
+        }
+        auto ailConfiguration = ailConfigurationCreateFunction();
+        return ailConfiguration;
+    }
     AILConfiguration() = default;
 
     MOCKABLE_VIRTUAL bool initProcessExecutableName();
 
-    static AILConfiguration *get(PRODUCT_FAMILY productFamily);
-
     virtual void apply(RuntimeCapabilityTable &runtimeCapabilityTable);
 
     virtual void modifyKernelIfRequired(std::string &kernel) = 0;
@@ -59,6 +70,8 @@ class AILConfiguration {
 
     virtual bool isContextSyncFlagRequired() = 0;
 
+    virtual ~AILConfiguration() = default;
+
   protected:
     virtual void applyExt(RuntimeCapabilityTable &runtimeCapabilityTable) = 0;
     std::string processName;
@@ -67,15 +80,13 @@ class AILConfiguration {
     MOCKABLE_VIRTUAL bool isKernelHashCorrect(const std::string &kernelSources, uint64_t expectedHash) const;
 };
 
-extern AILConfiguration *ailConfigurationTable[IGFX_MAX_PRODUCT];
-
 extern const std::set<std::string_view> applicationsContextSyncFlag;
 
 template <PRODUCT_FAMILY Product>
 class AILConfigurationHw : public AILConfiguration {
   public:
-    static AILConfigurationHw<Product> &get() {
+    static std::unique_ptr<AILConfiguration> create() {
-        static AILConfigurationHw<Product> ailConfiguration;
+        auto ailConfiguration = std::unique_ptr<AILConfiguration>(new AILConfigurationHw());
         return ailConfiguration;
     }
 
@@ -89,7 +100,8 @@ class AILConfigurationHw : public AILConfiguration {
 template <PRODUCT_FAMILY product>
 struct EnableAIL {
     EnableAIL() {
-        ailConfigurationTable[product] = &AILConfigurationHw<product>::get();
+        auto ailConfigurationCreateFunction = AILConfigurationHw<product>::create;
+        ailConfigurationFactory[product] = ailConfigurationCreateFunction;
     }
 };
 

shared/source/ail/ail_configuration_extra.cpp

@@ -28,11 +28,7 @@ std::map<std::string_view, std::vector<AILEnumeration>> applicationMapMTL = {{"s
 
 const std::set<std::string_view> applicationsContextSyncFlag = {};
 
-AILConfiguration *ailConfigurationTable[IGFX_MAX_PRODUCT] = {};
+AILConfigurationCreateFunctionType ailConfigurationFactory[IGFX_MAX_PRODUCT];
-
-AILConfiguration *AILConfiguration::get(PRODUCT_FAMILY productFamily) {
-    return ailConfigurationTable[productFamily];
-}
 
 void AILConfiguration::apply(RuntimeCapabilityTable &runtimeCapabilityTable) {
     auto search = applicationMap.find(processName);

shared/source/execution_environment/root_device_environment.cpp

@@ -101,11 +101,6 @@ void RootDeviceEnvironment::prepareForCleanup() const {
 }
 
 bool RootDeviceEnvironment::initAilConfiguration() {
-    if (!DebugManager.flags.EnableAIL.get()) {
-        return true;
-    }
-    auto ailConfiguration = AILConfiguration::get(hwInfo->platform.eProductFamily);
-
     if (ailConfiguration == nullptr) {
         return true;
     }
@@ -161,6 +156,7 @@ void RootDeviceEnvironment::initHelpers() {
     initApiGfxCoreHelper();
     initCompilerProductHelper();
     initReleaseHelper();
+    initAilConfigurationHelper();
 }
 
 void RootDeviceEnvironment::initGfxCoreHelper() {
@@ -186,10 +182,20 @@ void RootDeviceEnvironment::initReleaseHelper() {
     }
 }
 
+void RootDeviceEnvironment::initAilConfigurationHelper() {
+    if (ailConfiguration == nullptr && DebugManager.flags.EnableAIL.get()) {
+        ailConfiguration = AILConfiguration::create(this->getHardwareInfo()->platform.eProductFamily);
+    }
+}
+
 ReleaseHelper *RootDeviceEnvironment::getReleaseHelper() const {
     return releaseHelper.get();
 }
 
+AILConfiguration *RootDeviceEnvironment::getAILConfigurationHelper() const {
+    return ailConfiguration.get();
+}
+
 BuiltIns *RootDeviceEnvironment::getBuiltIns() {
     if (this->builtins.get() == nullptr) {
         std::lock_guard<std::mutex> autolock(this->mtx);

shared/source/execution_environment/root_device_environment.h

@@ -40,6 +40,7 @@ class ApiGfxCoreHelper;
 class CompilerProductHelper;
 class GraphicsAllocation;
 class ReleaseHelper;
+class AILConfiguration;
 
 struct AllocationProperties;
 struct HardwareInfo;
@@ -85,7 +86,9 @@ struct RootDeviceEnvironment : NonCopyableClass {
     void initApiGfxCoreHelper();
     void initCompilerProductHelper();
     void initReleaseHelper();
+    void initAilConfigurationHelper();
     ReleaseHelper *getReleaseHelper() const;
+    AILConfiguration *getAILConfigurationHelper() const;
     template <typename HelperType>
     HelperType &getHelper() const;
     const ProductHelper &getProductHelper() const;
@@ -108,6 +111,7 @@ struct RootDeviceEnvironment : NonCopyableClass {
     std::unique_ptr<ProductHelper> productHelper;
     std::unique_ptr<CompilerProductHelper> compilerProductHelper;
     std::unique_ptr<ReleaseHelper> releaseHelper;
+    std::unique_ptr<AILConfiguration> ailConfiguration;
 
     std::unique_ptr<AssertHandler> assertHandler;
 

shared/test/common/mocks/mock_ail_configuration.h

@@ -13,10 +13,8 @@ namespace NEO {
 class MockAILConfiguration : public AILConfiguration {
   public:
     bool initProcessExecutableName() override {
-        initCalled = true;
         return true;
     }
-    bool initCalled = false;
     void modifyKernelIfRequired(std::string &kernel) override {}
 
     bool isFallbackToPatchtokensRequired(const std::string &kernelSources) override {
@@ -33,7 +31,7 @@ class MockAILConfiguration : public AILConfiguration {
 };
 
 template <PRODUCT_FAMILY productFamily>
-class AILMock : public AILConfigurationHw<productFamily> {
+class AILWhitebox : public AILConfigurationHw<productFamily> {
   public:
     using AILConfiguration::apply;
     using AILConfiguration::isKernelHashCorrect;

shared/test/unit_test/ail/ail_tests.cpp

@@ -19,54 +19,37 @@ using IsHostPtrTrackingDisabled = IsWithinGfxCore<IGFX_GEN9_CORE, IGFX_GEN11LP_C
 
 using AILTests = ::testing::Test;
 
-HWTEST2_F(AILTests, givenInitializedTemplateWhenGetAILConfigurationThenNullptrIsNotReturned, IsSKL) {
+TEST(AILTests, whenAILConfigurationCreateFunctionIsCalledWithUnknownGfxCoreThenNullptrIsReturned) {
-    auto ailConfiguration = AILConfiguration::get(productFamily);
+    EXPECT_EQ(nullptr, AILConfiguration::create(IGFX_UNKNOWN));
-    EXPECT_NE(nullptr, ailConfiguration);
 }
 
 HWTEST2_F(AILTests, givenInitilizedTemplateWhenApplyWithBlenderIsCalledThenFP64SupportIsEnabled, IsAtLeastGen12lp) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
-
+    ail.processName = "blender";
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "blender";
-    ailConfigurationTable[productFamily] = &ailTemp;
-
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
 
     NEO::RuntimeCapabilityTable rtTable = {};
     rtTable.ftrSupportsFP64 = false;
 
-    ailConfiguration->apply(rtTable);
+    ail.apply(rtTable);
 
     EXPECT_EQ(rtTable.ftrSupportsFP64, true);
 }
 
 HWTEST2_F(AILTests, givenInitilizedTemplateWhenApplyWithAdobePremiereProIsCalledThenPreferredPlatformNameIsSet, IsAtLeastGen9) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
-
+    ail.processName = "Adobe Premiere Pro";
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "Adobe Premiere Pro";
-    ailConfigurationTable[productFamily] = &ailTemp;
-
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
 
     NEO::RuntimeCapabilityTable rtTable = {};
     rtTable.preferredPlatformName = nullptr;
 
-    ailConfiguration->apply(rtTable);
+    ail.apply(rtTable);
 
     EXPECT_NE(nullptr, rtTable.preferredPlatformName);
     EXPECT_STREQ("Intel(R) OpenCL", rtTable.preferredPlatformName);
 }
 
 HWTEST2_F(AILTests, whenCheckingIfSourcesContainKernelThenCorrectResultIsReturned, IsAtLeastGen12lp) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
-    AILMock<productFamily> ail;
-    ailConfigurationTable[productFamily] = &ail;
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
 
     std::string kernelSources = R"( 
 __kernel void CopyBufferToBufferLeftLeftover(
@@ -96,11 +79,7 @@ __kernel void CopyBufferToBufferMiddle(
 }
 
 HWTEST2_F(AILTests, whenCheckingIsKernelHashCorrectThenCorrectResultIsReturned, IsAtLeastGen12lp) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
-    AILMock<productFamily> ail;
-    ailConfigurationTable[productFamily] = &ail;
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
 
     std::string kernelSources = R"( 
 __kernel void CopyBufferToBufferLeftLeftover(
@@ -125,11 +104,7 @@ __kernel void CopyBufferToBufferLeftLeftover(
 }
 
 HWTEST2_F(AILTests, whenModifyKernelIfRequiredIsCalledThenDontChangeKernelSources, IsAtLeastGen12lp) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
-    AILMock<productFamily> ail;
-    ailConfigurationTable[productFamily] = &ail;
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
 
     std::string kernelSources = "example_kernel(){}";
     auto copyKernel = kernelSources;
@@ -140,99 +115,48 @@ HWTEST2_F(AILTests, whenModifyKernelIfRequiredIsCalledThenDontChangeKernelSource
 }
 
 HWTEST2_F(AILTests, givenPreGen12AndProcessNameIsResolveWhenApplyWithDavinciResolveThenHostPtrTrackingIsDisabled, IsHostPtrTrackingDisabled) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
-
+    ail.processName = "resolve";
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "resolve";
-    ailConfigurationTable[productFamily] = &ailTemp;
-
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
 
     NEO::RuntimeCapabilityTable rtTable = {};
     rtTable.hostPtrTrackingEnabled = true;
 
-    ailConfiguration->apply(rtTable);
+    ail.apply(rtTable);
 
     EXPECT_FALSE(rtTable.hostPtrTrackingEnabled);
 }
 
 HWTEST2_F(AILTests, givenPreGen12AndAndProcessNameIsNotResolveWhenApplyWithDavinciResolveThenHostPtrTrackingIsEnabled, IsHostPtrTrackingDisabled) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
-
+    ail.processName = "usualProcessName";
-    AILMock<productFamily> ailTemp;
-    ailTemp.processName = "usualProcessName";
-    ailConfigurationTable[productFamily] = &ailTemp;
-
-    auto ailConfiguration = AILConfiguration::get(productFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
 
     NEO::RuntimeCapabilityTable rtTable = {};
     rtTable.hostPtrTrackingEnabled = true;
 
-    ailConfiguration->apply(rtTable);
+    ail.apply(rtTable);
 
     EXPECT_TRUE(rtTable.hostPtrTrackingEnabled);
 }
 
-HWTEST_F(AILTests, whenAilIsDisabledByDebugVariableThenAilIsNotInitialized) {
-    DebugManagerStateRestore restore;
-    NEO::DebugManager.flags.EnableAIL.set(false);
-
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    MockAILConfiguration ailConfig;
-    ailConfigurationTable[productFamily] = &ailConfig;
-
-    HardwareInfo hwInfo{};
-    hwInfo.platform.eProductFamily = productFamily;
-    hwInfo.platform.eRenderCoreFamily = renderCoreFamily;
-
-    NEO::MockExecutionEnvironment executionEnvironment{&hwInfo, true, 1};
-    auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[0].get();
-    rootDeviceEnvironment->initAilConfiguration();
-
-    EXPECT_EQ(false, ailConfig.initCalled);
-}
-
-HWTEST_F(AILTests, whenAilIsEnabledByDebugVariableThenAilIsInitialized) {
-    DebugManagerStateRestore restore;
-    NEO::DebugManager.flags.EnableAIL.set(true);
-
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    MockAILConfiguration ailConfig;
-    ailConfigurationTable[productFamily] = &ailConfig;
-
-    HardwareInfo hwInfo{};
-    hwInfo.platform.eProductFamily = productFamily;
-    hwInfo.platform.eRenderCoreFamily = renderCoreFamily;
-
-    NEO::MockExecutionEnvironment executionEnvironment{&hwInfo, true, 1};
-    auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[0].get();
-    rootDeviceEnvironment->initAilConfiguration();
-
-    EXPECT_EQ(true, ailConfig.initCalled);
-}
-
 HWTEST_F(AILTests, GivenPlatformHasNoAilAvailableWhenAilIsEnabledThenAilInitializationReturnsTrue) {
     DebugManagerStateRestore restore;
     NEO::DebugManager.flags.EnableAIL.set(true);
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    ailConfigurationTable[productFamily] = nullptr;
-
     HardwareInfo hwInfo{};
     hwInfo.platform.eProductFamily = productFamily;
     hwInfo.platform.eRenderCoreFamily = renderCoreFamily;
 
     NEO::MockExecutionEnvironment executionEnvironment{&hwInfo, true, 1};
     auto rootDeviceEnvironment = executionEnvironment.rootDeviceEnvironments[0].get();
+    rootDeviceEnvironment->ailConfiguration.reset(nullptr);
+
     EXPECT_TRUE(rootDeviceEnvironment->initAilConfiguration());
 }
 
 HWTEST2_F(AILTests, GivenAilWhenCheckingContextSyncFlagRequiredThenExpectFalse, IsAtLeastGen9) {
-    AILMock<productFamily> ailTemp;
+    AILWhitebox<productFamily> ail;
-    ailTemp.processName = "other";
+    ail.processName = "other";
-    EXPECT_FALSE(ailTemp.isContextSyncFlagRequired());
+    EXPECT_FALSE(ail.isContextSyncFlagRequired());
 }
 
 } // namespace NEO

shared/test/unit_test/ail/ail_tests_base.cpp

@@ -5,9 +5,9 @@
  *
  */
 
-#include "shared/source/ail/ail_configuration.h"
 #include "shared/test/common/helpers/default_hw_info.h"
 #include "shared/test/common/helpers/variable_backup.h"
+#include "shared/test/common/mocks/mock_ail_configuration.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
 namespace NEO {
@@ -27,15 +27,7 @@ HWTEST2_F(AILBaseTests, whenKernelSourceIsNotANGenDummyKernelThenDoNotEnforcePat
 }
 
 HWTEST2_F(AILBaseTests, givenApplicationNamesThatRequirAILWhenCheckingIfPatchtokenFallbackIsRequiredThenIsCorrectResult, IsAtLeastSkl) {
-    class AILMock : public AILConfigurationHw<productFamily> {
+    AILWhitebox<productFamily> ail;
-      public:
-        using AILConfiguration::processName;
-    };
-
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
-    AILMock ail;
-    ailConfigurationTable[productFamily] = &ail;
-
     for (const auto &name : {"Resolve",
                              "ArcControlAssist",
                              "ArcControl"}) {

shared/test/unit_test/ail/windows/ail_windows_tests.cpp

@@ -5,9 +5,9 @@
  *
  */
 
-#include "shared/source/ail/ail_configuration.h"
 #include "shared/test/common/helpers/unit_test_helper.h"
 #include "shared/test/common/helpers/variable_backup.h"
+#include "shared/test/common/mocks/mock_ail_configuration.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
 namespace NEO {
@@ -17,52 +17,37 @@ namespace SysCalls {
 extern const wchar_t *currentLibraryPath;
 }
 
-template <PRODUCT_FAMILY productFamily>
-class AILMock : public AILConfigurationHw<productFamily> {
-  public:
-    using AILConfiguration::processName;
-};
-
 HWTEST2_F(AILTests, givenValidApplicationPathWhenAILinitProcessExecutableNameThenProperProcessNameIsReturned, IsAtLeastGen12lp) {
     VariableBackup<const wchar_t *> applicationPathBackup(&SysCalls::currentLibraryPath);
     applicationPathBackup = L"C\\Users\\Administrator\\application.exe";
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
 
-    AILMock<productFamily> ailTemp;
+    EXPECT_EQ(ail.initProcessExecutableName(), true);
-    ailConfigurationTable[productFamily] = &ailTemp;
 
-    EXPECT_EQ(ailTemp.initProcessExecutableName(), true);
+    EXPECT_EQ("application", ail.processName);
-
-    EXPECT_EQ("application", ailTemp.processName);
 }
 
 HWTEST2_F(AILTests, givenValidApplicationPathWithoutLongNameWhenAILinitProcessExecutableNameThenProperProcessNameIsReturned, IsAtLeastGen12lp) {
     VariableBackup<const wchar_t *> applicationPathBackup(&SysCalls::currentLibraryPath);
     applicationPathBackup = L"C\\Users\\Administrator\\application";
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
 
-    AILMock<productFamily> ailTemp;
+    EXPECT_EQ(ail.initProcessExecutableName(), true);
-    ailConfigurationTable[productFamily] = &ailTemp;
 
-    EXPECT_EQ(ailTemp.initProcessExecutableName(), true);
+    EXPECT_EQ("application", ail.processName);
-
-    EXPECT_EQ("application", ailTemp.processName);
 }
 
 HWTEST2_F(AILTests, givenApplicationPathWithNonLatinCharactersWhenAILinitProcessExecutableNameThenProperProcessNameIsReturned, IsAtLeastGen12lp) {
     VariableBackup<const wchar_t *> applicationPathBackup(&SysCalls::currentLibraryPath);
     applicationPathBackup = L"C\\\u4E20\u4E24\\application";
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
 
-    AILMock<productFamily> ailTemp;
+    EXPECT_EQ(ail.initProcessExecutableName(), true);
-    ailConfigurationTable[productFamily] = &ailTemp;
 
-    EXPECT_EQ(ailTemp.initProcessExecutableName(), true);
+    EXPECT_EQ("application", ail.processName);
-
-    EXPECT_EQ("application", ailTemp.processName);
 }
 
 } // namespace NEO

shared/test/unit_test/execution_environment/execution_environment_tests.cpp

@@ -207,6 +207,17 @@ TEST(RootDeviceEnvironment, givenHardwareInfoAndDebugVariableNodeOrdinalEqualsCc
     EXPECT_TRUE(hwInfo->featureTable.flags.ftrRcsNode);
 }
 
+TEST(RootDeviceEnvironment, givenEnableAILFlagSetToFalseWhenInitializingAILConfigurationThenSkipInitializingIt) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.EnableAIL.set(false);
+
+    MockExecutionEnvironment executionEnvironment;
+    auto rootDeviceEnvironment = static_cast<MockRootDeviceEnvironment *>(executionEnvironment.rootDeviceEnvironments[0].get());
+    ASSERT_EQ(nullptr, rootDeviceEnvironment->ailConfiguration);
+    rootDeviceEnvironment->initAilConfiguration();
+    EXPECT_EQ(nullptr, rootDeviceEnvironment->ailConfiguration);
+}
+
 TEST(ExecutionEnvironment, givenExecutionEnvironmentWhenInitializeMemoryManagerIsCalledThenLocalMemorySupportedInMemoryManagerHasCorrectValue) {
     const HardwareInfo *hwInfo = defaultHwInfo.get();
     auto device = std::unique_ptr<Device>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(hwInfo));

shared/test/unit_test/gen12lp/dg1/execution_environment_tests_dg1.cpp

@@ -6,7 +6,6 @@
  */
 
 #include "shared/source/ail/ail_configuration.h"
-#include "shared/test/common/helpers/variable_backup.h"
 #include "shared/test/common/mocks/mock_execution_environment.h"
 #include "shared/test/common/test_macros/hw_test.h"
 #include "shared/test/common/utilities/destructor_counted.h"
@@ -25,11 +24,7 @@ HWTEST2_F(RootDeviceEnvironmentTests, givenRootDeviceEnvironmentWhenAILInitProce
             return false;
         }
     };
-    VariableBackup<AILConfiguration *> ailConfiguration(&ailConfigurationTable[productFamily]);
+    rootDeviceEnvironment->ailConfiguration.reset(new AILDG1());
-
-    AILDG1 ailDg1;
-    ailConfigurationTable[productFamily] = &ailDg1;
-
     EXPECT_EQ(false, rootDeviceEnvironment->initAilConfiguration());
 }
 } // namespace NEO

shared/test/unit_test/xe_hpg_core/dg2/ail_tests_dg2.cpp

@@ -28,12 +28,7 @@ HWTEST2_F(AILTestsDg2, givenFixesForApplicationsWhenModifyKernelIfRequiredIsCall
         bool hashCorrect = {true};
     };
 
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
     AILMock ail;
-    ailConfigurationTable[productFamily] = &ail;
-    auto ailConfiguration = AILConfiguration::get(defaultHwInfo->platform.eProductFamily);
-    ASSERT_NE(nullptr, ailConfiguration);
-
     std::string_view fixCode = "else { SYNC_WARPS; }";
 
     for (auto name : {"FAHBench-gui", "FAHBench-cmd"}) {

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

@@ -6,7 +6,6 @@
  */
 
 #include "shared/test/common/helpers/default_hw_info.h"
-#include "shared/test/common/helpers/variable_backup.h"
 #include "shared/test/common/mocks/mock_ail_configuration.h"
 #include "shared/test/common/test_macros/hw_test.h"
 
@@ -15,9 +14,7 @@ namespace NEO {
 using AILTestsMTL = ::testing::Test;
 
 HWTEST2_F(AILTestsMTL, givenMtlWhenSvchostAppIsDetectedThenDisableDirectSubmission, IsMTL) {
-    VariableBackup<AILConfiguration *> ailConfigurationBackup(&ailConfigurationTable[productFamily]);
+    AILWhitebox<productFamily> ail;
-    AILMock<productFamily> ail;
-    ailConfigurationTable[productFamily] = &ail;
 
     auto capabilityTable = defaultHwInfo->capabilityTable;
     auto defaultEngineSupportedValue = capabilityTable.directSubmissionEngines.data[aub_stream::ENGINE_CCS].engineSupported;