fix: blink ULLS light

Related-To: NEO-13922

Signed-off-by: Lukasz Jobczyk <[email protected]>

Author: LukaszJobczyk

shared/source/direct_submission/linux/drm_direct_submission.h

@@ -39,6 +39,7 @@ class DrmDirectSubmission : public DirectSubmissionHw<GfxFamily, Dispatcher> {
     bool isCompleted(uint32_t ringBufferIndex) override;
     bool isCompletionFenceSupported();
     bool isGpuHangDetected(std::chrono::high_resolution_clock::time_point &lastHangCheckTime);
+    MOCKABLE_VIRTUAL std::chrono::steady_clock::time_point getCpuTimePoint();
 
     MOCKABLE_VIRTUAL void wait(TaskCountType taskCountToWait);
 
@@ -47,6 +48,9 @@ class DrmDirectSubmission : public DirectSubmissionHw<GfxFamily, Dispatcher> {
     TaskCountType completionFenceValue{};
     std::chrono::microseconds gpuHangCheckPeriod{CommonConstants::gpuHangCheckTimeInUS};
 
+    constexpr static size_t ullsLightTimeout = 2'000'000;
+    std::chrono::steady_clock::time_point lastUllsLightExecTimestamp{};
+
     std::vector<BufferObject *> residency{};
     std::vector<ExecObject> execObjectsStorage{};
 };

shared/source/direct_submission/linux/drm_direct_submission.inl

@@ -141,6 +141,8 @@ bool DrmDirectSubmission<GfxFamily, Dispatcher>::submit(uint64_t gpuAddress, siz
 
     if (!allocationsForResidency) {
         this->handleResidency();
+    } else {
+        this->lastUllsLightExecTimestamp = std::chrono::steady_clock::now();
     }
 
     auto currentBase = this->ringCommandStream.getGraphicsAllocation()->getGpuAddress();
@@ -212,7 +214,8 @@ bool DrmDirectSubmission<GfxFamily, Dispatcher>::handleResidency() {
 template <typename GfxFamily, typename Dispatcher>
 void DrmDirectSubmission<GfxFamily, Dispatcher>::handleRingRestartForUllsLightResidency(ResidencyContainer *allocationsForResidency) {
     if (allocationsForResidency) {
-        auto restartNeeded = static_cast<DrmMemoryOperationsHandler *>(this->memoryOperationHandler)->obtainAndResetNewResourcesSinceLastRingSubmit();
+        auto restartNeeded = (static_cast<DrmMemoryOperationsHandler *>(this->memoryOperationHandler)->obtainAndResetNewResourcesSinceLastRingSubmit() ||
+                              std::chrono::duration_cast<std::chrono::microseconds>(this->getCpuTimePoint() - this->lastUllsLightExecTimestamp) > std::chrono::microseconds{ullsLightTimeout});
         if (restartNeeded) {
             this->stopRingBuffer(false);
         }
@@ -292,6 +295,11 @@ void DrmDirectSubmission<GfxFamily, Dispatcher>::wait(TaskCountType taskCountToW
     }
 }
 
+template <typename GfxFamily, typename Dispatcher>
+std::chrono::steady_clock::time_point DrmDirectSubmission<GfxFamily, Dispatcher>::getCpuTimePoint() {
+    return std::chrono::steady_clock::now();
+}
+
 template <typename GfxFamily, typename Dispatcher>
 bool DrmDirectSubmission<GfxFamily, Dispatcher>::isGpuHangDetected(std::chrono::high_resolution_clock::time_point &lastHangCheckTime) {
     if (!this->detectGpuHang) {

shared/test/unit_test/direct_submission/linux/drm_direct_submission_tests.cpp

@@ -93,6 +93,7 @@ struct MockDrmDirectSubmission : public DrmDirectSubmission<GfxFamily, Dispatche
     using BaseClass::inputMonitorFenceDispatchRequirement;
     using BaseClass::isCompleted;
     using BaseClass::isNewResourceHandleNeeded;
+    using BaseClass::lastUllsLightExecTimestamp;
     using BaseClass::miMemFenceRequired;
     using BaseClass::partitionConfigSet;
     using BaseClass::partitionedMode;
@@ -106,6 +107,16 @@ struct MockDrmDirectSubmission : public DrmDirectSubmission<GfxFamily, Dispatche
     using BaseClass::updateTagValue;
     using BaseClass::wait;
     using BaseClass::workPartitionAllocation;
+
+    MockDrmDirectSubmission(const DirectSubmissionInputParams &inputParams) : BaseClass(inputParams) {
+        this->lastUllsLightExecTimestamp = std::chrono::time_point<std::chrono::steady_clock>::max();
+    }
+
+    std::chrono::steady_clock::time_point getCpuTimePoint() override {
+        return this->callBaseGetCpuTimePoint ? BaseClass::getCpuTimePoint() : cpuTimePointReturnValue;
+    }
+    std::chrono::steady_clock::time_point cpuTimePointReturnValue{};
+    bool callBaseGetCpuTimePoint = true;
 };
 
 using namespace NEO;
@@ -810,6 +821,58 @@ HWTEST_F(DrmDirectSubmissionTest, givenDirectSubmissionLightWhenRegisterResource
     executionEnvironment.memoryManager->freeGraphicsMemory(commandBuffer);
 }
 
+HWTEST_F(DrmDirectSubmissionTest, givenDirectSubmissionLightWhenExecTimeoutReachedThenRestart) {
+    using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
+    using BATCH_BUFFER_END = typename FamilyType::MI_BATCH_BUFFER_END;
+    MockDrmDirectSubmission<FamilyType, RenderDispatcher<FamilyType>> drmDirectSubmission(*device->getDefaultEngine().commandStreamReceiver);
+    EXPECT_TRUE(drmDirectSubmission.initialize(false));
+
+    FlushStampTracker flushStamp(true);
+    BatchBuffer batchBuffer = {};
+    GraphicsAllocation *commandBuffer = nullptr;
+    LinearStream stream;
+
+    const AllocationProperties commandBufferProperties{device->getRootDeviceIndex(), 0x1000,
+                                                       AllocationType::commandBuffer, device->getDeviceBitfield()};
+    commandBuffer = executionEnvironment.memoryManager->allocateGraphicsMemoryWithProperties(commandBufferProperties);
+
+    stream.replaceGraphicsAllocation(commandBuffer);
+    stream.replaceBuffer(commandBuffer->getUnderlyingBuffer(), commandBuffer->getUnderlyingBufferSize());
+    stream.getSpace(0x20);
+
+    memset(stream.getCpuBase(), 0, 0x20);
+
+    batchBuffer.endCmdPtr = ptrOffset(stream.getCpuBase(), 0x20);
+    batchBuffer.commandBufferAllocation = commandBuffer;
+    batchBuffer.usedSize = 0x40;
+    batchBuffer.taskStartAddress = 0x881112340000;
+    batchBuffer.stream = &stream;
+    batchBuffer.hasStallingCmds = true;
+
+    ResidencyContainer residencyContainer{};
+    batchBuffer.allocationsForResidency = &residencyContainer;
+    drmDirectSubmission.ringStart = true;
+    static_cast<DrmMemoryOperationsHandler *>(executionEnvironment.rootDeviceEnvironments[device->getRootDeviceIndex()]->memoryOperationsInterface.get())->obtainAndResetNewResourcesSinceLastRingSubmit();
+
+    drmDirectSubmission.lastUllsLightExecTimestamp = std::chrono::steady_clock::time_point{};
+    drmDirectSubmission.cpuTimePointReturnValue = std::chrono::time_point<std::chrono::steady_clock>::max();
+    drmDirectSubmission.callBaseGetCpuTimePoint = false;
+
+    EXPECT_TRUE(drmDirectSubmission.dispatchCommandBuffer(batchBuffer, flushStamp));
+
+    HardwareParse hwParse;
+    hwParse.parsePipeControl = true;
+    hwParse.parseCommands<FamilyType>(drmDirectSubmission.ringCommandStream, 0);
+    hwParse.findHardwareCommands<FamilyType>();
+    auto *pipeControl = hwParse.getCommand<PIPE_CONTROL>();
+    EXPECT_NE(pipeControl, nullptr);
+    auto *bbe = hwParse.getCommand<BATCH_BUFFER_END>();
+    EXPECT_NE(bbe, nullptr);
+
+    drmDirectSubmission.ringStart = false;
+    executionEnvironment.memoryManager->freeGraphicsMemory(commandBuffer);
+}
+
 HWTEST_F(DrmDirectSubmissionTest, givenDirectSubmissionLightWhenNoRegisteredResourcesThenNoRestart) {
     using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
     using BATCH_BUFFER_END = typename FamilyType::MI_BATCH_BUFFER_END;