diff --git a/src/profiling/ConnectionAcknowledgedCommandHandler.cpp b/src/profiling/ConnectionAcknowledgedCommandHandler.cpp
index deffd14..a0825c7 100644
--- a/src/profiling/ConnectionAcknowledgedCommandHandler.cpp
+++ b/src/profiling/ConnectionAcknowledgedCommandHandler.cpp
@@ -38,6 +38,11 @@
         // Once a Connection Acknowledged packet has been received, move to the Active state immediately
         m_StateMachine.TransitionToState(ProfilingState::Active);
 
+        m_SendCounterPacket.SendCounterDirectoryPacket(m_CounterDirectory);
+
+        // Notify the Send Thread that new data is available in the Counter Stream Buffer
+        m_SendCounterPacket.SetReadyToRead();
+
         break;
     case ProfilingState::Active:
         return; // NOP
diff --git a/src/profiling/ConnectionAcknowledgedCommandHandler.hpp b/src/profiling/ConnectionAcknowledgedCommandHandler.hpp
index 255fcf6..7e7904d 100644
--- a/src/profiling/ConnectionAcknowledgedCommandHandler.hpp
+++ b/src/profiling/ConnectionAcknowledgedCommandHandler.hpp
@@ -6,6 +6,7 @@
 #pragma once
 
 #include "CommandHandlerFunctor.hpp"
+#include "ISendCounterPacket.hpp"
 #include "Packet.hpp"
 #include "ProfilingStateMachine.hpp"
 
@@ -22,15 +23,22 @@
     ConnectionAcknowledgedCommandHandler(uint32_t familyId,
                                          uint32_t packetId,
                                          uint32_t version,
+                                         ICounterDirectory& counterDirectory,
+                                         ISendCounterPacket& sendCounterPacket,
                                          ProfilingStateMachine& profilingStateMachine)
         : CommandHandlerFunctor(familyId, packetId, version)
+        , m_CounterDirectory(counterDirectory)
+        , m_SendCounterPacket(sendCounterPacket)
         , m_StateMachine(profilingStateMachine)
     {}
 
     void operator()(const Packet& packet) override;
 
 private:
-    ProfilingStateMachine& m_StateMachine;
+    const ICounterDirectory& m_CounterDirectory;
+    ISendCounterPacket&      m_SendCounterPacket;
+    ProfilingStateMachine&   m_StateMachine;
+
 };
 
 } // namespace profiling
diff --git a/src/profiling/DirectoryCaptureCommandHandler.cpp b/src/profiling/DirectoryCaptureCommandHandler.cpp
new file mode 100644
index 0000000..22d1e6d
--- /dev/null
+++ b/src/profiling/DirectoryCaptureCommandHandler.cpp
@@ -0,0 +1,336 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "DirectoryCaptureCommandHandler.hpp"
+#include "SendCounterPacket.hpp"
+
+#include <iostream>
+
+namespace armnn
+{
+
+namespace profiling
+{
+
+// Utils
+uint32_t uint16_t_size = sizeof(uint16_t);
+uint32_t uint32_t_size = sizeof(uint32_t);
+
+void DirectoryCaptureCommandHandler::ParseData(const armnn::profiling::Packet& packet)
+{
+    uint16_t categoryRecordCount;
+    uint16_t counterSetRecordCount;
+    uint16_t deviceRecordCount;
+
+    uint32_t offset = 0;
+
+    if (packet.GetLength() < 8)
+    {
+        std::cout << "Counter directory packet received." << std::endl;
+        return;
+    }
+
+    const unsigned char* data = packet.GetData();
+    // Body header word 0:
+    // 0:15  [16] reserved: all zeros
+    offset += uint16_t_size;
+    // 16:31 [16] device_records_count: number of entries in the device_records_pointer_table
+    deviceRecordCount = profiling::ReadUint16(data, offset);
+    offset += uint16_t_size;
+
+    // Body header word 1:
+    // 0:31 [32] device_records_pointer_table_offset: offset to the device_records_pointer_table
+    // The offset is always zero here, as the device record pointer table field is always the first item in the pool
+    offset += uint32_t_size;
+
+    // Body header word 2:
+    // 0:15  [16] reserved: all zeros
+    offset += uint16_t_size;
+    // 16:31 [16] counter_set_count: number of entries in the counter_set_pointer_table
+    counterSetRecordCount = profiling::ReadUint16(data, offset);
+    offset += uint16_t_size;
+
+    // Body header word 3:
+    // 0:31 [32] counter_set_pointer_table_offset: offset to the counter_set_pointer_table
+    // counterPointerTableSetOffset = profiling::ReadUint32(data, offset);
+    offset += uint32_t_size;
+
+    // Body header word 4:
+    // 0:15  [16] reserved: all zeros
+    offset += uint16_t_size;
+    // 16:31 [16] categories_count: number of entries in the categories_pointer_table
+    categoryRecordCount = profiling::ReadUint16(data, offset);
+    offset += uint16_t_size;
+
+    // Body header word 5:
+    // 0:31 [32] categories_pointer_table_offset: offset to the categories_pointer_table
+    // categoriesPointerTableOffset = profiling::ReadUint32(data, offset);
+    offset += uint32_t_size;
+
+    std::vector<uint32_t> deviceRecordOffsets(deviceRecordCount);
+    std::vector<uint32_t> counterSetOffsets(counterSetRecordCount);
+    std::vector<uint32_t> categoryOffsets(categoryRecordCount);
+
+    for (uint32_t i = 0; i < deviceRecordCount; ++i)
+    {
+        deviceRecordOffsets[i] = profiling::ReadUint32(data, offset);
+        offset += uint32_t_size;
+    }
+
+    for (uint32_t i = 0; i < counterSetRecordCount; ++i)
+    {
+        counterSetOffsets[i] = profiling::ReadUint32(data, offset);
+        offset += uint32_t_size;
+    }
+
+    for (uint32_t i = 0; i < categoryRecordCount; ++i)
+    {
+        categoryOffsets[i] = profiling::ReadUint32(data, offset);
+        offset += uint32_t_size;
+    }
+
+    for (uint32_t deviceIndex = 0; deviceIndex < deviceRecordCount; ++deviceIndex)
+    {
+        uint32_t deviceRecordOffset = offset + deviceRecordOffsets[deviceIndex];
+        // Device record word 0:
+        // 0:15  [16] cores: the number of individual streams of counters for one or more cores of some device
+        uint16_t deviceCores = profiling::ReadUint16(data, deviceRecordOffset);
+        // 16:31 [16] deviceUid: the unique identifier for the device
+        deviceRecordOffset += uint16_t_size;
+        uint16_t deviceUid = profiling::ReadUint16(data, deviceRecordOffset);
+        deviceRecordOffset += uint16_t_size;
+
+        // Device record word 1:
+        // Offset from the beginning of the device record pool to the name field.
+        uint32_t nameOffset = profiling::ReadUint32(data, deviceRecordOffset);
+
+        deviceRecordOffset += uint32_t_size;
+        deviceRecordOffset += uint32_t_size;
+        deviceRecordOffset += nameOffset;
+
+        const std::string& deviceName             = GetStringNameFromBuffer(data, deviceRecordOffset);
+        const Device* registeredDevice            = m_CounterDirectory.RegisterDevice(deviceName, deviceCores);
+        m_UidTranslation[registeredDevice->m_Uid] = deviceUid;
+    }
+
+    for (uint32_t counterSetIndex = 0; counterSetIndex < counterSetRecordCount; ++counterSetIndex)
+    {
+        uint32_t counterSetOffset = offset + counterSetOffsets[counterSetIndex];
+
+        // Counter set record word 0:
+        // 0:15  [16] count: the number of counters which can be active in this set at any one time
+        uint16_t counterSetCount = profiling::ReadUint16(data, counterSetOffset);
+        counterSetOffset += uint16_t_size;
+
+        // 16:31 [16] deviceUid: the unique identifier for the counter_set
+        uint16_t counterSetUid = profiling::ReadUint16(data, counterSetOffset);
+        counterSetOffset += uint16_t_size;
+
+        // Counter set record word 1:
+        // 0:31 [32] name_offset: offset from the beginning of the counter set pool to the name field
+        // The offset is always zero here, as the name field is always the first (and only) item in the pool
+        counterSetOffset += uint32_t_size;
+        counterSetOffset += uint32_t_size;
+
+        auto counterSet =
+            m_CounterDirectory.RegisterCounterSet(GetStringNameFromBuffer(data, counterSetOffset), counterSetCount);
+        m_UidTranslation[counterSet->m_Uid] = counterSetUid;
+    }
+    ReadCategoryRecords(data, offset, categoryOffsets);
+}
+
+void DirectoryCaptureCommandHandler::ReadCategoryRecords(const unsigned char* const data,
+                                                         uint32_t offset,
+                                                         std::vector<uint32_t> categoryOffsets)
+{
+    uint32_t categoryRecordCount = static_cast<uint32_t>(categoryOffsets.size());
+
+    for (uint32_t categoryIndex = 0; categoryIndex < categoryRecordCount; ++categoryIndex)
+    {
+        uint32_t categoryRecordOffset = offset + categoryOffsets[categoryIndex];
+
+        // Category record word 0:
+        // 0:15  The deviceUid of a counter_set the category is associated with.
+        // Set to zero if the category is NOT associated with a counter set.
+        uint16_t counterSetUid = profiling::ReadUint16(data, categoryRecordOffset);
+        categoryRecordOffset += uint16_t_size;
+
+        // 16:31 The deviceUid of a device element which identifies some hardware device that the category belongs to.
+        // Set to zero if the category is NOT associated with a device
+        uint16_t deviceUid = profiling::ReadUint16(data, categoryRecordOffset);
+
+        categoryRecordOffset += uint16_t_size;
+
+        // Category record word 1:
+        // 0:15 Reserved, value 0x0000.
+        categoryRecordOffset += uint16_t_size;
+        // 16:31 Number of events belonging to this category.
+        uint32_t eventCount = profiling::ReadUint16(data, categoryRecordOffset);
+        categoryRecordOffset += uint16_t_size;
+
+        // Category record word 2
+        // 0:31  Offset from the beginning of the category data pool to the event_pointer_table
+        uint32_t eventPointerTableOffset = profiling::ReadUint32(data, categoryRecordOffset);
+        categoryRecordOffset += uint32_t_size;
+
+        // Category record word 3
+        // 0:31 Offset from the beginning of the category data pool to the name field.
+        uint32_t nameOffset = profiling::ReadUint32(data, categoryRecordOffset);
+        categoryRecordOffset += uint32_t_size;
+
+        std::vector<uint32_t> eventRecordsOffsets(eventCount);
+
+        eventPointerTableOffset += categoryRecordOffset;
+
+        for (uint32_t eventIndex = 0; eventIndex < eventCount; ++eventIndex)
+        {
+            eventRecordsOffsets[eventIndex] =
+                profiling::ReadUint32(data, eventPointerTableOffset + uint32_t_size * eventIndex);
+        }
+
+        const std::vector<CounterDirectoryEventRecord>& eventRecords =
+            ReadEventRecords(data, categoryRecordOffset, eventRecordsOffsets);
+        categoryRecordOffset += uint32_t_size;
+
+        const Category* category = m_CounterDirectory.RegisterCategory(
+            GetStringNameFromBuffer(data, categoryRecordOffset + nameOffset), deviceUid, counterSetUid);
+        for (auto& counter : eventRecords)
+        {
+            const Counter* registeredCounter = m_CounterDirectory.RegisterCounter(
+                category->m_Name, counter.m_CounterClass, counter.m_CounterInterpolation, counter.m_CounterMultiplier,
+                counter.m_CounterName, counter.m_CounterDescription, counter.m_CounterUnits);
+            m_UidTranslation[registeredCounter->m_Uid] = counter.m_CounterUid;
+        }
+    }
+}
+
+std::vector<CounterDirectoryEventRecord> DirectoryCaptureCommandHandler::ReadEventRecords(
+    const unsigned char* data, uint32_t offset, std::vector<uint32_t> eventRecordsOffsets)
+{
+    uint32_t eventCount = static_cast<uint32_t>(eventRecordsOffsets.size());
+
+    std::vector<CounterDirectoryEventRecord> eventRecords(eventCount);
+    for (unsigned long i = 0; i < eventCount; ++i)
+    {
+        uint32_t eventRecordOffset = eventRecordsOffsets[i] + offset;
+
+        // Event record word 0:
+        // 0:15  [16] count_uid: unique ID for the counter. Must be unique across all counters in all categories
+        eventRecords[i].m_CounterUid = profiling::ReadUint16(data, eventRecordOffset);
+        eventRecordOffset += uint16_t_size;
+        // 16:31 [16] max_counter_uid: if the device this event is associated with has more than one core and there
+        //                             is one of these counters per core this value will be set to
+        //                             (counter_uid + cores (from device_record)) - 1.
+        //                             If there is only a single core then this value will be the same as
+        //                             the counter_uid value
+        eventRecords[i].m_MaxCounterUid = profiling::ReadUint16(data, eventRecordOffset);
+        eventRecordOffset += uint16_t_size;
+
+        // Event record word 1:
+        // 0:15  [16] counter_set: UID of the counter_set this event is associated with. Set to zero if the event
+        //                         is NOT associated with a counter_set
+        eventRecords[i].m_DeviceUid = profiling::ReadUint16(data, eventRecordOffset);
+        eventRecordOffset += uint16_t_size;
+
+        // 16:31 [16] device: UID of the device this event is associated with. Set to zero if the event is NOT
+        //                    associated with a device
+        eventRecords[i].m_CounterSetUid = profiling::ReadUint16(data, eventRecordOffset);
+        eventRecordOffset += uint16_t_size;
+
+        // Event record word 2:
+        // 0:15  [16] interpolation: type describing how to interpolate each data point in a stream of data points
+        eventRecords[i].m_CounterClass = profiling::ReadUint16(data, eventRecordOffset);
+        eventRecordOffset += uint16_t_size;
+
+        // 16:31 [16] class: type describing how to treat each data point in a stream of data points
+        eventRecords[i].m_CounterInterpolation = profiling::ReadUint16(data, eventRecordOffset);
+        eventRecordOffset += uint16_t_size;
+
+        // Event record word 3-4:
+        // 0:63 [64] multiplier: internal data stream is represented as integer values, this allows scaling of
+        //                       those values as if they are fixed point numbers. Zero is not a valid value
+        uint32_t multiplier[2] = { 0u, 0u };
+
+        multiplier[0] = profiling::ReadUint32(data, eventRecordOffset);
+        eventRecordOffset += uint32_t_size;
+        multiplier[1] = profiling::ReadUint32(data, eventRecordOffset);
+        eventRecordOffset += uint32_t_size;
+
+        std::memcpy(&eventRecords[i].m_CounterMultiplier, &multiplier, sizeof(multiplier));
+
+        // Event record word 5:
+        // 0:31 [32] name_eventRecordOffset: eventRecordOffset from the
+        // beginning of the event record pool to the name field
+        // The eventRecordOffset is always zero here, as the name field is always the first item in the pool
+        eventRecordOffset += uint32_t_size;
+
+        // Event record word 6:
+        // 0:31 [32] description_eventRecordOffset: eventRecordOffset from the
+        // beginning of the event record pool to the description field
+        // The size of the name buffer in bytes
+        uint32_t descriptionOffset = profiling::ReadUint32(data, eventRecordOffset);
+        eventRecordOffset += uint32_t_size;
+
+        // Event record word 7:
+        // 0:31 [32] units_eventRecordOffset: (optional) eventRecordOffset from the
+        // beginning of the event record pool to the units field.
+        // An eventRecordOffset value of zero indicates this field is not provided
+        uint32_t unitsOffset = profiling::ReadUint32(data, eventRecordOffset);
+        eventRecordOffset += uint32_t_size;
+        eventRecordOffset += uint32_t_size;
+
+        eventRecords[i].m_CounterName = GetStringNameFromBuffer(data, eventRecordOffset);
+
+        eventRecords[i].m_CounterDescription = GetStringNameFromBuffer(data, eventRecordOffset + descriptionOffset);
+
+        eventRecords[i].m_CounterUnits = GetStringNameFromBuffer(data, eventRecordOffset + unitsOffset);
+    }
+
+    return eventRecords;
+}
+
+void DirectoryCaptureCommandHandler::operator()(const profiling::Packet& packet)
+{
+    if (!m_QuietOperation)    // Are we supposed to print to stdout?
+    {
+        std::cout << "Counter directory packet received." << std::endl;
+    }
+
+    // The ArmNN counter directory is static per ArmNN instance. Ensure we don't parse it a second time.
+    if (!ParsedCounterDirectory())
+    {
+        ParseData(packet);
+        m_AlreadyParsed = true;
+    }
+
+    if (!m_QuietOperation)
+    {
+        armnn::profiling::PrintCounterDirectory(m_CounterDirectory);
+    }
+}
+
+const ICounterDirectory& DirectoryCaptureCommandHandler::GetCounterDirectory() const
+{
+    return m_CounterDirectory;
+}
+
+std::string DirectoryCaptureCommandHandler::GetStringNameFromBuffer(const unsigned char* const data, uint32_t offset)
+{
+    std::string deviceName;
+    u_char nextChar = profiling::ReadUint8(data, offset);
+
+    while (isprint(nextChar))
+    {
+        deviceName += static_cast<char>(nextChar);
+        offset++;
+        nextChar = profiling::ReadUint8(data, offset);
+    }
+
+    return deviceName;
+}
+
+}    // namespace profiling
+
+}    // namespace armnn
\ No newline at end of file
diff --git a/src/profiling/DirectoryCaptureCommandHandler.hpp b/src/profiling/DirectoryCaptureCommandHandler.hpp
new file mode 100644
index 0000000..03bbb1e
--- /dev/null
+++ b/src/profiling/DirectoryCaptureCommandHandler.hpp
@@ -0,0 +1,84 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "CommandHandlerFunctor.hpp"
+#include "CounterDirectory.hpp"
+
+#include <atomic>
+
+namespace armnn
+{
+
+namespace profiling
+{
+
+struct CounterDirectoryEventRecord
+{
+    uint16_t m_CounterClass;
+    std::string m_CounterDescription;
+    uint16_t m_CounterInterpolation;
+    double m_CounterMultiplier;
+    std::string m_CounterName;
+    uint16_t m_CounterSetUid;
+    uint16_t m_CounterUid;
+    std::string m_CounterUnits;
+    uint16_t m_DeviceUid;
+    uint16_t m_MaxCounterUid;
+};
+
+class DirectoryCaptureCommandHandler : public profiling::CommandHandlerFunctor
+{
+
+public:
+    DirectoryCaptureCommandHandler(uint32_t familyId, uint32_t packetId, uint32_t version, bool quietOperation = true)
+        : CommandHandlerFunctor(familyId, packetId, version)
+        , m_QuietOperation(quietOperation)
+        , m_AlreadyParsed(false)
+    {}
+
+    void operator()(const armnn::profiling::Packet& packet) override;
+
+    const ICounterDirectory& GetCounterDirectory() const;
+
+    bool ParsedCounterDirectory()
+    {
+        return m_AlreadyParsed.load();
+    }
+
+    /**
+     * Given a Uid that came from a copy of the counter directory translate it to the original.
+     *
+     * @param copyUid
+     * @return the original Uid that the copy maps to.
+     */
+    uint16_t TranslateUIDCopyToOriginal(uint16_t copyUid)
+    {
+        return m_UidTranslation[copyUid];
+    }
+
+private:
+    void ParseData(const armnn::profiling::Packet& packet);
+
+    void ReadCategoryRecords(const unsigned char* data, uint32_t offset, std::vector<uint32_t> categoryOffsets);
+
+    std::vector<CounterDirectoryEventRecord>
+        ReadEventRecords(const unsigned char* data, uint32_t offset, std::vector<uint32_t> eventRecordsOffsets);
+
+    std::string GetStringNameFromBuffer(const unsigned char* data, uint32_t offset);
+    bool IsValidChar(unsigned char c);
+
+    CounterDirectory m_CounterDirectory;
+    std::unordered_map<uint16_t, uint16_t> m_UidTranslation;
+    bool m_QuietOperation;
+    // We can only parse the counter directory once per instance. It won't change anyway as it's static
+    // per instance of ArmNN.
+    std::atomic<bool> m_AlreadyParsed;
+};
+
+}    // namespace profiling
+
+}    // namespace armnn
diff --git a/src/profiling/FileOnlyProfilingConnection.cpp b/src/profiling/FileOnlyProfilingConnection.cpp
new file mode 100644
index 0000000..b32ae49
--- /dev/null
+++ b/src/profiling/FileOnlyProfilingConnection.cpp
@@ -0,0 +1,216 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "FileOnlyProfilingConnection.hpp"
+#include "PacketVersionResolver.hpp"
+
+#include <armnn/Exceptions.hpp>
+
+#include <boost/numeric/conversion/cast.hpp>
+#include <iostream>
+#include <thread>
+
+namespace armnn
+{
+
+namespace profiling
+{
+
+FileOnlyProfilingConnection::~FileOnlyProfilingConnection()
+{
+    Close();
+}
+
+bool FileOnlyProfilingConnection::IsOpen() const
+{
+    // This type of connection is always open.
+    return true;
+}
+
+void FileOnlyProfilingConnection::Close()
+{
+    // Dump any unread packets out of the queue.
+    for (unsigned int i = 0; i < m_PacketQueue.size(); i++)
+    {
+        m_PacketQueue.pop();
+    }
+}
+
+bool FileOnlyProfilingConnection::WaitForStreamMeta(const unsigned char* buffer, uint32_t length)
+{
+    // The first word, stream_metadata_identifer, should always be 0.
+    if (ToUint32(buffer, TargetEndianness::BeWire) != 0)
+    {
+        Fail("Protocol error. The stream_metadata_identifer was not 0.");
+    }
+
+    // Before we interpret the length we need to read the pipe_magic word to determine endianness.
+    if (ToUint32(buffer + 8, TargetEndianness::BeWire) == PIPE_MAGIC)
+    {
+        m_Endianness = TargetEndianness::BeWire;
+    }
+    else if (ToUint32(buffer + 8, TargetEndianness::LeWire) == PIPE_MAGIC)
+    {
+        m_Endianness = TargetEndianness::LeWire;
+    }
+    else
+    {
+        Fail("Protocol read error. Unable to read PIPE_MAGIC value.");
+    }
+    return true;
+}
+
+void FileOnlyProfilingConnection::SendConnectionAck()
+{
+    if (!m_QuietOp)
+    {
+        std::cout << "Sending connection acknowledgement." << std::endl;
+    }
+    std::unique_ptr<unsigned char[]> uniqueNullPtr = nullptr;
+    m_PacketQueue.push(Packet(0x10000, 0, uniqueNullPtr));
+}
+
+bool FileOnlyProfilingConnection::SendCounterSelectionPacket()
+{
+    uint32_t uint16_t_size = sizeof(uint16_t);
+    uint32_t uint32_t_size = sizeof(uint32_t);
+
+    uint32_t offset   = 0;
+    uint32_t bodySize = uint32_t_size + boost::numeric_cast<uint32_t>(m_IdList.size()) * uint16_t_size;
+
+    auto uniqueData     = std::make_unique<unsigned char[]>(bodySize);
+    unsigned char* data = reinterpret_cast<unsigned char*>(uniqueData.get());
+
+    // Copy capturePeriod
+    WriteUint32(data, offset, m_Options.m_CapturePeriod);
+
+    // Copy m_IdList
+    offset += uint32_t_size;
+    for (const uint16_t& id : m_IdList)
+    {
+        WriteUint16(data, offset, id);
+        offset += uint16_t_size;
+    }
+
+    m_PacketQueue.push(Packet(0x40000, bodySize, uniqueData));
+
+    return true;
+}
+
+bool FileOnlyProfilingConnection::WritePacket(const unsigned char* buffer, uint32_t length)
+{
+    BOOST_ASSERT(buffer);
+
+    // Read Header and determine case
+    uint32_t outgoingHeaderAsWords[2];
+    PackageActivity packageActivity = GetPackageActivity(buffer, outgoingHeaderAsWords);
+
+    switch (packageActivity)
+    {
+        case PackageActivity::StreamMetaData:
+        {
+            if (!WaitForStreamMeta(buffer, length))
+            {
+                return EXIT_FAILURE;
+            }
+
+            SendConnectionAck();
+            break;
+        }
+        case PackageActivity::CounterDirectory:
+        {
+            std::unique_ptr<unsigned char[]> uniqueCounterData = std::make_unique<unsigned char[]>(length - 8);
+
+            std::memcpy(uniqueCounterData.get(), buffer + 8, length - 8);
+
+            Packet directoryPacket(outgoingHeaderAsWords[0], length - 8, uniqueCounterData);
+
+            armnn::profiling::PacketVersionResolver packetVersionResolver;
+            DirectoryCaptureCommandHandler directoryCaptureCommandHandler(
+                0, 2, packetVersionResolver.ResolvePacketVersion(0, 2).GetEncodedValue());
+            directoryCaptureCommandHandler.operator()(directoryPacket);
+            const ICounterDirectory& counterDirectory = directoryCaptureCommandHandler.GetCounterDirectory();
+            for (auto& category : counterDirectory.GetCategories())
+            {
+                // Remember we need to translate the Uid's from our CounterDirectory instance to the parent one.
+                std::vector<uint16_t> translatedCounters;
+                for (auto const& copyUid : category->m_Counters)
+                {
+                    translatedCounters.emplace_back(directoryCaptureCommandHandler.TranslateUIDCopyToOriginal(copyUid));
+                }
+                m_IdList.insert(std::end(m_IdList), std::begin(translatedCounters), std::end(translatedCounters));
+            }
+            SendCounterSelectionPacket();
+            break;
+        }
+        default:
+        {
+            break;
+        }
+    }
+    return true;
+}
+
+Packet FileOnlyProfilingConnection::ReadPacket(uint32_t timeout)
+{
+    uint16_t loopCount       = 10;
+    uint32_t timeoutFraction = timeout / loopCount;
+    while (m_PacketQueue.empty())
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(timeoutFraction));
+        --loopCount;
+        if ((loopCount) == 0)
+        {
+            throw armnn::TimeoutException("Thread has timed out as per requested time limit");
+        }
+    }
+    Packet returnedPacket = std::move(m_PacketQueue.front());
+    m_PacketQueue.pop();
+    return returnedPacket;
+}
+
+PackageActivity FileOnlyProfilingConnection::GetPackageActivity(const unsigned char* buffer, uint32_t headerAsWords[2])
+{
+    headerAsWords[0] = ToUint32(buffer, m_Endianness);
+    headerAsWords[1] = ToUint32(buffer + 4, m_Endianness);
+    if (headerAsWords[0] == 0x20000)    // Packet family = 0 Packet Id = 2
+    {
+        return PackageActivity::CounterDirectory;
+    }
+    else if (headerAsWords[0] == 0)    // Packet family = 0 Packet Id = 0
+    {
+        return PackageActivity::StreamMetaData;
+    }
+    else
+    {
+        return PackageActivity::Unknown;
+    }
+}
+
+uint32_t FileOnlyProfilingConnection::ToUint32(const unsigned char* data, TargetEndianness endianness)
+{
+    // Extract the first 4 bytes starting at data and push them into a 32bit integer based on the
+    // specified endianness.
+    if (endianness == TargetEndianness::BeWire)
+    {
+        return static_cast<uint32_t>(data[0]) << 24 | static_cast<uint32_t>(data[1]) << 16 |
+               static_cast<uint32_t>(data[2]) << 8 | static_cast<uint32_t>(data[3]);
+    }
+    else
+    {
+        return static_cast<uint32_t>(data[3]) << 24 | static_cast<uint32_t>(data[2]) << 16 |
+               static_cast<uint32_t>(data[1]) << 8 | static_cast<uint32_t>(data[0]);
+    }
+}
+
+void FileOnlyProfilingConnection::Fail(const std::string& errorMessage)
+{
+    Close();
+    throw RuntimeException(errorMessage);
+}
+
+}    // namespace profiling
+
+}    // namespace armnn
diff --git a/src/profiling/FileOnlyProfilingConnection.hpp b/src/profiling/FileOnlyProfilingConnection.hpp
new file mode 100644
index 0000000..12a87a1
--- /dev/null
+++ b/src/profiling/FileOnlyProfilingConnection.hpp
@@ -0,0 +1,82 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "CounterDirectory.hpp"
+#include "DirectoryCaptureCommandHandler.hpp"
+#include "IProfilingConnection.hpp"
+#include "ProfilingUtils.hpp"
+#include "Runtime.hpp"
+
+#include <fstream>
+#include <queue>
+
+namespace armnn
+{
+
+namespace profiling
+{
+
+enum class TargetEndianness
+{
+    BeWire,
+    LeWire
+};
+
+enum class PackageActivity
+{
+    StreamMetaData,
+    CounterDirectory,
+    Unknown
+};
+
+class FileOnlyProfilingConnection : public IProfilingConnection
+{
+public:
+    FileOnlyProfilingConnection(const Runtime::CreationOptions::ExternalProfilingOptions& options,
+                                const bool quietOp = true)
+        : m_Options(options)
+        , m_QuietOp(quietOp)
+        , m_Endianness(TargetEndianness::LeWire)    // Set a sensible default. WaitForStreamMeta will set a real value.
+        {};
+
+    ~FileOnlyProfilingConnection();
+
+    bool IsOpen() const override;
+
+    void Close() override;
+
+    // This is effectively receiving a data packet from ArmNN.
+    bool WritePacket(const unsigned char* buffer, uint32_t length) override;
+
+    // Sending a packet back to ArmNN.
+    Packet ReadPacket(uint32_t timeout) override;
+
+private:
+    bool WaitForStreamMeta(const unsigned char* buffer, uint32_t length);
+
+    uint32_t ToUint32(const unsigned char* data, TargetEndianness endianness);
+
+    void SendConnectionAck();
+
+    bool SendCounterSelectionPacket();
+
+    PackageActivity GetPackageActivity(const unsigned char* buffer, uint32_t headerAsWords[2]);
+
+    void Fail(const std::string& errorMessage);
+
+    static const uint32_t PIPE_MAGIC = 0x45495434;
+
+    Runtime::CreationOptions::ExternalProfilingOptions m_Options;
+    bool m_QuietOp;
+    std::vector<uint16_t> m_IdList;
+    std::queue<Packet> m_PacketQueue;
+    TargetEndianness m_Endianness;
+};
+
+}    // namespace profiling
+
+}    // namespace armnn
\ No newline at end of file
diff --git a/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp b/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
index 5a14aa8..d61911b 100644
--- a/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
+++ b/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
@@ -43,7 +43,9 @@
 
 void ProfilingConnectionDumpToFileDecorator::Close()
 {
+    m_IncomingDumpFileStream.flush();
     m_IncomingDumpFileStream.close();
+    m_OutgoingDumpFileStream.flush();
     m_OutgoingDumpFileStream.close();
     m_Connection->Close();
 }
