IVGCVSW-4541 Modify Timeline Packet construction

 * Changed TimelinePacket encoding so that there is only one header for
   multiple timeline swtrace messages
 * Refactored function names to have more suitable description
 * Refactored CodeStyle to coincide with ArmNN coding standards
 * Refactored profiling test names to be descriptive
 * Refactored ErrorCode name to TimelineStatus
 * Updated existing unit tests

Signed-off-by: Keith Davis <keith.davis@arm.com>
Change-Id: I83bd4bb9e7393617bca97eba96a6e1388916e5b0
diff --git a/src/profiling/test/ProfilingTestUtils.cpp b/src/profiling/test/ProfilingTestUtils.cpp
index dd54ca9..89b5926 100644
--- a/src/profiling/test/ProfilingTestUtils.cpp
+++ b/src/profiling/test/ProfilingTestUtils.cpp
@@ -25,19 +25,16 @@
     return numberOfBytes + uint32_t_size - remainder;
 }
 
-void VerifyTimelineLabelBinaryPacket(Optional<ProfilingGuid> guid,
-                                     const std::string& label,
-                                     const unsigned char* readableData,
-                                     unsigned int& offset)
+void VerifyTimelineHeaderBinary(const unsigned char* readableData,
+                                unsigned int& offset,
+                                uint32_t packetDataLength)
 {
     BOOST_ASSERT(readableData);
 
     // Utils
     unsigned int uint32_t_size = sizeof(uint32_t);
-    unsigned int uint64_t_size = sizeof(uint64_t);
-    unsigned int label_size    = boost::numeric_cast<unsigned int>(label.size());
 
-    // Check the TimelineLabelBinaryPacket header
+    // Check the TimelineEventClassBinaryPacket header
     uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(readableData, offset);
     uint32_t entityBinaryPacketFamily      = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
     uint32_t entityBinaryPacketClass       = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
@@ -52,10 +49,23 @@
     uint32_t eventBinaryPacketSequenceNumber = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001;
     uint32_t eventBinaryPacketDataLength     = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
     BOOST_CHECK(eventBinaryPacketSequenceNumber == 0);
-    BOOST_CHECK(eventBinaryPacketDataLength     == 16 + OffsetToNextWord(label_size + 1));
+    BOOST_CHECK(eventBinaryPacketDataLength     == packetDataLength);
+    offset += uint32_t_size;
+}
+
+void VerifyTimelineLabelBinaryPacketData(Optional<ProfilingGuid> guid,
+                                         const std::string& label,
+                                         const unsigned char* readableData,
+                                         unsigned int& offset)
+{
+    BOOST_ASSERT(readableData);
+
+    // Utils
+    unsigned int uint32_t_size = sizeof(uint32_t);
+    unsigned int uint64_t_size = sizeof(uint64_t);
+    unsigned int label_size    = boost::numeric_cast<unsigned int>(label.size());
 
     // Check the decl id
-    offset += uint32_t_size;
     uint32_t eventClassDeclId = ReadUint32(readableData, offset);
     BOOST_CHECK(eventClassDeclId == 0);
 
@@ -74,20 +84,19 @@
     // Check the SWTrace label
     offset += uint64_t_size;
     uint32_t swTraceLabelLength = ReadUint32(readableData, offset);
-    BOOST_CHECK(swTraceLabelLength == label_size + 1); // Label length including the null-terminator
+    BOOST_CHECK(swTraceLabelLength == label_size + 1);               // Label length including the null-terminator
     offset += uint32_t_size;
     BOOST_CHECK(std::memcmp(readableData + offset,                  // Offset to the label in the buffer
-                            label.data(),                           // The original label
-                            swTraceLabelLength - 1) == 0);          // The length of the label
-    BOOST_CHECK(readableData[offset + swTraceLabelLength] == '\0'); // The null-terminator
+                               label.data(),                           // The original label
+                               swTraceLabelLength - 1) == 0);          // The length of the label
 
     // SWTrace strings are written in blocks of words, so the offset has to be updated to the next whole word
     offset += OffsetToNextWord(swTraceLabelLength);
 }
 
