Dont allocate HwTimeStamp when TimestampPacket is used

Signed-off-by: Bartosz Dunajski <[email protected]>

Author: BartoszDunajski

opencl/source/command_queue/enqueue_common.h

@@ -729,7 +729,12 @@ CompletionStamp CommandQueueHw<GfxFamily>::enqueueNonBlocked(
     if (isProfilingEnabled() && eventBuilder.getEvent()) {
         this->getDevice().getOSTime()->getCpuTime(&submitTimeStamp.CPUTimeinNS);
         eventBuilder.getEvent()->setSubmitTimeStamp(&submitTimeStamp);
-        getGpgpuCommandStreamReceiver().makeResident(*eventBuilder.getEvent()->getHwTimeStampNode()->getBaseGraphicsAllocation());
+
+        auto hwTimestampNode = eventBuilder.getEvent()->getHwTimeStampNode();
+        if (hwTimestampNode) {
+            getGpgpuCommandStreamReceiver().makeResident(*hwTimestampNode->getBaseGraphicsAllocation());
+        }
+
         if (isPerfCountersEnabled()) {
             getGpgpuCommandStreamReceiver().makeResident(*eventBuilder.getEvent()->getHwPerfCounterNode()->getBaseGraphicsAllocation());
         }

opencl/source/event/event.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2017-2020 Intel Corporation
+ * Copyright (C) 2017-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -737,7 +737,7 @@ void Event::setEndTimeStamp() {
 }
 
 TagNode<HwTimeStamps> *Event::getHwTimeStampNode() {
-    if (!timeStampNode) {
+    if (!cmdQueue->getTimestampPacketContainer() && !timeStampNode) {
         timeStampNode = cmdQueue->getGpgpuCommandStreamReceiver().getEventTsAllocator()->getTag();
     }
     return timeStampNode;

opencl/test/unit_test/event/event_tests.cpp

@@ -866,8 +866,13 @@ HWTEST_F(InternalsEventWithPerfCountersTest, givenCpuProfilingPerfCountersPathWh
     event->setCPUProfilingPath(true);
     HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
     ASSERT_NE(nullptr, perfCounter);
-    HwTimeStamps *timeStamps = event->getHwTimeStampNode()->tagForCpuAccess;
-    ASSERT_NE(nullptr, timeStamps);
+
+    auto hwTimeStampNode = event->getHwTimeStampNode();
+    if (pCmdQ->getTimestampPacketContainer()) {
+        EXPECT_EQ(nullptr, hwTimeStampNode);
+    } else {
+        ASSERT_NE(nullptr, hwTimeStampNode->tagForCpuAccess);
+    }
 
     event->setCommand(std::unique_ptr<Command>(new CommandWithoutKernel(*pCmdQ)));
 
@@ -1109,8 +1114,12 @@ TEST_F(EventTest, GivenNoQueueWhenSettingCpuTimeStampThenTimesIsNotSet) {
     EXPECT_EQ(0ULL, outCPUtimeStamp);
 }
 
-TEST_F(EventTest, WhenGettingHwTimeStampsThenValidPointerIsReturned) {
-    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
+HWTEST_F(EventTest, WhenGettingHwTimeStampsThenValidPointerIsReturned) {
+    pDevice->getUltCommandStreamReceiver<FamilyType>().timestampPacketWriteEnabled = false;
+
+    auto myCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(pCmdQ->getContextPtr(), pClDevice, nullptr);
+
+    std::unique_ptr<Event> event(new Event(myCmdQ.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
     ASSERT_NE(nullptr, event);
 
     HwTimeStamps *timeStamps = event->getHwTimeStampNode()->tagForCpuAccess;
@@ -1130,8 +1139,12 @@ TEST_F(EventTest, WhenGettingHwTimeStampsThenValidPointerIsReturned) {
     ASSERT_EQ(timeStamps, timeStamps2);
 }
 
-TEST_F(EventTest, WhenGetHwTimeStampsAllocationThenValidPointerIsReturned) {
-    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
+HWTEST_F(EventTest, WhenGetHwTimeStampsAllocationThenValidPointerIsReturned) {
+    pDevice->getUltCommandStreamReceiver<FamilyType>().timestampPacketWriteEnabled = false;
+
+    auto myCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(pCmdQ->getContextPtr(), pClDevice, nullptr);
+
+    std::unique_ptr<Event> event(new Event(myCmdQ.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
     ASSERT_NE(nullptr, event);
 
     GraphicsAllocation *allocation = event->getHwTimeStampNode()->getBaseGraphicsAllocation();
@@ -1144,8 +1157,12 @@ TEST_F(EventTest, WhenGetHwTimeStampsAllocationThenValidPointerIsReturned) {
     EXPECT_GT(memoryStorageSize, 0u);
 }
 
-TEST_F(EventTest, WhenEventIsCreatedThenHwTimeStampsMemoryIsPlacedInGraphicsAllocation) {
-    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
+HWTEST_F(EventTest, WhenEventIsCreatedThenHwTimeStampsMemoryIsPlacedInGraphicsAllocation) {
+    pDevice->getUltCommandStreamReceiver<FamilyType>().timestampPacketWriteEnabled = false;
+
+    auto myCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(pCmdQ->getContextPtr(), pClDevice, nullptr);
+
+    std::unique_ptr<Event> event(new Event(myCmdQ.get(), CL_COMMAND_COPY_BUFFER, 0, 0));
     ASSERT_NE(nullptr, event);
 
     HwTimeStamps *timeStamps = event->getHwTimeStampNode()->tagForCpuAccess;

opencl/test/unit_test/profiling/profiling_tests.cpp

@@ -888,6 +888,8 @@ HWTEST_F(ProfilingWithPerfCountersTests, GivenCommandQueueWithProfilingPerfCount
 
 template <typename TagType>
 struct FixedGpuAddressTagAllocator : TagAllocator<TagType> {
+    using TagAllocator<TagType>::usedTags;
+    using TagAllocator<TagType>::deferredTags;
 
     struct MockTagNode : TagNode<TagType> {
         void setGpuAddress(uint64_t value) { this->gpuAddress = value; }
@@ -936,6 +938,28 @@ HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersTests, GivenCommandQueueWit
     clReleaseEvent(event);
 }
 
+HWTEST_F(ProfilingWithPerfCountersTests, givenTimestampPacketsEnabledWhenEnqueueIsCalledThenDontAllocateHwTimeStamps) {
+    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
+    csr.timestampPacketWriteEnabled = true;
+
+    auto mockAllocator = new FixedGpuAddressTagAllocator<HwTimeStamps>(csr, 0x123);
+    csr.profilingTimeStampAllocator.reset(mockAllocator);
+
+    auto myCmdQ = std::make_unique<MockCommandQueueHw<FamilyType>>(pCmdQ->getContextPtr(), pClDevice.get(), nullptr);
+    myCmdQ->setProfilingEnabled();
+
+    size_t globalOffsets[3] = {0, 0, 0};
+    size_t workItems[3] = {1, 1, 1};
+    cl_event event;
+
+    myCmdQ->enqueueKernel(kernel->mockKernel, 1, globalOffsets, workItems, nullptr, 0, nullptr, &event);
+
+    EXPECT_EQ(!!myCmdQ->getTimestampPacketContainer(), mockAllocator->usedTags.peekIsEmpty());
+    EXPECT_TRUE(mockAllocator->deferredTags.peekIsEmpty());
+
+    clReleaseEvent(event);
+}
+
 HWCMDTEST_F(IGFX_GEN8_CORE, ProfilingWithPerfCountersOnCCSTests, givenCommandQueueBlockedWithProfilingPerfCountersWhenWalkerIsDispatchedThenPipeControlWithTimeStampIsPresentInCS) {
     using PIPE_CONTROL = typename FamilyType::PIPE_CONTROL;
     using GPGPU_WALKER = typename FamilyType::GPGPU_WALKER;