Track waitlist TimestampPackets to avoid too early return to the pool

Signed-off-by: Bartosz Dunajski <bartosz.dunajski@intel.com>

opencl/source/command_queue/enqueue_common.h

@@ -355,6 +355,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueHandler(Surface **surfacesForResidency,
 
     if (deferredTimestampPackets.get()) {
         timestampPacketDependencies.moveNodesToNewContainer(*deferredTimestampPackets);
+        csrDeps.copyNodesToNewContainer(*deferredTimestampPackets);
     }
 
     commandStreamReceiverOwnership.unlock();
@@ -1179,6 +1180,7 @@ cl_int CommandQueueHw<GfxFamily>::enqueueBlit(const MultiDispatchInfo &multiDisp
     }
 
     timestampPacketDependencies.moveNodesToNewContainer(*deferredTimestampPackets);
+    csrDeps.copyNodesToNewContainer(*deferredTimestampPackets);
 
     queueOwnership.unlock();
     bcsCommandStreamReceiverOwnership.unlock();

opencl/test/unit_test/command_queue/blit_enqueue_tests.cpp

@@ -1571,6 +1571,44 @@ HWTEST_TEMPLATED_F(BlitEnqueueTaskCountTests, givenMarkerThatFollowsCopyOperatio
     clReleaseEvent(outEvent1);
 }
 
+HWTEST_TEMPLATED_F(BlitEnqueueTaskCountTests, givenWaitlistWithTimestampPacketWhenEnqueueingThenDeferWaitlistNodes) {
+    device->getUltCommandStreamReceiver<FamilyType>().timestampPacketWriteEnabled = true;
+
+    auto buffer = createBuffer(1, false);
+
+    auto mockCmdQueue = static_cast<MockCommandQueueHw<FamilyType> *>(commandQueue.get());
+
+    TimestampPacketContainer *deferredTimestampPackets = mockCmdQueue->deferredTimestampPackets.get();
+
+    MockTimestampPacketContainer timestamp(*device->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator(), 1);
+
+    Event waitlistEvent(mockCmdQueue, 0, 0, 0);
+    waitlistEvent.addTimestampPacketNodes(timestamp);
+
+    cl_event waitlist[] = {&waitlistEvent};
+
+    mockCmdQueue->enqueueWriteBuffer(buffer.get(), false, 0, 1, &hostPtr, nullptr, 1, waitlist, nullptr);
+
+    auto deferredNodesCount = deferredTimestampPackets->peekNodes().size();
+
+    EXPECT_TRUE(deferredNodesCount >= 1);
+
+    bool waitlistNodeFound = false;
+    for (auto &node : deferredTimestampPackets->peekNodes()) {
+        if (node->getGpuAddress() == timestamp.peekNodes()[0]->getGpuAddress()) {
+            waitlistNodeFound = true;
+        }
+    }
+
+    EXPECT_TRUE(waitlistNodeFound);
+
+    mockCmdQueue->flush();
+    EXPECT_EQ(deferredNodesCount, deferredTimestampPackets->peekNodes().size());
+
+    mockCmdQueue->finish();
+    EXPECT_EQ(0u, deferredTimestampPackets->peekNodes().size());
+}
+
 HWTEST_TEMPLATED_F(BlitEnqueueTaskCountTests, givenMarkerThatFollowsCopyOperationWhenItIsWaitedItHasProperDependenciesOnWait) {
     auto buffer = createBuffer(1, false);
     int hostPtr = 0;

opencl/test/unit_test/helpers/timestamp_packet_1_tests.cpp

@@ -816,6 +816,34 @@ HWTEST_F(TimestampPacketTests, givenTimestampPacketWriteEnabledWhenEnqueueingThe
     EXPECT_EQ(0u, deferredTimestampPackets->peekNodes().size());
 }
 
+HWTEST_F(TimestampPacketTests, givenWaitlistWithTimestampPacketWhenEnqueueingThenDeferWaitlistNodes) {
+    device->getUltCommandStreamReceiver<FamilyType>().timestampPacketWriteEnabled = true;
+
+    auto cmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, device.get(), nullptr);
+
+    TimestampPacketContainer *deferredTimestampPackets = cmdQ->deferredTimestampPackets.get();
+
+    MockTimestampPacketContainer timestamp(*device->getGpgpuCommandStreamReceiver().getTimestampPacketAllocator(), 1);
+
+    Event waitlistEvent(cmdQ.get(), 0, 0, 0);
+    waitlistEvent.addTimestampPacketNodes(timestamp);
+
+    cl_event waitlist[] = {&waitlistEvent};
+
+    cmdQ->enqueueKernel(kernel->mockKernel, 1, nullptr, gws, nullptr, 1, waitlist, nullptr);
+
+    EXPECT_EQ(1u, deferredTimestampPackets->peekNodes().size());
+
+    EXPECT_EQ(timestamp.peekNodes()[0]->getGpuAddress(), deferredTimestampPackets->peekNodes()[0]->getGpuAddress());
+
+    cmdQ->flush();
+    EXPECT_EQ(1u, deferredTimestampPackets->peekNodes().size());
+    EXPECT_EQ(timestamp.peekNodes()[0]->getGpuAddress(), deferredTimestampPackets->peekNodes()[0]->getGpuAddress());
+
+    cmdQ->finish();
+    EXPECT_EQ(0u, deferredTimestampPackets->peekNodes().size());
+}
+
 HWTEST_F(TimestampPacketTests, givenTimestampWaitEnabledWhenEnqueueWithEventThenEventHasCorrectTimestampsToCheckForCompletion) {
     DebugManagerStateRestore restorer;
     DebugManager.flags.UpdateTaskCountFromWait.set(3);

shared/source/command_stream/csr_deps.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -16,4 +16,10 @@ void CsrDependencies::makeResident(CommandStreamReceiver &commandStreamReceiver)
         timestampPacketContainer->makeResident(commandStreamReceiver);
     }
 }
+
+void CsrDependencies::copyNodesToNewContainer(TimestampPacketContainer &newTimestampPacketContainer) {
+    for (auto &timestampPacketContainer : timestampPacketContainer) {
+        newTimestampPacketContainer.assignAndIncrementNodesRefCounts(*timestampPacketContainer);
+    }
+}
 } // namespace NEO

shared/source/command_stream/csr_deps.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -25,5 +25,6 @@ class CsrDependencies {
     StackVec<TimestampPacketContainer *, 32> timestampPacketContainer;
 
     void makeResident(CommandStreamReceiver &commandStreamReceiver) const;
+    void copyNodesToNewContainer(TimestampPacketContainer &newTimestampPacketContainer);
 };
 } // namespace NEO