diff --git a/src/profiling/ProfilingConnectionDumpToFileDecorator.hpp b/src/profiling/ProfilingConnectionDumpToFileDecorator.hpp
index 450c38a..545c57f 100644
--- a/src/profiling/ProfilingConnectionDumpToFileDecorator.hpp
+++ b/src/profiling/ProfilingConnectionDumpToFileDecorator.hpp
@@ -28,7 +28,7 @@
 
     ProfilingConnectionDumpToFileDecorator(std::unique_ptr<IProfilingConnection> connection,
                                            const Runtime::CreationOptions::ExternalProfilingOptions& options,
-                                           bool ignoreFailures);
+                                           bool ignoreFailures = false);
 
     ~ProfilingConnectionDumpToFileDecorator();
 
diff --git a/src/profiling/ProfilingConnectionFactory.cpp b/src/profiling/ProfilingConnectionFactory.cpp
index 759eb7a..4af81a0 100644
--- a/src/profiling/ProfilingConnectionFactory.cpp
+++ b/src/profiling/ProfilingConnectionFactory.cpp
@@ -1,11 +1,13 @@
 //
-// Copyright © 2017 Arm Ltd. All rights reserved.
+// Copyright © 2019 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
 #include "ProfilingConnectionFactory.hpp"
-#include "SocketProfilingConnection.hpp"
+
+#include "FileOnlyProfilingConnection.hpp"
 #include "ProfilingConnectionDumpToFileDecorator.hpp"
+#include "SocketProfilingConnection.hpp"
 
 namespace armnn
 {
@@ -16,19 +18,31 @@
 std::unique_ptr<IProfilingConnection> ProfilingConnectionFactory::GetProfilingConnection(
     const Runtime::CreationOptions::ExternalProfilingOptions& options) const
 {
-    if ( !options.m_IncomingCaptureFile.empty() || !options.m_OutgoingCaptureFile.empty() )
+    // We can create 3 different types of IProfilingConnection.
+    // 1: If no relevant options are specified then a SocketProfilingConnection is returned.
+    // 2: If both incoming and outgoing capture files are specified then a SocketProfilingConnection decorated by a
+    //    ProfilingConnectionDumpToFileDecorator is returned.
+    // 3: If both incoming and outgoing capture files are specified and "file only" then a FileOnlyProfilingConnection
+    //    decorated by a ProfilingConnectionDumpToFileDecorator is returned.
+    if ((!options.m_IncomingCaptureFile.empty() || !options.m_OutgoingCaptureFile.empty()) && !options.m_FileOnly)
     {
-        bool ignoreFailures = false;
+        // This is type 2.
         return std::make_unique<ProfilingConnectionDumpToFileDecorator>(std::make_unique<SocketProfilingConnection>(),
-                                                                        options,
-                                                                        ignoreFailures);
+                                                                        options);
+    }
+    else if ((!options.m_IncomingCaptureFile.empty() || !options.m_OutgoingCaptureFile.empty()) && options.m_FileOnly)
+    {
+        // This is type 3.
+        return std::make_unique<ProfilingConnectionDumpToFileDecorator>(
+            std::make_unique<FileOnlyProfilingConnection>(options), options);
     }
     else
     {
+        // This is type 1.
         return std::make_unique<SocketProfilingConnection>();
     }
 }
 
