diff --git a/src/profiling/RegisterBackendCounters.cpp b/src/profiling/RegisterBackendCounters.cpp
new file mode 100644
index 0000000..0c68838
--- /dev/null
+++ b/src/profiling/RegisterBackendCounters.cpp
@@ -0,0 +1,87 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "RegisterBackendCounters.hpp"
+
+namespace armnn
+{
+
+namespace profiling
+{
+
+void RegisterBackendCounters::RegisterCategory(const std::string& categoryName,
+                                               const Optional<uint16_t>& deviceUid,
+                                               const Optional<uint16_t>& counterSetUid)
+{
+     m_CounterDirectory.RegisterCategory(categoryName, deviceUid, counterSetUid);
+}
+
+uint16_t RegisterBackendCounters::RegisterDevice(const std::string& deviceName,
+                                                 uint16_t cores,
+                                                 const Optional<std::string>& parentCategoryName)
+{
+    const Device* devicePtr = m_CounterDirectory.RegisterDevice(deviceName, cores, parentCategoryName);
+    return devicePtr->m_Uid;
+}
+
+uint16_t RegisterBackendCounters::RegisterCounterSet(const std::string& counterSetName,
+                                                     uint16_t count,
+                                                     const Optional<std::string>& parentCategoryName)
+{
+    const CounterSet* counterSetPtr = m_CounterDirectory.RegisterCounterSet(counterSetName, count, parentCategoryName);
+    return counterSetPtr->m_Uid;
+}
+
+uint16_t RegisterBackendCounters::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 Optional<std::string>& units,
+                                                  const Optional<uint16_t>& numberOfCores,
+                                                  const Optional<uint16_t>& deviceUid,
+                                                  const Optional<uint16_t>& counterSetUid)
+{
+    ++m_CurrentMaxGlobalCounterID;
+    const Counter* counterPtr = m_CounterDirectory.RegisterCounter(m_BackendId,
+                                                                   m_CurrentMaxGlobalCounterID,
+                                                                   parentCategoryName,
+                                                                   counterClass,
+                                                                   interpolation,
+                                                                   multiplier,
+                                                                   name,
+                                                                   description,
+                                                                   units,
+                                                                   numberOfCores,
+                                                                   deviceUid,
+                                                                   counterSetUid);
+    m_CurrentMaxGlobalCounterID = counterPtr->m_MaxCounterUid;
+    // register mappings
+    IRegisterCounterMapping& counterIdMap = ProfilingService::Instance().GetCounterMappingRegistry();
+    uint16_t globalCounterId = counterPtr->m_Uid;
+    if (globalCounterId == counterPtr->m_MaxCounterUid)
+    {
+        counterIdMap.RegisterMapping(globalCounterId, uid, m_BackendId);
+    }
+    else
+    {
+        uint16_t backendCounterId = uid;
+        while (globalCounterId <= counterPtr->m_MaxCounterUid)
+        {
+            // register mapping
+            // globalCounterId -> backendCounterId, m_BackendId
+            counterIdMap.RegisterMapping(globalCounterId, backendCounterId, m_BackendId);
+            ++globalCounterId;
+            ++backendCounterId;
+        }
+    }
+    return m_CurrentMaxGlobalCounterID;
+}
+
+} // namespace profiling
+
+} // namespace armnn