diff --git a/src/profiling/LabelsAndEventClasses.cpp b/src/profiling/LabelsAndEventClasses.cpp
index a00562d..2424104 100644
--- a/src/profiling/LabelsAndEventClasses.cpp
+++ b/src/profiling/LabelsAndEventClasses.cpp
@@ -17,6 +17,7 @@
 std::string LabelsAndEventClasses::NAME_LABEL("name");
 std::string LabelsAndEventClasses::TYPE_LABEL("type");
 std::string LabelsAndEventClasses::INDEX_LABEL("index");
+std::string LabelsAndEventClasses::BACKENDID_LABEL("backendId");
 
 ProfilingStaticGuid LabelsAndEventClasses::NAME_GUID(
     m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::NAME_LABEL));
@@ -24,6 +25,23 @@
     m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::TYPE_LABEL));
 ProfilingStaticGuid LabelsAndEventClasses::INDEX_GUID(
     m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::INDEX_LABEL));
+ProfilingStaticGuid LabelsAndEventClasses::BACKENDID_GUID(
+    m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::BACKENDID_LABEL));
+
+// Common types
+std::string LabelsAndEventClasses::LAYER("layer");
+std::string LabelsAndEventClasses::WORKLOAD("workload");
+std::string LabelsAndEventClasses::NETWORK("network");
+std::string LabelsAndEventClasses::CONNECTION("connection");
+
+ProfilingStaticGuid LabelsAndEventClasses::LAYER_GUID(
+    m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::LAYER));
+ProfilingStaticGuid LabelsAndEventClasses::WORKLOAD_GUID(
+    m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::WORKLOAD));
+ProfilingStaticGuid LabelsAndEventClasses::NETWORK_GUID(
+    m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::NETWORK));
+ProfilingStaticGuid LabelsAndEventClasses::CONNECTION_GUID(
+    m_GuidGenerator.GenerateStaticId(LabelsAndEventClasses::CONNECTION));
 
 // Event Class GUIDs
 ProfilingStaticGuid LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS(
diff --git a/src/profiling/LabelsAndEventClasses.hpp b/src/profiling/LabelsAndEventClasses.hpp
index daa33ad..c2082dd 100644
--- a/src/profiling/LabelsAndEventClasses.hpp
+++ b/src/profiling/LabelsAndEventClasses.hpp
@@ -22,9 +22,21 @@
     static std::string NAME_LABEL;
     static std::string TYPE_LABEL;
     static std::string INDEX_LABEL;
+    static std::string BACKENDID_LABEL;
     static ProfilingStaticGuid NAME_GUID;
     static ProfilingStaticGuid TYPE_GUID;
     static ProfilingStaticGuid INDEX_GUID;
+    static ProfilingStaticGuid BACKENDID_GUID;
+
+    // Common types
+    static std::string LAYER;
+    static std::string WORKLOAD;
+    static std::string NETWORK;
+    static std::string CONNECTION;
+    static ProfilingStaticGuid LAYER_GUID;
+    static ProfilingStaticGuid WORKLOAD_GUID;
+    static ProfilingStaticGuid NETWORK_GUID;
+    static ProfilingStaticGuid CONNECTION_GUID;
 
     // Event Class GUIDs
     static ProfilingStaticGuid ARMNN_PROFILING_SOL_EVENT_CLASS;
diff --git a/src/profiling/ProfilingService.hpp b/src/profiling/ProfilingService.hpp
index 9fc642f..f9b057c 100644
--- a/src/profiling/ProfilingService.hpp
+++ b/src/profiling/ProfilingService.hpp
@@ -77,6 +77,9 @@
 
     std::unique_ptr<ISendTimelinePacket> GetSendTimelinePacket() const;
 
+    /// Check if the profiling is enabled
+    bool IsEnabled() { return m_Options.m_EnableProfiling; }
+
 private:
     // Copy/move constructors/destructors and copy/move assignment operators are deleted
     ProfilingService(const ProfilingService&) = delete;
@@ -201,6 +204,11 @@
     {
         return instance.m_SendCounterPacket.WaitForPacketSent(timeout);
     }
+
+    BufferManager& GetBufferManager(ProfilingService& instance)
+    {
+        return instance.m_BufferManager;
+    }
 };
 
 } // namespace profiling
diff --git a/src/profiling/TimelineUtilityMethods.cpp b/src/profiling/TimelineUtilityMethods.cpp
index c1ae610..d540c59 100644
--- a/src/profiling/TimelineUtilityMethods.cpp
+++ b/src/profiling/TimelineUtilityMethods.cpp
@@ -13,25 +13,60 @@
 namespace profiling
 {
 
+std::unique_ptr<TimelineUtilityMethods> TimelineUtilityMethods::GetTimelineUtils()
+{
+    if (ProfilingService::Instance().IsEnabled())
+    {
+        std::unique_ptr<ISendTimelinePacket> sendTimelinepacket = ProfilingService::Instance().GetSendTimelinePacket();
+        return std::make_unique<TimelineUtilityMethods>(sendTimelinepacket);
+    }
+    else
+    {
+        std::unique_ptr<TimelineUtilityMethods> empty;
+        return empty;
+    }
+}
+
+
 void TimelineUtilityMethods::SendWellKnownLabelsAndEventClasses()
 {
     // Send the "name" label, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::NAME_GUID,
-                                                       LabelsAndEventClasses::NAME_LABEL);
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(LabelsAndEventClasses::NAME_GUID,
+                                                        LabelsAndEventClasses::NAME_LABEL);
 
     // Send the "type" label, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::TYPE_GUID,
-                                                       LabelsAndEventClasses::TYPE_LABEL);
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(LabelsAndEventClasses::TYPE_GUID,
+                                                        LabelsAndEventClasses::TYPE_LABEL);
 
     // Send the "index" label, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineLabelBinaryPacket(LabelsAndEventClasses::INDEX_GUID,
-                                                       LabelsAndEventClasses::INDEX_LABEL);
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(LabelsAndEventClasses::INDEX_GUID,
+                                                        LabelsAndEventClasses::INDEX_LABEL);
+
+    // Send the "backendId" label, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(LabelsAndEventClasses::BACKENDID_GUID,
+                                                        LabelsAndEventClasses::BACKENDID_LABEL);
+
+    // Send the "layer" label, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(LabelsAndEventClasses::LAYER_GUID,
+                                                        LabelsAndEventClasses::LAYER);
+
+    // Send the "workload" label, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(LabelsAndEventClasses::WORKLOAD_GUID,
+                                                        LabelsAndEventClasses::WORKLOAD);
+
+    // Send the "network" label, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(LabelsAndEventClasses::NETWORK_GUID,
+                                                        LabelsAndEventClasses::NETWORK);
+
+    // Send the "connection" label, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(LabelsAndEventClasses::CONNECTION_GUID,
+                                                        LabelsAndEventClasses::CONNECTION);
 
     // Send the "start of life" event class, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS);