-} // namespace profiling
+}    // namespace profiling
 
-} // namespace armnn
+}    // namespace armnn
diff --git a/src/profiling/ProfilingConnectionFactory.hpp b/src/profiling/ProfilingConnectionFactory.hpp
index c4b10c6..b3a1658 100644
--- a/src/profiling/ProfilingConnectionFactory.hpp
+++ b/src/profiling/ProfilingConnectionFactory.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2017 Arm Ltd. All rights reserved.
+// Copyright © 2019 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -26,6 +26,6 @@
     IProfilingConnectionPtr GetProfilingConnection(const ExternalProfilingOptions& options) const override;
 };
 
-} // namespace profiling
+}    // namespace profiling
 
-} // namespace armnn
+}    // namespace armnn
diff --git a/src/profiling/ProfilingService.hpp b/src/profiling/ProfilingService.hpp
index 54b0f93..427cdbd 100644
--- a/src/profiling/ProfilingService.hpp
+++ b/src/profiling/ProfilingService.hpp
@@ -136,6 +136,8 @@
         , m_ConnectionAcknowledgedCommandHandler(0,
                                                  1,
                                                  m_PacketVersionResolver.ResolvePacketVersion(0, 1).GetEncodedValue(),
+                                                 m_CounterDirectory,
+                                                 m_SendCounterPacket,
                                                  m_StateMachine)
         , m_RequestCounterDirectoryCommandHandler(0,
                                                   3,
diff --git a/src/profiling/ProfilingUtils.cpp b/src/profiling/ProfilingUtils.cpp
index 93eca25..4202b68 100644
--- a/src/profiling/ProfilingUtils.cpp
+++ b/src/profiling/ProfilingUtils.cpp
@@ -11,6 +11,7 @@
 #include <boost/assert.hpp>
 
 #include <fstream>
+#include <iostream>
 #include <limits>
 
 namespace armnn
@@ -94,7 +95,23 @@
     WriteBytes(packetBuffer->GetWritableData(), offset, value, valueSize);
 }
 
-void WriteUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint64_t value)
+uint32_t ConstructHeader(uint32_t packetFamily,
+                         uint32_t packetId)
+{
+    return ((packetFamily & 0x3F) << 26)|
+           ((packetId & 0x3FF) << 16);
+}
+
+uint32_t ConstructHeader(uint32_t packetFamily,
+                         uint32_t packetClass,
+                         uint32_t packetType)
+{
+    return ((packetFamily & 0x3F) << 26)|
+           ((packetClass & 0x3FF) << 19)|
+           ((packetType & 0x3FFF) << 16);
+}
+
+void WriteUint64(const std::unique_ptr<IPacketBuffer>& packetBuffer, unsigned int offset, uint64_t value)
 {
     BOOST_ASSERT(packetBuffer);
 
@@ -872,6 +889,208 @@
     return TimelinePacketStatus::Ok;
 }
 
+
+std::string CentreAlignFormatting(const std::string& stringToPass, const int spacingWidth)
+{
+    std::stringstream outputStream, centrePadding;
+    int padding = spacingWidth - static_cast<int>(stringToPass.size());
+
+    for (int i = 0; i < padding / 2; ++i)
+    {
+        centrePadding << " ";
+    }
+
+    outputStream << centrePadding.str() << stringToPass << centrePadding.str();
+
+    if (padding > 0 && padding %2 != 0)
+    {
+        outputStream << " ";
+    }
+
+    return outputStream.str();
+}
+
+void PrintDeviceDetails(const std::pair<const unsigned short, std::unique_ptr<Device>>& devicePair)
+{
+    std::string body;
+
+    body.append(CentreAlignFormatting(devicePair.second->m_Name, 20));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(devicePair.first), 13));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(devicePair.second->m_Cores), 10));
+    body.append("\n");
+
+    std::cout << std::string(body.size(), '-') << "\n";
+    std::cout<< body;
+}
+
+void PrintCounterSetDetails(const std::pair<const unsigned short, std::unique_ptr<CounterSet>>& counterSetPair)
+{
+    std::string body;
+
+    body.append(CentreAlignFormatting(counterSetPair.second->m_Name, 20));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counterSetPair.first), 13));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counterSetPair.second->m_Count), 10));
+    body.append("\n");
+
+    std::cout << std::string(body.size(), '-') << "\n";
+
+    std::cout<< body;
+}
+
+void PrintCounterDetails(std::shared_ptr<Counter>& counter)
+{
+    std::string body;
+
+    body.append(CentreAlignFormatting(counter->m_Name, 20));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(counter->m_Description, 50));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(counter->m_Units, 14));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counter->m_Uid), 6));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counter->m_MaxCounterUid), 10));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counter->m_Class), 8));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counter->m_Interpolation), 14));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counter->m_Multiplier), 20));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counter->m_CounterSetUid), 16));
+    body.append(" | ");
+    body.append(CentreAlignFormatting(std::to_string(counter->m_DeviceUid), 14));
+
+    body.append("\n");
+
+    std::cout << std::string(body.size(), '-') << "\n";
+
+    std::cout << body;
+}
+
+void PrintCategoryDetails(const std::unique_ptr<Category>& category,
+                          std::unordered_map<unsigned short, std::shared_ptr<Counter>> counterMap)
+{
+    std::string categoryBody;
+    std::string categoryHeader;
+
+    categoryHeader.append(CentreAlignFormatting("Name", 20));
+    categoryHeader.append(" | ");
+    categoryHeader.append(CentreAlignFormatting("Device", 12));
+    categoryHeader.append(" | ");
+    categoryHeader.append(CentreAlignFormatting("Counter set UID:", 16));
+    categoryHeader.append(" | ");
+    categoryHeader.append(CentreAlignFormatting("Event Count", 14));
+    categoryHeader.append("\n");
+
+    categoryBody.append(CentreAlignFormatting(category->m_Name, 20));
+    categoryBody.append(" | ");
+    categoryBody.append(CentreAlignFormatting(std::to_string(category->m_DeviceUid), 12));
+    categoryBody.append(" | ");
+    categoryBody.append(CentreAlignFormatting(std::to_string(category->m_CounterSetUid), 16));
+    categoryBody.append(" | ");
+    categoryBody.append(CentreAlignFormatting(std::to_string(category->m_Counters.size()), 14));
+
+    std::cout << "\n" << "\n";
+    std::cout << CentreAlignFormatting("CATEGORY", static_cast<int>(categoryHeader.size()));
+    std::cout << "\n";
+    std::cout << std::string(categoryHeader.size(), '=') << "\n";
+
+    std::cout << categoryHeader;
+
+    std::cout << std::string(categoryBody.size(), '-') << "\n";
+
+    std::cout << categoryBody;
+
+    std::string counterHeader;
+
+    counterHeader.append(CentreAlignFormatting("Counter Name", 20));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("Description", 50));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("Units", 14));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("UID", 6));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("Max UID", 10));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("Class", 8));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("Interpolation", 14));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("Multiplier", 20));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("Counter set UID", 16));
+    counterHeader.append(" | ");
+    counterHeader.append(CentreAlignFormatting("Device UID", 14));
+    counterHeader.append("\n");
+
+    std::cout << "\n" << "\n";
+    std::cout << CentreAlignFormatting("EVENTS IN CATEGORY: " + category->m_Name,
+                                       static_cast<int>(counterHeader.size()));
+    std::cout << "\n";
+    std::cout << std::string(counterHeader.size(), '=') << "\n";
+    std::cout << counterHeader;
+    for (auto& it: category->m_Counters) {
+        auto search = counterMap.find(it);
+        if(search != counterMap.end()) {
+            PrintCounterDetails(search->second);
+        }
+    }
+}
+
+void PrintCounterDirectory(ICounterDirectory& counterDirectory)
+{
+    std::string devicesHeader;
+
+    devicesHeader.append(CentreAlignFormatting("Device name", 20));
+    devicesHeader.append(" | ");
+    devicesHeader.append(CentreAlignFormatting("UID", 13));
+    devicesHeader.append(" | ");
+    devicesHeader.append(CentreAlignFormatting("Cores", 10));
+    devicesHeader.append("\n");
+
+    std::cout << "\n" << "\n";
+    std::cout << CentreAlignFormatting("DEVICES", static_cast<int>(devicesHeader.size()));
+    std::cout << "\n";
+    std::cout << std::string(devicesHeader.size(), '=') << "\n";
+    std::cout << devicesHeader;
+    for (auto& it: counterDirectory.GetDevices()) {
+        PrintDeviceDetails(it);
+    }
+
+    std::string counterSetHeader;
+
+    counterSetHeader.append(CentreAlignFormatting("Counter set name", 20));
+    counterSetHeader.append(" | ");
+    counterSetHeader.append(CentreAlignFormatting("UID", 13));
+    counterSetHeader.append(" | ");
+    counterSetHeader.append(CentreAlignFormatting("Count", 10));
+    counterSetHeader.append("\n");
+
+    std::cout << "\n" << "\n";
+    std::cout << CentreAlignFormatting("COUNTER SETS", static_cast<int>(counterSetHeader.size()));
+    std::cout << "\n";
+    std::cout << std::string(counterSetHeader.size(), '=') << "\n";
+
+    std::cout << counterSetHeader;
+
+    for (auto& it: counterDirectory.GetCounterSets()) {
+        PrintCounterSetDetails(it);
+    }
+
+    auto counters = counterDirectory.GetCounters();
+    for (auto& it: counterDirectory.GetCategories()) {
+        PrintCategoryDetails(it, counters);
+    }
+    std::cout << "\n";
+}
+
+
 } // namespace profiling
 
 } // namespace armnn
diff --git a/src/profiling/ProfilingUtils.hpp b/src/profiling/ProfilingUtils.hpp
index 3e0a8a2..fae1a83 100644
--- a/src/profiling/ProfilingUtils.hpp
+++ b/src/profiling/ProfilingUtils.hpp
@@ -7,6 +7,7 @@
 
 #include <armnn/Exceptions.hpp>
 
+#include "ICounterDirectory.hpp"
 #include "IPacketBuffer.hpp"
 
 #include <boost/numeric/conversion/cast.hpp>
@@ -55,10 +56,7 @@
 bool IsValidSwTraceString(const std::string& s)
 {
     // Check that all the characters in the given string conform to the given policy
-    return std::all_of(s.begin(), s.end(), [](unsigned char c)
-    {
-        return SwTracePolicy::IsValidChar(c);
-    });
+    return std::all_of(s.begin(), s.end(), [](unsigned char c) { return SwTracePolicy::IsValidChar(c); });
 }
 
 template <typename SwTracePolicy>
@@ -77,7 +75,7 @@
     }
 
     // Prepare the output buffer
-    size_t s_size = s.size() + 1; // The size of the string (in chars) plus the null-terminator
+    size_t s_size        = s.size() + 1;    // The size of the string (in chars) plus the null-terminator
     size_t uint32_t_size = sizeof(uint32_t);
     size_t outBufferSize = 1 + s_size / uint32_t_size + (s_size % uint32_t_size != 0 ? 1 : 0);
     outputBuffer.resize(outBufferSize, '\0');
@@ -95,6 +93,10 @@
 
 void WriteBytes(const IPacketBuffer& packetBuffer, unsigned int offset, const void* value, unsigned int valueSize);
 
+uint32_t ConstructHeader(uint32_t packetFamily, uint32_t packetId);
+
+uint32_t ConstructHeader(uint32_t packetFamily, uint32_t packetClass, uint32_t packetType);
+
 void WriteUint64(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint64_t value);
 
 void WriteUint32(const IPacketBufferPtr& packetBuffer, unsigned int offset, uint32_t value);
@@ -146,10 +148,10 @@
 
 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).
+    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).
 };
 
 uint32_t CalculateSizeOfPaddedSwString(const std::string& str);
@@ -191,14 +193,18 @@
                                                     unsigned int bufferSize,
                                                     unsigned int& numberOfBytesWritten);
 
+std::string CentreAlignFormatting(const std::string& stringToPass, const int spacingWidth);
+
+void PrintCounterDirectory(ICounterDirectory& counterDirectory);
+
 class BufferExhaustion : public armnn::Exception
 {
     using Exception::Exception;
 };
 
-} // namespace profiling
+}    // namespace profiling
 