-void VerifyTimelineEventClassBinaryPacket(ProfilingGuid guid,
-                                          const unsigned char* readableData,
-                                          unsigned int& offset)
+void VerifyTimelineEventClassBinaryPacketData(ProfilingGuid guid,
+                                              const unsigned char* readableData,
+                                              unsigned int& offset)
 {
     BOOST_ASSERT(readableData);
 
@@ -95,25 +104,7 @@
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
 
-    // Check the TimelineEventClassBinaryPacket header
-    uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(readableData, offset);
-    uint32_t entityBinaryPacketFamily      = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t entityBinaryPacketClass       = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t entityBinaryPacketType        = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007;
-    uint32_t entityBinaryPacketStreamId    = (entityBinaryPacketHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(entityBinaryPacketFamily   == 1);
-    BOOST_CHECK(entityBinaryPacketClass    == 0);
-    BOOST_CHECK(entityBinaryPacketType     == 1);
-    BOOST_CHECK(entityBinaryPacketStreamId == 0);
-    offset += uint32_t_size;
-    uint32_t entityBinaryPacketHeaderWord1   = ReadUint32(readableData, offset);
-    uint32_t eventBinaryPacketSequenceNumber = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001;
-    uint32_t eventBinaryPacketDataLength     = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(eventBinaryPacketSequenceNumber == 0);
-    BOOST_CHECK(eventBinaryPacketDataLength     == 12);
-
     // Check the decl id
-    offset += uint32_t_size;
     uint32_t eventClassDeclId = ReadUint32(readableData, offset);
     BOOST_CHECK(eventClassDeclId == 2);
 
@@ -126,7 +117,7 @@
     offset += uint64_t_size;
 }
 
-void VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType relationshipType,
+void VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType relationshipType,
                                             Optional<ProfilingGuid> relationshipGuid,
                                             Optional<ProfilingGuid> headGuid,
                                             Optional<ProfilingGuid> tailGuid,
@@ -158,25 +149,7 @@
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
 
-    // Check the TimelineLabelBinaryPacket header
-    uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(readableData, offset);
-    uint32_t entityBinaryPacketFamily      = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t entityBinaryPacketClass       = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t entityBinaryPacketType        = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007;
-    uint32_t entityBinaryPacketStreamId    = (entityBinaryPacketHeaderWord0 >>  0) & 0x00000007;
-    BOOST_CHECK(entityBinaryPacketFamily   == 1);
-    BOOST_CHECK(entityBinaryPacketClass    == 0);
-    BOOST_CHECK(entityBinaryPacketType     == 1);
-    BOOST_CHECK(entityBinaryPacketStreamId == 0);
-    offset += uint32_t_size;
-    uint32_t entityBinaryPacketHeaderWord1   = ReadUint32(readableData, offset);
-    uint32_t eventBinaryPacketSequenceNumber = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001;
-    uint32_t eventBinaryPacketDataLength     = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(eventBinaryPacketSequenceNumber == 0);
-    BOOST_CHECK(eventBinaryPacketDataLength     == 32);
-
     // Check the decl id
-    offset += uint32_t_size;
     uint32_t eventClassDeclId = ReadUint32(readableData, offset);
     BOOST_CHECK(eventClassDeclId == 3);
 
@@ -225,9 +198,9 @@
     offset += uint64_t_size;
 }
 
