fix: correct calculating submit cpu timestamp

Related-To: NEO-9590, HSD-18035219634
Signed-off-by: Mateusz Jablonski <[email protected]>

Source: aac8686

Author: JablonskiMateusz

opencl/source/command_queue/cpu_data_transfer_handler.cpp

@@ -96,9 +96,7 @@ void *CommandQueue::cpuDataTransferHandler(TransferProperties &transferPropertie
         bool modifySimulationFlags = false;
 
         if (outEventObj) {
-            TimeStampData submitTimeStamp;
-            getDevice().getOSTime()->getGpuCpuTime(&submitTimeStamp);
-            outEventObj->setSubmitTimeStamp(submitTimeStamp);
+            outEventObj->setSubmitTimeStamp();
         }
         // wait for the completness of previous commands
         if (transferProperties.finishRequired) {

opencl/source/command_queue/enqueue_common.h

@@ -420,9 +420,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
             completionStamp.taskLevel = taskLevel;
 
             if (eventBuilder.getEvent() && isProfilingEnabled()) {
-                TimeStampData submitTimeStamp;
-                getDevice().getOSTime()->getGpuCpuTime(&submitTimeStamp);
-                eventBuilder.getEvent()->setSubmitTimeStamp(submitTimeStamp);
+                eventBuilder.getEvent()->setSubmitTimeStamp();
                 eventBuilder.getEvent()->setStartTimeStamp();
             }
 
@@ -846,9 +844,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
     }
 
     if (isProfilingEnabled() && eventBuilder.getEvent()) {
-        TimeStampData submitTimeStamp;
-        getDevice().getOSTime()->getGpuCpuTime(&submitTimeStamp);
-        eventBuilder.getEvent()->setSubmitTimeStamp(submitTimeStamp);
+        eventBuilder.getEvent()->setSubmitTimeStamp();
 
         auto hwTimestampNode = eventBuilder.getEvent()->getHwTimeStampNode();
         if (hwTimestampNode) {
@@ -1113,9 +1109,7 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueCommandWithoutKernel(
     }
 
     if (eventBuilder.getEvent() && isProfilingEnabled()) {
-        TimeStampData submitTimeStamp;
-        getDevice().getOSTime()->getGpuCpuTime(&submitTimeStamp);
-        eventBuilder.getEvent()->setSubmitTimeStamp(submitTimeStamp);
+        eventBuilder.getEvent()->setSubmitTimeStamp();
         eventBuilder.getEvent()->setStartTimeStamp();
     }
 

opencl/source/event/event.cpp

@@ -291,15 +291,18 @@ void Event::setupRelativeProfilingInfo(ProfilingInfo &profilingInfo) {
     }
 }
 
-void Event::setSubmitTimeStamp(const TimeStampData &submitTimeStamp) {
+void Event::setSubmitTimeStamp() {
     UNRECOVERABLE_IF(!cmdQueue);
     auto &device = cmdQueue->getDevice();
     auto &gfxCoreHelper = device.getGfxCoreHelper();
     double resolution = device.getDeviceInfo().profilingTimerResolution;
     UNRECOVERABLE_IF(resolution == 0.0);
-    this->submitTimeStamp.cpuTimeInNs = submitTimeStamp.cpuTimeinNS;
-    this->submitTimeStamp.gpuTimeInNs = gfxCoreHelper.getGpuTimeStampInNS(submitTimeStamp.gpuTimeStamp, resolution);
-    this->submitTimeStamp.gpuTimeStamp = submitTimeStamp.gpuTimeStamp;
+
+    this->cmdQueue->getDevice().getOSTime()->getCpuTime(&this->submitTimeStamp.cpuTimeInNs);
+    TimeStampData submitCpuGpuTime{};
+    this->cmdQueue->getDevice().getOSTime()->getGpuCpuTime(&submitCpuGpuTime);
+    this->submitTimeStamp.gpuTimeInNs = gfxCoreHelper.getGpuTimeStampInNS(submitCpuGpuTime.gpuTimeStamp, resolution);
+    this->submitTimeStamp.gpuTimeStamp = submitCpuGpuTime.gpuTimeStamp;
 
     setupRelativeProfilingInfo(queueTimeStamp);
 }
@@ -608,9 +611,7 @@ void Event::submitCommand(bool abortTasks) {
                 this->cmdQueue->getGpgpuCommandStreamReceiver().makeResident(*timeStampNode->getBaseGraphicsAllocation());
                 cmdToProcess->timestamp = timeStampNode;
             }
-            TimeStampData submitTimeStamp{};
-            this->cmdQueue->getDevice().getOSTime()->getGpuCpuTime(&submitTimeStamp);
-            this->setSubmitTimeStamp(submitTimeStamp);
+            this->setSubmitTimeStamp();
             if (profilingCpuPath) {
                 setStartTimeStamp();
             } else {

opencl/source/event/event.h

@@ -294,7 +294,7 @@ class Event : public BaseObject<_cl_event>, public IDNode<Event> {
     }
 
     void setQueueTimeStamp();
-    void setSubmitTimeStamp(const TimeStampData &submitTimeStamp);
+    void setSubmitTimeStamp();
     void setStartTimeStamp();
     void setEndTimeStamp();
 

opencl/test/unit_test/event/event_tests.cpp

@@ -1357,7 +1357,14 @@ TEST_F(EventTest, whenSettingSubmitTimestampThenQueueAndSubmitTimestampsAreSet)
     submitTimeStamp.cpuTimeinNS = cpuTimeStamp + expectedCpuDiff;
     submitTimeStamp.gpuTimeStamp = expectedQueueGpuTimeStamp + expectedGpuDiff;
 
-    event.setSubmitTimeStamp(submitTimeStamp);
+    auto osTime = static_cast<MockOSTime *>(pDevice->getOSTime());
+    osTime->cpuTimeResult = submitTimeStamp.cpuTimeinNS;
+
+    auto deviceTime = static_cast<MockDeviceTime *>(osTime->deviceTime.get());
+    deviceTime->cpuTimeResult = submitTimeStamp.cpuTimeinNS;
+    deviceTime->gpuTimeStampResult = submitTimeStamp.gpuTimeStamp;
+
+    event.setSubmitTimeStamp();
 
     EXPECT_EQ(expectedQueueGpuTimeStamp, event.queueTimeStamp.gpuTimeStamp);
     EXPECT_EQ(cpuTimeStamp, event.queueTimeStamp.cpuTimeInNs);

shared/test/common/mocks/mock_ostime.h

@@ -14,9 +14,19 @@ namespace NEO {
 static std::atomic<int> PerfTicks{0};
 constexpr uint64_t convertToNs = 100;
 class MockDeviceTime : public DeviceTime {
+  public:
+    ~MockDeviceTime() override = default;
     bool getGpuCpuTimeImpl(TimeStampData *pGpuCpuTime, OSTime *osTime) override {
-        pGpuCpuTime->gpuTimeStamp = ++PerfTicks;
-        pGpuCpuTime->cpuTimeinNS = PerfTicks * convertToNs;
+        if (gpuTimeStampResult) {
+            pGpuCpuTime->gpuTimeStamp = *gpuTimeStampResult;
+        } else {
+            pGpuCpuTime->gpuTimeStamp = ++PerfTicks;
+        }
+        if (cpuTimeResult) {
+            pGpuCpuTime->cpuTimeinNS = *cpuTimeResult;
+        } else {
+            pGpuCpuTime->cpuTimeinNS = PerfTicks * convertToNs;
+        }
         return true;
     }
 
@@ -27,16 +37,24 @@ class MockDeviceTime : public DeviceTime {
     uint64_t getDynamicDeviceTimerClock(HardwareInfo const &hwInfo) const override {
         return static_cast<uint64_t>(1000000000.0 / OSTime::getDeviceTimerResolution(hwInfo));
     }
+    std::optional<uint64_t> gpuTimeStampResult{};
+    std::optional<uint64_t> cpuTimeResult{};
 };
 
 class MockOSTime : public OSTime {
   public:
+    using OSTime::deviceTime;
     MockOSTime() {
         this->deviceTime = std::make_unique<MockDeviceTime>();
     }
+    ~MockOSTime() override = default;
 
     bool getCpuTime(uint64_t *timeStamp) override {
-        *timeStamp = ++PerfTicks * convertToNs;
+        if (cpuTimeResult) {
+            *timeStamp = *cpuTimeResult;
+        } else {
+            *timeStamp = ++PerfTicks * convertToNs;
+        }
         return true;
     };
     double getHostTimerResolution() const override {
@@ -49,6 +67,7 @@ class MockOSTime : public OSTime {
     static std::unique_ptr<OSTime> create() {
         return std::unique_ptr<OSTime>(new MockOSTime());
     }
+    std::optional<uint64_t> cpuTimeResult{};
 };
 
 class MockDeviceTimeWithConstTimestamp : public DeviceTime {