-} // namespace armnn
+}    // namespace armnn
 
 namespace std
 {
diff --git a/src/profiling/test/FileOnlyProfilingDecoratorTests.cpp b/src/profiling/test/FileOnlyProfilingDecoratorTests.cpp
new file mode 100644
index 0000000..7f927bd
--- /dev/null
+++ b/src/profiling/test/FileOnlyProfilingDecoratorTests.cpp
@@ -0,0 +1,111 @@
+//
+// Copyright © 2019 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "../FileOnlyProfilingConnection.hpp"
+#include <Runtime.hpp>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <ProfilingService.hpp>
+#include <cstdio>
+#include <fstream>
+#include <sstream>
+#include <sys/stat.h>
+
+#if defined(__ANDROID__)
+#define ARMNN_PROFILING_CONNECTION_TEST_DUMP_DIR "/data/local/tmp"
+#else
+#define ARMNN_PROFILING_CONNECTION_TEST_DUMP_DIR "/tmp"
+#endif
+
+using namespace armnn::profiling;
+using namespace armnn;
+
+using namespace std::chrono_literals;
+
+BOOST_AUTO_TEST_SUITE(FileOnlyProfilingDecoratorTests)
+
+BOOST_AUTO_TEST_CASE(DumpOutgoingValidFileEndToEnd)
+{
+    // Create a temporary file name.
+    boost::filesystem::path tempPath = boost::filesystem::temp_directory_path();
+    boost::filesystem::path tempFile = boost::filesystem::unique_path();
+    tempPath                         = tempPath / tempFile;
+    armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
+    options.m_EnableProfiling     = true;
+    options.m_FileOnly            = true;
+    options.m_IncomingCaptureFile = "";
+    options.m_OutgoingCaptureFile = tempPath.c_str();
+    options.m_CapturePeriod       = 100;
+
+    // Enable the profiling service
+    ProfilingService& profilingService = ProfilingService::Instance();
+    profilingService.ResetExternalProfilingOptions(options, true);
+    // Bring the profiling service to the "WaitingForAck" state
+    profilingService.Update();
+    profilingService.Update();
+
+    u_int32_t timeout   = 2000;
+    u_int32_t sleepTime = 50;
+    u_int32_t timeSlept = 0;
+
+    // Give the profiling service sending thread time start executing and send the stream metadata.
+    while (profilingService.GetCurrentState() != ProfilingState::WaitingForAck)
+    {
+        if (timeSlept >= timeout)
+        {
+            BOOST_FAIL("Timeout: Profiling service did not switch to WaitingForAck state");
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
+        timeSlept += sleepTime;
+    }
+
+    profilingService.Update();
+
+    timeSlept = 0;
+
+    while (profilingService.GetCurrentState() != profiling::ProfilingState::Active)
+    {
+        if (timeSlept >= timeout)
+        {
+            BOOST_FAIL("Timeout: Profiling service did not switch to Active state");
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
+        timeSlept += sleepTime;
+    }
+
+    // Minimum test here is to check that the file was created.
+    BOOST_CHECK(boost::filesystem::exists(tempPath.c_str()) == true);
+
+    // Increment a counter.
+    BOOST_CHECK(profilingService.IsCounterRegistered(0) == true);
+    profilingService.IncrementCounterValue(0);
+    BOOST_CHECK(profilingService.GetCounterValue(0) > 0);
+
+    // At this point the profiling service is active and we've activated all the counters. Waiting a collection
+    // period should be enough to have some data in the file.
+
+    // Wait for 1 collection period plus a bit of overhead..
+    std::this_thread::sleep_for(std::chrono::milliseconds(150));
+
+    // In order to flush the files we need to gracefully close the profiling service.
+    options.m_EnableProfiling = false;
+    profilingService.ResetExternalProfilingOptions(options, true);
+    // Wait a short time to allow the threads to clean themselves up.
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+    // The output file size should be greater than 0.
+    struct stat statusBuffer;
+    BOOST_CHECK(stat(tempPath.c_str(), &statusBuffer) == 0);
+    BOOST_CHECK(statusBuffer.st_size > 0);
+
+    // Delete the tmp file.
+    BOOST_CHECK(remove(tempPath.c_str()) == 0);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp b/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
index c42891d..ec4e591 100644
--- a/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
+++ b/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
@@ -81,7 +81,6 @@
 
 BOOST_AUTO_TEST_SUITE(ProfilingConnectionDumpToFileDecoratorTests)
 
-
 BOOST_AUTO_TEST_CASE(DumpIncomingInvalidFile)
 {
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
diff --git a/src/profiling/test/ProfilingTests.cpp b/src/profiling/test/ProfilingTests.cpp
index aba9675..79a241b 100644
--- a/src/profiling/test/ProfilingTests.cpp
+++ b/src/profiling/test/ProfilingTests.cpp
@@ -32,10 +32,10 @@
 
 #include <cstdint>
 #include <cstring>
+#include <iostream>
 #include <limits>
 #include <map>
 #include <random>
-#include <iostream>
 
 using namespace armnn::profiling;
 
@@ -58,53 +58,49 @@
     BOOST_CHECK(testKey1_0 == testKey1_1);
     BOOST_CHECK(testKey1_0 < testKey1_2);
 
-    BOOST_CHECK(testKey1<testKey4);
-    BOOST_CHECK(testKey1>testKey3);
-    BOOST_CHECK(testKey1<=testKey4);
-    BOOST_CHECK(testKey1>=testKey3);
-    BOOST_CHECK(testKey1<=testKey2);
-    BOOST_CHECK(testKey1>=testKey2);
-    BOOST_CHECK(testKey1==testKey2);
-    BOOST_CHECK(testKey1==testKey1);
+    BOOST_CHECK(testKey1 < testKey4);
+    BOOST_CHECK(testKey1 > testKey3);
+    BOOST_CHECK(testKey1 <= testKey4);
+    BOOST_CHECK(testKey1 >= testKey3);
+    BOOST_CHECK(testKey1 <= testKey2);
+    BOOST_CHECK(testKey1 >= testKey2);
+    BOOST_CHECK(testKey1 == testKey2);
+    BOOST_CHECK(testKey1 == testKey1);
 
-    BOOST_CHECK(!(testKey1==testKey5));
-    BOOST_CHECK(!(testKey1!=testKey1));
-    BOOST_CHECK(testKey1!=testKey5);
+    BOOST_CHECK(!(testKey1 == testKey5));
+    BOOST_CHECK(!(testKey1 != testKey1));
+    BOOST_CHECK(testKey1 != testKey5);
 
-    BOOST_CHECK(testKey1==testKey2 && testKey2==testKey1);
-    BOOST_CHECK(testKey0==testKey1 && testKey1==testKey2 && testKey0==testKey2);
+    BOOST_CHECK(testKey1 == testKey2 && testKey2 == testKey1);
+    BOOST_CHECK(testKey0 == testKey1 && testKey1 == testKey2 && testKey0 == testKey2);
 
-    BOOST_CHECK(testKey1.GetPacketId()==1);
-    BOOST_CHECK(testKey1.GetVersion()==1);
+    BOOST_CHECK(testKey1.GetPacketId() == 1);
+    BOOST_CHECK(testKey1.GetVersion() == 1);
 
-    std::vector<CommandHandlerKey> vect =
-    {
-        CommandHandlerKey(0,0,1), CommandHandlerKey(0,2,0), CommandHandlerKey(0,1,0),
-        CommandHandlerKey(0,2,1), CommandHandlerKey(0,1,1), CommandHandlerKey(0,0,1),
-        CommandHandlerKey(0,2,0), CommandHandlerKey(0,0,0)
-    };
+    std::vector<CommandHandlerKey> vect = { CommandHandlerKey(0, 0, 1), CommandHandlerKey(0, 2, 0),
+                                            CommandHandlerKey(0, 1, 0), CommandHandlerKey(0, 2, 1),
+                                            CommandHandlerKey(0, 1, 1), CommandHandlerKey(0, 0, 1),
+                                            CommandHandlerKey(0, 2, 0), CommandHandlerKey(0, 0, 0) };
 
     std::sort(vect.begin(), vect.end());
 
-    std::vector<CommandHandlerKey> expectedVect =
-    {
-        CommandHandlerKey(0,0,0), CommandHandlerKey(0,0,1), CommandHandlerKey(0,0,1),
-        CommandHandlerKey(0,1,0), CommandHandlerKey(0,1,1), CommandHandlerKey(0,2,0),
-        CommandHandlerKey(0,2,0), CommandHandlerKey(0,2,1)
-    };
+    std::vector<CommandHandlerKey> expectedVect = { CommandHandlerKey(0, 0, 0), CommandHandlerKey(0, 0, 1),
+                                                    CommandHandlerKey(0, 0, 1), CommandHandlerKey(0, 1, 0),
+                                                    CommandHandlerKey(0, 1, 1), CommandHandlerKey(0, 2, 0),
+                                                    CommandHandlerKey(0, 2, 0), CommandHandlerKey(0, 2, 1) };
 
     BOOST_CHECK(vect == expectedVect);
 }
 
 BOOST_AUTO_TEST_CASE(CheckPacketKeyComparisons)
 {
-    PacketKey key0(0,0);
-    PacketKey key1(0,0);
-    PacketKey key2(0,1);
-    PacketKey key3(0,2);
-    PacketKey key4(1,0);
-    PacketKey key5(1,0);
-    PacketKey key6(1,1);
+    PacketKey key0(0, 0);
+    PacketKey key1(0, 0);
+    PacketKey key2(0, 1);
+    PacketKey key3(0, 2);
+    PacketKey key4(1, 0);
+    PacketKey key5(1, 0);
+    PacketKey key6(1, 1);
 
     BOOST_CHECK(!(key0 < key1));
     BOOST_CHECK(!(key0 > key1));
@@ -129,8 +125,11 @@
     TestProfilingConnectionBase testProfilingConnectionBase;
     TestProfilingConnectionTimeoutError testProfilingConnectionTimeOutError;
     TestProfilingConnectionArmnnError testProfilingConnectionArmnnError;
-
-    ConnectionAcknowledgedCommandHandler connectionAcknowledgedCommandHandler(0, 1, 4194304, profilingStateMachine);
+    CounterDirectory counterDirectory;
+    MockBufferManager mockBuffer(1024);
+    SendCounterPacket sendCounterPacket(profilingStateMachine, mockBuffer);
+    ConnectionAcknowledgedCommandHandler connectionAcknowledgedCommandHandler(0, 1, 4194304, counterDirectory,
+                                                                              sendCounterPacket, profilingStateMachine);
     CommandHandlerRegistry commandHandlerRegistry;
 
     commandHandlerRegistry.RegisterFunctor(&connectionAcknowledgedCommandHandler);
@@ -138,10 +137,7 @@
     profilingStateMachine.TransitionToState(ProfilingState::NotConnected);
     profilingStateMachine.TransitionToState(ProfilingState::WaitingForAck);
 
-    CommandHandler commandHandler0(1,
-                                   true,
-                                   commandHandlerRegistry,
-                                   packetVersionResolver);
+    CommandHandler commandHandler0(1, true, commandHandlerRegistry, packetVersionResolver);
 
     commandHandler0.Start(testProfilingConnectionBase);
     commandHandler0.Start(testProfilingConnectionBase);
@@ -154,10 +150,7 @@
     profilingStateMachine.TransitionToState(ProfilingState::NotConnected);
     profilingStateMachine.TransitionToState(ProfilingState::WaitingForAck);
     // commandHandler1 should give up after one timeout
-    CommandHandler commandHandler1(10,
-                                   true,
-                                   commandHandlerRegistry,
-                                   packetVersionResolver);
+    CommandHandler commandHandler1(10, true, commandHandlerRegistry, packetVersionResolver);
 
     commandHandler1.Start(testProfilingConnectionTimeOutError);
 
@@ -185,10 +178,7 @@
 
     BOOST_CHECK(profilingStateMachine.GetCurrentState() == ProfilingState::Active);
 
-    CommandHandler commandHandler2(100,
-                                   false,
-                                   commandHandlerRegistry,
-                                   packetVersionResolver);
+    CommandHandler commandHandler2(100, false, commandHandlerRegistry, packetVersionResolver);
 
     commandHandler2.Start(testProfilingConnectionArmnnError);
 
@@ -231,7 +221,7 @@
 
 BOOST_AUTO_TEST_CASE(CheckPacketClass)
 {
-    uint32_t length = 4;
+    uint32_t length                              = 4;
     std::unique_ptr<unsigned char[]> packetData0 = std::make_unique<unsigned char[]>(length);
     std::unique_ptr<unsigned char[]> packetData1 = std::make_unique<unsigned char[]>(0);
     std::unique_ptr<unsigned char[]> nullPacketData;
@@ -288,11 +278,11 @@
 
     // Check the order of the map is correct
     auto it = registry.begin();
-    BOOST_CHECK(it->first==keyC); // familyId == 5
+    BOOST_CHECK(it->first == keyC);    // familyId == 5
     it++;
-    BOOST_CHECK(it->first==keyA); // familyId == 7
+    BOOST_CHECK(it->first == keyA);    // familyId == 7
     it++;
-    BOOST_CHECK(it->first==keyB); // familyId == 8
+    BOOST_CHECK(it->first == keyB);    // familyId == 8
 
     std::unique_ptr<unsigned char[]> packetDataA;
     std::unique_ptr<unsigned char[]> packetDataB;
@@ -407,7 +397,7 @@
 {
     ProfilingStateMachine profilingState1(ProfilingState::Uninitialised);
     profilingState1.TransitionToState(ProfilingState::Uninitialised);
-    BOOST_CHECK(profilingState1.GetCurrentState() ==  ProfilingState::Uninitialised);
+    BOOST_CHECK(profilingState1.GetCurrentState() == ProfilingState::Uninitialised);
 
     ProfilingStateMachine profilingState2(ProfilingState::Uninitialised);
     profilingState2.TransitionToState(ProfilingState::NotConnected);
@@ -438,44 +428,37 @@
     BOOST_CHECK(profilingState8.GetCurrentState() == ProfilingState::Active);
 
     ProfilingStateMachine profilingState9(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(profilingState9.TransitionToState(ProfilingState::WaitingForAck),
-                      armnn::Exception);
+    BOOST_CHECK_THROW(profilingState9.TransitionToState(ProfilingState::WaitingForAck), armnn::Exception);
 
     ProfilingStateMachine profilingState10(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(profilingState10.TransitionToState(ProfilingState::Active),
-                      armnn::Exception);
+    BOOST_CHECK_THROW(profilingState10.TransitionToState(ProfilingState::Active), armnn::Exception);
 
     ProfilingStateMachine profilingState11(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(profilingState11.TransitionToState(ProfilingState::Uninitialised),
-                      armnn::Exception);
+    BOOST_CHECK_THROW(profilingState11.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
 
     ProfilingStateMachine profilingState12(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(profilingState12.TransitionToState(ProfilingState::Active),
-                      armnn::Exception);
+    BOOST_CHECK_THROW(profilingState12.TransitionToState(ProfilingState::Active), armnn::Exception);
 
     ProfilingStateMachine profilingState13(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(profilingState13.TransitionToState(ProfilingState::Uninitialised),
-                      armnn::Exception);
+    BOOST_CHECK_THROW(profilingState13.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
 
     ProfilingStateMachine profilingState14(ProfilingState::WaitingForAck);
     profilingState14.TransitionToState(ProfilingState::NotConnected);
     BOOST_CHECK(profilingState14.GetCurrentState() == ProfilingState::NotConnected);
 
     ProfilingStateMachine profilingState15(ProfilingState::Active);
-    BOOST_CHECK_THROW(profilingState15.TransitionToState(ProfilingState::Uninitialised),
-                      armnn::Exception);
+    BOOST_CHECK_THROW(profilingState15.TransitionToState(ProfilingState::Uninitialised), armnn::Exception);
 
     ProfilingStateMachine profilingState16(armnn::profiling::ProfilingState::Active);
-    BOOST_CHECK_THROW(profilingState16.TransitionToState(ProfilingState::WaitingForAck),
-                      armnn::Exception);
+    BOOST_CHECK_THROW(profilingState16.TransitionToState(ProfilingState::WaitingForAck), armnn::Exception);
 
     ProfilingStateMachine profilingState17(ProfilingState::Uninitialised);
 
-    std::thread thread1 (ProfilingCurrentStateThreadImpl,std::ref(profilingState17));
-    std::thread thread2 (ProfilingCurrentStateThreadImpl,std::ref(profilingState17));
-    std::thread thread3 (ProfilingCurrentStateThreadImpl,std::ref(profilingState17));
-    std::thread thread4 (ProfilingCurrentStateThreadImpl,std::ref(profilingState17));
-    std::thread thread5 (ProfilingCurrentStateThreadImpl,std::ref(profilingState17));
+    std::thread thread1(ProfilingCurrentStateThreadImpl, std::ref(profilingState17));
+    std::thread thread2(ProfilingCurrentStateThreadImpl, std::ref(profilingState17));
+    std::thread thread3(ProfilingCurrentStateThreadImpl, std::ref(profilingState17));
+    std::thread thread4(ProfilingCurrentStateThreadImpl, std::ref(profilingState17));
+    std::thread thread5(ProfilingCurrentStateThreadImpl, std::ref(profilingState17));
 
     thread1.join();
     thread2.join();
@@ -541,17 +524,14 @@
     std::vector<std::thread> readThreadsVect;
     for (uint32_t i = 0; i < numThreads; ++i)
     {
-        threadsVect.emplace_back(std::thread(CaptureDataWriteThreadImpl,
-                                 std::ref(holder),
-                                 i,
-                                 std::ref(periodIdMap[i])));
+        threadsVect.emplace_back(
+            std::thread(CaptureDataWriteThreadImpl, std::ref(holder), i, std::ref(periodIdMap[i])));
 
         // Verify that the CaptureData goes into the thread in a virgin state
         BOOST_CHECK(captureDataIdMap.at(i).GetCapturePeriod() == 0);
         BOOST_CHECK(captureDataIdMap.at(i).GetCounterIds().empty());
-        readThreadsVect.emplace_back(std::thread(CaptureDataReadThreadImpl,
-                                     std::ref(holder),
-                                     std::ref(captureDataIdMap.at(i))));
+        readThreadsVect.emplace_back(
+            std::thread(CaptureDataReadThreadImpl, std::ref(holder), std::ref(captureDataIdMap.at(i))));
     }
 
     for (uint32_t i = 0; i < numThreads; ++i)
@@ -572,7 +552,7 @@
 BOOST_AUTO_TEST_CASE(CaptureDataMethods)
 {
     // Check CaptureData setter and getter functions
-    std::vector<uint16_t> counterIds = {42, 29, 13};
+    std::vector<uint16_t> counterIds = { 42, 29, 13 };
     CaptureData captureData;
     BOOST_CHECK(captureData.GetCapturePeriod() == 0);
     BOOST_CHECK((captureData.GetCounterIds()).empty());
@@ -611,7 +591,7 @@
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
 
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
@@ -672,13 +652,13 @@
 BOOST_AUTO_TEST_CASE(CheckProfilingServiceCounterValues)
 {
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     profilingService.Update();
     const ICounterDirectory& counterDirectory = profilingService.GetCounterDirectory();
-    const Counters& counters = counterDirectory.GetCounters();
+    const Counters& counters                  = counterDirectory.GetCounters();
     BOOST_CHECK(!counters.empty());
 
     // Get the UID of the first counter for testing
@@ -687,13 +667,13 @@
     ProfilingService* profilingServicePtr = &profilingService;
     std::vector<std::thread> writers;
 
-    for (int i = 0; i < 100 ; ++i)
+    for (int i = 0; i < 100; ++i)
     {
         // Increment and decrement the first counter
         writers.push_back(std::thread(&ProfilingService::IncrementCounterValue, profilingServicePtr, counterUid));
         writers.push_back(std::thread(&ProfilingService::DecrementCounterValue, profilingServicePtr, counterUid));
         // Add 10 and subtract 5 from the first counter
-        writers.push_back(std::thread(&ProfilingService::AddCounterValue,      profilingServicePtr, counterUid, 10));
+        writers.push_back(std::thread(&ProfilingService::AddCounterValue, profilingServicePtr, counterUid, 10));
         writers.push_back(std::thread(&ProfilingService::SubtractCounterValue, profilingServicePtr, counterUid, 5));
     }
 
@@ -733,7 +713,7 @@
     BOOST_CHECK_NO_THROW(counterUidsMultiCore = GetNextCounterUids(numberOfCores));
     BOOST_CHECK(counterUidsMultiCore.size() == numberOfCores);
     BOOST_CHECK(counterUidsMultiCore.front() >= nextCounterUids[0]);
-    for (size_t i = 1; i < numberOfCores; i ++)
+    for (size_t i = 1; i < numberOfCores; i++)
     {
         BOOST_CHECK(counterUidsMultiCore[i] == counterUidsMultiCore[i - 1] + 1);
     }
@@ -743,10 +723,10 @@
 BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCategory)
 {
     CounterDirectory counterDirectory;
-    BOOST_CHECK(counterDirectory.GetCategoryCount()   == 0);
-    BOOST_CHECK(counterDirectory.GetDeviceCount()     == 0);
+    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
+    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterCount()    == 0);
+    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
 
     // Register a category with an invalid name
     const Category* noCategory = nullptr;
@@ -762,7 +742,7 @@
 
     // Register a new category
     const std::string categoryName = "some_category";
-    const Category* category = nullptr;
+    const Category* category       = nullptr;
     BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
     BOOST_CHECK(category);
@@ -791,7 +771,7 @@
 
     // Register a device for testing
     const std::string deviceName = "some_device";
-    const Device* device = nullptr;
+    const Device* device         = nullptr;
     BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName));
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
     BOOST_CHECK(device);
@@ -801,7 +781,7 @@
 
     // Register a new category not associated to any device
     const std::string categoryWoDeviceName = "some_category_without_device";
-    const Category* categoryWoDevice = nullptr;
+    const Category* categoryWoDevice       = nullptr;
     BOOST_CHECK_NO_THROW(categoryWoDevice = counterDirectory.RegisterCategory(categoryWoDeviceName, 0));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
     BOOST_CHECK(categoryWoDevice);
@@ -818,19 +798,17 @@
     ARMNN_NO_CONVERSION_WARN_END
 
     const Category* categoryWInvalidDevice = nullptr;
-    BOOST_CHECK_THROW(categoryWInvalidDevice
-                      = counterDirectory.RegisterCategory(categoryWInvalidDeviceName,
-                                                          invalidDeviceUid),
+    BOOST_CHECK_THROW(categoryWInvalidDevice =
+                          counterDirectory.RegisterCategory(categoryWInvalidDeviceName, invalidDeviceUid),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
     BOOST_CHECK(!categoryWInvalidDevice);
 
     // Register a new category associated to a valid device
     const std::string categoryWValidDeviceName = "some_category_with_valid_device";
-    const Category* categoryWValidDevice = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWValidDevice
-                         = counterDirectory.RegisterCategory(categoryWValidDeviceName,
-                                                             device->m_Uid));
+    const Category* categoryWValidDevice       = nullptr;
+    BOOST_CHECK_NO_THROW(categoryWValidDevice =
+                             counterDirectory.RegisterCategory(categoryWValidDeviceName, device->m_Uid));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 3);
     BOOST_CHECK(categoryWValidDevice);
     BOOST_CHECK(categoryWValidDevice != category);
@@ -840,7 +818,7 @@
 
     // Register a counter set for testing
     const std::string counterSetName = "some_counter_set";
-    const CounterSet* counterSet = nullptr;
+    const CounterSet* counterSet     = nullptr;
     BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
     BOOST_CHECK(counterSet);
@@ -850,11 +828,9 @@
 
     // Register a new category not associated to any counter set
     const std::string categoryWoCounterSetName = "some_category_without_counter_set";
-    const Category* categoryWoCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWoCounterSet
-                         = counterDirectory.RegisterCategory(categoryWoCounterSetName,
-                                                             armnn::EmptyOptional(),
-                                                             0));
+    const Category* categoryWoCounterSet       = nullptr;
+    BOOST_CHECK_NO_THROW(categoryWoCounterSet =
+                             counterDirectory.RegisterCategory(categoryWoCounterSetName, armnn::EmptyOptional(), 0));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 4);
     BOOST_CHECK(categoryWoCounterSet);
     BOOST_CHECK(categoryWoCounterSet->m_Name == categoryWoCounterSetName);
@@ -869,21 +845,17 @@
     ARMNN_NO_CONVERSION_WARN_END
 
     const Category* categoryWInvalidCounterSet = nullptr;
-    BOOST_CHECK_THROW(categoryWInvalidCounterSet
-                      = counterDirectory.RegisterCategory(categoryWInvalidCounterSetName,
-                                                          armnn::EmptyOptional(),
-                                                          invalidCunterSetUid),
+    BOOST_CHECK_THROW(categoryWInvalidCounterSet = counterDirectory.RegisterCategory(
+                          categoryWInvalidCounterSetName, armnn::EmptyOptional(), invalidCunterSetUid),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 4);
     BOOST_CHECK(!categoryWInvalidCounterSet);
 
     // Register a new category associated to a valid counter set
     const std::string categoryWValidCounterSetName = "some_category_with_valid_counter_set";
-    const Category* categoryWValidCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWValidCounterSet
-                         = counterDirectory.RegisterCategory(categoryWValidCounterSetName,
-                                                             armnn::EmptyOptional(),
-                                                             counterSet->m_Uid));
+    const Category* categoryWValidCounterSet       = nullptr;
+    BOOST_CHECK_NO_THROW(categoryWValidCounterSet = counterDirectory.RegisterCategory(
+                             categoryWValidCounterSetName, armnn::EmptyOptional(), counterSet->m_Uid));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 5);
     BOOST_CHECK(categoryWValidCounterSet);
     BOOST_CHECK(categoryWValidCounterSet != category);
@@ -893,11 +865,9 @@
 
     // Register a new category associated to a valid device and counter set
     const std::string categoryWValidDeviceAndValidCounterSetName = "some_category_with_valid_device_and_counter_set";
-    const Category* categoryWValidDeviceAndValidCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(categoryWValidDeviceAndValidCounterSet
-                         = counterDirectory.RegisterCategory(categoryWValidDeviceAndValidCounterSetName,
-                                                             device->m_Uid,
-                                                             counterSet->m_Uid));
+    const Category* categoryWValidDeviceAndValidCounterSet       = nullptr;
+    BOOST_CHECK_NO_THROW(categoryWValidDeviceAndValidCounterSet = counterDirectory.RegisterCategory(
+                             categoryWValidDeviceAndValidCounterSetName, device->m_Uid, counterSet->m_Uid));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 6);
     BOOST_CHECK(categoryWValidDeviceAndValidCounterSet);
     BOOST_CHECK(categoryWValidDeviceAndValidCounterSet != category);
@@ -909,10 +879,10 @@
 BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterDevice)
 {
     CounterDirectory counterDirectory;
-    BOOST_CHECK(counterDirectory.GetCategoryCount()   == 0);
-    BOOST_CHECK(counterDirectory.GetDeviceCount()     == 0);
+    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
+    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterCount()    == 0);
+    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
 
     // Register a device with an invalid name
     const Device* noDevice = nullptr;
@@ -927,7 +897,7 @@
 
     // Register a new device with no cores or parent category
     const std::string deviceName = "some_device";
-    const Device* device = nullptr;
+    const Device* device         = nullptr;
     BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName));
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
     BOOST_CHECK(device);
@@ -953,7 +923,7 @@
 
     // Register a new device with cores and no parent category
     const std::string deviceWCoresName = "some_device_with_cores";
-    const Device* deviceWCores = nullptr;
+    const Device* deviceWCores         = nullptr;
     BOOST_CHECK_NO_THROW(deviceWCores = counterDirectory.RegisterDevice(deviceWCoresName, 2));
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
     BOOST_CHECK(deviceWCores);
@@ -971,29 +941,25 @@
 
     // Register a new device with cores and invalid parent category
     const std::string deviceWCoresWInvalidParentCategoryName = "some_device_with_cores_with_invalid_parent_category";
-    const Device* deviceWCoresWInvalidParentCategory = nullptr;
-    BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory
-                      = counterDirectory.RegisterDevice(deviceWCoresWInvalidParentCategoryName,
-                                                        3,
-                                                        std::string("")),
+    const Device* deviceWCoresWInvalidParentCategory         = nullptr;
+    BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory =
+                          counterDirectory.RegisterDevice(deviceWCoresWInvalidParentCategoryName, 3, std::string("")),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
     BOOST_CHECK(!deviceWCoresWInvalidParentCategory);
 
     // Register a new device with cores and invalid parent category
     const std::string deviceWCoresWInvalidParentCategoryName2 = "some_device_with_cores_with_invalid_parent_category2";
-    const Device* deviceWCoresWInvalidParentCategory2 = nullptr;
-    BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory2
-                      = counterDirectory.RegisterDevice(deviceWCoresWInvalidParentCategoryName2,
-                                                        3,
-                                                        std::string("invalid_parent_category")),
+    const Device* deviceWCoresWInvalidParentCategory2         = nullptr;
+    BOOST_CHECK_THROW(deviceWCoresWInvalidParentCategory2 = counterDirectory.RegisterDevice(
+                          deviceWCoresWInvalidParentCategoryName2, 3, std::string("invalid_parent_category")),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
     BOOST_CHECK(!deviceWCoresWInvalidParentCategory2);
 
     // Register a category for testing
     const std::string categoryName = "some_category";
-    const Category* category = nullptr;
+    const Category* category       = nullptr;
     BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
     BOOST_CHECK(category);
@@ -1004,11 +970,9 @@
 
     // Register a new device with cores and valid parent category
     const std::string deviceWCoresWValidParentCategoryName = "some_device_with_cores_with_valid_parent_category";
-    const Device* deviceWCoresWValidParentCategory = nullptr;
-    BOOST_CHECK_NO_THROW(deviceWCoresWValidParentCategory
-                         = counterDirectory.RegisterDevice(deviceWCoresWValidParentCategoryName,
-                                                           4,
-                                                           categoryName));
+    const Device* deviceWCoresWValidParentCategory         = nullptr;
+    BOOST_CHECK_NO_THROW(deviceWCoresWValidParentCategory =
+                             counterDirectory.RegisterDevice(deviceWCoresWValidParentCategoryName, 4, categoryName));
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 3);
     BOOST_CHECK(deviceWCoresWValidParentCategory);
     BOOST_CHECK(deviceWCoresWValidParentCategory->m_Name == deviceWCoresWValidParentCategoryName);
@@ -1020,7 +984,7 @@
 
     // Register a device associated to a category already associated to a different device
     const std::string deviceSameCategoryName = "some_device_with_invalid_parent_category";
-    const Device* deviceSameCategory = nullptr;
+    const Device* deviceSameCategory         = nullptr;
     BOOST_CHECK_THROW(deviceSameCategory = counterDirectory.RegisterDevice(deviceSameCategoryName, 0, categoryName),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 3);
@@ -1030,10 +994,10 @@
 BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounterSet)
 {
     CounterDirectory counterDirectory;
-    BOOST_CHECK(counterDirectory.GetCategoryCount()   == 0);
-    BOOST_CHECK(counterDirectory.GetDeviceCount()     == 0);
+    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
+    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterCount()    == 0);
+    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
 
     // Register a counter set with an invalid name
     const CounterSet* noCounterSet = nullptr;
@@ -1049,7 +1013,7 @@
 
     // Register a new counter set with no count or parent category
     const std::string counterSetName = "some_counter_set";
-    const CounterSet* counterSet = nullptr;
+    const CounterSet* counterSet     = nullptr;
     BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
     BOOST_CHECK(counterSet);
@@ -1076,7 +1040,7 @@
 
     // Register a new counter set with count and no parent category
     const std::string counterSetWCountName = "some_counter_set_with_count";
-    const CounterSet* counterSetWCount = nullptr;
+    const CounterSet* counterSetWCount     = nullptr;
     BOOST_CHECK_NO_THROW(counterSetWCount = counterDirectory.RegisterCounterSet(counterSetWCountName, 37));
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 2);
     BOOST_CHECK(counterSetWCount);
@@ -1096,10 +1060,8 @@
     const std::string counterSetWCountWInvalidParentCategoryName = "some_counter_set_with_count_"
                                                                    "with_invalid_parent_category";
     const CounterSet* counterSetWCountWInvalidParentCategory = nullptr;
-    BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory
-                      = counterDirectory.RegisterCounterSet(counterSetWCountWInvalidParentCategoryName,
-                                                            42,
-                                                            std::string("")),
+    BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory = counterDirectory.RegisterCounterSet(
+                          counterSetWCountWInvalidParentCategoryName, 42, std::string("")),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 2);
     BOOST_CHECK(!counterSetWCountWInvalidParentCategory);
@@ -1108,17 +1070,15 @@
     const std::string counterSetWCountWInvalidParentCategoryName2 = "some_counter_set_with_count_"
                                                                     "with_invalid_parent_category2";
     const CounterSet* counterSetWCountWInvalidParentCategory2 = nullptr;
-    BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory2
-                      = counterDirectory.RegisterCounterSet(counterSetWCountWInvalidParentCategoryName2,
-                                                            42,
-                                                            std::string("invalid_parent_category")),
+    BOOST_CHECK_THROW(counterSetWCountWInvalidParentCategory2 = counterDirectory.RegisterCounterSet(
+                          counterSetWCountWInvalidParentCategoryName2, 42, std::string("invalid_parent_category")),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 2);
     BOOST_CHECK(!counterSetWCountWInvalidParentCategory2);
 
     // Register a category for testing
     const std::string categoryName = "some_category";
-    const Category* category = nullptr;
+    const Category* category       = nullptr;
     BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
     BOOST_CHECK(category);
@@ -1131,10 +1091,8 @@
     const std::string counterSetWCountWValidParentCategoryName = "some_counter_set_with_count_"
                                                                  "with_valid_parent_category";
     const CounterSet* counterSetWCountWValidParentCategory = nullptr;
-    BOOST_CHECK_NO_THROW(counterSetWCountWValidParentCategory
-                         = counterDirectory.RegisterCounterSet(counterSetWCountWValidParentCategoryName,
-                                                               42,
-                                                               categoryName));
+    BOOST_CHECK_NO_THROW(counterSetWCountWValidParentCategory = counterDirectory.RegisterCounterSet(
+                             counterSetWCountWValidParentCategoryName, 42, categoryName));
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 3);
     BOOST_CHECK(counterSetWCountWValidParentCategory);
     BOOST_CHECK(counterSetWCountWValidParentCategory->m_Name == counterSetWCountWValidParentCategoryName);
@@ -1146,10 +1104,9 @@
 
     // Register a counter set associated to a category already associated to a different counter set
     const std::string counterSetSameCategoryName = "some_counter_set_with_invalid_parent_category";
-    const CounterSet* counterSetSameCategory = nullptr;
-    BOOST_CHECK_THROW(counterSetSameCategory = counterDirectory.RegisterCounterSet(counterSetSameCategoryName,
-                                                                                   0,
-                                                                                   categoryName),
+    const CounterSet* counterSetSameCategory     = nullptr;
+    BOOST_CHECK_THROW(counterSetSameCategory =
+                          counterDirectory.RegisterCounterSet(counterSetSameCategoryName, 0, categoryName),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 3);
     BOOST_CHECK(!counterSetSameCategory);
@@ -1158,130 +1115,85 @@
 BOOST_AUTO_TEST_CASE(CheckCounterDirectoryRegisterCounter)
 {
     CounterDirectory counterDirectory;
-    BOOST_CHECK(counterDirectory.GetCategoryCount()   == 0);
-    BOOST_CHECK(counterDirectory.GetDeviceCount()     == 0);
+    BOOST_CHECK(counterDirectory.GetCategoryCount() == 0);
+    BOOST_CHECK(counterDirectory.GetDeviceCount() == 0);
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 0);
-    BOOST_CHECK(counterDirectory.GetCounterCount()    == 0);
+    BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
 
     // Register a counter with an invalid parent category name
     const Counter* noCounter = nullptr;
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("",
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name",
-                                                                   "valid description"),
+    BOOST_CHECK_THROW(noCounter =
+                          counterDirectory.RegisterCounter("", 0, 1, 123.45f, "valid name", "valid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid parent category name
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("invalid parent category",
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name",
-                                                                   "valid description"),
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("invalid parent category", 0, 1, 123.45f,
+                                                                   "valid name", "valid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid class
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category",
-                                                                   2,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name",
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category", 2, 1, 123.45f, "valid name",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid interpolation
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category",
-                                                                   0,
-                                                                   3,
-                                                                   123.45f,
-                                                                   "valid name",
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category", 0, 3, 123.45f, "valid name",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid multiplier
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category",
-                                                                   0,
-                                                                   1,
-                                                                   .0f,
-                                                                   "valid name",
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category", 0, 1, .0f, "valid name",
                                                                    "valid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid name
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category",
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "",
-                                                                   "valid description"),
-                      armnn::InvalidArgumentException);
+    BOOST_CHECK_THROW(
+        noCounter = counterDirectory.RegisterCounter("valid_parent_category", 0, 1, 123.45f, "", "valid description"),
+        armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid name
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category",
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "invalid nam€",
-                                                                   "valid description"),
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category", 0, 1, 123.45f,
+                                                                   "invalid nam€", "valid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid description
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category",
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name",
-                                                                   ""),
+    BOOST_CHECK_THROW(noCounter =
+                          counterDirectory.RegisterCounter("valid_parent_category", 0, 1, 123.45f, "valid name", ""),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid description
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category",
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name",
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category", 0, 1, 123.45f, "valid name",
                                                                    "inv@lid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with an invalid unit2
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category",
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name",
-                                                                   "valid description",
-                                                                   std::string("Mb/s2")),
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("valid_parent_category", 0, 1, 123.45f, "valid name",
+                                                                   "valid description", std::string("Mb/s2")),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with a non-existing parent category name
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("invalid_parent_category",
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name",
-                                                                   "valid description"),
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter("invalid_parent_category", 0, 1, 123.45f,
+                                                                   "valid name", "valid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 0);
     BOOST_CHECK(!noCounter);
@@ -1292,7 +1204,7 @@
 
     // Register a category for testing
     const std::string categoryName = "some_category";
-    const Category* category = nullptr;
+    const Category* category       = nullptr;
     BOOST_CHECK_NO_THROW(category = counterDirectory.RegisterCategory(categoryName));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 1);
     BOOST_CHECK(category);
@@ -1303,12 +1215,8 @@
 
     // Register a counter with a valid parent category name
     const Counter* counter = nullptr;
-    BOOST_CHECK_NO_THROW(counter = counterDirectory.RegisterCounter(categoryName,
-                                                                    0,
-                                                                    1,
-                                                                    123.45f,
-                                                                    "valid name",
-                                                                    "valid description"));
+    BOOST_CHECK_NO_THROW(
+        counter = counterDirectory.RegisterCounter(categoryName, 0, 1, 123.45f, "valid name", "valid description"));
     BOOST_CHECK(counterDirectory.GetCounterCount() == 1);
     BOOST_CHECK(counter);
     BOOST_CHECK(counter->m_Uid >= 0);
@@ -1326,25 +1234,17 @@
 
     // Register a counter with a name of a counter already registered for the given parent category name
     const Counter* counterSameName = nullptr;
-    BOOST_CHECK_THROW(counterSameName = counterDirectory.RegisterCounter(categoryName,
-                                                                         0,
-                                                                         0,
-                                                                         1.0f,
-                                                                         "valid name",
-                                                                         "valid description"),
+    BOOST_CHECK_THROW(counterSameName =
+                          counterDirectory.RegisterCounter(categoryName, 0, 0, 1.0f, "valid name", "valid description"),
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 1);
     BOOST_CHECK(!counterSameName);
 
     // Register a counter with a valid parent category name and units
     const Counter* counterWUnits = nullptr;
-    BOOST_CHECK_NO_THROW(counterWUnits = counterDirectory.RegisterCounter(categoryName,
-                                                                          0,
-                                                                          1,
-                                                                          123.45f,
-                                                                          "valid name 2",
+    BOOST_CHECK_NO_THROW(counterWUnits = counterDirectory.RegisterCounter(categoryName, 0, 1, 123.45f, "valid name 2",
                                                                           "valid description",
-                                                                          std::string("Mnnsq2"))); // Units
+                                                                          std::string("Mnnsq2")));    // Units
     BOOST_CHECK(counterDirectory.GetCounterCount() == 2);
     BOOST_CHECK(counterWUnits);
     BOOST_CHECK(counterWUnits->m_Uid >= 0);
@@ -1363,15 +1263,11 @@
 
     // Register a counter with a valid parent category name and not associated with a device
     const Counter* counterWoDevice = nullptr;
-    BOOST_CHECK_NO_THROW(counterWoDevice = counterDirectory.RegisterCounter(categoryName,
-                                                                            0,
-                                                                            1,
-                                                                            123.45f,
-                                                                            "valid name 3",
-                                                                            "valid description",
-                                                                            armnn::EmptyOptional(), // Units
-                                                                            armnn::EmptyOptional(), // Number of cores
-                                                                            0));                    // Device UID
+    BOOST_CHECK_NO_THROW(counterWoDevice = counterDirectory.RegisterCounter(
+                             categoryName, 0, 1, 123.45f, "valid name 3", "valid description",
+                             armnn::EmptyOptional(),    // Units
+                             armnn::EmptyOptional(),    // Number of cores
+                             0));                       // Device UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 3);
     BOOST_CHECK(counterWoDevice);
     BOOST_CHECK(counterWoDevice->m_Uid >= 0);
@@ -1389,22 +1285,18 @@
     BOOST_CHECK(category->m_Counters.back() == counterWoDevice->m_Uid);
 
     // Register a counter with a valid parent category name and associated to an invalid device
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(categoryName,
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name 4",
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(categoryName, 0, 1, 123.45f, "valid name 4",
                                                                    "valid description",
-                                                                   armnn::EmptyOptional(), // Units
-                                                                   armnn::EmptyOptional(), // Number of cores
-                                                                   100),                   // Device UID
+                                                                   armnn::EmptyOptional(),    // Units
+                                                                   armnn::EmptyOptional(),    // Number of cores
+                                                                   100),                      // Device UID
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 3);
     BOOST_CHECK(!noCounter);
 
     // Register a device for testing
     const std::string deviceName = "some_device";
-    const Device* device = nullptr;
+    const Device* device         = nullptr;
     BOOST_CHECK_NO_THROW(device = counterDirectory.RegisterDevice(deviceName));
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 1);
     BOOST_CHECK(device);
@@ -1414,15 +1306,11 @@
 
     // Register a counter with a valid parent category name and associated to a device
     const Counter* counterWDevice = nullptr;
-    BOOST_CHECK_NO_THROW(counterWDevice = counterDirectory.RegisterCounter(categoryName,
-                                                                           0,
-                                                                           1,
-                                                                           123.45f,
-                                                                           "valid name 5",
+    BOOST_CHECK_NO_THROW(counterWDevice = counterDirectory.RegisterCounter(categoryName, 0, 1, 123.45f, "valid name 5",
                                                                            "valid description",
-                                                                           armnn::EmptyOptional(), // Units
-                                                                           armnn::EmptyOptional(), // Number of cores
-                                                                           device->m_Uid));        // Device UID
+                                                                           armnn::EmptyOptional(),    // Units
+                                                                           armnn::EmptyOptional(),    // Number of cores
+                                                                           device->m_Uid));           // Device UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 4);
     BOOST_CHECK(counterWDevice);
     BOOST_CHECK(counterWDevice->m_Uid >= 0);
@@ -1441,17 +1329,12 @@
 
     // Register a counter with a valid parent category name and not associated with a counter set
     const Counter* counterWoCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterWoCounterSet
-                         = counterDirectory.RegisterCounter(categoryName,
-                                                            0,
-                                                            1,
-                                                            123.45f,
-                                                            "valid name 6",
-                                                            "valid description",
-                                                            armnn::EmptyOptional(), // Units
-                                                            armnn::EmptyOptional(), // Number of cores
-                                                            armnn::EmptyOptional(), // Device UID
-                                                            0));                    // Counter set UID
+    BOOST_CHECK_NO_THROW(counterWoCounterSet = counterDirectory.RegisterCounter(
+                             categoryName, 0, 1, 123.45f, "valid name 6", "valid description",
+                             armnn::EmptyOptional(),    // Units
+                             armnn::EmptyOptional(),    // Number of cores
+                             armnn::EmptyOptional(),    // Device UID
+                             0));                       // Counter set UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 5);
     BOOST_CHECK(counterWoCounterSet);
     BOOST_CHECK(counterWoCounterSet->m_Uid >= 0);
@@ -1469,34 +1352,25 @@
     BOOST_CHECK(category->m_Counters.back() == counterWoCounterSet->m_Uid);
 
     // Register a counter with a valid parent category name and associated to an invalid counter set
-    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(categoryName,
-                                                                   0,
-                                                                   1,
-                                                                   123.45f,
-                                                                   "valid name 7",
+    BOOST_CHECK_THROW(noCounter = counterDirectory.RegisterCounter(categoryName, 0, 1, 123.45f, "valid name 7",
                                                                    "valid description",
-                                                                   armnn::EmptyOptional(), // Units
-                                                                   armnn::EmptyOptional(), // Number of cores
-                                                                   armnn::EmptyOptional(), // Device UID
-                                                                   100),                   // Counter set UID
+                                                                   armnn::EmptyOptional(),    // Units
+                                                                   armnn::EmptyOptional(),    // Number of cores
+                                                                   armnn::EmptyOptional(),    // Device UID
+                                                                   100),                      // Counter set UID
                       armnn::InvalidArgumentException);
     BOOST_CHECK(counterDirectory.GetCounterCount() == 5);
     BOOST_CHECK(!noCounter);
 
     // Register a counter with a valid parent category name and with a given number of cores
     const Counter* counterWNumberOfCores = nullptr;
-    uint16_t numberOfCores = 15;
-    BOOST_CHECK_NO_THROW(counterWNumberOfCores
-                         = counterDirectory.RegisterCounter(categoryName,
-                                                            0,
-                                                            1,
-                                                            123.45f,
-                                                            "valid name 8",
-                                                            "valid description",
-                                                            armnn::EmptyOptional(),   // Units
-                                                            numberOfCores,            // Number of cores
-                                                            armnn::EmptyOptional(),   // Device UID
-                                                            armnn::EmptyOptional())); // Counter set UID
+    uint16_t numberOfCores               = 15;
+    BOOST_CHECK_NO_THROW(counterWNumberOfCores = counterDirectory.RegisterCounter(
+                             categoryName, 0, 1, 123.45f, "valid name 8", "valid description",
+                             armnn::EmptyOptional(),      // Units
+                             numberOfCores,               // Number of cores
+                             armnn::EmptyOptional(),      // Device UID
+                             armnn::EmptyOptional()));    // Counter set UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 20);
     BOOST_CHECK(counterWNumberOfCores);
     BOOST_CHECK(counterWNumberOfCores->m_Uid >= 0);
@@ -1511,7 +1385,7 @@
     BOOST_CHECK(counterWNumberOfCores->m_DeviceUid == 0);
     BOOST_CHECK(counterWNumberOfCores->m_CounterSetUid == 0);
     BOOST_CHECK(category->m_Counters.size() == 20);
-    for (size_t i = 0; i < numberOfCores; i ++)
+    for (size_t i = 0; i < numberOfCores; i++)
     {
         BOOST_CHECK(category->m_Counters[category->m_Counters.size() - numberOfCores + i] ==
                     counterWNumberOfCores->m_Uid + i);
@@ -1519,7 +1393,7 @@
 
     // Register a multi-core device for testing
     const std::string multiCoreDeviceName = "some_multi_core_device";
-    const Device* multiCoreDevice = nullptr;
+    const Device* multiCoreDevice         = nullptr;
     BOOST_CHECK_NO_THROW(multiCoreDevice = counterDirectory.RegisterDevice(multiCoreDeviceName, 4));
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 2);
     BOOST_CHECK(multiCoreDevice);
@@ -1529,17 +1403,12 @@
 
     // Register a counter with a valid parent category name and associated to the multi-core device
     const Counter* counterWMultiCoreDevice = nullptr;
-    BOOST_CHECK_NO_THROW(counterWMultiCoreDevice
-                         = counterDirectory.RegisterCounter(categoryName,
-                                                            0,
-                                                            1,
-                                                            123.45f,
-                                                            "valid name 9",
-                                                            "valid description",
-                                                            armnn::EmptyOptional(),   // Units
-                                                            armnn::EmptyOptional(),   // Number of cores
-                                                            multiCoreDevice->m_Uid,   // Device UID
-                                                            armnn::EmptyOptional())); // Counter set UID
+    BOOST_CHECK_NO_THROW(counterWMultiCoreDevice = counterDirectory.RegisterCounter(
+                             categoryName, 0, 1, 123.45f, "valid name 9", "valid description",
+                             armnn::EmptyOptional(),      // Units
+                             armnn::EmptyOptional(),      // Number of cores
+                             multiCoreDevice->m_Uid,      // Device UID
+                             armnn::EmptyOptional()));    // Counter set UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 24);
     BOOST_CHECK(counterWMultiCoreDevice);
     BOOST_CHECK(counterWMultiCoreDevice->m_Uid >= 0);
@@ -1555,16 +1424,16 @@
     BOOST_CHECK(counterWMultiCoreDevice->m_DeviceUid == multiCoreDevice->m_Uid);
     BOOST_CHECK(counterWMultiCoreDevice->m_CounterSetUid == 0);
     BOOST_CHECK(category->m_Counters.size() == 24);
-    for (size_t i = 0; i < 4; i ++)
+    for (size_t i = 0; i < 4; i++)
     {
         BOOST_CHECK(category->m_Counters[category->m_Counters.size() - 4 + i] == counterWMultiCoreDevice->m_Uid + i);
     }
 
     // Register a multi-core device associate to a parent category for testing
     const std::string multiCoreDeviceNameWParentCategory = "some_multi_core_device_with_parent_category";
-    const Device* multiCoreDeviceWParentCategory = nullptr;
+    const Device* multiCoreDeviceWParentCategory         = nullptr;
     BOOST_CHECK_NO_THROW(multiCoreDeviceWParentCategory =
-            counterDirectory.RegisterDevice(multiCoreDeviceNameWParentCategory, 2, categoryName));
+                             counterDirectory.RegisterDevice(multiCoreDeviceNameWParentCategory, 2, categoryName));
     BOOST_CHECK(counterDirectory.GetDeviceCount() == 3);
     BOOST_CHECK(multiCoreDeviceWParentCategory);
     BOOST_CHECK(multiCoreDeviceWParentCategory->m_Name == multiCoreDeviceNameWParentCategory);
