Extend TimestampPacket data with Submit field

Change-Id: Ia2a23003476db06afeee25ca7766cfd1bc6da4a3
Signed-off-by: Dunajski, Bartosz <[email protected]>

Author: BartoszDunajski

runtime/command_queue/gpgpu_walker.inl

@@ -588,7 +588,7 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchWalker(
         bool setupTimestampPacket = timestampPacket && (currentDispatchIndex == multiDispatchInfo.size() - 1);
         if (setupTimestampPacket) {
             GpgpuWalkerHelper<GfxFamily>::setupTimestampPacket(commandStream, nullptr, timestampPacket,
-                                                               TimestampPacket::WriteOperationType::Start);
+                                                               TimestampPacket::WriteOperationType::BeforeWalker);
         }
 
         // Program the walker.  Invokes execution so all state should already be programmed
@@ -597,7 +597,7 @@ void GpgpuWalkerHelper<GfxFamily>::dispatchWalker(
 
         if (setupTimestampPacket) {
             GpgpuWalkerHelper<GfxFamily>::setupTimestampPacket(commandStream, pWalkerCmd, timestampPacket,
-                                                               TimestampPacket::WriteOperationType::End);
+                                                               TimestampPacket::WriteOperationType::AfterWalker);
         }
 
         auto idd = obtainInterfaceDescriptorData(pWalkerCmd);
@@ -744,7 +744,12 @@ void GpgpuWalkerHelper<GfxFamily>::setupTimestampPacket(
     TimestampPacket *timestampPacket,
     TimestampPacket::WriteOperationType writeOperationType) {
 
-    uint64_t address = timestampPacket->pickAddressForPipeControlWrite(writeOperationType);
+    uint64_t address;
+    if (TimestampPacket::WriteOperationType::BeforeWalker == writeOperationType) {
+        address = timestampPacket->pickAddressForDataWrite(TimestampPacket::DataIndex::Submit);
+    } else {
+        address = timestampPacket->pickAddressForDataWrite(TimestampPacket::DataIndex::ContextEnd);
+    }
 
     auto pipeControlCmd = cmdStream->getSpaceForCmd<PIPE_CONTROL>();
     *pipeControlCmd = PIPE_CONTROL::sInit();

runtime/helpers/timestamp_packet.h

@@ -33,34 +33,28 @@ class TimestampPacket {
         GlobalStart,
         ContextEnd,
         GlobalEnd,
+        Submit,
         Max
     };
 
     enum class WriteOperationType : uint32_t {
-        Start,
-        End
+        BeforeWalker,
+        AfterWalker
     };
 
     bool canBeReleased() const {
         return data[static_cast<uint32_t>(DataIndex::ContextEnd)] != 1 &&
                data[static_cast<uint32_t>(DataIndex::GlobalEnd)] != 1;
     }
 
-    const uint32_t *pickDataPtr() const { return &(data[0]); }
-
-    uint64_t pickAddressForPipeControlWrite(WriteOperationType operationType) const {
-        auto index = WriteOperationType::Start == operationType
-                         ? static_cast<uint32_t>(DataIndex::ContextStart)
-                         : static_cast<uint32_t>(DataIndex::ContextEnd);
-
+    uint64_t pickAddressForDataWrite(DataIndex operationType) const {
+        auto index = static_cast<uint32_t>(operationType);
         return reinterpret_cast<uint64_t>(&data[index]);
     }
 
-    uint32_t pickDataValue(DataIndex index) const { return data[static_cast<uint32_t>(index)]; }
-
-    void initialize() { data = {{1, 1, 1, 1}}; }
+    void initialize() { data = {{1, 1, 1, 1, 1}}; }
 
   protected:
-    std::array<uint32_t, static_cast<uint32_t>(DataIndex::Max)> data = {{1, 1, 1, 1}};
+    std::array<uint32_t, static_cast<uint32_t>(DataIndex::Max)> data = {{1, 1, 1, 1, 1}};
 };
 } // namespace OCLRT

unit_tests/helpers/timestamp_packet_tests.cpp