-void VerifyTimelineEntityBinaryPacket(Optional<ProfilingGuid> guid,
-                                      const unsigned char* readableData,
-                                      unsigned int& offset)
+void VerifyTimelineEntityBinaryPacketData(Optional<ProfilingGuid> guid,
+                                          const unsigned char* readableData,
+                                          unsigned int& offset)
 {
     BOOST_ASSERT(readableData);
 
@@ -236,26 +209,7 @@
     unsigned int uint64_t_size = sizeof(uint64_t);
 
     // Reading TimelineEntityClassBinaryPacket
-    uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(readableData, offset);
-    uint32_t entityBinaryPacketFamily = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t entityBinaryPacketClass = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t entityBinaryPacketType = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007;
-    uint32_t entityBinaryPacketStreamId = (entityBinaryPacketHeaderWord0 >>  0) & 0x00000007;
-
-    BOOST_CHECK(entityBinaryPacketFamily == 1);
-    BOOST_CHECK(entityBinaryPacketClass  == 0);
-    BOOST_CHECK(entityBinaryPacketType   == 1);
-    BOOST_CHECK(entityBinaryPacketStreamId     == 0);
-
-    offset += uint32_t_size;
-    uint32_t entityBinaryPacketHeaderWord1 = ReadUint32(readableData, offset);
-    uint32_t entityBinaryPacketSequenceNumbered = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001;
-    uint32_t entityBinaryPacketDataLength       = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(entityBinaryPacketSequenceNumbered == 0);
-    BOOST_CHECK(entityBinaryPacketDataLength       == 12);
-
     // Check the decl_id
-    offset += uint32_t_size;
     uint32_t entityDeclId = ReadUint32(readableData, offset);
     BOOST_CHECK(entityDeclId == 1);
 
@@ -289,26 +243,7 @@
     unsigned int threadId_size = sizeof(std::thread::id);
 
     // Reading TimelineEventBinaryPacket
-    uint32_t entityBinaryPacketHeaderWord0 = ReadUint32(readableData, offset);
-    uint32_t entityBinaryPacketFamily   = (entityBinaryPacketHeaderWord0 >> 26) & 0x0000003F;
-    uint32_t entityBinaryPacketClass    = (entityBinaryPacketHeaderWord0 >> 19) & 0x0000007F;
-    uint32_t entityBinaryPacketType     = (entityBinaryPacketHeaderWord0 >> 16) & 0x00000007;
-    uint32_t entityBinaryPacketStreamId = (entityBinaryPacketHeaderWord0 >>  0) & 0x00000007;
-
-    BOOST_CHECK(entityBinaryPacketFamily   == 1);
-    BOOST_CHECK(entityBinaryPacketClass    == 0);
-    BOOST_CHECK(entityBinaryPacketType     == 1);
-    BOOST_CHECK(entityBinaryPacketStreamId == 0);
-
-    offset += uint32_t_size;
-    uint32_t entityBinaryPacketHeaderWord1 = ReadUint32(readableData, offset);
-    uint32_t entityBinaryPacketSequenceNumbered = (entityBinaryPacketHeaderWord1 >> 24) & 0x00000001;
-    uint32_t entityBinaryPacketDataLength       = (entityBinaryPacketHeaderWord1 >>  0) & 0x00FFFFFF;
-    BOOST_CHECK(entityBinaryPacketSequenceNumbered == 0);
-    BOOST_CHECK(entityBinaryPacketDataLength       == 20 + threadId_size);
-
     // Check the decl_id
-    offset += uint32_t_size;
     uint32_t entityDeclId = ReadUint32(readableData, offset);
     BOOST_CHECK(entityDeclId == 4);
 
@@ -368,18 +303,18 @@
 
     // Convolution details
     TensorInfo inputInfo({ 1, 2, 5, 1 }, DataType::Float32);
-    TensorInfo weightInfo({ 3, 2, 3, 1}, DataType::Float32);
+    TensorInfo weightInfo({ 3, 2, 3, 1 }, DataType::Float32);
     TensorInfo biasInfo({ 3 }, DataType::Float32);
-    TensorInfo outputInfo({ 1, 3, 7, 1}, DataType::Float32);
+    TensorInfo outputInfo({ 1, 3, 7, 1 }, DataType::Float32);
     std::vector<float> weightsData{
-            1.0f,  0.0f,  0.0f,
-            0.0f,  2.0f, -1.5f,
+        1.0f, 0.0f, 0.0f,
+        0.0f, 2.0f, -1.5f,
 
-            0.0f,  0.0f,  0.0f,
-            0.2f,  0.2f,  0.2f,
+        0.0f, 0.0f, 0.0f,
+        0.2f, 0.2f, 0.2f,
 
-            0.5f,  0.0f,  0.5f,
-            0.0f, -1.0f,  0.0f
+        0.5f, 0.0f, 0.5f,
+        0.0f, -1.0f, 0.0f
     };
     ConstTensor weights(weightInfo, weightsData);
 
@@ -393,8 +328,8 @@
 
     // Convolution2d layer
     Convolution2dDescriptor conv2dDesc;
-    conv2dDesc.m_StrideX  = 1;
-    conv2dDesc.m_StrideY  = 1;
+    conv2dDesc.m_StrideX = 1;
+    conv2dDesc.m_StrideY = 1;
     conv2dDesc.m_PadLeft = 0;
     conv2dDesc.m_PadRight = 0;
     conv2dDesc.m_PadTop = 2;
@@ -435,386 +370,389 @@
     BOOST_CHECK(readableBuffer != nullptr);
 
     unsigned int size = readableBuffer->GetSize();
-    BOOST_CHECK(size == 1980);
+    BOOST_CHECK(size == 1556);
 
     const unsigned char* readableData = readableBuffer->GetReadableData();
     BOOST_CHECK(readableData != nullptr);
 
     unsigned int offset = 0;
 
+    // Verify Header
+    VerifyTimelineHeaderBinary(readableData, offset, 1548);
+
     // Post-optimisation network
     // Network entity
-    VerifyTimelineEntityBinaryPacket(optNetGuid, readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(optNetGuid, readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           optNetGuid,
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               optNetGuid,
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Input layer
     // Input layer entity
-    VerifyTimelineEntityBinaryPacket(input->GetGuid(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(input->GetGuid(), readableData, offset);
 
     // Name Entity
-    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "input", readableData, offset);
+    VerifyTimelineLabelBinaryPacketData(EmptyOptional(), "input", readableData, offset);
 
     // Entity - Name relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           input->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               input->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Name label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::NAME_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::NAME_GUID,
+                                               readableData,
+                                               offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           input->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               input->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Network - Input layer relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           optNetGuid,
-                                           input->GetGuid(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               optNetGuid,
+                                               input->GetGuid(),
+                                               readableData,
+                                               offset);
 
     // Conv2d layer
     // Conv2d layer entity
-    VerifyTimelineEntityBinaryPacket(conv2d->GetGuid(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(conv2d->GetGuid(), readableData, offset);
 
     // Name entity
-    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "<Unnamed>", readableData, offset);
+    VerifyTimelineLabelBinaryPacketData(EmptyOptional(), "<Unnamed>", readableData, offset);
 
     // Entity - Name relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           conv2d->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               conv2d->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Name label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::NAME_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::NAME_GUID,
+                                               readableData,
+                                               offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           conv2d->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               conv2d->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Network - Conv2d layer relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           optNetGuid,
-                                           conv2d->GetGuid(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               optNetGuid,
+                                               conv2d->GetGuid(),
+                                               readableData,
+                                               offset);
 
     // Input layer - Conv2d layer relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           input->GetGuid(),
-                                           conv2d->GetGuid(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               input->GetGuid(),
+                                               conv2d->GetGuid(),
+                                               readableData,
+                                               offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::CONNECTION_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::CONNECTION_GUID,
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Conv2d workload
     // Conv2d workload entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // BackendId entity
-    VerifyTimelineLabelBinaryPacket(EmptyOptional(), backendId.Get(), readableData, offset);
+    VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
 
     // Entity - BackendId relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // BackendId label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::BACKENDID_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::BACKENDID_GUID,
+                                               readableData,
+                                               offset);
 
     // Conv2d layer - Conv2d workload relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           conv2d->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               conv2d->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Activation layer
     // Activation layer entity
-    VerifyTimelineEntityBinaryPacket(activation->GetGuid(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(activation->GetGuid(), readableData, offset);
 
     // Name entity
-    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "activation", readableData, offset);
+    VerifyTimelineLabelBinaryPacketData(EmptyOptional(), "activation", readableData, offset);
 
     // Entity - Name relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           activation->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               activation->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Name label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::NAME_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::NAME_GUID,
+                                               readableData,
+                                               offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           activation->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               activation->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Network - Activation layer relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           optNetGuid,
-                                           activation->GetGuid(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               optNetGuid,
+                                               activation->GetGuid(),
+                                               readableData,
+                                               offset);
 
     // Conv2d layer - Activation layer relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           conv2d->GetGuid(),
-                                           activation->GetGuid(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               conv2d->GetGuid(),
+                                               activation->GetGuid(),
+                                               readableData,
+                                               offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::CONNECTION_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::CONNECTION_GUID,
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Activation workload
     // Activation workload entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // BackendId entity
-    VerifyTimelineLabelBinaryPacket(EmptyOptional(), backendId.Get(), readableData, offset);
+    VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
 
     // Entity - BackendId relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // BackendId label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::BACKENDID_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::BACKENDID_GUID,
+                                               readableData,
+                                               offset);
 
     // Activation layer - Activation workload relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           activation->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               activation->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Output layer
     // Output layer entity
-    VerifyTimelineEntityBinaryPacket(output->GetGuid(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(output->GetGuid(), readableData, offset);
 
     // Name entity
-    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "output", readableData, offset);
+    VerifyTimelineLabelBinaryPacketData(EmptyOptional(), "output", readableData, offset);
 
     // Entity - Name relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           output->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               output->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Name label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::NAME_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::NAME_GUID,
+                                               readableData,
+                                               offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           output->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               output->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Network - Output layer relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           optNetGuid,
-                                           output->GetGuid(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               optNetGuid,
+                                               output->GetGuid(),
+                                               readableData,
+                                               offset);
 
     // Activation layer - Output layer relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           activation->GetGuid(),
-                                           output->GetGuid(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               activation->GetGuid(),
+                                               output->GetGuid(),
+                                               readableData,
+                                               offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::CONNECTION_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::CONNECTION_GUID,
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     bufferManager.MarkRead(readableBuffer);
 
@@ -823,13 +761,13 @@
     std::vector<float> outputData(outputInfo.GetNumElements());
 
     InputTensors inputTensors
-    {
-        {0, ConstTensor(runtime->GetInputTensorInfo(netId, 0), inputData.data())}
-    };
+        {
+            { 0, ConstTensor(runtime->GetInputTensorInfo(netId, 0), inputData.data()) }
+        };
     OutputTensors outputTensors
-    {
-        {0, Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data())}
-    };
+        {
+            { 0, Tensor(runtime->GetOutputTensorInfo(netId, 0), outputData.data()) }
+        };
 
     // Does the inference.
     runtime->EnqueueWorkload(netId, inputTensors, outputTensors);
@@ -848,501 +786,510 @@
 
     // Validate input workload data
     size = inputReadableBuffer->GetSize();
-    BOOST_CHECK(size == 252);
+    BOOST_CHECK(size == 204);
 
     readableData = inputReadableBuffer->GetReadableData();
     BOOST_CHECK(readableData != nullptr);
 
     offset = 0;
 
+    // Verify Header
+    VerifyTimelineHeaderBinary(readableData, offset, 196);
+
     // Input workload
     // Input workload entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // BackendId entity
-    VerifyTimelineLabelBinaryPacket(EmptyOptional(), backendId.Get(), readableData, offset);
+    VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
 
     // Entity - BackendId relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // BackendId label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::BACKENDID_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::BACKENDID_GUID,
+                                               readableData,
+                                               offset);
 
     // Input layer - Input workload relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           input->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               input->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     bufferManager.MarkRead(inputReadableBuffer);
 
     // Validate output workload data
     size = outputReadableBuffer->GetSize();
-    BOOST_CHECK(size == 252);
+    BOOST_CHECK(size == 204);
 
     readableData = outputReadableBuffer->GetReadableData();
     BOOST_CHECK(readableData != nullptr);
 
     offset = 0;
 
+    // Verify Header
+    VerifyTimelineHeaderBinary(readableData, offset, 196);
+
     // Output workload
     // Output workload entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // BackendId entity
-    VerifyTimelineLabelBinaryPacket(EmptyOptional(), backendId.Get(), readableData, offset);
+    VerifyTimelineLabelBinaryPacketData(EmptyOptional(), backendId.Get(), readableData, offset);
 
     // Entity - BackendId relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // BackendId label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::BACKENDID_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::BACKENDID_GUID,
+                                               readableData,
+                                               offset);
 
     // Output layer - Output workload relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           output->GetGuid(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               output->GetGuid(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     bufferManager.MarkRead(outputReadableBuffer);
 
     // Validate inference data
     size = inferenceReadableBuffer->GetSize();
-    BOOST_CHECK(size == 2020);
+    BOOST_CHECK(size == 1596);
 
     readableData = inferenceReadableBuffer->GetReadableData();
     BOOST_CHECK(readableData != nullptr);
 
     offset = 0;
 
+    // Verify Header
+    VerifyTimelineHeaderBinary(readableData, offset, 1588);
+
     // Inference timeline trace
     // Inference entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::INFERENCE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::INFERENCE_GUID,
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Network - Inference relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           optNetGuid,
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               optNetGuid,
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Start Inference life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Inference - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // Execution
     // Input workload execution
     // Input workload execution entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Inference - Workload execution relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Workload - Workload execution relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Start Input workload execution life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Input workload execution - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // End of Input workload execution life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Input workload execution - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // Conv2d workload execution
     // Conv2d workload execution entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Inference - Workload execution relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Workload - Workload execution relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Start Conv2d workload execution life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Conv2d workload execution - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // End of Conv2d workload execution life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Conv2d workload execution - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // Activation workload execution
     // Activation workload execution entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Inference - Workload execution relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Workload - Workload execution relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Start Activation workload execution life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Activation workload execution - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // End of Activation workload execution life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Activation workload execution - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // Output workload execution
     // Output workload execution entity
-    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+    VerifyTimelineEntityBinaryPacketData(EmptyOptional(), readableData, offset);
 
     // Entity - Type relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::WORKLOAD_EXECUTION_GUID,
+                                               readableData,
+                                               offset);
 
     // Type label relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::TYPE_GUID,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::LabelLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::TYPE_GUID,
+                                               readableData,
+                                               offset);
 
     // Inference - Workload execution relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Workload - Workload execution relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::RetentionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Start Output workload execution life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Output workload execution - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // End of Normalize workload execution life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Output workload execution - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     // End of Inference life
     // Event packet - timeline, threadId, eventGuid
     VerifyTimelineEventBinaryPacket(EmptyOptional(), EmptyOptional(), EmptyOptional(), readableData, offset);
 
     // Inference - event relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::ExecutionLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               readableData,
+                                               offset);
 
     // Event - event class relationship
-    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                           EmptyOptional(),
-                                           EmptyOptional(),
-                                           LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
-                                           readableData,
-                                           offset);
+    VerifyTimelineRelationshipBinaryPacketData(ProfilingRelationshipType::DataLink,
+                                               EmptyOptional(),
+                                               EmptyOptional(),
+                                               LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS,
+                                               readableData,
+                                               offset);
 
     bufferManager.MarkRead(inferenceReadableBuffer);
 }