@@ -1574,17 +1443,12 @@
     // Register a counter with a valid parent category name and getting the number of cores of the multi-core device
     // associated to that category
     const Counter* counterWMultiCoreDeviceWParentCategory = nullptr;
-    BOOST_CHECK_NO_THROW(counterWMultiCoreDeviceWParentCategory
-                         = counterDirectory.RegisterCounter(categoryName,
-                                                            0,
-                                                            1,
-                                                            123.45f,
-                                                            "valid name 10",
-                                                            "valid description",
-                                                            armnn::EmptyOptional(),   // Units
-                                                            armnn::EmptyOptional(),   // Number of cores
-                                                            armnn::EmptyOptional(),   // Device UID
-                                                            armnn::EmptyOptional())); // Counter set UID
+    BOOST_CHECK_NO_THROW(counterWMultiCoreDeviceWParentCategory = counterDirectory.RegisterCounter(
+                             categoryName, 0, 1, 123.45f, "valid name 10", "valid description",
+                             armnn::EmptyOptional(),      // Units
+                             armnn::EmptyOptional(),      // Number of cores
+                             armnn::EmptyOptional(),      // Device UID
+                             armnn::EmptyOptional()));    // Counter set UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 26);
     BOOST_CHECK(counterWMultiCoreDeviceWParentCategory);
     BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_Uid >= 0);
