refactor: add patchtokens fallback AIL

Related-To: HSD-14023878700

Signed-off-by: Jaroslaw Warchulski <jaroslaw.warchulski@intel.com>

opencl/source/program/create.inl

@@ -78,6 +78,9 @@ T *Program::create(
         }
 
         program = new T(pContext, false, pContext->getDevices());
+        if (ail && ail->isFallbackToPatchtokensRequired()) {
+            pContext->setContextAsNonZebin();
+        }
         program->sourceCode.swap(combinedString);
         program->createdFrom = CreatedFrom::source;
     }

opencl/test/unit_test/program/program_tests.cpp

@@ -681,7 +681,7 @@ void MinimumProgramFixture::TearDown() {
     NEO::PlatformFixture::tearDown();
 }
 
-HWTEST2_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSourcesDoNotChange, IsDG2) {
+TEST_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSourcesDoNotChange) {
     auto pDevice = pContext->getDevice(0);
     auto rootDeviceEnvironment = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex].get();
     rootDeviceEnvironment->ailConfiguration.reset(nullptr);
@@ -702,6 +702,38 @@ HWTEST2_F(MinimumProgramFixture, givenEmptyAilWhenCreateProgramWithSourcesThenSo
     pProgram->release();
 }
 
+TEST_F(MinimumProgramFixture, givenAILReturningTrueForFallbackRequirementWhenBuildingProgramThenMarkContextAsNonZebin) {
+    class MockAIL : public MockAILConfiguration {
+      public:
+        bool isFallbackToPatchtokensRequired() override {
+            return true;
+        }
+    };
+    auto pDevice = pContext->getDevice(0);
+    auto rootDeviceEnvironment = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[rootDeviceIndex].get();
+    rootDeviceEnvironment->ailConfiguration.reset(new MockAIL());
+
+    ASSERT_FALSE(pContext->checkIfContextIsNonZebin());
+
+    const char *kernelSources[] = {"some source code"};
+    size_t knownSourceSize = strlen(kernelSources[0]);
+    MockProgram *pProgram = nullptr;
+    pProgram = Program::create<SucceedingGenBinaryProgram>(
+        pContext,
+        1,
+        kernelSources,
+        &knownSourceSize,
+        retVal);
+
+    ASSERT_NE(nullptr, pProgram);
+    ASSERT_EQ(CL_SUCCESS, retVal);
+
+    retVal = pProgram->build(pProgram->getDevices(), "");
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    EXPECT_TRUE(pContext->checkIfContextIsNonZebin());
+    pProgram->release();
+}
+
 TEST_F(MinimumProgramFixture, givenApplicationContextMarkedAsNonZebinWhenBuildingProgramThenInternalOptionsShouldContainDisableZebinOption) {
     const char *kernelSources[] = {"some source code"};
     size_t knownSourceSize = strlen(kernelSources[0]);

shared/source/ail/ail_configuration.h

@@ -88,6 +88,8 @@ class AILConfiguration {
 
     virtual bool isRunAloneContextRequired() = 0;
 
+    virtual bool isFallbackToPatchtokensRequired() = 0;
+
   protected:
     virtual void applyExt(RuntimeCapabilityTable &runtimeCapabilityTable) = 0;
     std::string processName;
@@ -105,6 +107,7 @@ extern const std::set<std::string_view> applicationsBufferPoolDisabledDg2;
 extern const std::set<std::string_view> applicationsOverfetchDisabled;
 extern const std::set<std::string_view> applicationsDrainHostptrsDisabled;
 extern const std::set<std::string_view> applicationsDeviceUSMRecyclingLimited;
+extern const std::set<std::string_view> applicationsFallbackToPatchtokensRequiredDg2;
 
 template <PRODUCT_FAMILY product>
 class AILConfigurationHw : public AILConfiguration {
@@ -127,6 +130,7 @@ class AILConfigurationHw : public AILConfiguration {
     bool disableBindlessAddressing() override;
     bool limitAmountOfDeviceMemoryForRecycling() override;
     bool isRunAloneContextRequired() override;
+    bool isFallbackToPatchtokensRequired() override;
 
     bool shouldForceRcs = false;
     bool shouldHandleDivergentBarriers = false;

shared/source/ail/ail_configuration_base.inl

@@ -76,4 +76,9 @@ inline bool AILConfigurationHw<product>::limitAmountOfDeviceMemoryForRecycling()
     return false;
 }
 
+template <PRODUCT_FAMILY product>
+inline bool AILConfigurationHw<product>::isFallbackToPatchtokensRequired() {
+    return false;
+}
+
 } // namespace NEO

shared/source/ail/ail_configuration_extra.cpp

@@ -42,6 +42,8 @@ const std::set<std::string_view> applicationsDrainHostptrsDisabled = {};
 
 const std::set<std::string_view> applicationsDeviceUSMRecyclingLimited = {};
 
+const std::set<std::string_view> applicationsFallbackToPatchtokensRequiredDg2 = {};
+
 AILConfigurationCreateFunctionType ailConfigurationFactory[IGFX_MAX_PRODUCT];
 
 void AILConfiguration::apply(RuntimeCapabilityTable &runtimeCapabilityTable) {

shared/source/ail/xe_hpg_core/dg2/ail_configuration_dg2.cpp

@@ -70,6 +70,12 @@ bool AILConfigurationHw<IGFX_DG2>::isBufferPoolEnabled() {
     return iterator == applicationsBufferPoolDisabledDg2.end();
 }
 
+template <>
+inline bool AILConfigurationHw<IGFX_DG2>::isFallbackToPatchtokensRequired() {
+    auto iterator = applicationsFallbackToPatchtokensRequiredDg2.find(processName);
+    return iterator != applicationsFallbackToPatchtokensRequiredDg2.end();
+}
+
 template class AILConfigurationHw<IGFX_DG2>;
 
 } // namespace NEO

shared/test/common/mocks/mock_ail_configuration.h

@@ -72,6 +72,10 @@ class MockAILConfiguration : public AILConfiguration {
         return true;
     }
 
+    bool isFallbackToPatchtokensRequired() override {
+        return false;
+    }
+
   protected:
     void applyExt(RuntimeCapabilityTable &runtimeCapabilityTable) override {}
 };

shared/test/unit_test/ail/ail_tests.cpp

@@ -112,22 +112,28 @@ HWTEST2_F(AILTests, whenModifyKernelIfRequiredIsCalledThenDontChangeKernelSource
     EXPECT_STREQ(copyKernel.c_str(), kernelSources.c_str());
 }
 
-HWTEST2_F(AILTests, GivenAilWhenCheckingContextSyncFlagRequiredThenExpectFalse, MatchAny) {
+HWTEST2_F(AILTests, givenAilWhenCheckingContextSyncFlagRequiredThenExpectFalse, MatchAny) {
     AILWhitebox<productFamily> ail;
     ail.processName = "other";
     EXPECT_FALSE(ail.isContextSyncFlagRequired());
 }
 
-HWTEST2_F(AILTests, GivenAilWhenCheckingOverfetchDisableRequiredThenExpectFalse, MatchAny) {
+HWTEST2_F(AILTests, givenAilWhenCheckingOverfetchDisableRequiredThenExpectFalse, MatchAny) {
     AILWhitebox<productFamily> ail;
     ail.processName = "other";
     EXPECT_FALSE(ail.is256BPrefetchDisableRequired());
 }
 
-HWTEST2_F(AILTests, GivenAilWhenCheckingDrainHostptrsRequiredThenExpectTrue, MatchAny) {
+HWTEST2_F(AILTests, givenAilWhenCheckingDrainHostptrsRequiredThenExpectTrue, MatchAny) {
     AILWhitebox<productFamily> ail;
     ail.processName = "other";
     EXPECT_TRUE(ail.drainHostptrs());
 }
 
+HWTEST2_F(AILTests, givenAilWhenCheckingIfPatchtokenFallbackIsRequiredThenExpectFalse, MatchAny) {
+    AILWhitebox<productFamily> ail;
+    ail.processName = "other";
+    EXPECT_FALSE(ail.isFallbackToPatchtokensRequired());
+}
+
 } // namespace NEO

shared/test/unit_test/ail/ail_tests_base.cpp

@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2023-2024 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "shared/source/ail/ail_configuration.h"
-#include "shared/test/common/test_macros/hw_test.h"
-
-namespace NEO {
-
-using AILBaseTests = ::testing::Test;
-
-HWTEST2_F(AILBaseTests, whenKernelSourceIsANGenDummyKernelThenDoEnforcePatchtokensFormat, MatchAny) {
-    std::string dummyKernelSource{"kernel void _(){}"};
-    AILConfigurationHw<productFamily> ail;
-    EXPECT_TRUE(ail.isFallbackToPatchtokensRequired(dummyKernelSource));
-}
-
-HWTEST2_F(AILBaseTests, whenKernelSourceIsNotANGenDummyKernelThenDoNotEnforcePatchtokensFormat, MatchAny) {
-    std::string dummyKernelSource{"kernel void copybuffer(__global int* a, __global int* b){ //some code }"};
-    AILConfigurationHw<productFamily> ail;
-    EXPECT_FALSE(ail.isFallbackToPatchtokensRequired(dummyKernelSource));
-}
-
-} // namespace NEO