+    m_SendTimelinePacket->SendTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS);
 
     // Send the "end of life" event class, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS);
+    m_SendTimelinePacket->SendTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_EOL_EVENT_CLASS);
 }
 
 ProfilingDynamicGuid TimelineUtilityMethods::CreateNamedTypedEntity(const std::string& name, const std::string& type)
@@ -56,7 +91,7 @@
     return entityGuid;
 }
 
-void TimelineUtilityMethods::CreateNamedTypedEntity(ProfilingDynamicGuid entityGuid,
+void TimelineUtilityMethods::CreateNamedTypedEntity(ProfilingGuid entityGuid,
                                                     const std::string& name,
                                                     const std::string& type)
 {
@@ -73,7 +108,7 @@
     }
 
     // Send Entity Binary Packet of the entity to the external profiling service
-    m_SendTimelinePacket.SendTimelineEntityBinaryPacket(entityGuid);
+    m_SendTimelinePacket->SendTimelineEntityBinaryPacket(entityGuid);
 
     // Create name entity and send the relationship of the entity with the given name
     NameEntity(entityGuid, name);
@@ -82,6 +117,26 @@
     TypeEntity(entityGuid, type);
 }
 
+void TimelineUtilityMethods::CreateNamedTypedEntity(ProfilingGuid entityGuid,
+                                                    const std::string& name,
+                                                    ProfilingStaticGuid typeGuid)
+{
+    // Check that the entity name is valid
+    if (name.empty())
+    {
+        throw InvalidArgumentException("Invalid entity name, the entity name cannot be empty");
+    }
+
+    // Send Entity Binary Packet of the entity to the external profiling service
+    m_SendTimelinePacket->SendTimelineEntityBinaryPacket(entityGuid);
+
+    // Create name entity and send the relationship of the entity with the given name
+    NameEntity(entityGuid, name);
+
+    // Create type entity and send the relationship of the entity with the given type
+    MarkEntityWithType(entityGuid, typeGuid);
+}
+
 ProfilingStaticGuid TimelineUtilityMethods::DeclareLabel(const std::string& labelName)
 {
     // Check that the label name is valid
@@ -95,52 +150,74 @@
     ProfilingStaticGuid labelGuid = ProfilingService::Instance().GenerateStaticId(labelName);
 
     // Send the new label to the external profiling service, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineLabelBinaryPacket(labelGuid, labelName);
+    m_SendTimelinePacket->SendTimelineLabelBinaryPacket(labelGuid, labelName);
 
     return labelGuid;
 }
 
-void TimelineUtilityMethods::CreateTypedLabel(ProfilingGuid entityGuid,
-                                              const std::string& entityName,
-                                              ProfilingStaticGuid labelTypeGuid)
+void TimelineUtilityMethods::MarkEntityWithLabel(ProfilingGuid entityGuid,
+                                                 const std::string& labelName,
+                                                 ProfilingStaticGuid labelTypeGuid)
 {
-    // Check that the entity name is valid
-    if (entityName.empty())
+    // Check that the label name is valid
+    if (labelName.empty())
     {
-        // The entity name is invalid
+        // The label name is invalid
         throw InvalidArgumentException("Invalid entity name, the entity name cannot be empty");
     }
 
-    // Declare a label with the entity's name, this call throws in case of error
-    ProfilingStaticGuid labelGuid = DeclareLabel(entityName);
+    // Declare a label with the label's name, this call throws in case of error
+    ProfilingStaticGuid labelGuid = DeclareLabel(labelName);
 
     // Generate a GUID for the label relationship
     ProfilingDynamicGuid relationshipGuid = ProfilingService::Instance().NextGuid();
 
     // Send the new label link to the external profiling service, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                                              relationshipGuid,
-                                                              entityGuid,
-                                                              labelGuid);
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                                               relationshipGuid,
+                                                               entityGuid,
+                                                               labelGuid);
 
     // Generate a GUID for the label relationship
     ProfilingDynamicGuid relationshipLabelGuid = ProfilingService::Instance().NextGuid();
 
     // Send the new label link to the external profiling service, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
-                                                              relationshipLabelGuid,
-                                                              relationshipGuid,
-                                                              labelTypeGuid);
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                                               relationshipLabelGuid,
+                                                               relationshipGuid,
+                                                               labelTypeGuid);
+}
+
+void TimelineUtilityMethods::MarkEntityWithType(ProfilingGuid entityGuid,
+                                                ProfilingStaticGuid typeNameGuid)
+{
+    // Generate a GUID for the label relationship
+    ProfilingDynamicGuid relationshipGuid = ProfilingService::Instance().NextGuid();
+
+    // Send the new label link to the external profiling service, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                                               relationshipGuid,
+                                                               entityGuid,
+                                                               typeNameGuid);
+
+    // Generate a GUID for the label relationship
+    ProfilingDynamicGuid relationshipLabelGuid = ProfilingService::Instance().NextGuid();
+
+    // Send the new label link to the external profiling service, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                                               relationshipLabelGuid,
+                                                               relationshipGuid,
+                                                               LabelsAndEventClasses::TYPE_GUID);
 }
 
 void TimelineUtilityMethods::NameEntity(ProfilingGuid entityGuid, const std::string& name)
 {
-    CreateTypedLabel(entityGuid, name, LabelsAndEventClasses::NAME_GUID);
+    MarkEntityWithLabel(entityGuid, name, LabelsAndEventClasses::NAME_GUID);
 }
 
 void TimelineUtilityMethods::TypeEntity(ProfilingGuid entityGuid, const std::string& type)
 {
-    CreateTypedLabel(entityGuid, type, LabelsAndEventClasses::TYPE_GUID);
+    MarkEntityWithLabel(entityGuid, type, LabelsAndEventClasses::TYPE_GUID);
 }
 
 ProfilingDynamicGuid TimelineUtilityMethods::CreateNamedTypedChildEntity(ProfilingGuid parentEntityGuid,
@@ -168,15 +245,15 @@
     ProfilingDynamicGuid retentionLinkGuid = ProfilingService::Instance().NextGuid();
 
     // Send the new retention link to the external profiling service, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                                              retentionLinkGuid,
-                                                              parentEntityGuid,
-                                                              childEntityGuid);
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                                               retentionLinkGuid,
+                                                               parentEntityGuid,
+                                                               childEntityGuid);
 
     return childEntityGuid;
 }
 