@@ -1600,7 +1464,7 @@
     BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_DeviceUid == 0);
     BOOST_CHECK(counterWMultiCoreDeviceWParentCategory->m_CounterSetUid == 0);
     BOOST_CHECK(category->m_Counters.size() == 26);
-    for (size_t i = 0; i < 2; i ++)
+    for (size_t i = 0; i < 2; i++)
     {
         BOOST_CHECK(category->m_Counters[category->m_Counters.size() - 2 + i] ==
                     counterWMultiCoreDeviceWParentCategory->m_Uid + i);
@@ -1608,7 +1472,7 @@
 
     // Register a counter set for testing
     const std::string counterSetName = "some_counter_set";
-    const CounterSet* counterSet = nullptr;
+    const CounterSet* counterSet     = nullptr;
     BOOST_CHECK_NO_THROW(counterSet = counterDirectory.RegisterCounterSet(counterSetName));
     BOOST_CHECK(counterDirectory.GetCounterSetCount() == 1);
     BOOST_CHECK(counterSet);
@@ -1618,17 +1482,12 @@
 
     // Register a counter with a valid parent category name and associated to a counter set
     const Counter* counterWCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterWCounterSet
-                         = counterDirectory.RegisterCounter(categoryName,
-                                                            0,
-                                                            1,
-                                                            123.45f,
-                                                            "valid name 11",
-                                                            "valid description",
-                                                            armnn::EmptyOptional(), // Units
-                                                            0,                      // Number of cores
-                                                            armnn::EmptyOptional(), // Device UID
-                                                            counterSet->m_Uid));    // Counter set UID
+    BOOST_CHECK_NO_THROW(counterWCounterSet = counterDirectory.RegisterCounter(
+                             categoryName, 0, 1, 123.45f, "valid name 11", "valid description",
+                             armnn::EmptyOptional(),    // Units
+                             0,                         // Number of cores
+                             armnn::EmptyOptional(),    // Device UID
+                             counterSet->m_Uid));       // Counter set UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 27);
     BOOST_CHECK(counterWCounterSet);
     BOOST_CHECK(counterWCounterSet->m_Uid >= 0);
@@ -1647,17 +1506,12 @@
 
     // Register a counter with a valid parent category name and associated to a device and a counter set
     const Counter* counterWDeviceWCounterSet = nullptr;