@@ -94,7 +94,7 @@ TEST_F(TimestampPacketTests, whenNewTagIsTakenThenReinitialize) {
     MockTagAllocator<MockTimestampPacket> allocator(&memoryManager, 1);
 
     auto firstNode = allocator.getTag();
-    firstNode->tag->data = {{5, 6, 7, 8}};
+    firstNode->tag->data = {{5, 6, 7, 8, 9}};
 
     allocator.returnTag(firstNode);
 
@@ -109,30 +109,22 @@ TEST_F(TimestampPacketTests, whenNewTagIsTakenThenReinitialize) {
 TEST_F(TimestampPacketTests, whenObjectIsCreatedThenInitializeAllStamps) {
     MockTimestampPacket timestampPacket;
     auto maxElements = static_cast<uint32_t>(TimestampPacket::DataIndex::Max);
-    EXPECT_EQ(4u, maxElements);
+    EXPECT_EQ(5u, maxElements);
 
     EXPECT_EQ(maxElements, timestampPacket.data.size());
 
     for (uint32_t i = 0; i < maxElements; i++) {
-        EXPECT_EQ(1u, timestampPacket.pickDataValue(static_cast<TimestampPacket::DataIndex>(i)));
         EXPECT_EQ(1u, timestampPacket.data[i]);
     }
 }
 
 TEST_F(TimestampPacketTests, whenAskedForStampAddressThenReturnWithValidOffset) {
     MockTimestampPacket timestampPacket;
 
-    EXPECT_EQ(&timestampPacket.data[0], timestampPacket.pickDataPtr());
-
-    auto startAddress = timestampPacket.pickAddressForPipeControlWrite(TimestampPacket::WriteOperationType::Start);
-    auto expectedStartAddress = &timestampPacket.data[static_cast<uint32_t>(TimestampPacket::DataIndex::ContextStart)];
-    EXPECT_EQ(expectedStartAddress, &timestampPacket.data[0]);
-    EXPECT_EQ(reinterpret_cast<uint64_t>(expectedStartAddress), startAddress);
-
-    auto endAddress = timestampPacket.pickAddressForPipeControlWrite(TimestampPacket::WriteOperationType::End);
-    auto expectedEndAddress = &timestampPacket.data[static_cast<uint32_t>(TimestampPacket::DataIndex::ContextEnd)];
-    EXPECT_EQ(expectedEndAddress, &timestampPacket.data[2]);
-    EXPECT_EQ(reinterpret_cast<uint64_t>(expectedEndAddress), endAddress);
+    for (size_t i = 0; i < static_cast<uint32_t>(TimestampPacket::DataIndex::Max); i++) {
+        auto address = timestampPacket.pickAddressForDataWrite(static_cast<TimestampPacket::DataIndex>(i));
+        EXPECT_EQ(address, reinterpret_cast<uint64_t>(&timestampPacket.data[i]));
+    }
 }
 
 HWTEST_F(TimestampPacketTests, givenDebugVariableEnabledWhenEstimatingStreamSizeThenAddTwoPipeControls) {
@@ -152,7 +144,7 @@ HWTEST_F(TimestampPacketTests, givenDebugVariableEnabledWhenEstimatingStreamSize
     getCommandStream<FamilyType, CL_COMMAND_NDRANGE_KERNEL>(cmdQ, false, false, multiDispatchInfo);
     auto sizeWithEnabled = cmdQ.requestedCmdStreamSize;
 
-    EXPECT_EQ(sizeWithEnabled, sizeWithDisabled + 2 * sizeof(typename FamilyType::PIPE_CONTROL));
+    EXPECT_EQ(sizeWithEnabled, sizeWithDisabled + (2 * sizeof(typename FamilyType::PIPE_CONTROL)));
 }
 
 HWCMDTEST_F(IGFX_GEN8_CORE, TimestampPacketTests, givenTimestampPacketWhenDispatchingGpuWalkerThenAddTwoPcForLastWalker) {
@@ -204,11 +196,11 @@ HWCMDTEST_F(IGFX_GEN8_CORE, TimestampPacketTests, givenTimestampPacketWhenDispat
             } else if (walkersFound == 2) {
                 auto pipeControl = genCmdCast<PIPE_CONTROL *>(*--it);
                 EXPECT_NE(nullptr, pipeControl);
-                verifyPipeControl(pipeControl, timestampPacket.pickAddressForPipeControlWrite(TimestampPacket::WriteOperationType::Start));
+                verifyPipeControl(pipeControl, timestampPacket.pickAddressForDataWrite(TimestampPacket::DataIndex::Submit));
                 it++;
                 pipeControl = genCmdCast<PIPE_CONTROL *>(*++it);
                 EXPECT_NE(nullptr, pipeControl);
-                verifyPipeControl(pipeControl, timestampPacket.pickAddressForPipeControlWrite(TimestampPacket::WriteOperationType::End));
+                verifyPipeControl(pipeControl, timestampPacket.pickAddressForDataWrite(TimestampPacket::DataIndex::ContextEnd));
                 it--;
             }
         }
@@ -256,8 +248,8 @@ HWTEST_F(TimestampPacketTests, givenDebugVariableEnabledWhenEnqueueingThenObtain
     EXPECT_NE(node1, node2);
     size_t dataSize = sizeof(uint32_t) * static_cast<size_t>(TimestampPacket::DataIndex::Max);
     // mark nodes as ready
-    memset(const_cast<uint32_t *>(node1->tag->pickDataPtr()), 0, dataSize);
-    memset(const_cast<uint32_t *>(node2->tag->pickDataPtr()), 0, dataSize);
+    memset(reinterpret_cast<void *>(node1->tag->pickAddressForDataWrite(TimestampPacket::DataIndex::ContextStart)), 0, dataSize);
+    memset(reinterpret_cast<void *>(node2->tag->pickAddressForDataWrite(TimestampPacket::DataIndex::ContextStart)), 0, dataSize);
 
     clReleaseEvent(event2);
     EXPECT_EQ(0u, mockTagAllocator->returnedToFreePoolNodes.size()); // nothing returned. cmdQ owns node2