-void TimelineUtilityMethods::CreateNamedTypedChildEntity(ProfilingDynamicGuid childEntityGuid,
+void TimelineUtilityMethods::CreateNamedTypedChildEntity(ProfilingGuid childEntityGuid,
                                                          ProfilingGuid parentEntityGuid,
                                                          const std::string& entityName,
                                                          const std::string& entityType)
@@ -202,10 +279,76 @@
     ProfilingDynamicGuid retentionLinkGuid = ProfilingService::Instance().NextGuid();
 
     // Send the new retention link to the external profiling service, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
-                                                              retentionLinkGuid,
-                                                              parentEntityGuid,
-                                                              childEntityGuid);
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                                               retentionLinkGuid,
+                                                               parentEntityGuid,
+                                                               childEntityGuid);
+}
+
+void TimelineUtilityMethods::CreateNamedTypedChildEntity(ProfilingGuid childEntityGuid,
+                                                         ProfilingGuid parentEntityGuid,
+                                                         const std::string& entityName,
+                                                         ProfilingStaticGuid typeGuid)
+{
+    // Check that the entity name is valid
+    if (entityName.empty())
+    {
+        // The entity name is invalid
+        throw InvalidArgumentException("Invalid entity name, the entity name cannot be empty");
+    }
+
+    // Create a named type entity from the given guid, name and type, this call throws in case of error
+    CreateNamedTypedEntity(childEntityGuid, entityName, typeGuid);
+
+    // Generate a GUID for the retention link relationship
+    ProfilingDynamicGuid retentionLinkGuid = ProfilingService::Instance().NextGuid();
+
+    // Send the new retention link to the external profiling service, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                                               retentionLinkGuid,
+                                                               parentEntityGuid,
+                                                               childEntityGuid);
+}
+
+ProfilingDynamicGuid TimelineUtilityMethods::CreateRelationship(ProfilingRelationshipType relationshipType,
+                                                                ProfilingGuid headGuid,
+                                                                ProfilingGuid tailGuid)
+{
+    // Generate a GUID for the relationship
+    ProfilingDynamicGuid relationshipGuid = ProfilingService::Instance().NextGuid();
+
+    // Send the new retention link to the external profiling service, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(relationshipType,
+                                                               relationshipGuid,
+                                                               headGuid,
+                                                               tailGuid);
+    return relationshipGuid;
+}
+
+ProfilingDynamicGuid TimelineUtilityMethods::CreateConnectionRelationship(ProfilingRelationshipType relationshipType,
+                                                                          ProfilingGuid headGuid,
+                                                                          ProfilingGuid tailGuid)
+{
+    // Generate a GUID for the relationship
+    ProfilingDynamicGuid relationshipGuid = ProfilingService::Instance().NextGuid();
+
+    // Send the new retention link to the external profiling service, this call throws in case of error
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(relationshipType,
+                                                               relationshipGuid,
+                                                               headGuid,
+                                                               tailGuid);
+
+    MarkEntityWithType(relationshipGuid, LabelsAndEventClasses::CONNECTION_GUID);
+    return relationshipGuid;
+}
+
+void TimelineUtilityMethods::CreateTypedEntity(ProfilingGuid entityGuid, ProfilingStaticGuid entityTypeGuid)
+{
+    // Send Entity Binary Packet of the entity to the external profiling service
+    m_SendTimelinePacket->SendTimelineEntityBinaryPacket(entityGuid);
+
+    // Create type entity and send the relationship of the entity with the given type
+    MarkEntityWithType(entityGuid, entityTypeGuid);
 }
 
 ProfilingDynamicGuid TimelineUtilityMethods::RecordEvent(ProfilingGuid entityGuid, ProfilingStaticGuid eventClassGuid)
@@ -220,25 +363,25 @@
     ProfilingDynamicGuid eventGuid = ProfilingService::Instance().NextGuid();
 
     // Send the new timeline event to the external profiling service, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineEventBinaryPacket(timestamp, threadId, eventGuid);
+    m_SendTimelinePacket->SendTimelineEventBinaryPacket(timestamp, threadId, eventGuid);
 
     // Generate a GUID for the execution link
     ProfilingDynamicGuid executionLinkId = ProfilingService::Instance().NextGuid();
 
     // Send the new execution link to the external profiling service, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
-                                                              executionLinkId,
-                                                              entityGuid,
-                                                              eventGuid);
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::ExecutionLink,
+                                                               executionLinkId,
+                                                               entityGuid,
+                                                               eventGuid);
 
     // Generate a GUID for the data relationship link
     ProfilingDynamicGuid eventClassLinkId = ProfilingService::Instance().NextGuid();
 
     // Send the new data relationship link to the external profiling service, this call throws in case of error
-    m_SendTimelinePacket.SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
-                                                              eventClassLinkId,
-                                                              entityGuid,
-                                                              eventClassGuid);
+    m_SendTimelinePacket->SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
+                                                               eventClassLinkId,
+                                                               eventGuid,
+                                                               eventClassGuid);
 
     return eventGuid;
 }
diff --git a/src/profiling/TimelineUtilityMethods.hpp b/src/profiling/TimelineUtilityMethods.hpp
index 3683ed3..8e07161 100644
--- a/src/profiling/TimelineUtilityMethods.hpp
+++ b/src/profiling/TimelineUtilityMethods.hpp
@@ -17,18 +17,34 @@
 class TimelineUtilityMethods
 {
 public:
-    TimelineUtilityMethods(ISendTimelinePacket& sendTimelinePacket)
-        : m_SendTimelinePacket(sendTimelinePacket)
-    {}
+
+    // static factory method which will return a pointer to a timelie utility methods
+    // object if profiling is enabled. Otherwise will return a null unique_ptr
+    static std::unique_ptr<TimelineUtilityMethods> GetTimelineUtils();
+
+    TimelineUtilityMethods(std::unique_ptr<ISendTimelinePacket>& sendTimelinePacket)
+        : m_SendTimelinePacket(std::move(sendTimelinePacket)) {}
+
+    TimelineUtilityMethods(TimelineUtilityMethods&& other)
+        : m_SendTimelinePacket(std::move(other.m_SendTimelinePacket)) {}
+
+    TimelineUtilityMethods(const TimelineUtilityMethods& other) = delete;
+
+    TimelineUtilityMethods& operator=(const TimelineUtilityMethods& other) = delete;
+
+    TimelineUtilityMethods& operator=(TimelineUtilityMethods&& other) = default;
+
     ~TimelineUtilityMethods() = default;
 
     void SendWellKnownLabelsAndEventClasses();
 
     ProfilingDynamicGuid CreateNamedTypedEntity(const std::string& name, const std::string& type);
 
-    void CreateNamedTypedEntity(ProfilingDynamicGuid entityGuid, const std::string& name, const std::string& type);
+    void CreateNamedTypedEntity(ProfilingGuid entityGuid, const std::string& name, const std::string& type);
 
-    void CreateTypedLabel(ProfilingGuid entityGuid, const std::string& entityName, ProfilingStaticGuid labelTypeGuid);
+    void CreateNamedTypedEntity(ProfilingGuid entityGuid, const std::string& name, ProfilingStaticGuid typeGuid);
+
+    void MarkEntityWithLabel(ProfilingGuid entityGuid, const std::string &labelName, ProfilingStaticGuid labelLinkGuid);
 
     ProfilingStaticGuid DeclareLabel(const std::string& labelName);
 
@@ -40,15 +56,34 @@
                                                      const std::string& entityName,
                                                      const std::string& entityType);
 
