Handle TimestampPacketNode residency

Change-Id: I1769d67426ca704b600931b58d3f505bef0e893d
Signed-off-by: Dunajski, Bartosz <bartosz.dunajski@intel.com>

Author: BartoszDunajski

runtime/command_queue/enqueue_common.h

@@ -42,6 +42,7 @@
 #include "runtime/program/printf_handler.h"
 #include "runtime/program/block_kernel_manager.h"
 #include "runtime/utilities/range.h"
+#include "runtime/utilities/tag_allocator.h"
 #include <memory>
 #include <new>
 
@@ -518,6 +519,9 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
         blocking = true;
         printfHandler->makeResident(commandStreamReceiver);
     }
+    if (timestampPacketNode) {
+        device->getCommandStreamReceiver().makeResident(*timestampPacketNode->getGraphicsAllocation());
+    }
 
     auto requiresCoherency = false;
     for (auto surface : CreateRange(surfaces, surfaceCount)) {
@@ -670,7 +674,7 @@ void CommandQueueHw<GfxFamily>::enqueueBlocked(
         }
         PreemptionMode preemptionMode = PreemptionHelper::taskPreemptionMode(*device, multiDispatchInfo);
         auto kernelOperation = std::unique_ptr<KernelOperation>(blockedCommandsData); // marking ownership
-        auto cmd = std::unique_ptr<Command>(new CommandComputeKernel(
+        auto cmd = std::make_unique<CommandComputeKernel>(
             *this,
             commandStreamReceiver,
             std::move(kernelOperation),
@@ -681,7 +685,11 @@ void CommandQueueHw<GfxFamily>::enqueueBlocked(
             std::move(printfHandler),
             preemptionMode,
             multiDispatchInfo.peekMainKernel(),
-            (uint32_t)multiDispatchInfo.size()));
+            (uint32_t)multiDispatchInfo.size());
+
+        if (timestampPacketNode) {
+            cmd->setTimestampPacketNode(timestampPacketNode);
+        }
         eventBuilder->getEvent()->setCommand(std::move(cmd));
     }
 

runtime/helpers/task_information.cpp

@@ -128,6 +128,10 @@ CommandComputeKernel::CommandComputeKernel(CommandQueue &commandQueue, CommandSt
 }
 
 CommandComputeKernel::~CommandComputeKernel() {
+    if (timestampPacketNode) {
+        auto allocator = commandStreamReceiver.getMemoryManager()->getTimestampPacketAllocator();
+        allocator->returnTag(timestampPacketNode);
+    }
     for (auto surface : surfaces) {
         delete surface;
     }
@@ -177,6 +181,9 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
     if (printfHandler) {
         printfHandler.get()->makeResident(commandStreamReceiver);
     }
+    if (timestampPacketNode) {
+        commandStreamReceiver.makeResident(*timestampPacketNode->getGraphicsAllocation());
+    }
 
     if (executionModelKernel) {
         uint32_t taskCount = commandStreamReceiver.peekTaskCount() + 1;
@@ -242,6 +249,11 @@ CompletionStamp &CommandComputeKernel::submit(uint32_t taskLevel, bool terminate
     return completionStamp;
 }
 
+void CommandComputeKernel::setTimestampPacketNode(TagNode<TimestampPacket> *node) {
+    node->incRefCount();
+    timestampPacketNode = node;
+}
+
 CompletionStamp &CommandMarker::submit(uint32_t taskLevel, bool terminated) {
     if (terminated) {
         return completionStamp;

runtime/helpers/task_information.h

@@ -40,6 +40,9 @@ class Surface;
 class PrintfHandler;
 struct HwTimeStamps;
 class MemoryManager;
+class TimestampPacket;
+template <typename TagType>
+struct TagNode;
 
 enum MapOperationType {
     MAP,
@@ -108,9 +111,9 @@ class CommandComputeKernel : public Command {
 
     CompletionStamp &submit(uint32_t taskLevel, bool terminated) override;
 
-    LinearStream *getCommandStream() override {
-        return kernelOperation->commandStream.get();
-    }
+    LinearStream *getCommandStream() override { return kernelOperation->commandStream.get(); }
+
+    void setTimestampPacketNode(TagNode<TimestampPacket> *node);
 
   private:
     CommandQueue &commandQueue;
@@ -124,6 +127,7 @@ class CommandComputeKernel : public Command {
     Kernel *kernel;
     uint32_t kernelCount;
     PreemptionMode preemptionMode;
+    TagNode<TimestampPacket> *timestampPacketNode = nullptr;
 };
 
 class CommandMarker : public Command {

unit_tests/command_queue/enqueue_kernel_tests.cpp

@@ -27,6 +27,7 @@
 #include "runtime/helpers/preamble.h"
 #include "runtime/memory_manager/graphics_allocation.h"
 #include "runtime/memory_manager/memory_constants.h"
+#include "runtime/utilities/tag_allocator.h"
 #include "unit_tests/command_queue/enqueue_fixture.h"
 #include "unit_tests/fixtures/hello_world_fixture.h"
 #include "unit_tests/fixtures/memory_management_fixture.h"
@@ -35,6 +36,7 @@
 #include "unit_tests/helpers/debug_manager_state_restore.h"
 #include "unit_tests/helpers/unit_test_helper.h"
 #include "unit_tests/mocks/mock_csr.h"
+#include "unit_tests/mocks/mock_command_queue.h"
 #include "unit_tests/mocks/mock_device_queue.h"
 #include "unit_tests/mocks/mock_buffer.h"
 #include "unit_tests/mocks/mock_submissions_aggregator.h"
@@ -1574,6 +1576,43 @@ HWTEST_F(EnqueueKernelTest, givenNonVMEKernelWhenEnqueueKernelThenDispatchFlagsD
     EXPECT_FALSE(mockCsr->passedDispatchFlags.mediaSamplerRequired);
 }
 
+HWTEST_F(EnqueueKernelTest, givenTimestampPacketWhenEnqueueingNonBlockedThenMakeItResident) {
+    DebugManagerStateRestore restore;
+    DebugManager.flags.EnableTimestampPacket.set(true);
+    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
+    MockKernelWithInternals mockKernel(*pDevice, context);
+    auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pDevice, nullptr);
+
+    csr.storeMakeResidentAllocations = true;
+    size_t gws[] = {1, 0, 0};
+
+    mockCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 0, nullptr, nullptr);
+    auto timestampPacketNode = mockCmdQ->timestampPacketNode;
+
+    EXPECT_TRUE(csr.isMadeResident(timestampPacketNode->getGraphicsAllocation()));
+}
+
+HWTEST_F(EnqueueKernelTest, givenTimestampPacketWhenEnqueueingBlockedThenMakeItResidentOnSubmit) {
+    DebugManagerStateRestore restore;
+    DebugManager.flags.EnableTimestampPacket.set(true);
+    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
+    MockKernelWithInternals mockKernel(*pDevice, context);
+    auto mockCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(context, pDevice, nullptr);
+
+    csr.storeMakeResidentAllocations = true;
+    size_t gws[] = {1, 0, 0};
+
+    UserEvent userEvent;
+    cl_event clEvent = &userEvent;
+
+    mockCmdQ->enqueueKernel(mockKernel.mockKernel, 1, nullptr, gws, nullptr, 1, &clEvent, nullptr);
+    auto timestampPacketNode = mockCmdQ->timestampPacketNode;
+
+    EXPECT_FALSE(csr.isMadeResident(timestampPacketNode->getGraphicsAllocation()));
+    userEvent.setStatus(CL_COMPLETE);
+    EXPECT_TRUE(csr.isMadeResident(timestampPacketNode->getGraphicsAllocation()));
+}
+
 struct EnqueueAuxKernelTests : public EnqueueKernelTest {
     template <typename FamilyType>
     class MyCmdQ : public CommandQueueHw<FamilyType> {