-    BOOST_CHECK_NO_THROW(counterWDeviceWCounterSet
-                         = counterDirectory.RegisterCounter(categoryName,
-                                                            0,
-                                                            1,
-                                                            123.45f,
-                                                            "valid name 12",
-                                                            "valid description",
-                                                            armnn::EmptyOptional(), // Units
-                                                            1,                      // Number of cores
-                                                            device->m_Uid,          // Device UID
-                                                            counterSet->m_Uid));    // Counter set UID
+    BOOST_CHECK_NO_THROW(counterWDeviceWCounterSet = counterDirectory.RegisterCounter(
+                             categoryName, 0, 1, 123.45f, "valid name 12", "valid description",
+                             armnn::EmptyOptional(),    // Units
+                             1,                         // Number of cores
+                             device->m_Uid,             // Device UID
+                             counterSet->m_Uid));       // Counter set UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 28);
     BOOST_CHECK(counterWDeviceWCounterSet);
     BOOST_CHECK(counterWDeviceWCounterSet->m_Uid >= 0);
@@ -1676,7 +1530,7 @@
 
     // Register another category for testing
     const std::string anotherCategoryName = "some_other_category";
-    const Category* anotherCategory = nullptr;
+    const Category* anotherCategory       = nullptr;
     BOOST_CHECK_NO_THROW(anotherCategory = counterDirectory.RegisterCategory(anotherCategoryName));
     BOOST_CHECK(counterDirectory.GetCategoryCount() == 2);
     BOOST_CHECK(anotherCategory);
@@ -1688,16 +1542,12 @@
 
     // Register a counter to the other category
     const Counter* anotherCounter = nullptr;
-    BOOST_CHECK_NO_THROW(anotherCounter = counterDirectory.RegisterCounter(anotherCategoryName,
-                                                                           1,
-                                                                           0,
-                                                                           .00043f,
-                                                                           "valid name",
-                                                                           "valid description",
-                                                                           armnn::EmptyOptional(), // Units
-                                                                           armnn::EmptyOptional(), // Number of cores
-                                                                           device->m_Uid,          // Device UID
-                                                                           counterSet->m_Uid));    // Counter set UID
+    BOOST_CHECK_NO_THROW(anotherCounter = counterDirectory.RegisterCounter(anotherCategoryName, 1, 0, .00043f,
+                                                                           "valid name", "valid description",
+                                                                           armnn::EmptyOptional(),    // Units
+                                                                           armnn::EmptyOptional(),    // Number of cores
+                                                                           device->m_Uid,             // Device UID
+                                                                           counterSet->m_Uid));       // Counter set UID
     BOOST_CHECK(counterDirectory.GetCounterCount() == 29);
     BOOST_CHECK(anotherCounter);
     BOOST_CHECK(anotherCounter->m_Uid >= 0);
@@ -1722,15 +1572,26 @@
 
     class TestCaptureThread : public IPeriodicCounterCapture
     {
-        void Start() override {}
-        void Stop() override {}
+        void Start() override
+        {}
+        void Stop() override
+        {}
     };
 
     class TestReadCounterValues : public IReadCounterValues
     {
-        bool IsCounterRegistered(uint16_t counterUid) const override { return true; }
-        uint16_t GetCounterCount() const override { return 0; }
-        uint32_t GetCounterValue(uint16_t counterUid) const override { return 0; }
+        bool IsCounterRegistered(uint16_t counterUid) const override
+        {
+            return true;
+        }
+        uint16_t GetCounterCount() const override
+        {
+            return 0;
+        }
+        uint32_t GetCounterValue(uint16_t counterUid) const override
+        {
+            return 0;
+        }
     };
     const uint32_t familyId = 0;
     const uint32_t packetId = 0x40000;
@@ -1746,12 +1607,12 @@
     uint32_t sizeOfUint16 = numeric_cast<uint32_t>(sizeof(uint16_t));
 
     // Data with period and counters
-    uint32_t period1 = 10;
+    uint32_t period1     = 10;
     uint32_t dataLength1 = 8;
-    uint32_t offset = 0;
+    uint32_t offset      = 0;
 
     std::unique_ptr<unsigned char[]> uniqueData1 = std::make_unique<unsigned char[]>(dataLength1);
-    unsigned char* data1 = reinterpret_cast<unsigned char*>(uniqueData1.get());
+    unsigned char* data1                         = reinterpret_cast<unsigned char*>(uniqueData1.get());
 
     WriteUint32(data1, offset, period1);
     offset += sizeOfUint32;
@@ -1761,14 +1622,8 @@
 
     Packet packetA(packetId, dataLength1, uniqueData1);
 
-    PeriodicCounterSelectionCommandHandler commandHandler(familyId,
-                                                          packetId,
-                                                          version,
-                                                          holder,
-                                                          captureThread,
-                                                          readCounterValues,
-                                                          sendCounterPacket,
-                                                          profilingStateMachine);
+    PeriodicCounterSelectionCommandHandler commandHandler(familyId, packetId, version, holder, captureThread,
+                                                          readCounterValues, sendCounterPacket, profilingStateMachine);
 
     profilingStateMachine.TransitionToState(ProfilingState::Uninitialised);
     BOOST_CHECK_THROW(commandHandler(packetA), armnn::RuntimeException);
@@ -1796,10 +1651,10 @@
     offset += sizeOfUint32;
     uint32_t period = ReadUint32(readBuffer, offset);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);  // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
-    BOOST_TEST(headerWord1 == 8);                   // data lenght
-    BOOST_TEST(period == 10);                       // capture period
+    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);     // packet family
+    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4);    // packet id
+    BOOST_TEST(headerWord1 == 8);                      // data lenght
+    BOOST_TEST(period == 10);                          // capture period
 
     uint16_t counterId = 0;
     offset += sizeOfUint32;
@@ -1812,7 +1667,7 @@
     mockBuffer.MarkRead(readBuffer);
 
     // Data with period only
-    uint32_t period2 = 11;
+    uint32_t period2     = 11;
     uint32_t dataLength2 = 4;
 
     std::unique_ptr<unsigned char[]> uniqueData2 = std::make_unique<unsigned char[]>(dataLength2);
@@ -1838,30 +1693,30 @@
     offset += sizeOfUint32;
     period = ReadUint32(readBuffer, offset);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);  // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4); // packet id
-    BOOST_TEST(headerWord1 == 4);                   // data length
-    BOOST_TEST(period == 11);                       // capture period
+    BOOST_TEST(((headerWord0 >> 26) & 0x3F) == 0);     // packet family
+    BOOST_TEST(((headerWord0 >> 16) & 0x3FF) == 4);    // packet id
+    BOOST_TEST(headerWord1 == 4);                      // data length
+    BOOST_TEST(period == 11);                          // capture period
 }
 
 BOOST_AUTO_TEST_CASE(CheckConnectionAcknowledged)
 {
     using boost::numeric_cast;
 
-    const uint32_t packetFamilyId = 0;
+    const uint32_t packetFamilyId     = 0;
     const uint32_t connectionPacketId = 0x10000;
-    const uint32_t version = 1;
+    const uint32_t version            = 1;
 
     uint32_t sizeOfUint32 = numeric_cast<uint32_t>(sizeof(uint32_t));
     uint32_t sizeOfUint16 = numeric_cast<uint32_t>(sizeof(uint16_t));
 
     // Data with period and counters
-    uint32_t period1 = 10;
+    uint32_t period1     = 10;
     uint32_t dataLength1 = 8;
-    uint32_t offset = 0;
+    uint32_t offset      = 0;
 
     std::unique_ptr<unsigned char[]> uniqueData1 = std::make_unique<unsigned char[]>(dataLength1);
-    unsigned char* data1 = reinterpret_cast<unsigned char*>(uniqueData1.get());
+    unsigned char* data1                         = reinterpret_cast<unsigned char*>(uniqueData1.get());
 
     WriteUint32(data1, offset, period1);
     offset += sizeOfUint32;
@@ -1873,8 +1728,12 @@
 
     ProfilingStateMachine profilingState(ProfilingState::Uninitialised);
     BOOST_CHECK(profilingState.GetCurrentState() == ProfilingState::Uninitialised);
+    CounterDirectory counterDirectory;
+    MockBufferManager mockBuffer(1024);
+    SendCounterPacket sendCounterPacket(profilingState, mockBuffer);
 
-    ConnectionAcknowledgedCommandHandler commandHandler(packetFamilyId, connectionPacketId, version, profilingState);
+    ConnectionAcknowledgedCommandHandler commandHandler(packetFamilyId, connectionPacketId, version, counterDirectory,
+                                                        sendCounterPacket, profilingState);
 
     // command handler received packet on ProfilingState::Uninitialised
     BOOST_CHECK_THROW(commandHandler(packetA), armnn::Exception);
@@ -1899,8 +1758,8 @@
     Packet packetB(differentPacketId, dataLength1, uniqueData1);
     profilingState.TransitionToState(ProfilingState::NotConnected);
     profilingState.TransitionToState(ProfilingState::WaitingForAck);
-    ConnectionAcknowledgedCommandHandler differentCommandHandler(
-        packetFamilyId, differentPacketId, version, profilingState);
+    ConnectionAcknowledgedCommandHandler differentCommandHandler(packetFamilyId, differentPacketId, version,
+                                                                 counterDirectory, sendCounterPacket, profilingState);
     BOOST_CHECK_THROW(differentCommandHandler(packetB), armnn::Exception);
 }
 
@@ -2021,7 +1880,7 @@
 
     // The buffer must include the null-terminator at the end of the string
     size_t nullTerminatorIndex = sizeof(uint32_t) + testString.size();
-    BOOST_CHECK(reinterpret_cast<unsigned char*>(buffer.data())[nullTerminatorIndex]  == '\0');
+    BOOST_CHECK(reinterpret_cast<unsigned char*>(buffer.data())[nullTerminatorIndex] == '\0');
 }
 
 BOOST_AUTO_TEST_CASE(StringToSwTraceStringTest)
@@ -2083,7 +1942,7 @@
     public:
         CaptureReader(uint16_t counterSize)
         {
-            for(uint16_t i = 0; i < counterSize; ++i)
+            for (uint16_t i = 0; i < counterSize; ++i)
             {
                 m_Data[i] = 0;
             }
@@ -2102,7 +1961,7 @@
 
         uint32_t GetCounterValue(uint16_t counterUid) const override
         {
-            if(counterUid > m_CounterSize)
+            if (counterUid > m_CounterSize)
             {
                 BOOST_FAIL("Invalid counter Uid");
             }
@@ -2111,7 +1970,7 @@
 
         void SetCounterValue(uint16_t counterUid, uint32_t value)
         {
-            if(counterUid > m_CounterSize)
+            if (counterUid > m_CounterSize)
             {
                 BOOST_FAIL("Invalid counter Uid");
             }
@@ -2135,8 +1994,8 @@
     std::vector<uint16_t> counterIds;
     CaptureReader captureReader(2);
 
-    unsigned int valueA = 10;
-    unsigned int valueB = 15;
+    unsigned int valueA   = 10;
+    unsigned int valueB   = 15;
     unsigned int numSteps = 5;
 
     PeriodicCounterCapture periodicCounterCapture(std::ref(data), std::ref(sendCounterPacket), captureReader);
@@ -2156,12 +2015,12 @@
     uint32_t headerWord0 = ReadUint32(buffer, 0);
     uint32_t headerWord1 = ReadUint32(buffer, 4);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 1); // packet family
-    BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0); // packet class
-    BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0); // packet type
+    BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 1);    // packet family
+    BOOST_TEST(((headerWord0 >> 19) & 0x0000007F) == 0);    // packet class
+    BOOST_TEST(((headerWord0 >> 16) & 0x00000007) == 0);    // packet type
     BOOST_TEST(headerWord1 == 20);
 
-    uint32_t offset = 16;
+    uint32_t offset    = 16;
     uint16_t readIndex = ReadUint16(buffer, offset);
     BOOST_TEST(0 == readIndex);
 
@@ -2184,50 +2043,46 @@
 
     const uint32_t familyId = 0;
     const uint32_t packetId = 3;
-    const uint32_t version = 1;
+    const uint32_t version  = 1;
     ProfilingStateMachine profilingStateMachine;
     CounterDirectory counterDirectory;
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(profilingStateMachine, mockBuffer);
-    RequestCounterDirectoryCommandHandler commandHandler(familyId,
-                                                         packetId,
-                                                         version,
-                                                         counterDirectory,
-                                                         sendCounterPacket,
-                                                         profilingStateMachine);
+    RequestCounterDirectoryCommandHandler commandHandler(familyId, packetId, version, counterDirectory,
+                                                         sendCounterPacket, profilingStateMachine);
 
     const uint32_t wrongPacketId = 47;
-    const uint32_t wrongHeader = (wrongPacketId & 0x000003FF) << 16;
+    const uint32_t wrongHeader   = (wrongPacketId & 0x000003FF) << 16;
 
     Packet wrongPacket(wrongHeader);
 
     profilingStateMachine.TransitionToState(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
+    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
+    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException); // Wrong profiling state
+    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::Active);
-    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::InvalidArgumentException); // Wrong packet
+    BOOST_CHECK_THROW(commandHandler(wrongPacket), armnn::InvalidArgumentException);    // Wrong packet
 
     const uint32_t rightHeader = (packetId & 0x000003FF) << 16;
 
     Packet rightPacket(rightHeader);
 
-    BOOST_CHECK_NO_THROW(commandHandler(rightPacket)); // Right packet
+    BOOST_CHECK_NO_THROW(commandHandler(rightPacket));    // Right packet
 
     auto readBuffer = mockBuffer.GetReadableBuffer();
 
     uint32_t headerWord0 = ReadUint32(readBuffer, 0);
     uint32_t headerWord1 = ReadUint32(readBuffer, 4);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 0);  // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x000003FF) == 2);  // packet id
-    BOOST_TEST(headerWord1 == 24);                        // data length
+    BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 0);    // packet family
+    BOOST_TEST(((headerWord0 >> 16) & 0x000003FF) == 2);    // packet id
+    BOOST_TEST(headerWord1 == 24);                          // data length
 
-    uint32_t bodyHeaderWord0 = ReadUint32(readBuffer,  8);
+    uint32_t bodyHeaderWord0   = ReadUint32(readBuffer, 8);
     uint16_t deviceRecordCount = numeric_cast<uint16_t>(bodyHeaderWord0 >> 16);
-    BOOST_TEST(deviceRecordCount == 0); // device_records_count
+    BOOST_TEST(deviceRecordCount == 0);    // device_records_count
 }
 
 BOOST_AUTO_TEST_CASE(RequestCounterDirectoryCommandHandlerTest2)
@@ -2236,32 +2091,28 @@
 
     const uint32_t familyId = 0;
     const uint32_t packetId = 3;
-    const uint32_t version = 1;
+    const uint32_t version  = 1;
     ProfilingStateMachine profilingStateMachine;
     CounterDirectory counterDirectory;
     MockBufferManager mockBuffer(1024);
     SendCounterPacket sendCounterPacket(profilingStateMachine, mockBuffer);
-    RequestCounterDirectoryCommandHandler commandHandler(familyId,
-                                                         packetId,
-                                                         version,
-                                                         counterDirectory,
-                                                         sendCounterPacket,
-                                                         profilingStateMachine);
+    RequestCounterDirectoryCommandHandler commandHandler(familyId, packetId, version, counterDirectory,
+                                                         sendCounterPacket, profilingStateMachine);
     const uint32_t header = (packetId & 0x000003FF) << 16;
     Packet packet(header);
 
-    const Device* device = counterDirectory.RegisterDevice("deviceA", 1);
+    const Device* device         = counterDirectory.RegisterDevice("deviceA", 1);
     const CounterSet* counterSet = counterDirectory.RegisterCounterSet("countersetA");
     counterDirectory.RegisterCategory("categoryA", device->m_Uid, counterSet->m_Uid);
     counterDirectory.RegisterCounter("categoryA", 0, 1, 2.0f, "counterA", "descA");
     counterDirectory.RegisterCounter("categoryA", 1, 1, 3.0f, "counterB", "descB");
 
     profilingStateMachine.TransitionToState(ProfilingState::Uninitialised);
-    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException); // Wrong profiling state
+    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::NotConnected);
-    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException); // Wrong profiling state
+    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::WaitingForAck);
-    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException); // Wrong profiling state
+    BOOST_CHECK_THROW(commandHandler(packet), armnn::RuntimeException);    // Wrong profiling state
     profilingStateMachine.TransitionToState(ProfilingState::Active);
     BOOST_CHECK_NO_THROW(commandHandler(packet));
 
@@ -2270,34 +2121,34 @@
     uint32_t headerWord0 = ReadUint32(readBuffer, 0);
     uint32_t headerWord1 = ReadUint32(readBuffer, 4);
 
-    BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 0);  // packet family
-    BOOST_TEST(((headerWord0 >> 16) & 0x000003FF) == 2);  // packet id
-    BOOST_TEST(headerWord1 == 240);                       // data length
+    BOOST_TEST(((headerWord0 >> 26) & 0x0000003F) == 0);    // packet family
+    BOOST_TEST(((headerWord0 >> 16) & 0x000003FF) == 2);    // packet id
+    BOOST_TEST(headerWord1 == 240);                         // data length
 