-    void CreateNamedTypedChildEntity(ProfilingDynamicGuid entityGuid,
+    void CreateNamedTypedChildEntity(ProfilingGuid entityGuid,
                                      ProfilingGuid parentEntityGuid,
                                      const std::string& entityName,
                                      const std::string& entityType);
 
+    void CreateNamedTypedChildEntity(ProfilingGuid entityGuid,
+                                     ProfilingGuid parentEntityGuid,
+                                     const std::string& entityName,
+                                     ProfilingStaticGuid typeGuid);
+
+    ProfilingDynamicGuid CreateRelationship(ProfilingRelationshipType relationshipType,
+                                            ProfilingGuid headGuid,
+                                            ProfilingGuid tailGuid);
+
+    ProfilingDynamicGuid CreateConnectionRelationship(ProfilingRelationshipType relationshipType,
+                                                      ProfilingGuid headGuid,
+                                                      ProfilingGuid tailGuid);
+
+    void CreateTypedEntity(ProfilingGuid entityGuid, ProfilingStaticGuid typeGuid);
+
+    void MarkEntityWithType(ProfilingGuid entityGuid, ProfilingStaticGuid typeNameGuid);
+
     ProfilingDynamicGuid RecordEvent(ProfilingGuid entityGuid, ProfilingStaticGuid eventClassGuid);
 
+    void Commit() { m_SendTimelinePacket->Commit(); }
+
 private:
-    ISendTimelinePacket& m_SendTimelinePacket;
+    std::unique_ptr<ISendTimelinePacket> m_SendTimelinePacket;
 };
 
 } // namespace profiling
