Prepare mechanism for returning GPU execution error on OCL API

JablonskiMateusz · Compute-Runtime-Automation · commit 1c3d5c38927a · 2022-11-04T15:54:19.000+01:00
translate task count value to OCL error

Related-To: NEO-7412
Signed-off-by: Mateusz Jablonski &lt;mateusz.jablonski@intel.com&gt;
diff --git a/opencl/source/command_queue/command_queue.cpp b/opencl/source/command_queue/command_queue.cpp
@@ -60,6 +60,18 @@ CommandQueue *CommandQueue::create(Context *context,
     return funcCreate(context, device, properties, internalUsage);
 }
 
+cl_int CommandQueue::getErrorCodeFromTaskCount(uint32_t taskCount) {
+    switch (taskCount) {
+    case CompletionStamp::gpuHang:
+    case CompletionStamp::outOfDeviceMemory:
+        return CL_OUT_OF_RESOURCES;
+    case CompletionStamp::outOfHostMemory:
+        return CL_OUT_OF_HOST_MEMORY;
+    default:
+        return CL_SUCCESS;
+    }
+}
+
 CommandQueue::CommandQueue(Context *context, ClDevice *device, const cl_queue_properties *properties, bool internalUsage)
     : context(context), device(device), isInternalUsage(internalUsage) {
     if (context) {
diff --git a/opencl/source/command_queue/command_queue.h b/opencl/source/command_queue/command_queue.h
@@ -58,6 +58,8 @@ class CommandQueue : public BaseObject<_cl_command_queue> {
                                 bool internalUsage,
                                 cl_int &errcodeRet);
 
+    static cl_int getErrorCodeFromTaskCount(uint32_t taskCount);
+
     CommandQueue() = delete;
 
     CommandQueue(Context *context, ClDevice *device, const cl_queue_properties *properties, bool internalUsage);
diff --git a/opencl/source/command_queue/enqueue_common.h b/opencl/source/command_queue/enqueue_common.h
@@ -335,8 +335,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
         this->latestSentEnqueueType = enqueueProperties.operation;
     }
 
-    if (completionStamp.taskCount == CompletionStamp::gpuHang) {
-        return CL_OUT_OF_RESOURCES;
+    if (completionStamp.taskCount > CompletionStamp::notReady) {
+        return CommandQueue::getErrorCodeFromTaskCount(completionStamp.taskCount);
     }
 
     updateFromCompletionStamp(completionStamp, eventBuilder.getEvent());
@@ -825,14 +825,14 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
     if (enqueueProperties.blitPropertiesContainer->size() > 0) {
         auto bcsCsr = getBcsForAuxTranslation();
         const auto newTaskCount = bcsCsr->flushBcsTask(*enqueueProperties.blitPropertiesContainer, false, this->isProfilingEnabled(), getDevice());
-        if (!newTaskCount) {
+        if (newTaskCount > CompletionStamp::notReady) {
             CompletionStamp completionStamp{};
-            completionStamp.taskCount = CompletionStamp::gpuHang;
+            completionStamp.taskCount = newTaskCount;
 
             return completionStamp;
         }
 
-        this->updateBcsTaskCount(bcsCsr->getOsContext().getEngineType(), *newTaskCount);
+        this->updateBcsTaskCount(bcsCsr->getOsContext().getEngineType(), newTaskCount);
         dispatchFlags.implicitFlush = true;
     }
 
@@ -1063,14 +1063,14 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
     if (enqueueProperties.operation == EnqueueProperties::Operation::Blit) {
         UNRECOVERABLE_IF(!enqueueProperties.blitPropertiesContainer);
         const auto newTaskCount = bcsCsr->flushBcsTask(*enqueueProperties.blitPropertiesContainer, false, this->isProfilingEnabled(), getDevice());
-        if (!newTaskCount) {
+        if (newTaskCount > CompletionStamp::notReady) {
             CompletionStamp completionStamp{};
-            completionStamp.taskCount = CompletionStamp::gpuHang;
+            completionStamp.taskCount = newTaskCount;
 
             return completionStamp;
         }
 
-        this->updateBcsTaskCount(bcsCsr->getOsContext().getEngineType(), *newTaskCount);
+        this->updateBcsTaskCount(bcsCsr->getOsContext().getEngineType(), newTaskCount);
     }
 
     return completionStamp;
@@ -1276,8 +1276,8 @@ cl_int CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDisp
         completionStamp = enqueueCommandWithoutKernel(nullptr, 0, gpgpuCommandStream, gpgpuCommandStreamStart, blocking,
                                                       enqueueProperties, timestampPacketDependencies, eventsRequest,
                                                       eventBuilder, taskLevel, csrDeps, &bcsCsr);
-        if (completionStamp.taskCount == CompletionStamp::gpuHang) {
-            return CL_OUT_OF_RESOURCES;
+        if (completionStamp.taskCount > CompletionStamp::notReady) {
+            return CommandQueue::getErrorCodeFromTaskCount(completionStamp.taskCount);
         }
 
         if (gpgpuSubmission) {
diff --git a/opencl/source/event/event.cpp b/opencl/source/event/event.cpp
@@ -597,7 +597,7 @@ void Event::submitCommand(bool abortTasks) {
             setEndTimeStamp();
         }
 
-        if (complStamp.taskCount == CompletionStamp::gpuHang) {
+        if (complStamp.taskCount > CompletionStamp::notReady) {
             abortExecutionDueToGpuHang();
             return;
         }
diff --git a/opencl/source/helpers/task_information.cpp b/opencl/source/helpers/task_information.cpp
@@ -258,14 +258,12 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
         commandQueue.clearLastBcsPackets();
     }
 
-    bool isGpuHangDetected{false};
-
     if (kernelOperation->blitPropertiesContainer.size() > 0) {
         const auto newTaskCount = bcsCsrForAuxTranslation->flushBcsTask(kernelOperation->blitPropertiesContainer, false, commandQueue.isProfilingEnabled(), commandQueue.getDevice());
-        if (newTaskCount) {
-            commandQueue.updateBcsTaskCount(bcsCsrForAuxTranslation->getOsContext().getEngineType(), *newTaskCount);
+        if (newTaskCount <= CompletionStamp::notReady) {
+            commandQueue.updateBcsTaskCount(bcsCsrForAuxTranslation->getOsContext().getEngineType(), newTaskCount);
         } else {
-            isGpuHangDetected = true;
+            completionStamp.taskCount = newTaskCount;
         }
     }
     commandQueue.updateLatestSentEnqueueType(EnqueueProperties::Operation::GpuKernel);
@@ -277,11 +275,11 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
     if (printfHandler) {
         const auto waitStatus = commandQueue.waitUntilComplete(completionStamp.taskCount, {}, completionStamp.flushStamp, false);
         if (waitStatus == WaitStatus::GpuHang) {
-            isGpuHangDetected = true;
+            completionStamp.taskCount = CompletionStamp::gpuHang;
         }
 
         if (!printfHandler->printEnqueueOutput()) {
-            isGpuHangDetected = true;
+            completionStamp.taskCount = CompletionStamp::gpuHang;
         }
     }
 
@@ -290,14 +288,10 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
     }
     surfaces.clear();
 
-    if (isGpuHangDetected) {
-        completionStamp.taskCount = CompletionStamp::gpuHang;
-    }
-
     return completionStamp;
 }
 
-bool CommandWithoutKernel::dispatchBlitOperation() {
+uint32_t CommandWithoutKernel::dispatchBlitOperation() {
     auto bcsCsr = kernelOperation->bcsCsr;
     UNRECOVERABLE_IF(bcsCsr == nullptr);
 
@@ -314,14 +308,14 @@ bool CommandWithoutKernel::dispatchBlitOperation() {
     }
 
     const auto newTaskCount = bcsCsr->flushBcsTask(kernelOperation->blitPropertiesContainer, false, commandQueue.isProfilingEnabled(), commandQueue.getDevice());
-    if (!newTaskCount) {
-        return false;
+    if (newTaskCount > CompletionStamp::notReady) {
+        return newTaskCount;
     }
 
-    commandQueue.updateBcsTaskCount(bcsCsr->getOsContext().getEngineType(), *newTaskCount);
+    commandQueue.updateBcsTaskCount(bcsCsr->getOsContext().getEngineType(), newTaskCount);
     commandQueue.setLastBcsPacket(bcsCsr->getOsContext().getEngineType());
 
-    return true;
+    return newTaskCount;
 }
 
 CompletionStamp &CommandWithoutKernel::submit(uint32_t taskLevel, bool terminated) {
@@ -420,8 +414,9 @@ CompletionStamp &CommandWithoutKernel::submit(uint32_t taskLevel, bool terminate
     }
 
     if (kernelOperation->blitEnqueue) {
-        if (!dispatchBlitOperation()) {
-            completionStamp.taskCount = CompletionStamp::gpuHang;
+        auto taskCount = dispatchBlitOperation();
+        if (taskCount > CompletionStamp::notReady) {
+            completionStamp.taskCount = taskCount;
         }
     }
 
diff --git a/opencl/source/helpers/task_information.h b/opencl/source/helpers/task_information.h
@@ -156,6 +156,6 @@ class CommandWithoutKernel : public Command {
   public:
     using Command::Command;
     CompletionStamp &submit(uint32_t taskLevel, bool terminated) override;
-    bool dispatchBlitOperation();
+    uint32_t dispatchBlitOperation();
 };
 } // namespace NEO
diff --git a/opencl/source/program/printf_handler.cpp b/opencl/source/program/printf_handler.cpp
@@ -98,7 +98,7 @@ bool PrintfHandler::printEnqueueOutput() {
                                                             0, 0, 0, Vec3<size_t>(printfOutputSize, 0, 0), 0, 0, 0, 0));
 
         const auto newTaskCount = bcsEngine.commandStreamReceiver->flushBcsTask(blitPropertiesContainer, true, false, device);
-        if (!newTaskCount) {
+        if (newTaskCount > CompletionStamp::notReady) {
             return false;
         }
     }
diff --git a/opencl/test/unit_test/command_queue/blit_enqueue_1_tests.cpp b/opencl/test/unit_test/command_queue/blit_enqueue_1_tests.cpp
@@ -113,7 +113,7 @@ HWTEST_TEMPLATED_F(BlitAuxTranslationTests, givenGpuHangOnFlushBcsAndBlitAuxTran
 
     auto ultBcsCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(bcsCsr);
     ultBcsCsr->callBaseFlushBcsTask = false;
-    ultBcsCsr->flushBcsTaskReturnValue = std::nullopt;
+    ultBcsCsr->flushBcsTaskReturnValue = CompletionStamp::gpuHang;
 
     auto mockCmdQ = static_cast<MockCommandQueueHw<FamilyType> *>(commandQueue.get());
 
@@ -666,7 +666,7 @@ HWTEST_TEMPLATED_F(BlitAuxTranslationTests, givenGpuHangOnFlushBcsTaskAndBlitTra
 
     auto ultBcsCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(bcsCsr);
     ultBcsCsr->callBaseFlushBcsTask = false;
-    ultBcsCsr->flushBcsTaskReturnValue = std::nullopt;
+    ultBcsCsr->flushBcsTaskReturnValue = CompletionStamp::gpuHang;
 
     UserEvent userEvent;
     cl_event waitlist[] = {&userEvent};
@@ -943,7 +943,7 @@ HWTEST_TEMPLATED_F(BlitEnqueueWithDebugCapabilityTests, givenDebugFlagSetWhenDis
 HWTEST_TEMPLATED_F(BlitEnqueueWithDebugCapabilityTests, givenGpuHangOnFlushBcsTaskAndDebugFlagSetWhenDispatchingBlitEnqueueThenOutOfResourcesIsReturned) {
     auto ultBcsCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(bcsCsr);
     ultBcsCsr->callBaseFlushBcsTask = false;
-    ultBcsCsr->flushBcsTaskReturnValue = std::nullopt;
+    ultBcsCsr->flushBcsTaskReturnValue = CompletionStamp::gpuHang;
 
     buffer = createBuffer(1, false);
     buffer->forceDisallowCPUCopy = true;
@@ -1194,7 +1194,7 @@ HWTEST_TEMPLATED_F(BlitEnqueueFlushTests, givenGpuHangOnFlushBcsTaskAndBlockedQu
     auto myUltBcsCsr = static_cast<MyUltCsr<FamilyType> *>(bcsCsr);
     myUltBcsCsr->flushCounter = &flushCounter;
     myUltBcsCsr->callBaseFlushBcsTask = false;
-    myUltBcsCsr->flushBcsTaskReturnValue = std::nullopt;
+    myUltBcsCsr->flushBcsTaskReturnValue = CompletionStamp::gpuHang;
 
     UserEvent userEvent;
     cl_event waitlist[] = {&userEvent};
diff --git a/opencl/test/unit_test/command_queue/command_queue_tests.cpp b/opencl/test/unit_test/command_queue/command_queue_tests.cpp
@@ -128,6 +128,13 @@ INSTANTIATE_TEST_CASE_P(CommandQueue,
                         CommandQueueTest,
                         ::testing::ValuesIn(AllCommandQueueProperties));
 
+TEST(CommandQueue, WhenGettingErrorCodeFromTaskCountThenProperValueIsReturned) {
+    EXPECT_EQ(CL_SUCCESS, CommandQueue::getErrorCodeFromTaskCount(0));
+    EXPECT_EQ(CL_OUT_OF_HOST_MEMORY, CommandQueue::getErrorCodeFromTaskCount(CompletionStamp::outOfHostMemory));
+    EXPECT_EQ(CL_OUT_OF_RESOURCES, CommandQueue::getErrorCodeFromTaskCount(CompletionStamp::outOfDeviceMemory));
+    EXPECT_EQ(CL_OUT_OF_RESOURCES, CommandQueue::getErrorCodeFromTaskCount(CompletionStamp::gpuHang));
+}
+
 TEST(CommandQueue, WhenConstructingCommandQueueThenTaskLevelAndTaskCountAreZero) {
     MockCommandQueue cmdQ(nullptr, nullptr, 0, false);
     EXPECT_EQ(0u, cmdQ.taskLevel);
diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_hw_2_tests.cpp b/opencl/test/unit_test/command_stream/command_stream_receiver_hw_2_tests.cpp
@@ -650,12 +650,12 @@ HWTEST_F(BcsTests, GivenNoneGpuHangWhenBlitFromHostPtrCalledThenCallWaitWithKmdF
                                                                           0, 0, {1, 1, 1}, 0, 0, 0, 0);
 
     const auto taskCount1 = flushBcsTask(myMockCsr.get(), blitProperties, false, *pDevice);
-    EXPECT_TRUE(taskCount1.has_value());
+    EXPECT_NE(CompletionStamp::gpuHang, taskCount1);
 
     EXPECT_EQ(0u, myMockCsr->waitForTaskCountWithKmdNotifyFallbackCalled);
 
     const auto taskCount2 = flushBcsTask(myMockCsr.get(), blitProperties, true, *pDevice);
-    EXPECT_TRUE(taskCount2.has_value());
+    EXPECT_NE(CompletionStamp::gpuHang, taskCount2);
 
     EXPECT_EQ(1u, myMockCsr->waitForTaskCountWithKmdNotifyFallbackCalled);
     EXPECT_EQ(myMockCsr->taskCount, myMockCsr->taskCountToWaitPassed);
@@ -687,14 +687,14 @@ HWTEST_F(BcsTests, GivenGpuHangWhenBlitFromHostPtrCalledThenCallWaitWithKmdFallb
                                                                           0, 0, {1, 1, 1}, 0, 0, 0, 0);
 
     const auto taskCount1 = flushBcsTask(myMockCsr.get(), blitProperties, false, *pDevice);
-    EXPECT_TRUE(taskCount1.has_value());
+    EXPECT_NE(CompletionStamp::gpuHang, taskCount1);
 
     EXPECT_EQ(0u, myMockCsr->waitForTaskCountWithKmdNotifyFallbackCalled);
 
     myMockCsr->waitForTaskCountWithKmdNotifyFallbackReturnValue = WaitStatus::GpuHang;
 
     const auto taskCount2 = flushBcsTask(myMockCsr.get(), blitProperties, true, *pDevice);
-    EXPECT_FALSE(taskCount2.has_value());
+    EXPECT_EQ(CompletionStamp::gpuHang, taskCount2);
 
     EXPECT_EQ(1u, myMockCsr->waitForTaskCountWithKmdNotifyFallbackCalled);
     EXPECT_EQ(myMockCsr->taskCount, myMockCsr->taskCountToWaitPassed);
diff --git a/opencl/test/unit_test/command_stream/command_stream_receiver_hw_fixture.h b/opencl/test/unit_test/command_stream/command_stream_receiver_hw_fixture.h
@@ -22,7 +22,7 @@ struct BcsTests : public Test<ClDeviceFixture> {
         Test<ClDeviceFixture>::TearDown();
     }
 
-    std::optional<uint32_t> flushBcsTask(CommandStreamReceiver *bcsCsr, const BlitProperties &blitProperties, bool blocking, Device &device) {
+    uint32_t flushBcsTask(CommandStreamReceiver *bcsCsr, const BlitProperties &blitProperties, bool blocking, Device &device) {
         BlitPropertiesContainer container;
         container.push_back(blitProperties);
 
diff --git a/opencl/test/unit_test/context/context_tests.cpp b/opencl/test/unit_test/context/context_tests.cpp
@@ -559,7 +559,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, ContextCreateTests, givenGpuHangOnFlushBcsTaskAndLo
 
     auto ultBcsCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(bcsEngine->commandStreamReceiver);
     ultBcsCsr->callBaseFlushBcsTask = false;
-    ultBcsCsr->flushBcsTaskReturnValue = std::nullopt;
+    ultBcsCsr->flushBcsTaskReturnValue = CompletionStamp::gpuHang;
 
     EXPECT_EQ(BlitOperationResult::GpuHang, BlitHelper::blitMemoryToAllocation(buffer->getContext()->getDevice(0)->getDevice(), memory, buffer->getOffset(), hostMemory, {1, 1, 1}));
 }
diff --git a/opencl/test/unit_test/kernel/kernel_tests.cpp b/opencl/test/unit_test/kernel/kernel_tests.cpp
@@ -543,7 +543,7 @@ class CommandStreamReceiverMock : public CommandStreamReceiver {
     WaitStatus waitForTaskCountWithKmdNotifyFallback(uint32_t taskCountToWait, FlushStamp flushStampToWait, bool quickKmdSleep, QueueThrottle throttle) override {
         return WaitStatus::Ready;
     }
-    std::optional<uint32_t> flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) override { return taskCount; };
+    uint32_t flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) override { return taskCount; };
 
     CompletionStamp flushTask(
         LinearStream &commandStream,
diff --git a/opencl/test/unit_test/program/printf_handler_tests.cpp b/opencl/test/unit_test/program/printf_handler_tests.cpp
@@ -183,7 +183,7 @@ HWTEST_F(PrintfHandlerTests, givenGpuHangOnFlushBcsStreamAndEnabledStatelessComp
     auto &bcsEngine = device->getEngine(EngineHelpers::getBcsEngineType(device->getHardwareInfo(), device->getDeviceBitfield(), device->getSelectorCopyEngine(), true), EngineUsage::Regular);
     auto bcsCsr = static_cast<UltCommandStreamReceiver<FamilyType> *>(bcsEngine.commandStreamReceiver);
     bcsCsr->callBaseFlushBcsTask = false;
-    bcsCsr->flushBcsTaskReturnValue = std::nullopt;
+    bcsCsr->flushBcsTaskReturnValue = CompletionStamp::gpuHang;
 
     EXPECT_FALSE(printfHandler->printEnqueueOutput());
     EXPECT_EQ(1u, bcsCsr->blitBufferCalled);
diff --git a/shared/source/command_stream/command_stream_receiver.h b/shared/source/command_stream/command_stream_receiver.h
@@ -233,7 +233,7 @@ class CommandStreamReceiver {
         this->latestFlushedTaskCount = latestFlushedTaskCount;
     }
 
-    virtual std::optional<uint32_t> flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) = 0;
+    virtual uint32_t flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) = 0;
 
     virtual void flushTagUpdate() = 0;
     virtual void updateTagFromWait() = 0;
diff --git a/shared/source/command_stream/command_stream_receiver_hw.h b/shared/source/command_stream/command_stream_receiver_hw.h
@@ -97,7 +97,7 @@ class CommandStreamReceiverHw : public CommandStreamReceiver {
         return CommandStreamReceiverType::CSR_HW;
     }
 
-    std::optional<uint32_t> flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) override;
+    uint32_t flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) override;
 
     void flushTagUpdate() override;
     void flushMiFlushDW();
diff --git a/shared/source/command_stream/command_stream_receiver_hw_base.inl b/shared/source/command_stream/command_stream_receiver_hw_base.inl
@@ -1057,7 +1057,7 @@ inline void CommandStreamReceiverHw<GfxFamily>::unregisterDirectSubmissionFromCo
 }
 
 template <typename GfxFamily>
-std::optional<uint32_t> CommandStreamReceiverHw<GfxFamily>::flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) {
+uint32_t CommandStreamReceiverHw<GfxFamily>::flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) {
     using MI_BATCH_BUFFER_END = typename GfxFamily::MI_BATCH_BUFFER_END;
     using MI_FLUSH_DW = typename GfxFamily::MI_FLUSH_DW;
 
@@ -1180,7 +1180,7 @@ std::optional<uint32_t> CommandStreamReceiverHw<GfxFamily>::flushBcsTask(const B
         internalAllocationStorage->cleanAllocationList(newTaskCount, TEMPORARY_ALLOCATION);
 
         if (waitStatus == WaitStatus::GpuHang) {
-            return std::nullopt;
+            return CompletionStamp::gpuHang;
         }
     }
 
diff --git a/shared/source/helpers/blit_commands_helper.cpp b/shared/source/helpers/blit_commands_helper.cpp
@@ -211,7 +211,7 @@ BlitOperationResult BlitHelper::blitMemoryToAllocationBanks(const Device &device
                                                             0, 0, 0, size, 0, 0, 0, 0));
 
         const auto newTaskCount = bcsEngine->commandStreamReceiver->flushBcsTask(blitPropertiesContainer, true, false, *pDeviceForBlit);
-        if (!newTaskCount) {
+        if (newTaskCount == CompletionStamp::gpuHang) {
             return BlitOperationResult::GpuHang;
         }
     }
diff --git a/shared/source/helpers/completion_stamp.h b/shared/source/helpers/completion_stamp.h
@@ -18,6 +18,8 @@ struct CompletionStamp {
 
     static constexpr uint32_t notReady = 0xFFFFFFF0;
     static constexpr uint32_t gpuHang = 0xFFFFFFFA;
+    static constexpr uint32_t outOfDeviceMemory = 0xFFFFFFFB;
+    static constexpr uint32_t outOfHostMemory = 0xFFFFFFFC;
 };
 
 } // namespace NEO
diff --git a/shared/test/common/libult/ult_aub_command_stream_receiver.h b/shared/test/common/libult/ult_aub_command_stream_receiver.h
@@ -49,7 +49,7 @@ class UltAubCommandStreamReceiver : public AUBCommandStreamReceiverHw<GfxFamily>
         return csr;
     }
 
-    std::optional<uint32_t> flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) override {
+    uint32_t flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) override {
         blitBufferCalled++;
         return BaseClass::flushBcsTask(blitPropertiesContainer, blocking, profilingEnabled, device);
     }
diff --git a/shared/test/common/libult/ult_command_stream_receiver.h b/shared/test/common/libult/ult_command_stream_receiver.h
@@ -285,7 +285,7 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
         return CommandStreamReceiverHw<GfxFamily>::obtainUniqueOwnership();
     }
 
-    std::optional<uint32_t> flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) override {
+    uint32_t flushBcsTask(const BlitPropertiesContainer &blitPropertiesContainer, bool blocking, bool profilingEnabled, Device &device) override {
         blitBufferCalled++;
         receivedBlitProperties = blitPropertiesContainer;
 
@@ -392,7 +392,7 @@ class UltCommandStreamReceiver : public CommandStreamReceiverHw<GfxFamily>, publ
     WaitStatus returnWaitForCompletionWithTimeout = WaitStatus::Ready;
     std::optional<WaitStatus> waitForTaskCountWithKmdNotifyFallbackReturnValue{};
     bool callBaseFlushBcsTask{true};
-    std::optional<uint32_t> flushBcsTaskReturnValue{};
+    uint32_t flushBcsTaskReturnValue{};
 };
 
 } // namespace NEO
diff --git a/shared/test/common/mocks/mock_command_stream_receiver.h b/shared/test/common/mocks/mock_command_stream_receiver.h

Original file line number	Diff line number	Diff line change
`@@ -597,7 +597,7 @@ void Event::submitCommand(bool abortTasks) {`
`597`	`597`	`setEndTimeStamp();`
`598`	`598`	`}`
`599`	`599`
`600`		`- if (complStamp.taskCount == CompletionStamp::gpuHang) {`
	`600`	`+ if (complStamp.taskCount > CompletionStamp::notReady) {`
`601`	`601`	`abortExecutionDueToGpuHang();`
`602`	`602`	`return;`
`603`	`603`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,14 +258,12 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate`
`258`	`258`	`commandQueue.clearLastBcsPackets();`
`259`	`259`	`}`
`260`	`260`
`261`		`- bool isGpuHangDetected{false};`
`262`		`-`
`263`	`261`	`if (kernelOperation->blitPropertiesContainer.size() > 0) {`
`264`	`262`	`const auto newTaskCount = bcsCsrForAuxTranslation->flushBcsTask(kernelOperation->blitPropertiesContainer, false, commandQueue.isProfilingEnabled(), commandQueue.getDevice());`
`265`		`- if (newTaskCount) {`
`266`		`- commandQueue.updateBcsTaskCount(bcsCsrForAuxTranslation->getOsContext().getEngineType(), *newTaskCount);`
	`263`	`+ if (newTaskCount <= CompletionStamp::notReady) {`
	`264`	`+ commandQueue.updateBcsTaskCount(bcsCsrForAuxTranslation->getOsContext().getEngineType(), newTaskCount);`
`267`	`265`	`} else {`
`268`		`- isGpuHangDetected = true;`
	`266`	`+ completionStamp.taskCount = newTaskCount;`
`269`	`267`	`}`
`270`	`268`	`}`
`271`	`269`	`commandQueue.updateLatestSentEnqueueType(EnqueueProperties::Operation::GpuKernel);`
`@@ -277,11 +275,11 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate`
`277`	`275`	`if (printfHandler) {`
`278`	`276`	`const auto waitStatus = commandQueue.waitUntilComplete(completionStamp.taskCount, {}, completionStamp.flushStamp, false);`
`279`	`277`	`if (waitStatus == WaitStatus::GpuHang) {`
`280`		`- isGpuHangDetected = true;`
	`278`	`+ completionStamp.taskCount = CompletionStamp::gpuHang;`
`281`	`279`	`}`
`282`	`280`
`283`	`281`	`if (!printfHandler->printEnqueueOutput()) {`
`284`		`- isGpuHangDetected = true;`
	`282`	`+ completionStamp.taskCount = CompletionStamp::gpuHang;`
`285`	`283`	`}`
`286`	`284`	`}`
`287`	`285`
`@@ -290,14 +288,10 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate`
`290`	`288`	`}`
`291`	`289`	`surfaces.clear();`
`292`	`290`
`293`		`- if (isGpuHangDetected) {`
`294`		`- completionStamp.taskCount = CompletionStamp::gpuHang;`
`295`		`- }`
`296`		`-`
`297`	`291`	`return completionStamp;`
`298`	`292`	`}`
`299`	`293`
`300`		`-bool CommandWithoutKernel::dispatchBlitOperation() {`
	`294`	`+uint32_t CommandWithoutKernel::dispatchBlitOperation() {`
`301`	`295`	`auto bcsCsr = kernelOperation->bcsCsr;`
`302`	`296`	`UNRECOVERABLE_IF(bcsCsr == nullptr);`
`303`	`297`
`@@ -314,14 +308,14 @@ bool CommandWithoutKernel::dispatchBlitOperation() {`
`314`	`308`	`}`
`315`	`309`
`316`	`310`	`const auto newTaskCount = bcsCsr->flushBcsTask(kernelOperation->blitPropertiesContainer, false, commandQueue.isProfilingEnabled(), commandQueue.getDevice());`
`317`		`- if (!newTaskCount) {`
`318`		`- return false;`
	`311`	`+ if (newTaskCount > CompletionStamp::notReady) {`
	`312`	`+ return newTaskCount;`
`319`	`313`	`}`
`320`	`314`
`321`		`- commandQueue.updateBcsTaskCount(bcsCsr->getOsContext().getEngineType(), *newTaskCount);`
	`315`	`+ commandQueue.updateBcsTaskCount(bcsCsr->getOsContext().getEngineType(), newTaskCount);`
`322`	`316`	`commandQueue.setLastBcsPacket(bcsCsr->getOsContext().getEngineType());`
`323`	`317`
`324`		`- return true;`
	`318`	`+ return newTaskCount;`
`325`	`319`	`}`
`326`	`320`
`327`	`321`	`CompletionStamp &CommandWithoutKernel::submit(uint32_t taskLevel, bool terminated) {`
`@@ -420,8 +414,9 @@ CompletionStamp &CommandWithoutKernel::submit(uint32_t taskLevel, bool terminate`
`420`	`414`	`}`
`421`	`415`
`422`	`416`	`if (kernelOperation->blitEnqueue) {`
`423`		`- if (!dispatchBlitOperation()) {`
`424`		`- completionStamp.taskCount = CompletionStamp::gpuHang;`
	`417`	`+ auto taskCount = dispatchBlitOperation();`
	`418`	`+ if (taskCount > CompletionStamp::notReady) {`
	`419`	`+ completionStamp.taskCount = taskCount;`
`425`	`420`	`}`
`426`	`421`	`}`
`427`	`422`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ bool PrintfHandler::printEnqueueOutput() {`
`98`	`98`	`0, 0, 0, Vec3<size_t>(printfOutputSize, 0, 0), 0, 0, 0, 0));`
`99`	`99`
`100`	`100`	`const auto newTaskCount = bcsEngine.commandStreamReceiver->flushBcsTask(blitPropertiesContainer, true, false, device);`
`101`		`- if (!newTaskCount) {`
	`101`	`+ if (newTaskCount > CompletionStamp::notReady) {`
`102`	`102`	`return false;`
`103`	`103`	`}`
`104`	`104`	`}`