From 39ccf0297fc1281f92261c1de9cd6a916bd85165 Mon Sep 17 00:00:00 2001
From: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>
Date: Wed, 6 Dec 2023 10:55:29 +0000
Subject: [PATCH] fix: Skip rebuild binary forced by flag  when lack of ir

when flag RebuildPrecompiledKernels set and call clCreateProgramWithBinary
skip rebuild if ir binary not available

Resolves: HSD-18035219734
Signed-off-by: Katarzyna Cencelewska <katarzyna.cencelewska@intel.com>
---
 opencl/source/program/program.cpp             | 15 +++++++--
 .../test/unit_test/program/program_tests.cpp  | 33 ++++++++++++++++++-
 2 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/opencl/source/program/program.cpp b/opencl/source/program/program.cpp
index 7ad325f119..3f68419d29 100644
--- a/opencl/source/program/program.cpp
+++ b/opencl/source/program/program.cpp
@@ -203,11 +203,20 @@ cl_int Program::createProgramFromBinary(
 
             auto isVmeUsed = containsVmeUsage(this->buildInfos[rootDeviceIndex].kernelInfoArray);
             bool rebuild = isRebuiltToPatchtokensRequired(&clDevice.getDevice(), archive, this->options, this->isBuiltIn, isVmeUsed);
-            rebuild |= debugManager.flags.RebuildPrecompiledKernels.get();
+            bool flagRebuild = debugManager.flags.RebuildPrecompiledKernels.get();
 
-            if (rebuild && 0u == this->irBinarySize) {
-                return CL_INVALID_BINARY;
+            if (0u == this->irBinarySize) {
+                if (flagRebuild) {
+                    PRINT_DEBUG_STRING(debugManager.flags.PrintDebugMessages.get(), stderr, "Skip rebuild binary. Lack of IR, rebuild impossible.\n");
+                }
+                if (rebuild) {
+                    return CL_INVALID_BINARY;
+                }
+                rebuild = 0;
+            } else {
+                rebuild |= flagRebuild;
             }
+
             if ((false == singleDeviceBinary.deviceBinary.empty()) && (false == rebuild)) {
                 this->buildInfos[rootDeviceIndex].unpackedDeviceBinary = makeCopy<char>(reinterpret_cast<const char *>(singleDeviceBinary.deviceBinary.begin()), singleDeviceBinary.deviceBinary.size());
                 this->buildInfos[rootDeviceIndex].unpackedDeviceBinarySize = singleDeviceBinary.deviceBinary.size();
diff --git a/opencl/test/unit_test/program/program_tests.cpp b/opencl/test/unit_test/program/program_tests.cpp
index 711f942c9b..8a078722a3 100644
--- a/opencl/test/unit_test/program/program_tests.cpp
+++ b/opencl/test/unit_test/program/program_tests.cpp
@@ -2766,9 +2766,10 @@ TEST_F(ProgramTests, GivenInjectInternalBuildOptionsWhenCompilingBuiltInProgramT
     EXPECT_FALSE(CompilerOptions::contains(cip->buildInternalOptions, "-abc")) << cip->buildInternalOptions;
 }
 
-TEST(CreateProgramFromBinaryTests, givenBinaryProgramBuiltInWhenKernelRebulildIsForcedAndIrBinaryIsNotPresentThenErrorIsReturned) {
+TEST(CreateProgramFromBinaryTests, givenBinaryProgramBuiltInWhenKernelRebulildIsForcedAndIrBinaryIsNotPresentThenSkipRebuildPrintDebugMssageAndReturnSuccess) {
     DebugManagerStateRestore dbgRestorer;
     debugManager.flags.RebuildPrecompiledKernels.set(true);
+    debugManager.flags.PrintDebugMessages.set(true);
     cl_int retVal = CL_INVALID_BINARY;
 
     PatchTokensTestData::ValidEmptyProgram programTokens;
@@ -2779,8 +2780,38 @@ TEST(CreateProgramFromBinaryTests, givenBinaryProgramBuiltInWhenKernelRebulildIs
     EXPECT_EQ(CL_SUCCESS, retVal);
 
     pProgram->irBinarySize = 0x10;
+    ::testing::internal::CaptureStderr();
     retVal = pProgram->createProgramFromBinary(programTokens.storage.data(), programTokens.storage.size(), *clDevice);
+    std::string output = testing::internal::GetCapturedStderr();
+    EXPECT_FALSE(pProgram->requiresRebuild);
+    EXPECT_EQ(CL_SUCCESS, retVal);
+    std::string expectedOutput = "Skip rebuild binary. Lack of IR, rebuild impossible.\n";
+    EXPECT_EQ(expectedOutput, output);
+}
+
+TEST(CreateProgramFromBinaryTests, givenCreateProgramFromBinaryWhenIrBinaryIsNotPresentAndIsRebuiltToPatchtokensRequiredThenReturnClInvalidBinary) {
+    DebugManagerStateRestore dbgRestorer;
+    debugManager.flags.RebuildPrecompiledKernels.set(false);
+    cl_int retVal = CL_INVALID_BINARY;
+
+    ZebinTestData::ValidEmptyProgram zebin;
+
+    auto clDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
+    auto rootDeviceIndex = clDevice->getRootDeviceIndex();
+    std::unique_ptr<MockProgram> pProgram(Program::createBuiltInFromGenBinary<MockProgram>(nullptr, toClDeviceVector(*clDevice), zebin.storage.data(), zebin.storage.size(), &retVal));
+    ASSERT_NE(nullptr, pProgram.get());
+    EXPECT_EQ(CL_SUCCESS, retVal);
+
+    pProgram->irBinarySize = 0x10;
+    pProgram->isBuiltIn = false;
+    KernelInfo kernelInfo;
+    kernelInfo.kernelDescriptor.kernelAttributes.flags.usesVme = true;
+
+    pProgram->buildInfos[rootDeviceIndex].kernelInfoArray.push_back(&kernelInfo);
+    retVal = pProgram->createProgramFromBinary(zebin.storage.data(), zebin.storage.size(), *clDevice);
+    EXPECT_FALSE(pProgram->requiresRebuild);
     EXPECT_EQ(CL_INVALID_BINARY, retVal);
+    pProgram->buildInfos[rootDeviceIndex].kernelInfoArray.clear();
 }
 
 TEST(CreateProgramFromBinaryTests, givenBinaryProgramBuiltInWhenKernelRebulildIsForcedAndIrBinaryIsPresentThenDeviceBinaryIsNotUsed) {