diff --git a/src/profiling/test/ProfilingTestUtils.cpp b/src/profiling/test/ProfilingTestUtils.cpp
new file mode 100644
index 0000000..7f18ef3
--- /dev/null
+++ b/src/profiling/test/ProfilingTestUtils.cpp
@@ -0,0 +1,818 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ProfilingTestUtils.hpp"
+#include "ProfilingUtils.hpp"
+
+#include <armnn/Descriptors.hpp>
+#include <LabelsAndEventClasses.hpp>
+#include <ProfilingService.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+inline unsigned int OffsetToNextWord(unsigned int numberOfBytes)
+{
+    unsigned int uint32_t_size = sizeof(uint32_t);
+
+    unsigned int remainder = numberOfBytes % uint32_t_size;
+    if (remainder == 0)
+    {
+        return numberOfBytes;
+    }
+
+    return numberOfBytes + uint32_t_size - remainder;
+}
+
+void VerifyTimelineLabelBinaryPacket(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 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     == 16 + OffsetToNextWord(label_size + 1));
+
+    // Check the decl id
+    offset += uint32_t_size;
+    uint32_t eventClassDeclId = ReadUint32(readableData, offset);
+    BOOST_CHECK(eventClassDeclId == 0);
+
+    // Check the profiling GUID
+    offset += uint32_t_size;
+    uint64_t readProfilingGuid = ReadUint64(readableData, offset);
+    if (guid.has_value())
+    {
+        BOOST_CHECK(readProfilingGuid == guid.value());
+    }
+    else
+    {
+        BOOST_CHECK(readProfilingGuid == ProfilingService::Instance().GenerateStaticId(label));
+    }
+
+    // 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
+    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
+
+    // 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)
+{
+    BOOST_ASSERT(readableData);
+
+    // Utils
+    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);
+
+    // Check the profiling GUID
+    offset += uint32_t_size;
+    uint64_t readProfilingGuid = ReadUint64(readableData, offset);
+    BOOST_CHECK(readProfilingGuid == guid);
+
+    // Update the offset to allow parsing to be continued after this function returns
+    offset += uint64_t_size;
+}
+
+void VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType relationshipType,
+                                            Optional<ProfilingGuid> relationshipGuid,
+                                            Optional<ProfilingGuid> headGuid,
+                                            Optional<ProfilingGuid> tailGuid,
+                                            const unsigned char* readableData,
+                                            unsigned int& offset)
+{
+    BOOST_ASSERT(readableData);
+
+    uint32_t relationshipTypeUint = 0;
+    switch (relationshipType)
+    {
+        case ProfilingRelationshipType::RetentionLink:
+            relationshipTypeUint = 0;
+            break;
+        case ProfilingRelationshipType::ExecutionLink:
+            relationshipTypeUint = 1;
+            break;
+        case ProfilingRelationshipType::DataLink:
+            relationshipTypeUint = 2;
+            break;
+        case ProfilingRelationshipType::LabelLink:
+            relationshipTypeUint = 3;
+            break;
+        default:
+            BOOST_ERROR("Unknown relationship type");
+    }
+
+    // Utils
+    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);
+
+    // Check the relationship type
+    offset += uint32_t_size;
+    uint32_t readRelationshipTypeUint = ReadUint32(readableData, offset);
+    BOOST_CHECK(readRelationshipTypeUint == relationshipTypeUint);
+
+    // Check the relationship GUID
+    offset += uint32_t_size;
+    uint64_t readRelationshipGuid = ReadUint64(readableData, offset);
+    if (relationshipGuid.has_value())
+    {
+        BOOST_CHECK(readRelationshipGuid == relationshipGuid.value());
+    }
+    else
+    {
+        BOOST_CHECK(readRelationshipGuid != ProfilingGuid(0));
+    }
+
+    // Check the head of relationship GUID
+    offset += uint64_t_size;
+    uint64_t readHeadRelationshipGuid = ReadUint64(readableData, offset);
+    if (headGuid.has_value())
+    {
+        BOOST_CHECK(readHeadRelationshipGuid == headGuid.value());
+    }
+    else
+    {
+        BOOST_CHECK(readHeadRelationshipGuid != ProfilingGuid(0));
+    }
+
+    // Check the tail of relationship GUID
+    offset += uint64_t_size;
+    uint64_t readTailRelationshipGuid = ReadUint64(readableData, offset);
+    if (tailGuid.has_value())
+    {
+        BOOST_CHECK(readTailRelationshipGuid == tailGuid.value());
+    }
+    else
+    {
+        BOOST_CHECK(readTailRelationshipGuid != ProfilingGuid(0));
+    }
+
+    // Update the offset to allow parsing to be continued after this function returns
+    offset += uint64_t_size;
+}
+
+void VerifyTimelineEntityBinaryPacket(Optional<ProfilingGuid> guid,
+                                      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);
+
+    // 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);
+
+    // Check the profiling GUID
+    offset += uint32_t_size;
+    uint64_t readProfilingGuid = ReadUint64(readableData, offset);
+
+    if (guid.has_value())
+    {
+        BOOST_CHECK(readProfilingGuid == guid.value());
+    }
+    else
+    {
+        BOOST_CHECK(readProfilingGuid != ProfilingGuid(0));
+    }
+
+    offset += uint64_t_size;
+}
+
+void VerifyTimelineEventBinaryPacket(Optional<uint64_t> timestamp,
+                                     Optional<std::thread::id> threadId,
+                                     Optional<ProfilingGuid> eventGuid,
+                                     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 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);
+
+    // Check the timestamp
+    offset += uint32_t_size;
+    uint64_t readTimestamp = ReadUint64(readableData, offset);
+    if (timestamp.has_value())
+    {
+        BOOST_CHECK(readTimestamp == timestamp.value());
+    }
+    else
+    {
+        BOOST_CHECK(readTimestamp != 0);
+    }
+
+    // Check the thread id
+    offset += uint64_t_size;
+    std::vector<uint8_t> readThreadId(threadId_size, 0);
+    ReadBytes(readableData, offset, threadId_size, readThreadId.data());
+    if (threadId.has_value())
+    {
+        BOOST_CHECK(readThreadId == threadId.value());
+    }
+    else
+    {
+        BOOST_CHECK(readThreadId == std::this_thread::get_id());
+    }
+
+    // Check the event GUID
+    offset += threadId_size;
+    uint64_t readEventGuid = ReadUint64(readableData, offset);
+    if (eventGuid.has_value())
+    {
+        BOOST_CHECK(readEventGuid == eventGuid.value());
+    }
+    else
+    {
+        BOOST_CHECK(readEventGuid != ProfilingGuid(0));
+    }
+
+    offset += uint64_t_size;
+}
+
+void VerifyPostOptimisationStructureTestImpl(armnn::BackendId backendId)
+{
+    using namespace armnn;
+
+    // Create runtime in which test will run
+    armnn::IRuntime::CreationOptions options;
+    options.m_ProfilingOptions.m_EnableProfiling = true;
+    armnn::IRuntimePtr runtime(armnn::IRuntime::Create(options));
+
+    // build up the structure of the network
+    INetworkPtr net(INetwork::Create());
+
+    // Convolution details
+    TensorInfo inputInfo({ 1, 2, 5, 1 }, DataType::Float32);
+    TensorInfo weightInfo({ 3, 2, 3, 1}, DataType::Float32);
+    TensorInfo biasInfo({ 3 }, 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,
+
+            0.0f,  0.0f,  0.0f,
+            0.2f,  0.2f,  0.2f,
+
+            0.5f,  0.0f,  0.5f,
+            0.0f, -1.0f,  0.0f
+    };
+    ConstTensor weights(weightInfo, weightsData);
+
+    Optional<ConstTensor> optionalBiases;
+    std::vector<float> biasesData{ 1.0f, 0.0f, 0.0f };
+    ConstTensor biases(biasInfo, biasesData);
+    optionalBiases = Optional<ConstTensor>(biases);
+
+    // Input layer
+    IConnectableLayer* input = net->AddInputLayer(0, "input");
+
+    // Convolution2d layer
+    Convolution2dDescriptor conv2dDesc;
+    conv2dDesc.m_StrideX  = 1;
+    conv2dDesc.m_StrideY  = 1;
+    conv2dDesc.m_PadLeft = 0;
+    conv2dDesc.m_PadRight = 0;
+    conv2dDesc.m_PadTop = 2;
+    conv2dDesc.m_PadBottom = 2;
+    conv2dDesc.m_BiasEnabled = true;
+    IConnectableLayer* conv2d = net->AddConvolution2dLayer(conv2dDesc, weights, optionalBiases);
+
+    // Activation layer
+    armnn::ActivationDescriptor activationDesc;
+    armnn::IConnectableLayer* const activation = net->AddActivationLayer(activationDesc, "activation");
+
+    // Output layer
+    IConnectableLayer* output = net->AddOutputLayer(0, "output");
+
+    input->GetOutputSlot(0).Connect(conv2d->GetInputSlot(0));
+    conv2d->GetOutputSlot(0).Connect(activation->GetInputSlot(0));
+    activation->GetOutputSlot(0).Connect(output->GetInputSlot(0));
+
+    input->GetOutputSlot(0).SetTensorInfo(inputInfo);
+    conv2d->GetOutputSlot(0).SetTensorInfo(outputInfo);
+    activation->GetOutputSlot(0).SetTensorInfo(outputInfo);
+
+    // optimize the network
+    std::vector<armnn::BackendId> backends = { backendId };
+    IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime->GetDeviceSpec());
+
+    ProfilingGuid optNetGuid = optNet->GetGuid();
+
+    // Load it into the runtime. It should success.
+    armnn::NetworkId netId;
+    BOOST_TEST(runtime->LoadNetwork(netId, std::move(optNet)) == Status::Success);
+
+    profiling::ProfilingServiceRuntimeHelper profilingServiceHelper;
+    profiling::BufferManager& bufferManager = profilingServiceHelper.GetProfilingBufferManager();
+    auto readableBuffer = bufferManager.GetReadableBuffer();
+
+    // Profiling is enable, the post-optimisation structure should be created
+    BOOST_CHECK(readableBuffer != nullptr);
+
+    unsigned int size = readableBuffer->GetSize();
+    BOOST_CHECK(size == 1980);
+
+    const unsigned char* readableData = readableBuffer->GetReadableData();
+    BOOST_CHECK(readableData != nullptr);
+
+    unsigned int offset = 0;
+
+    // Post-optimisation network
+    // Network entity
+    VerifyTimelineEntityBinaryPacket(optNetGuid, readableData, offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           optNetGuid,
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // Input layer
+    // Input layer entity
+    VerifyTimelineEntityBinaryPacket(input->GetGuid(), readableData, offset);
+
+    // Name Entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "input", readableData, offset);
+
+    // Entity - Name relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           input->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Name label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::NAME_GUID,
+                                           readableData,
+                                           offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           input->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // Network - Input layer relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           optNetGuid,
+                                           input->GetGuid(),
+                                           readableData,
+                                           offset);
+
+    // Conv2d layer
+    // Conv2d layer entity
+    VerifyTimelineEntityBinaryPacket(conv2d->GetGuid(), readableData, offset);
+
+    // Name entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "<Unnamed>", readableData, offset);
+
+    // Entity - Name relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           conv2d->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Name label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::NAME_GUID,
+                                           readableData,
+                                           offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           conv2d->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // Network - Conv2d layer relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           optNetGuid,
+                                           conv2d->GetGuid(),
+                                           readableData,
+                                           offset);
+
+    // Input layer - Conv2d layer relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           input->GetGuid(),
+                                           conv2d->GetGuid(),
+                                           readableData,
+                                           offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::CONNECTION_GUID,
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // Conv2d workload
+    // Conv2d workload entity
+    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // BackendId entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), backendId.Get(), readableData, offset);
+
+    // Entity - BackendId relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // BackendId label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::BACKENDID_GUID,
+                                           readableData,
+                                           offset);
+
+    // Conv2d layer - Conv2d workload relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           conv2d->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Activation layer
+    // Activation layer entity
+    VerifyTimelineEntityBinaryPacket(activation->GetGuid(), readableData, offset);
+
+    // Name entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "activation", readableData, offset);
+
+    // Entity - Name relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           activation->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Name label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::NAME_GUID,
+                                           readableData,
+                                           offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           activation->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // Network - Activation layer relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           optNetGuid,
+                                           activation->GetGuid(),
+                                           readableData,
+                                           offset);
+
+    // Conv2d layer - Activation layer relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           conv2d->GetGuid(),
+                                           activation->GetGuid(),
+                                           readableData,
+                                           offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::CONNECTION_GUID,
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // Activation workload
+    // Activation workload entity
+    VerifyTimelineEntityBinaryPacket(EmptyOptional(), readableData, offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // BackendId entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), backendId.Get(), readableData, offset);
+
+    // Entity - BackendId relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // BackendId label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::BACKENDID_GUID,
+                                           readableData,
+                                           offset);
+
+    // Activation layer - Activation workload relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           activation->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Output layer
+    // Output layer entity
+    VerifyTimelineEntityBinaryPacket(output->GetGuid(), readableData, offset);
+
+    // Name entity
+    VerifyTimelineLabelBinaryPacket(EmptyOptional(), "output", readableData, offset);
+
+    // Entity - Name relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           output->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Name label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::NAME_GUID,
+                                           readableData,
+                                           offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           output->GetGuid(),
+                                           EmptyOptional(),
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    // Network - Output layer relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           optNetGuid,
+                                           output->GetGuid(),
+                                           readableData,
+                                           offset);
+
+    // Activation layer - Output layer relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::RetentionLink,
+                                           EmptyOptional(),
+                                           activation->GetGuid(),
+                                           output->GetGuid(),
+                                           readableData,
+                                           offset);
+
+    // Entity - Type relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::CONNECTION_GUID,
+                                           readableData,
+                                           offset);
+
+    // Type label relationship
+    VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::LabelLink,
+                                           EmptyOptional(),
+                                           EmptyOptional(),
+                                           LabelsAndEventClasses::TYPE_GUID,
+                                           readableData,
+                                           offset);
+
+    bufferManager.MarkRead(readableBuffer);
+}
diff --git a/src/profiling/test/ProfilingTestUtils.hpp b/src/profiling/test/ProfilingTestUtils.hpp
new file mode 100644
index 0000000..7fb5d62
--- /dev/null
+++ b/src/profiling/test/ProfilingTestUtils.hpp
@@ -0,0 +1,70 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "ProfilingUtils.hpp"
+
+#include <armnn/BackendId.hpp>
+#include <armnn/Optional.hpp>
+#include <armnn/Types.hpp>
+#include <BufferManager.hpp>
+#include <ProfilingService.hpp>
+
+using namespace armnn;
+using namespace armnn::profiling;
+
+inline unsigned int OffsetToNextWord(unsigned int numberOfBytes);
+
+void VerifyTimelineLabelBinaryPacket(Optional<ProfilingGuid> guid,
+                                     const std::string& label,
+                                     const unsigned char* readableData,
+                                     unsigned int& offset);
+
+void VerifyTimelineEventClassBinaryPacket(ProfilingGuid guid,
+                                          const unsigned char* readableData,
+                                          unsigned int& offset);
+
+void VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType relationshipType,
+                                            Optional<ProfilingGuid> relationshipGuid,
+                                            Optional<ProfilingGuid> headGuid,
+                                            Optional<ProfilingGuid> tailGuid,
+                                            const unsigned char* readableData,
+                                            unsigned int& offset);
+
+void VerifyTimelineEntityBinaryPacket(Optional<ProfilingGuid> guid,
+                                      const unsigned char* readableData,
+                                      unsigned int& offset);
+
+void VerifyTimelineEventBinaryPacket(Optional<uint64_t> timestamp,
+                                     Optional<std::thread::id> threadId,
+                                     Optional<ProfilingGuid> eventGuid,
+                                     const unsigned char* readableData,
+                                     unsigned int& offset);
+
+void VerifyPostOptimisationStructureTestImpl(armnn::BackendId backendId);
+
+namespace armnn
+{
+
+namespace profiling
+{
+
+class ProfilingServiceRuntimeHelper : public ProfilingService
+{
+public:
+    ProfilingServiceRuntimeHelper() = default;
+    ~ProfilingServiceRuntimeHelper() = default;
+
+    BufferManager& GetProfilingBufferManager()
+    {
+        return GetBufferManager(ProfilingService::Instance());
+    }
+};
+
+} // namespace profiling
+
+} // namespace armnn
+
diff --git a/src/profiling/test/TimelineUtilityMethodsTests.cpp b/src/profiling/test/TimelineUtilityMethodsTests.cpp
index 7d1a7c1..ae1ee55 100644
--- a/src/profiling/test/TimelineUtilityMethodsTests.cpp
+++ b/src/profiling/test/TimelineUtilityMethodsTests.cpp
@@ -4,368 +4,26 @@
 //
 
 #include "SendCounterPacketTests.hpp"