-    uint32_t bodyHeaderWord0 = ReadUint32(readBuffer,  8);
-    uint32_t bodyHeaderWord1 = ReadUint32(readBuffer, 12);
-    uint32_t bodyHeaderWord2 = ReadUint32(readBuffer, 16);
-    uint32_t bodyHeaderWord3 = ReadUint32(readBuffer, 20);
-    uint32_t bodyHeaderWord4 = ReadUint32(readBuffer, 24);
-    uint32_t bodyHeaderWord5 = ReadUint32(readBuffer, 28);
-    uint16_t deviceRecordCount = numeric_cast<uint16_t>(bodyHeaderWord0 >> 16);
+    uint32_t bodyHeaderWord0       = ReadUint32(readBuffer, 8);
+    uint32_t bodyHeaderWord1       = ReadUint32(readBuffer, 12);
+    uint32_t bodyHeaderWord2       = ReadUint32(readBuffer, 16);
+    uint32_t bodyHeaderWord3       = ReadUint32(readBuffer, 20);
+    uint32_t bodyHeaderWord4       = ReadUint32(readBuffer, 24);
+    uint32_t bodyHeaderWord5       = ReadUint32(readBuffer, 28);
+    uint16_t deviceRecordCount     = numeric_cast<uint16_t>(bodyHeaderWord0 >> 16);
     uint16_t counterSetRecordCount = numeric_cast<uint16_t>(bodyHeaderWord2 >> 16);
-    uint16_t categoryRecordCount = numeric_cast<uint16_t>(bodyHeaderWord4 >> 16);
-    BOOST_TEST(deviceRecordCount == 1);     // device_records_count
-    BOOST_TEST(bodyHeaderWord1 == 0);       // device_records_pointer_table_offset
-    BOOST_TEST(counterSetRecordCount == 1); // counter_set_count
-    BOOST_TEST(bodyHeaderWord3 == 4);       // counter_set_pointer_table_offset
-    BOOST_TEST(categoryRecordCount == 1);   // categories_count
-    BOOST_TEST(bodyHeaderWord5 == 8);       // categories_pointer_table_offset
+    uint16_t categoryRecordCount   = numeric_cast<uint16_t>(bodyHeaderWord4 >> 16);
+    BOOST_TEST(deviceRecordCount == 1);        // device_records_count
+    BOOST_TEST(bodyHeaderWord1 == 0);          // device_records_pointer_table_offset
+    BOOST_TEST(counterSetRecordCount == 1);    // counter_set_count
+    BOOST_TEST(bodyHeaderWord3 == 4);          // counter_set_pointer_table_offset
+    BOOST_TEST(categoryRecordCount == 1);      // categories_count
+    BOOST_TEST(bodyHeaderWord5 == 8);          // categories_pointer_table_offset
 
     uint32_t deviceRecordOffset = ReadUint32(readBuffer, 32);
-    BOOST_TEST(deviceRecordOffset ==  0);
+    BOOST_TEST(deviceRecordOffset == 0);
 
     uint32_t counterSetRecordOffset = ReadUint32(readBuffer, 36);
     BOOST_TEST(counterSetRecordOffset == 20);
 
     uint32_t categoryRecordOffset = ReadUint32(readBuffer, 40);
-    BOOST_TEST(categoryRecordOffset ==  44);
+    BOOST_TEST(categoryRecordOffset == 44);
 }
 
 BOOST_AUTO_TEST_CASE(CheckProfilingServiceBadConnectionAcknowledgedPacket)
@@ -2313,21 +2164,21 @@
     StreamRedirector streamRedirector(std::cout, ss.rdbuf());
 
     // Calculate the size of a Stream Metadata packet
-    std::string processName = GetProcessName().substr(0, 60);
+    std::string processName      = GetProcessName().substr(0, 60);
     unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
     unsigned int streamMetadataPacketsize = 118 + processNameSize;
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "WaitingForAck" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update();// Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
@@ -2356,9 +2207,8 @@
     // 8:15  [8]  reserved: Reserved, value 0b00000000
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
-    uint32_t packetId     = 37; // Wrong packet id!!!
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t packetId     = 37;    // Wrong packet id!!!
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
     // Create the Connection Acknowledged Packet
     Packet connectionAcknowledgedPacket(header);
@@ -2387,21 +2237,21 @@
     SwapProfilingConnectionFactoryHelper helper;
 
     // Calculate the size of a Stream Metadata packet
-    std::string processName = GetProcessName().substr(0, 60);
+    std::string processName      = GetProcessName().substr(0, 60);
     unsigned int processNameSize = processName.empty() ? 0 : boost::numeric_cast<unsigned int>(processName.size()) + 1;
     unsigned int streamMetadataPacketsize = 118 + processNameSize;
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "WaitingForAck" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
 
     // Get the mock profiling connection
     MockProfilingConnection* mockProfilingConnection = helper.GetMockProfilingConnection();
@@ -2411,7 +2261,7 @@
     mockProfilingConnection->Clear();
 
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet to be sent
     helper.WaitForProfilingPacketsSent();
@@ -2431,8 +2281,7 @@
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
     uint32_t packetId     = 1;
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
     // Create the Connection Acknowledged Packet
     Packet connectionAcknowledgedPacket(header);
@@ -2466,7 +2315,7 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
@@ -2474,9 +2323,9 @@
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     helper.ForceTransitionToState(ProfilingState::NotConnected);
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2502,9 +2351,8 @@
     // 8:15  [8]  reserved: Reserved, value 0b00000000
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
-    uint32_t packetId     = 123; // Wrong packet id!!!
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t packetId     = 123;    // Wrong packet id!!!
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
     // Create the Request Counter Directory packet
     Packet requestCounterDirectoryPacket(header);
@@ -2534,17 +2382,17 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "Active" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2571,8 +2419,7 @@
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
     uint32_t packetId     = 3;
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
     // Create the Request Counter Directory packet
     Packet requestCounterDirectoryPacket(header);
@@ -2586,7 +2433,7 @@
     // Check that the mock profiling connection contains one Counter Directory packet
     const std::vector<uint32_t> writtenData = mockProfilingConnection->GetWrittenData();
     BOOST_TEST(writtenData.size() == 1);
-    BOOST_TEST(writtenData[0] == 416); // The size of the expected Counter Directory packet
+    BOOST_TEST(writtenData[0] == 416);    // The size of the expected Counter Directory packet
 
     // The Request Counter Directory Command Handler should not have updated the profiling state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Active);
@@ -2610,17 +2457,17 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "Active" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2646,12 +2493,11 @@
     // 8:15  [8]  reserved: Reserved, value 0b00000000
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
-    uint32_t packetId     = 999; // Wrong packet id!!!
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t packetId     = 999;    // Wrong packet id!!!
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
     // Create the Periodic Counter Selection packet
-    Packet periodicCounterSelectionPacket(header); // Length == 0, this will disable the collection of counters
+    Packet periodicCounterSelectionPacket(header);    // Length == 0, this will disable the collection of counters
 
     // Write the packet to the mock profiling connection
     mockProfilingConnection->WritePacket(std::move(periodicCounterSelectionPacket));
@@ -2681,17 +2527,17 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "Active" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2718,17 +2564,16 @@
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
     uint32_t packetId     = 4;
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
-    uint32_t capturePeriod = 123456; // Some capture period (microseconds)
+    uint32_t capturePeriod = 123456;    // Some capture period (microseconds)
 
     // Get the first valid counter UID
     const ICounterDirectory& counterDirectory = profilingService.GetCounterDirectory();
-    const Counters& counters = counterDirectory.GetCounters();
+    const Counters& counters                  = counterDirectory.GetCounters();
     BOOST_CHECK(counters.size() > 1);
-    uint16_t counterUidA = counters.begin()->first; // First valid counter UID
-    uint16_t counterUidB = 9999;                    // Second invalid counter UID
+    uint16_t counterUidA = counters.begin()->first;    // First valid counter UID
+    uint16_t counterUidB = 9999;                       // Second invalid counter UID
 
     uint32_t length = 8;
 
@@ -2738,8 +2583,8 @@
     WriteUint16(data.get(), 6, counterUidB);
 
     // Create the Periodic Counter Selection packet
-    Packet periodicCounterSelectionPacket(header, length, data); // Length > 0, this will start the Period Counter
-                                                                 // Capture thread
+    Packet periodicCounterSelectionPacket(header, length, data);    // Length > 0, this will start the Period Counter
+                                                                    // Capture thread
 
     // Write the packet to the mock profiling connection
     mockProfilingConnection->WritePacket(std::move(periodicCounterSelectionPacket));
@@ -2760,8 +2605,7 @@
         }
         receivedPackets.insert(receivedPackets.end(), writtenData.begin(), writtenData.end());
         expectedPackets -= boost::numeric_cast<int>(writtenData.size());
-    }
-    while (expectedPackets > 0);
+    } while (expectedPackets > 0);
     BOOST_TEST(!receivedPackets.empty());
 
     // The size of the expected Periodic Counter Selection packet
@@ -2784,17 +2628,17 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "Active" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2821,11 +2665,10 @@
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
     uint32_t packetId     = 4;
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
     // Create the Periodic Counter Selection packet
-    Packet periodicCounterSelectionPacket(header); // Length == 0, this will disable the collection of counters
+    Packet periodicCounterSelectionPacket(header);    // Length == 0, this will disable the collection of counters
 
     // Write the packet to the mock profiling connection
     mockProfilingConnection->WritePacket(std::move(periodicCounterSelectionPacket));
@@ -2838,8 +2681,8 @@
 
     // Check that the mock profiling connection contains one Periodic Counter Selection
     const std::vector<uint32_t> writtenData = mockProfilingConnection->GetWrittenData();
-    BOOST_TEST(writtenData.size() == 1); // Only one packet is expected (no Periodic Counter packets)
-    BOOST_TEST(writtenData[0] == 12); // The size of the expected Periodic Counter Selection (echos the sent one)
+    BOOST_TEST(writtenData.size() == 1);    // Only one packet is expected (no Periodic Counter packets)
+    BOOST_TEST(writtenData[0] == 12);       // The size of the expected Periodic Counter Selection (echos the sent one)
 
     // Reset the profiling service to stop any running thread
     options.m_EnableProfiling = false;
@@ -2853,17 +2696,17 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "Active" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2890,16 +2733,15 @@
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
     uint32_t packetId     = 4;
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
-    uint32_t capturePeriod = 123456; // Some capture period (microseconds)
+    uint32_t capturePeriod = 123456;    // Some capture period (microseconds)
 
     // Get the first valid counter UID
     const ICounterDirectory& counterDirectory = profilingService.GetCounterDirectory();
-    const Counters& counters = counterDirectory.GetCounters();
+    const Counters& counters                  = counterDirectory.GetCounters();
     BOOST_CHECK(!counters.empty());
-    uint16_t counterUid = counters.begin()->first; // Valid counter UID
+    uint16_t counterUid = counters.begin()->first;    // Valid counter UID
 
     uint32_t length = 6;
 
@@ -2908,8 +2750,8 @@
     WriteUint16(data.get(), 4, counterUid);
 
     // Create the Periodic Counter Selection packet
-    Packet periodicCounterSelectionPacket(header, length, data); // Length > 0, this will start the Period Counter
-                                                                 // Capture thread
+    Packet periodicCounterSelectionPacket(header, length, data);    // Length > 0, this will start the Period Counter
+                                                                    // Capture thread
 
     // Write the packet to the mock profiling connection
     mockProfilingConnection->WritePacket(std::move(periodicCounterSelectionPacket));
@@ -2930,8 +2772,7 @@
         }
         receivedPackets.insert(receivedPackets.end(), writtenData.begin(), writtenData.end());
         expectedPackets -= boost::numeric_cast<int>(writtenData.size());
-    }
-    while (expectedPackets > 0);
+    } while (expectedPackets > 0);
     BOOST_TEST(!receivedPackets.empty());
 
     // The size of the expected Periodic Counter Selection packet (echos the sent one)
@@ -2954,17 +2795,17 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "Active" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -2991,17 +2832,16 @@
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
     uint32_t packetId     = 4;
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
-    uint32_t capturePeriod = 123456; // Some capture period (microseconds)
+    uint32_t capturePeriod = 123456;    // Some capture period (microseconds)
 
     // Get the first valid counter UID
     const ICounterDirectory& counterDirectory = profilingService.GetCounterDirectory();
-    const Counters& counters = counterDirectory.GetCounters();
+    const Counters& counters                  = counterDirectory.GetCounters();
     BOOST_CHECK(counters.size() > 1);
-    uint16_t counterUidA = counters.begin()->first;     // First valid counter UID
-    uint16_t counterUidB = (counters.begin()++)->first; // Second valid counter UID
+    uint16_t counterUidA = counters.begin()->first;        // First valid counter UID
+    uint16_t counterUidB = (counters.begin()++)->first;    // Second valid counter UID
 
     uint32_t length = 8;
 
@@ -3011,8 +2851,8 @@
     WriteUint16(data.get(), 6, counterUidB);
 
     // Create the Periodic Counter Selection packet
-    Packet periodicCounterSelectionPacket(header, length, data); // Length > 0, this will start the Period Counter
-                                                                 // Capture thread
+    Packet periodicCounterSelectionPacket(header, length, data);    // Length > 0, this will start the Period Counter
+                                                                    // Capture thread
 
     // Write the packet to the mock profiling connection
     mockProfilingConnection->WritePacket(std::move(periodicCounterSelectionPacket));
@@ -3033,8 +2873,7 @@
         }
         receivedPackets.insert(receivedPackets.end(), writtenData.begin(), writtenData.end());
         expectedPackets -= boost::numeric_cast<int>(writtenData.size());
-    }
-    while (expectedPackets > 0);
+    } while (expectedPackets > 0);
     BOOST_TEST(!receivedPackets.empty());
 
     // The size of the expected Periodic Counter Selection packet (echos the sent one)
@@ -3057,29 +2896,29 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Try to disconnect the profiling service while in the "Uninitialised" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.Disconnect();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised); // The state should not change
+    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);    // The state should not change
 
     // Try to disconnect the profiling service while in the "NotConnected" state
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
     profilingService.Disconnect();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected); // The state should not change
+    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);    // The state should not change
 
     // Try to disconnect the profiling service while in the "WaitingForAck" state
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
     profilingService.Disconnect();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck); // The state should not change
+    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);    // The state should not change
 
     // Try to disconnect the profiling service while in the "Active" state
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -3097,7 +2936,7 @@
     BOOST_CHECK(mockProfilingConnection->IsOpen());
 
     profilingService.Disconnect();
-    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected); // The state should have changed
+    BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);    // The state should have changed
 
     // Check that the profiling connection has been reset
     mockProfilingConnection = helper.GetMockProfilingConnection();
@@ -3115,17 +2954,17 @@
 
     // Reset the profiling service to the uninitialized state
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     profilingService.ResetExternalProfilingOptions(options, true);
 
     // Bring the profiling service to the "Active" state
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
-    profilingService.Update(); // Initialize the counter directory
+    profilingService.Update();    // Initialize the counter directory
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::NotConnected);
-    profilingService.Update(); // Create the profiling connection
+    profilingService.Update();    // Create the profiling connection
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::WaitingForAck);
-    profilingService.Update(); // Start the command handler and the send thread
+    profilingService.Update();    // Start the command handler and the send thread
 
     // Wait for the Stream Metadata packet the be sent
     // (we are not testing the connection acknowledgement here so it will be ignored by this test)
@@ -3152,11 +2991,10 @@
     // 0:7   [8]  reserved: Reserved, value 0b00000000
     uint32_t packetFamily = 0;
     uint32_t packetId     = 5;
-    uint32_t header = ((packetFamily & 0x0000003F) << 26) |
-                      ((packetId     & 0x000003FF) << 16);
+    uint32_t header       = ((packetFamily & 0x0000003F) << 26) | ((packetId & 0x000003FF) << 16);
 
     // Create the Per-Job Counter Selection packet
-    Packet periodicCounterSelectionPacket(header); // Length == 0, this will disable the collection of counters
+    Packet periodicCounterSelectionPacket(header);    // Length == 0, this will disable the collection of counters
 
     // Write the packet to the mock profiling connection
     mockProfilingConnection->WritePacket(std::move(periodicCounterSelectionPacket));
@@ -3181,7 +3019,7 @@
 BOOST_AUTO_TEST_CASE(CheckConfigureProfilingServiceOn)
 {
     armnn::Runtime::CreationOptions::ExternalProfilingOptions options;
-    options.m_EnableProfiling = true;
+    options.m_EnableProfiling          = true;
     ProfilingService& profilingService = ProfilingService::Instance();
     BOOST_CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.ConfigureProfilingService(options);