IVGCVSW-6706 Move headers to profiling/client/include

!android-nn-driver:7337

Change-Id: Ide401623829cc99fb9b51e9bbce3482ce706a8dd
Signed-off-by: Jim Flynn <jim.flynn@arm.com>

17 files changed, 802 insertions, 1 deletions

diff --git a/profiling/CMakeLists.txt b/profiling/CMakeLists.txt
index f9ffd66433..265c5365c7 100644
--- a/profiling/CMakeLists.txt
+++ b/profiling/CMakeLists.txt
@@ -22,6 +22,7 @@ add_custom_target(AdditionalCMakeFiles SOURCES ${additional_cmake_files})
 include(GNUInstallDirs)
 
 include_directories(SYSTEM common/include)
+include_directories(SYSTEM client/include)
 include_directories(SYSTEM ${PROJECT_SOURCE_DIR})
 
 set(BUILD_UNIT_TESTS 0)
diff --git a/profiling/client/include/CounterIdMap.hpp b/profiling/client/include/CounterIdMap.hpp
new file mode 100644
index 0000000000..cce7184c46
--- /dev/null
+++ b/profiling/client/include/CounterIdMap.hpp
@@ -0,0 +1,51 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include <map>
+#include <string>
+
+namespace arm
+{
+namespace pipe
+{
+
+class ICounterMappings
+{
+public:
+    virtual uint16_t GetGlobalId(uint16_t backendCounterId, const std::string& backendId) const = 0;
+    virtual const std::pair<uint16_t, std::string>& GetBackendId(uint16_t globalCounterId) const = 0;
+    virtual ~ICounterMappings() {}
+};
+
+class IRegisterCounterMapping
+{
+public:
+    virtual void RegisterMapping(uint16_t globalCounterId,
+                                 uint16_t backendCounterId,
+                                 const std::string& backendId) = 0;
+    virtual void Reset() = 0;
+    virtual ~IRegisterCounterMapping() {}
+};
+
+class CounterIdMap : public ICounterMappings, public IRegisterCounterMapping
+{
+
+public:
+    CounterIdMap() = default;
+    virtual ~CounterIdMap() {}
+    void RegisterMapping(uint16_t globalCounterId,
+                         uint16_t backendCounterId,
+                         const std::string& backendId) override;
+    void Reset() override;
+    uint16_t GetGlobalId(uint16_t backendCounterId, const std::string& backendId) const override;
+    const std::pair<uint16_t, std::string>& GetBackendId(uint16_t globalCounterId) const override;
+private:
+    std::map<uint16_t, std::pair<uint16_t, std::string>> m_GlobalCounterIdMap;
+    std::map<std::pair<uint16_t, std::string>, uint16_t> m_BackendCounterIdMap;
+};
+
+}    // namespace pipe
+}    // namespace arm
diff --git a/profiling/client/include/Holder.hpp b/profiling/client/include/Holder.hpp
new file mode 100644
index 0000000000..db5468feda
--- /dev/null
+++ b/profiling/client/include/Holder.hpp
@@ -0,0 +1,67 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <mutex>
+#include <vector>
+#include <set>
+
+namespace arm
+{
+
+namespace pipe
+{
+
+class CaptureData
+{
+public:
+    CaptureData()
+        : m_CapturePeriod(0)
+        , m_CounterIds()
+        , m_ActiveBackends(){}
+    CaptureData(uint32_t capturePeriod, std::vector<uint16_t>& counterIds, std::set<std::string> activeBackends)
+        : m_CapturePeriod(capturePeriod)
+        , m_CounterIds(counterIds)
+        , m_ActiveBackends(activeBackends){}
+    CaptureData(const CaptureData& captureData)
+        : m_CapturePeriod(captureData.m_CapturePeriod)
+        , m_CounterIds(captureData.m_CounterIds)
+        , m_ActiveBackends(captureData.m_ActiveBackends){}
+
+    CaptureData& operator=(const CaptureData& other);
+
+    void SetActiveBackends(const std::set<std::string>& activeBackends);
+    void SetCapturePeriod(uint32_t capturePeriod);
+    void SetCounterIds(const std::vector<uint16_t>& counterIds);
+    uint32_t GetCapturePeriod() const;
+    const std::vector<uint16_t>& GetCounterIds() const;
+    const std::set<std::string>& GetActiveBackends() const;
+    bool IsCounterIdInCaptureData(uint16_t counterId);
+
+private:
+    uint32_t m_CapturePeriod;
+    std::vector<uint16_t> m_CounterIds;
+    std::set<std::string> m_ActiveBackends;
+};
+
+class Holder
+{
+public:
+    Holder()
+        : m_CaptureData() {}
+    CaptureData GetCaptureData() const;
+    void SetCaptureData(uint32_t capturePeriod,
+                        const std::vector<uint16_t>& counterIds,
+                        const std::set<std::string>& activeBackends);
+
+private:
+    mutable std::mutex m_CaptureThreadMutex;
+    CaptureData m_CaptureData;
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/ICounterValues.hpp b/profiling/client/include/ICounterValues.hpp
new file mode 100644
index 0000000000..a851c6b3f3
--- /dev/null
+++ b/profiling/client/include/ICounterValues.hpp
@@ -0,0 +1,47 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <cstdint>
+
+namespace arm
+{
+
+namespace pipe
+{
+
+class IReadCounterValues
+{
+public:
+    virtual ~IReadCounterValues() {}
+
+    virtual bool IsCounterRegistered(uint16_t counterUid) const = 0;
+    virtual bool IsCounterRegistered(const std::string& counterName) const = 0;
+    virtual uint16_t GetCounterCount() const = 0;
+    virtual uint32_t GetAbsoluteCounterValue(uint16_t counterUid) const = 0;
+    virtual uint32_t GetDeltaCounterValue(uint16_t counterUid) = 0;
+};
+
+class IWriteCounterValues
+{
+public:
+    virtual ~IWriteCounterValues() {}
+
+    virtual void SetCounterValue(uint16_t counterUid, uint32_t value) = 0;
+    virtual uint32_t AddCounterValue(uint16_t counterUid, uint32_t value) = 0;
+    virtual uint32_t SubtractCounterValue(uint16_t counterUid, uint32_t value) = 0;
+    virtual uint32_t IncrementCounterValue(uint16_t counterUid) = 0;
+};
+
+class IReadWriteCounterValues : public IReadCounterValues, public IWriteCounterValues
+{
+public:
+    virtual ~IReadWriteCounterValues() {}
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/IInitialiseProfilingService.hpp b/profiling/client/include/IInitialiseProfilingService.hpp
new file mode 100644
index 0000000000..fc3f4b9a5d
--- /dev/null
+++ b/profiling/client/include/IInitialiseProfilingService.hpp
@@ -0,0 +1,26 @@
+//
+// Copyright © 2022 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+namespace arm
+{
+
+namespace pipe
+{
+
+// forward declaration
+class IProfilingService;
+
+class IInitialiseProfilingService
+{
+public:
+    virtual ~IInitialiseProfilingService() {}
+    virtual void InitialiseProfilingService(IProfilingService& profilingService) = 0;
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/ILocalPacketHandler.hpp b/profiling/client/include/ILocalPacketHandler.hpp
new file mode 100644
index 0000000000..0a69f27491
--- /dev/null
+++ b/profiling/client/include/ILocalPacketHandler.hpp
@@ -0,0 +1,68 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+
+#include <common/include/IgnoreUnused.hpp>
+#include <common/include/TargetEndianess.hpp>
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+// forward declare to prevent a circular dependency
+namespace arm
+{
+namespace pipe
+{
+
+class Packet;
+
+// the handlers need to be able to do two
+// things to service the FileOnlyProfilingConnection
+// and any other implementation of IProfilingConnection
+// set the endianness and write a packet back i.e.
+// return a packet and close the connection
+class IInternalProfilingConnection
+{
+public:
+    virtual ~IInternalProfilingConnection() {};
+
+    virtual void SetEndianess(const TargetEndianness& endianness) = 0;
+
+    virtual void ReturnPacket(Packet& packet) = 0;
+
+    virtual void Close() = 0;
+};
+
+class ILocalPacketHandler
+{
+public:
+    virtual ~ILocalPacketHandler() {};
+
+    /// @return lists the headers of the packets that this handler accepts
+    ///         only these packets will get sent to this handler.
+    ///         If this function returns an empty list then ALL packets
+    ///         will be sent to the PacketHandler i.e. a universal handler.
+    virtual std::vector<uint32_t> GetHeadersAccepted() = 0;
+
+    /// process the packet
+    virtual void HandlePacket(const Packet& packet) = 0;
+
+    /// Set a profiling connection on the handler. Only need to implement this
+    /// function if the handler will be writing data back to the profiled application.
+    virtual void SetConnection(IInternalProfilingConnection* profilingConnection)
+    {
+        arm::pipe::IgnoreUnused(profilingConnection);
+    }
+};
+
+using ILocalPacketHandlerPtr = std::unique_ptr<ILocalPacketHandler>;
+using ILocalPacketHandlerSharedPtr = std::shared_ptr<ILocalPacketHandler>;
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/IProfilingService.hpp b/profiling/client/include/IProfilingService.hpp
new file mode 100644
index 0000000000..21d5c9ce77
--- /dev/null
+++ b/profiling/client/include/IProfilingService.hpp
@@ -0,0 +1,81 @@
+//
+// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "CounterIdMap.hpp"
+#include "Holder.hpp"
+#include "ICounterValues.hpp"
+#include "IInitialiseProfilingService.hpp"
+#include "IProfilingServiceStatus.hpp"
+#include "ISendCounterPacket.hpp"
+#include "IReportStructure.hpp"
+#include "ProfilingOptions.hpp"
+#include "ProfilingState.hpp"
+
+#include <client/include/backends/IBackendProfilingContext.hpp>
+
+#include <common/include/ICounterRegistry.hpp>
+#include <common/include/Optional.hpp>
+#include <common/include/ProfilingGuidGenerator.hpp>
+
+
+namespace arm
+{
+
+namespace pipe
+{
+
+class IProfilingService : public IProfilingGuidGenerator,
+                          public IProfilingServiceStatus,
+                          public IReadWriteCounterValues
+{
+public:
+    static std::unique_ptr<IProfilingService> CreateProfilingService(
+        uint16_t maxGlobalCounterId,
+        IInitialiseProfilingService& initialiser,
+        const std::string& softwareInfo,
+        const std::string& softwareVersion,
+        const std::string& hardwareVersion,
+        arm::pipe::Optional<IReportStructure&> reportStructure = arm::pipe::EmptyOptional());
+    virtual ~IProfilingService() {};
+    virtual std::unique_ptr<ISendTimelinePacket> GetSendTimelinePacket() const = 0;
+    virtual const ICounterMappings& GetCounterMappings() const = 0;
+    virtual ISendCounterPacket& GetSendCounterPacket() = 0;
+    virtual bool IsProfilingEnabled() const = 0;
+    virtual bool IsTimelineReportingEnabled() const = 0;
+    virtual CaptureData GetCaptureData() = 0;
+    virtual ProfilingState GetCurrentState() const = 0;
+    // Resets the profiling options, optionally clears the profiling service entirely
+    virtual void ResetExternalProfilingOptions(const ProfilingOptions& options,
+                                               bool resetProfilingService = false) = 0;
+    virtual ProfilingState ConfigureProfilingService(const ProfilingOptions& options,
+                                                     bool resetProfilingService = false) = 0;
+    // Store a profiling context returned from a backend that support profiling.
+    virtual void AddBackendProfilingContext(const std::string& backendId,
+        std::shared_ptr<IBackendProfilingContext> profilingContext) = 0;
+    virtual ICounterRegistry& GetCounterRegistry() = 0;
+    virtual IRegisterCounterMapping& GetCounterMappingRegistry() = 0;
+    virtual bool IsCategoryRegistered(const std::string& categoryName) const = 0;
+    virtual void InitializeCounterValue(uint16_t counterUid) = 0;
+
+    // IProfilingGuidGenerator functions
+    /// Return the next random Guid in the sequence
+    ProfilingDynamicGuid NextGuid() override;
+    /// Create a ProfilingStaticGuid based on a hash of the string
+    ProfilingStaticGuid GenerateStaticId(const std::string& str) override;
+    static ProfilingDynamicGuid GetNextGuid();
+    static ProfilingStaticGuid GetStaticId(const std::string& str);
+    void ResetGuidGenerator();
+
+    virtual void Disconnect() = 0;
+
+private:
+    static ProfilingGuidGenerator m_GuidGenerator;
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/IProfilingServiceStatus.hpp b/profiling/client/include/IProfilingServiceStatus.hpp
new file mode 100644
index 0000000000..f979e740f0
--- /dev/null
+++ b/profiling/client/include/IProfilingServiceStatus.hpp
@@ -0,0 +1,30 @@
+//
+// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "ILocalPacketHandler.hpp"
+
+#include <common/include/Packet.hpp>
+
+#include <cstdint>
+
+namespace arm
+{
+
+namespace pipe
+{
+
+class IProfilingServiceStatus
+{
+public:
+    virtual void NotifyProfilingServiceActive() = 0;
+    virtual void WaitForProfilingServiceActivation(unsigned int timeout) = 0;
+    virtual ~IProfilingServiceStatus() {};
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/IReportStructure.hpp b/profiling/client/include/IReportStructure.hpp
new file mode 100644
index 0000000000..8891cbd3b0
--- /dev/null
+++ b/profiling/client/include/IReportStructure.hpp
@@ -0,0 +1,26 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+namespace arm
+{
+
+namespace pipe
+{
+
+class IProfilingService;
+
+class IReportStructure
+{
+public:
+    virtual ~IReportStructure() {}
+    virtual void ReportStructure(arm::pipe::IProfilingService& profilingService) = 0;
+};
+
+} // namespace pipe
+
+} // namespace arm
+
diff --git a/profiling/client/include/ISendCounterPacket.hpp b/profiling/client/include/ISendCounterPacket.hpp
new file mode 100644
index 0000000000..c76150fc58
--- /dev/null
+++ b/profiling/client/include/ISendCounterPacket.hpp
@@ -0,0 +1,41 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <client/include/backends/IBackendProfiling.hpp>
+
+#include <common/include/ICounterDirectory.hpp>
+
+namespace arm
+{
+
+namespace pipe
+{
+
+class ISendCounterPacket
+{
+public:
+    using IndexValuePairsVector = std::vector<CounterValue>;
+
+    virtual ~ISendCounterPacket() {}
+
+    /// Create and write a StreamMetaDataPacket in the buffer
+    virtual void SendStreamMetaDataPacket() = 0;
+
+    /// Create and write a CounterDirectoryPacket from the parameters to the buffer.
+    virtual void SendCounterDirectoryPacket(const ICounterDirectory& counterDirectory) = 0;
+
+    /// Create and write a PeriodicCounterCapturePacket from the parameters to the buffer.
+    virtual void SendPeriodicCounterCapturePacket(uint64_t timestamp, const IndexValuePairsVector& values) = 0;
+
+    /// Create and write a PeriodicCounterSelectionPacket from the parameters to the buffer.
+    virtual void SendPeriodicCounterSelectionPacket(uint32_t capturePeriod,
+                                                    const std::vector<uint16_t>& selectedCounterIds) = 0;
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/ISendTimelinePacket.hpp b/profiling/client/include/ISendTimelinePacket.hpp
new file mode 100644
index 0000000000..4785e04ef8
--- /dev/null
+++ b/profiling/client/include/ISendTimelinePacket.hpp
@@ -0,0 +1,61 @@
+//
+// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace arm
+{
+
+namespace pipe
+{
+
+enum class ProfilingRelationshipType
+{
+    RetentionLink,    /// Head retains(parents) Tail
+    ExecutionLink,    /// Head execution start depends on Tail execution completion
+    DataLink,         /// Head uses data of Tail
+    LabelLink         /// Head uses label Tail (Tail MUST be a guid of a label).
+};
+
+class ISendTimelinePacket
+{
+public:
+    virtual ~ISendTimelinePacket()
+    {}
+
+    /// Commits the current buffer and reset the member variables
+    virtual void Commit() = 0;
+
+    /// Create and write a TimelineEntityBinaryPacket from the parameters to the buffer.
+    virtual void SendTimelineEntityBinaryPacket(uint64_t profilingGuid) = 0;
+
+    /// Create and write a TimelineEventBinaryPacket from the parameters to the buffer.
+    virtual void
+        SendTimelineEventBinaryPacket(uint64_t timestamp, int threadId, uint64_t profilingGuid) = 0;
+
+    /// Create and write a TimelineEventClassBinaryPacket from the parameters to the buffer.
+    virtual void SendTimelineEventClassBinaryPacket(uint64_t profilingGuid, uint64_t nameGuid) = 0;
+
+    /// Create and write a TimelineLabelBinaryPacket from the parameters to the buffer.
+    virtual void SendTimelineLabelBinaryPacket(uint64_t profilingGuid, const std::string& label) = 0;
+
+    /// Create and write a TimelineMessageDirectoryPackage in the buffer
+    virtual void SendTimelineMessageDirectoryPackage() = 0;
+
+    /// Create and write a TimelineRelationshipBinaryPacket from the parameters to the buffer.
+    virtual void SendTimelineRelationshipBinaryPacket(ProfilingRelationshipType relationshipType,
+                                                      uint64_t relationshipGuid,
+                                                      uint64_t headGuid,
+                                                      uint64_t tailGuid,
+                                                      uint64_t attributeGuid) = 0;
+};
+
+}    // namespace pipe
+
+}    // namespace arm
diff --git a/profiling/client/include/ProfilingOptions.hpp b/profiling/client/include/ProfilingOptions.hpp
new file mode 100644
index 0000000000..30d383d92e
--- /dev/null
+++ b/profiling/client/include/ProfilingOptions.hpp
@@ -0,0 +1,45 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "ILocalPacketHandler.hpp"
+
+#include <string>
+#include <vector>
+
+namespace arm
+{
+namespace pipe
+{
+/// The lowest performance data capture interval we support is 10 miliseconds.
+constexpr unsigned int LOWEST_CAPTURE_PERIOD = 10000u;
+
+struct ProfilingOptions {
+    ProfilingOptions()
+    : m_EnableProfiling(false), m_TimelineEnabled(false), m_OutgoingCaptureFile(""),
+      m_IncomingCaptureFile(""), m_FileOnly(false), m_CapturePeriod(arm::pipe::LOWEST_CAPTURE_PERIOD),
+      m_FileFormat("binary"), m_LocalPacketHandlers() {}
+
+    /// Indicates whether external profiling is enabled or not.
+    bool m_EnableProfiling;
+    /// Indicates whether external timeline profiling is enabled or not.
+    bool m_TimelineEnabled;
+    /// Path to a file in which outgoing timeline profiling messages will be stored.
+    std::string m_OutgoingCaptureFile;
+    /// Path to a file in which incoming timeline profiling messages will be stored.
+    std::string m_IncomingCaptureFile;
+    /// Enable profiling output to file only.
+    bool m_FileOnly;
+    /// The duration at which captured profiling messages will be flushed.
+    uint32_t m_CapturePeriod;
+    /// The format of the file used for outputting profiling data.
+    std::string m_FileFormat;
+    std::vector <ILocalPacketHandlerSharedPtr> m_LocalPacketHandlers;
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/ProfilingState.hpp b/profiling/client/include/ProfilingState.hpp
new file mode 100644
index 0000000000..0fc1903118
--- /dev/null
+++ b/profiling/client/include/ProfilingState.hpp
@@ -0,0 +1,24 @@
+//
+// Copyright © 2022 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+namespace arm
+{
+
+namespace pipe
+{
+
+enum class ProfilingState
+{
+    Uninitialised,
+    NotConnected,
+    WaitingForAck,
+    Active
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/TimelineUtilityMethods.hpp b/profiling/client/include/TimelineUtilityMethods.hpp
new file mode 100644
index 0000000000..5bb4e5ead0
--- /dev/null
+++ b/profiling/client/include/TimelineUtilityMethods.hpp
@@ -0,0 +1,98 @@
+//
+// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <client/include/IProfilingService.hpp>
+#include <client/include/ISendTimelinePacket.hpp>
+
+namespace arm
+{
+
+namespace pipe
+{
+
+class TimelineUtilityMethods
+{
+public:
+
+    // 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(IProfilingService& profilingService);
+
+    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;
+
+    static void SendWellKnownLabelsAndEventClasses(ISendTimelinePacket& timelinePacket);
+
+    ProfilingDynamicGuid CreateNamedTypedEntity(const std::string& name, const std::string& type);
+
+    void CreateNamedTypedEntity(ProfilingGuid entityGuid, const std::string& name, const std::string& type);
+
+    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);
+
+    void NameEntity(ProfilingGuid entityGuid, const std::string& name);
+
+    void TypeEntity(ProfilingGuid entityGuid, const std::string& type);
+
+    ProfilingDynamicGuid CreateNamedTypedChildEntity(ProfilingGuid parentEntityGuid,
+                                                     const std::string& entityName,
+                                                     const std::string& entityType);
+
+    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,
+                                            ProfilingGuid relationshipCategory);
+
+    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);
+
+    ProfilingDynamicGuid RecordWorkloadInferenceAndStartOfLifeEvent(ProfilingGuid workloadGuid,
+                                                                    ProfilingGuid inferenceGuid);
+
+    void RecordEndOfLifeEvent(ProfilingGuid entityGuid);
+
+    void Commit() { m_SendTimelinePacket->Commit(); }
+
+private:
+    std::unique_ptr<ISendTimelinePacket> m_SendTimelinePacket;
+};
+
+} // namespace pipe
+
+} // namespace arm
diff --git a/profiling/client/include/backends/IBackendProfiling.hpp b/profiling/client/include/backends/IBackendProfiling.hpp
new file mode 100644
index 0000000000..347d2ddf03
--- /dev/null
+++ b/profiling/client/include/backends/IBackendProfiling.hpp
@@ -0,0 +1,106 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include <client/include/ISendTimelinePacket.hpp>
+
+#include <common/include/IProfilingGuidGenerator.hpp>
+#include <common/include/Optional.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace arm
+{
+
+namespace pipe
+{
+
+struct CounterValue
+{
+    CounterValue(uint16_t id, uint32_t value) :
+        counterId(id), counterValue(value) {}
+    uint16_t counterId;
+    uint32_t counterValue;
+};
+
+struct Timestamp
+{
+    uint64_t timestamp;
+    std::vector<CounterValue> counterValues;
+};
+
+struct CounterStatus
+{
+    CounterStatus(uint16_t backendCounterId,
+                  uint16_t globalCounterId,
+                  bool enabled,
+                  uint32_t samplingRateInMicroseconds)
+                  : m_BackendCounterId(backendCounterId),
+                    m_GlobalCounterId(globalCounterId),
+                    m_Enabled(enabled),
+                    m_SamplingRateInMicroseconds(samplingRateInMicroseconds) {}
+    uint16_t m_BackendCounterId;
+    uint16_t m_GlobalCounterId;
+    bool     m_Enabled;
+    uint32_t m_SamplingRateInMicroseconds;
+};
+
+class IRegisterBackendCounters
+{
+public:
+    virtual void RegisterCategory(const std::string& categoryName) = 0;
+
+    virtual uint16_t RegisterDevice(const std::string& deviceName,
+                                    uint16_t cores = 0,
+                                    const arm::pipe::Optional<std::string>& parentCategoryName
+                                        = arm::pipe::EmptyOptional()) = 0;
+
+    virtual uint16_t RegisterCounterSet(const std::string& counterSetName,
+                                        uint16_t count = 0,
+                                        const arm::pipe::Optional<std::string>& parentCategoryName
+                                            = arm::pipe::EmptyOptional()) = 0;
+
+    virtual uint16_t RegisterCounter(const uint16_t uid,
+        const std::string& parentCategoryName,
+        uint16_t counterClass,
+        uint16_t interpolation,
+        double multiplier,
+        const std::string& name,
+        const std::string& description,
+        const arm::pipe::Optional<std::string>& units      = arm::pipe::EmptyOptional(),
+        const arm::pipe::Optional<uint16_t>& numberOfCores = arm::pipe::EmptyOptional(),
+        const arm::pipe::Optional<uint16_t>& deviceUid     = arm::pipe::EmptyOptional(),
+        const arm::pipe::Optional<uint16_t>& counterSetUid = arm::pipe::EmptyOptional()) = 0;
+
+    virtual ~IRegisterBackendCounters() {}
+};
+
+class IBackendProfiling
+{
+public:
+    virtual ~IBackendProfiling()
+    {}
+
+    virtual std::unique_ptr<IRegisterBackendCounters>
+            GetCounterRegistrationInterface(uint16_t currentMaxGlobalCounterID) = 0;
+
+    virtual std::unique_ptr<ISendTimelinePacket> GetSendTimelinePacket() = 0;
+
+    virtual IProfilingGuidGenerator& GetProfilingGuidGenerator() = 0;
+
+    virtual void ReportCounters(const std::vector<Timestamp>& counterValues) = 0;
+
+    virtual CounterStatus GetCounterStatus(uint16_t backendCounterId) = 0;
+
+    virtual std::vector<CounterStatus> GetActiveCounters() = 0;
+
+    virtual bool IsProfilingEnabled() const = 0;
+
+};
+
+}    // namespace pipe
+
+}    // namespace arm
diff --git a/profiling/client/include/backends/IBackendProfilingContext.hpp b/profiling/client/include/backends/IBackendProfilingContext.hpp
new file mode 100644
index 0000000000..a1ed05e43d
--- /dev/null
+++ b/profiling/client/include/backends/IBackendProfilingContext.hpp
@@ -0,0 +1,30 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#pragma once
+
+#include "IBackendProfiling.hpp"
+#include <vector>
+
+namespace arm
+{
+namespace pipe
+{
+
+class IBackendProfilingContext
+{
+public:
+    virtual ~IBackendProfilingContext()
+    {}
+    virtual uint16_t RegisterCounters(uint16_t currentMaxGlobalCounterID) = 0;
+    virtual arm::pipe::Optional<std::string> ActivateCounters(
+        uint32_t capturePeriod, const std::vector<uint16_t>& counterIds) = 0;
+    virtual std::vector<Timestamp> ReportCounterValues() = 0;
+    virtual bool EnableProfiling(bool flag) = 0;
+    virtual bool EnableTimelineReporting(bool flag) = 0;
+};
+
+using IBackendProfilingContextUniquePtr = std::unique_ptr<IBackendProfilingContext>;
+}    // namespace pipe
+}    // namespace arm
diff --git a/profiling/server/src/basePipeServer/tests/BasePipeServerTests.cpp b/profiling/server/src/basePipeServer/tests/BasePipeServerTests.cpp
index 516e648ce4..ebf408ef7f 100644
--- a/profiling/server/src/basePipeServer/tests/BasePipeServerTests.cpp
+++ b/profiling/server/src/basePipeServer/tests/BasePipeServerTests.cpp
@@ -14,7 +14,6 @@
 
 TEST_SUITE("BasePipeServerTests")
 {
-using namespace armnn;
 using namespace arm::pipe;
 
 TEST_CASE("BasePipeServerTest")