+#include "ProfilingTestUtils.hpp"
 
 #include <SendTimelinePacket.hpp>
 #include <TimelineUtilityMethods.hpp>
 #include <LabelsAndEventClasses.hpp>
 #include <ProfilingService.hpp>
 
+#include <memory>
+
 #include <boost/test/unit_test.hpp>
 
 using namespace armnn;
 using namespace armnn::profiling;
 
-namespace
-{
-
-inline unsigned int OffsetToNextWord(unsigned int numberOfBytes)
-{
-    unsigned int uint32_t_size = sizeof(uint32_t);
-
-    unsigned int remainder = numberOfBytes % uint32_t_size;
-    if (remainder == 0)
-    {
-        return numberOfBytes;
-    }
-
-    return numberOfBytes + uint32_t_size - remainder;
-}
-
-void VerifyTimelineLabelBinaryPacket(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 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     == 16 + OffsetToNextWord(label_size + 1));
-
-    // Check the decl id
-    offset += uint32_t_size;
-    uint32_t eventClassDeclId = ReadUint32(readableData, offset);
-    BOOST_CHECK(eventClassDeclId == 0);
-
-    // Check the profiling GUID
-    offset += uint32_t_size;
-    uint64_t readProfilingGuid = ReadUint64(readableData, offset);
-    if (guid.has_value())
-    {
-        BOOST_CHECK(readProfilingGuid == guid.value());
-    }
-    else
-    {
-        BOOST_CHECK(readProfilingGuid == ProfilingService::Instance().GenerateStaticId(label));
-    }
-
-    // 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
-    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
-
-    // 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)
-{
-    BOOST_ASSERT(readableData);
-
-    // Utils
-    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);
-
-    // Check the profiling GUID
-    offset += uint32_t_size;
-    uint64_t readProfilingGuid = ReadUint64(readableData, offset);
-    BOOST_CHECK(readProfilingGuid == guid);
-
-    // Update the offset to allow parsing to be continued after this function returns
-    offset += uint64_t_size;
-}
-
-void VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType relationshipType,
-                                            Optional<ProfilingGuid> relationshipGuid,
-                                            Optional<ProfilingGuid> headGuid,
-                                            Optional<ProfilingGuid> tailGuid,
-                                            const unsigned char* readableData,
-                                            unsigned int& offset)
-{
-    BOOST_ASSERT(readableData);
-
-    uint32_t relationshipTypeUint = 0;
-    switch (relationshipType)
-    {
-        case ProfilingRelationshipType::RetentionLink:
-            relationshipTypeUint = 0;
-            break;
-        case ProfilingRelationshipType::ExecutionLink:
-            relationshipTypeUint = 1;
-            break;
-        case ProfilingRelationshipType::DataLink:
-            relationshipTypeUint = 2;
-            break;
-        case ProfilingRelationshipType::LabelLink:
-            relationshipTypeUint = 3;
-            break;
-        default:
-            BOOST_ERROR("Unknown relationship type");
-    }
-
-    // Utils
-    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);
-
-    // Check the relationship type
-    offset += uint32_t_size;
-    uint32_t readRelationshipTypeUint = ReadUint32(readableData, offset);
-    BOOST_CHECK(readRelationshipTypeUint == relationshipTypeUint);
-
-    // Check the relationship GUID
-    offset += uint32_t_size;
-    uint64_t readRelationshipGuid = ReadUint64(readableData, offset);
-    if (relationshipGuid.has_value())
-    {
-        BOOST_CHECK(readRelationshipGuid == relationshipGuid.value());
-    }
-    else
-    {
-        BOOST_CHECK(readRelationshipGuid != ProfilingGuid(0));
-    }
-
-    // Check the head of relationship GUID
-    offset += uint64_t_size;
-    uint64_t readHeadRelationshipGuid = ReadUint64(readableData, offset);
-    if (headGuid.has_value())
-    {
-        BOOST_CHECK(readHeadRelationshipGuid == headGuid.value());
-    }
-    else
-    {
-        BOOST_CHECK(readHeadRelationshipGuid != ProfilingGuid(0));
-    }
-
-    // Check the tail of relationship GUID
-    offset += uint64_t_size;
-    uint64_t readTailRelationshipGuid = ReadUint64(readableData, offset);
-    if (tailGuid.has_value())
-    {
-        BOOST_CHECK(readTailRelationshipGuid == tailGuid.value());
-    }
-    else
-    {
-        BOOST_CHECK(readTailRelationshipGuid != ProfilingGuid(0));
-    }
-
-    // Update the offset to allow parsing to be continued after this function returns
-    offset += uint64_t_size;
-}
-
-void VerifyTimelineEntityBinaryPacket(Optional<ProfilingGuid> guid,
-                                      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);
-
-    // 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);
-
-    // Check the profiling GUID
-    offset += uint32_t_size;
-    uint64_t readProfilingGuid = ReadUint64(readableData, offset);
-
-    if (guid.has_value())
-    {
-        BOOST_CHECK(readProfilingGuid == guid.value());
-    }
-    else
-    {
-        BOOST_CHECK(readProfilingGuid != ProfilingGuid(0));
-    }
-
-    offset += uint64_t_size;
-}
-
-void VerifyTimelineEventBinaryPacket(Optional<uint64_t> timestamp,
-                                     Optional<std::thread::id> threadId,
-                                     Optional<ProfilingGuid> eventGuid,
-                                     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 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);
-
-    // Check the timestamp
-    offset += uint32_t_size;
-    uint64_t readTimestamp = ReadUint64(readableData, offset);
-    if (timestamp.has_value())
-    {
-        BOOST_CHECK(readTimestamp == timestamp.value());
-    }
-    else
-    {
-        BOOST_CHECK(readTimestamp != 0);
-    }
-
-    // Check the thread id
-    offset += uint64_t_size;
-    std::vector<uint8_t> readThreadId(threadId_size, 0);
-    ReadBytes(readableData, offset, threadId_size, readThreadId.data());
-    if (threadId.has_value())
-    {
-        BOOST_CHECK(readThreadId == threadId.value());
-    }
-    else
-    {
-        BOOST_CHECK(readThreadId == std::this_thread::get_id());
-    }
-
-    // Check the event GUID
-    offset += threadId_size;
-    uint64_t readEventGuid = ReadUint64(readableData, offset);
-    if (eventGuid.has_value())
-    {
-        BOOST_CHECK(readEventGuid == eventGuid.value());
-    }
-    else
-    {
-        BOOST_CHECK(readEventGuid != ProfilingGuid(0));
-    }
-
-    offset += uint64_t_size;
-}
-
-} // Anonymous namespace
-
 BOOST_AUTO_TEST_SUITE(TimelineUtilityMethodsTests)
 
 BOOST_AUTO_TEST_CASE(CreateTypedLabelTest)
 {
     MockBufferManager mockBufferManager(1024);
-    SendTimelinePacket sendTimelinePacket(mockBufferManager);
+    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = std::make_unique<SendTimelinePacket>(mockBufferManager);
     TimelineUtilityMethods timelineUtilityMethods(sendTimelinePacket);
 
     // Generate first guid to ensure that the named typed entity guid is not 0 on local single test.
@@ -375,10 +33,10 @@
     const std::string entityName = "some entity";
     ProfilingStaticGuid labelTypeGuid(456);
 
-    BOOST_CHECK_NO_THROW(timelineUtilityMethods.CreateTypedLabel(entityGuid, entityName, labelTypeGuid));
+    BOOST_CHECK_NO_THROW(timelineUtilityMethods.MarkEntityWithLabel(entityGuid, entityName, labelTypeGuid));
 
     // Commit all packets at once
-    sendTimelinePacket.Commit();
+    timelineUtilityMethods.Commit();
 
     // Get the readable buffer
     auto readableBuffer = mockBufferManager.GetReadableBuffer();
@@ -417,19 +75,19 @@
 BOOST_AUTO_TEST_CASE(SendWellKnownLabelsAndEventClassesTest)
 {
     MockBufferManager mockBufferManager(1024);
-    SendTimelinePacket sendTimelinePacket(mockBufferManager);
+    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = std::make_unique<SendTimelinePacket>(mockBufferManager);
     TimelineUtilityMethods timelineUtilityMethods(sendTimelinePacket);
 
     BOOST_CHECK_NO_THROW(timelineUtilityMethods.SendWellKnownLabelsAndEventClasses());
 
     // Commit all packets at once
-    sendTimelinePacket.Commit();
+    timelineUtilityMethods.Commit();
 
     // Get the readable buffer
     auto readableBuffer = mockBufferManager.GetReadableBuffer();
     BOOST_CHECK(readableBuffer != nullptr);
     unsigned int size = readableBuffer->GetSize();
-    BOOST_CHECK(size == 136);
+    BOOST_TEST(size == 308);
     const unsigned char* readableData = readableBuffer->GetReadableData();
     BOOST_CHECK(readableData != nullptr);
 
@@ -454,6 +112,37 @@
                                     readableData,
                                     offset);
 
+    // Forth "well-known" label: BACKENDID
+    VerifyTimelineLabelBinaryPacket(LabelsAndEventClasses::BACKENDID_GUID,
+                                    LabelsAndEventClasses::BACKENDID_LABEL,
+                                    readableData,
+                                    offset);
+
+    // Well-known types
+    // Layer
+    VerifyTimelineLabelBinaryPacket(LabelsAndEventClasses::LAYER_GUID,
+                                    LabelsAndEventClasses::LAYER,
+                                    readableData,
+                                    offset);
+
+    // Workload
+    VerifyTimelineLabelBinaryPacket(LabelsAndEventClasses::WORKLOAD_GUID,
+                                    LabelsAndEventClasses::WORKLOAD,
+                                    readableData,
+                                    offset);
+
+    // Network
+    VerifyTimelineLabelBinaryPacket(LabelsAndEventClasses::NETWORK_GUID,
+                                    LabelsAndEventClasses::NETWORK,
+                                    readableData,
+                                    offset);
+
+    // Connection
+    VerifyTimelineLabelBinaryPacket(LabelsAndEventClasses::CONNECTION_GUID,
+                                    LabelsAndEventClasses::CONNECTION,
+                                    readableData,
+                                    offset);
+
     // First "well-known" event class: START OF LIFE
     VerifyTimelineEventClassBinaryPacket(LabelsAndEventClasses::ARMNN_PROFILING_SOL_EVENT_CLASS,
                                          readableData,
@@ -471,7 +160,7 @@
 BOOST_AUTO_TEST_CASE(CreateNamedTypedChildEntityTest)
 {
     MockBufferManager mockBufferManager(1024);
-    SendTimelinePacket sendTimelinePacket(mockBufferManager);
+    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = std::make_unique<SendTimelinePacket>(mockBufferManager);
     TimelineUtilityMethods timelineUtilityMethods(sendTimelinePacket);
 
     ProfilingDynamicGuid childEntityGuid(0);
@@ -497,7 +186,7 @@
     BOOST_CHECK(childEntityGuid != ProfilingGuid(0));
 
     // Commit all packets at once
-    sendTimelinePacket.Commit();
+    timelineUtilityMethods.Commit();
 
     // Get the readable buffer
     auto readableBuffer = mockBufferManager.GetReadableBuffer();
@@ -566,7 +255,7 @@
 BOOST_AUTO_TEST_CASE(DeclareLabelTest)
 {
     MockBufferManager mockBufferManager(1024);
-    SendTimelinePacket sendTimelinePacket(mockBufferManager);
+    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = std::make_unique<SendTimelinePacket>(mockBufferManager);
     TimelineUtilityMethods timelineUtilityMethods(sendTimelinePacket);
 
     // Generate first guid to ensure that the named typed entity guid is not 0 on local single test.
@@ -594,7 +283,7 @@
 BOOST_AUTO_TEST_CASE(CreateNameTypeEntityInvalidTest)
 {
     MockBufferManager mockBufferManager(1024);
-    SendTimelinePacket sendTimelinePacket(mockBufferManager);
+    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = std::make_unique<SendTimelinePacket>(mockBufferManager);
     TimelineUtilityMethods timelineUtilityMethods(sendTimelinePacket);
 
     // Invalid name
@@ -618,7 +307,7 @@
 BOOST_AUTO_TEST_CASE(CreateNameTypeEntityTest)
 {
     MockBufferManager mockBufferManager(1024);
-    SendTimelinePacket sendTimelinePacket(mockBufferManager);
+    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = std::make_unique<SendTimelinePacket>(mockBufferManager);
     TimelineUtilityMethods timelineUtilityMethods(sendTimelinePacket);
 
     const std::string entityName = "Entity0";
@@ -631,7 +320,7 @@
     BOOST_CHECK(guid != ProfilingGuid(0));
 
     // Commit all packets at once
-    sendTimelinePacket.Commit();
+    timelineUtilityMethods.Commit();
 
     // Get the readable buffer
     auto readableBuffer = mockBufferManager.GetReadableBuffer();
@@ -694,9 +383,8 @@
 BOOST_AUTO_TEST_CASE(RecordEventTest)
 {
     MockBufferManager mockBufferManager(1024);
-    SendTimelinePacket sendTimelinePacket(mockBufferManager);
+    std::unique_ptr<ISendTimelinePacket> sendTimelinePacket = std::make_unique<SendTimelinePacket>(mockBufferManager);
     TimelineUtilityMethods timelineUtilityMethods(sendTimelinePacket);
-
     // Generate first guid to ensure that the named typed entity guid is not 0 on local single test.
     ProfilingService::Instance().NextGuid();
 
@@ -707,7 +395,7 @@
     BOOST_CHECK(eventGuid != ProfilingGuid(0));
 
     // Commit all packets at once
-    sendTimelinePacket.Commit();
+    timelineUtilityMethods.Commit();
 
     // Get the readable buffer
     auto readableBuffer = mockBufferManager.GetReadableBuffer();
@@ -734,7 +422,7 @@
     // Third packet sent: TimelineRelationshipBinaryPacket
     VerifyTimelineRelationshipBinaryPacket(ProfilingRelationshipType::DataLink,
                                            EmptyOptional(),
-                                           entityGuid,
+                                           eventGuid,
                                            eventClassGuid,
                                            readableData,
                                            offset);