IVGCVSW-6841 Replace armnn::numeric_cast with arm::pipe::numeric_cast in profiling code

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

17 files changed, 126 insertions, 118 deletions

diff --git a/src/armnn/ArmNNProfilingServiceInitialiser.cpp b/src/armnn/ArmNNProfilingServiceInitialiser.cpp
index d23cce5634..03ca56288b 100644
--- a/src/armnn/ArmNNProfilingServiceInitialiser.cpp
+++ b/src/armnn/ArmNNProfilingServiceInitialiser.cpp
@@ -7,6 +7,8 @@
 
 #include <armnn/BackendRegistry.hpp>
 #include <armnn/profiling/ArmNNProfiling.hpp>
+#include <armnn/utility/Assert.hpp>
+
 #include <Counter.hpp>
 
 namespace armnn
diff --git a/src/profiling/CounterDirectory.hpp b/src/profiling/CounterDirectory.hpp
index 4438042caf..b655f92b2f 100644
--- a/src/profiling/CounterDirectory.hpp
+++ b/src/profiling/CounterDirectory.hpp
@@ -12,7 +12,7 @@
 #include <unordered_set>
 #include <unordered_map>
 
-#include <armnn/utility/NumericCast.hpp>
+#include <common/include/NumericCast.hpp>
 
 namespace arm
 {
@@ -50,10 +50,10 @@ public:
                                    const armnn::Optional<uint16_t>& counterSetUid = armnn::EmptyOptional()) override;
 
     // Getters for counts
-    uint16_t GetCategoryCount()   const override { return armnn::numeric_cast<uint16_t>(m_Categories.size());  }
-    uint16_t GetDeviceCount()     const override { return armnn::numeric_cast<uint16_t>(m_Devices.size());    }
-    uint16_t GetCounterSetCount() const override { return armnn::numeric_cast<uint16_t>(m_CounterSets.size()); }
-    uint16_t GetCounterCount()    const override { return armnn::numeric_cast<uint16_t>(m_Counters.size());    }
+    uint16_t GetCategoryCount()   const override { return arm::pipe::numeric_cast<uint16_t>(m_Categories.size());  }
+    uint16_t GetDeviceCount()     const override { return arm::pipe::numeric_cast<uint16_t>(m_Devices.size());     }
+    uint16_t GetCounterSetCount() const override { return arm::pipe::numeric_cast<uint16_t>(m_CounterSets.size()); }
+    uint16_t GetCounterCount()    const override { return arm::pipe::numeric_cast<uint16_t>(m_Counters.size());    }
 
     // Getters for collections
     const Categories&  GetCategories()  const override { return m_Categories;  }
diff --git a/src/profiling/PeriodicCounterSelectionCommandHandler.cpp b/src/profiling/PeriodicCounterSelectionCommandHandler.cpp
index 014500cc45..d405e296fc 100644
--- a/src/profiling/PeriodicCounterSelectionCommandHandler.cpp
+++ b/src/profiling/PeriodicCounterSelectionCommandHandler.cpp
@@ -7,7 +7,7 @@
 #include "ProfilingUtils.hpp"
 
 #include <armnn/profiling/ProfilingOptions.hpp>
-#include <armnn/utility/NumericCast.hpp>
+#include <common/include/NumericCast.hpp>
 
 #include <fmt/format.h>
 
@@ -22,8 +22,8 @@ namespace pipe
 void PeriodicCounterSelectionCommandHandler::ParseData(const arm::pipe::Packet& packet, CaptureData& captureData)
 {
     std::vector<uint16_t> counterIds;
-    uint32_t sizeOfUint32 = armnn::numeric_cast<uint32_t>(sizeof(uint32_t));
-    uint32_t sizeOfUint16 = armnn::numeric_cast<uint32_t>(sizeof(uint16_t));
+    uint32_t sizeOfUint32 = arm::pipe::numeric_cast<uint32_t>(sizeof(uint32_t));
+    uint32_t sizeOfUint16 = arm::pipe::numeric_cast<uint32_t>(sizeof(uint16_t));
     uint32_t offset = 0;
 
     if (packet.GetLength() < 4)
diff --git a/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp b/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
index a0c5bc29dd..7f13b08ae1 100644
--- a/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
+++ b/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
@@ -5,7 +5,7 @@
 
 #include "ProfilingConnectionDumpToFileDecorator.hpp"
 
-#include <armnn/utility/NumericCast.hpp>
+#include <common/include/NumericCast.hpp>
 #include <common/include/ProfilingException.hpp>
 
 #include <fstream>
@@ -109,7 +109,7 @@ void ProfilingConnectionDumpToFileDecorator::DumpIncomingToFile(const arm::pipe:
     m_IncomingDumpFileStream.write(reinterpret_cast<const char*>(&header), sizeof header);
     m_IncomingDumpFileStream.write(reinterpret_cast<const char*>(&packetLength), sizeof packetLength);
     m_IncomingDumpFileStream.write(reinterpret_cast<const char*>(packet.GetData()),
-                                   armnn::numeric_cast<std::streamsize>(packetLength));
+                                   arm::pipe::numeric_cast<std::streamsize>(packetLength));
 
     success &= m_IncomingDumpFileStream.good();
     if (!(success || m_IgnoreFileErrors))
@@ -141,7 +141,7 @@ bool ProfilingConnectionDumpToFileDecorator::DumpOutgoingToFile(const unsigned c
 
     // attempt to write binary data
     m_OutgoingDumpFileStream.write(reinterpret_cast<const char*>(buffer),
-                                   armnn::numeric_cast<std::streamsize>(length));
+                                   arm::pipe::numeric_cast<std::streamsize>(length));
     success &= m_OutgoingDumpFileStream.good();
     if (!(success || m_IgnoreFileErrors))
     {
diff --git a/src/profiling/ProfilingService.cpp b/src/profiling/ProfilingService.cpp
index f187b398a1..f0d668cc32 100644
--- a/src/profiling/ProfilingService.cpp
+++ b/src/profiling/ProfilingService.cpp
@@ -6,8 +6,8 @@
 #include "ProfilingService.hpp"
 
 #include <armnn/Logging.hpp>
-#include <armnn/utility/NumericCast.hpp>
 
+#include <common/include/NumericCast.hpp>
 #include <common/include/ProfilingGuid.hpp>
 
 #include <common/include/SocketConnectionException.hpp>
@@ -323,7 +323,7 @@ void ProfilingService::InitializeCounterValue(uint16_t counterUid)
     // Increase the size of the counter index if necessary
     if (counterUid >= m_CounterIndex.size())
     {
-        m_CounterIndex.resize(armnn::numeric_cast<size_t>(counterUid) + 1);
+        m_CounterIndex.resize(arm::pipe::numeric_cast<size_t>(counterUid) + 1);
     }
 
     // Create a new atomic counter and add it to the list
diff --git a/src/profiling/ProfilingUtils.cpp b/src/profiling/ProfilingUtils.cpp
index d827500a3c..993585a566 100644
--- a/src/profiling/ProfilingUtils.cpp
+++ b/src/profiling/ProfilingUtils.cpp
@@ -15,6 +15,8 @@
 
 #include <armnn/utility/Assert.hpp>
 
+#include <common/include/NumericCast.hpp>
+
 #include <fstream>
 #include <iostream>
 #include <limits>
@@ -288,7 +290,7 @@ TimelinePacketStatus WriteTimelineLabelBinaryPacket(uint64_t profilingGuid,
     }
 
     // Calculate the size of the SWTrace string label (in bytes)
-    unsigned int swTraceLabelSize = armnn::numeric_cast<unsigned int>(swTraceLabel.size()) * uint32_t_size;
+    unsigned int swTraceLabelSize = arm::pipe::numeric_cast<unsigned int>(swTraceLabel.size()) * uint32_t_size;
 
     // Calculate the length of the data (in bytes)
     unsigned int timelineLabelPacketDataLength = uint32_t_size +   // decl_Id
@@ -491,7 +493,7 @@ TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
         uint32_t declId = 0;
         try
         {
-            declId = armnn::numeric_cast<uint32_t>(std::stoul(directoryComponent[0]));
+            declId = arm::pipe::numeric_cast<uint32_t>(std::stoul(directoryComponent[0]));
         }
         catch (const std::exception&)
         {
@@ -515,7 +517,7 @@ TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
     }
 
     unsigned int dataLength = 3 * uint8_t_size +  // Stream header (3 bytes)
-                              armnn::numeric_cast<unsigned int>(swTraceBuffer.size()) *
+                              arm::pipe::numeric_cast<unsigned int>(swTraceBuffer.size()) *
                                   uint32_t_size; // Trace directory (5 messages)
 
     // Calculate the timeline directory binary packet size (in bytes)
@@ -529,7 +531,7 @@ TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
     }
 
     // Create packet header
-    auto packetHeader = CreateTimelinePacketHeader(1, 0, 0, 0, 0, armnn::numeric_cast<uint32_t>(dataLength));
+    auto packetHeader = CreateTimelinePacketHeader(1, 0, 0, 0, 0, arm::pipe::numeric_cast<uint32_t>(dataLength));
 
     // Initialize the offset for writing in the buffer
     unsigned int offset = 0;
@@ -542,8 +544,8 @@ TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
 
     // Write the stream header
     uint8_t streamVersion = 4;
-    uint8_t pointerBytes  = armnn::numeric_cast<uint8_t>(uint64_t_size); // All GUIDs are uint64_t
-    uint8_t threadIdBytes = armnn::numeric_cast<uint8_t>(ThreadIdSize);
+    uint8_t pointerBytes  = arm::pipe::numeric_cast<uint8_t>(uint64_t_size); // All GUIDs are uint64_t
+    uint8_t threadIdBytes = arm::pipe::numeric_cast<uint8_t>(ThreadIdSize);
     switch (threadIdBytes)
     {
     case 4: // Typically Windows and Android
@@ -560,7 +562,7 @@ TimelinePacketStatus WriteTimelineMessageDirectoryPackage(unsigned char* buffer,
     offset += uint8_t_size;
 
     // Write the SWTrace directory
-    uint32_t numberOfDeclarations = armnn::numeric_cast<uint32_t>(timelineDirectoryMessages.size());
+    uint32_t numberOfDeclarations = arm::pipe::numeric_cast<uint32_t>(timelineDirectoryMessages.size());
     WriteUint32(buffer, offset, numberOfDeclarations); // Number of declarations
     offset += uint32_t_size;
     for (uint32_t i : swTraceBuffer)
diff --git a/src/profiling/ProfilingUtils.hpp b/src/profiling/ProfilingUtils.hpp
index 893f6abf6c..39ecebf9e8 100644
--- a/src/profiling/ProfilingUtils.hpp
+++ b/src/profiling/ProfilingUtils.hpp
@@ -9,8 +9,6 @@
 
 #include <armnn/profiling/ISendTimelinePacket.hpp>
 
-#include <armnn/utility/NumericCast.hpp>
-
 #include "ICounterDirectory.hpp"
 #include "IPacketBuffer.hpp"
 
diff --git a/src/profiling/SendCounterPacket.cpp b/src/profiling/SendCounterPacket.cpp
index c91a02acce..3ac2272e5b 100644
--- a/src/profiling/SendCounterPacket.cpp
+++ b/src/profiling/SendCounterPacket.cpp
@@ -14,7 +14,7 @@
 #include <Processes.hpp>
 
 #include <armnn/utility/Assert.hpp>
-#include <armnn/utility/NumericCast.hpp>
+#include <common/include/NumericCast.hpp>
 
 #include <fmt/format.h>
 
@@ -33,10 +33,10 @@ void SendCounterPacket::SendStreamMetaDataPacket()
     const std::string softwareVersion(GetSoftwareVersion());
     const std::string processName = GetProcessName().substr(0, 60);
 
-    const uint32_t infoSize =            armnn::numeric_cast<uint32_t>(info.size()) + 1;
-    const uint32_t hardwareVersionSize = armnn::numeric_cast<uint32_t>(hardwareVersion.size()) + 1;
-    const uint32_t softwareVersionSize = armnn::numeric_cast<uint32_t>(softwareVersion.size()) + 1;
-    const uint32_t processNameSize =     armnn::numeric_cast<uint32_t>(processName.size()) + 1;
+    const uint32_t infoSize =            arm::pipe::numeric_cast<uint32_t>(info.size()) + 1;
+    const uint32_t hardwareVersionSize = arm::pipe::numeric_cast<uint32_t>(hardwareVersion.size()) + 1;
+    const uint32_t softwareVersionSize = arm::pipe::numeric_cast<uint32_t>(softwareVersion.size()) + 1;
+    const uint32_t processNameSize =     arm::pipe::numeric_cast<uint32_t>(processName.size()) + 1;
 
     const uint32_t sizeUint32 = sizeof(uint32_t);
 
@@ -75,10 +75,10 @@ void SendCounterPacket::SendStreamMetaDataPacket()
     packetVersions.push_back(std::make_pair(ConstructHeader(3, 1, 1), arm::pipe::EncodeVersion(1, 0, 0)));
     packetVersions.push_back(std::make_pair(ConstructHeader(1, 0, 0), arm::pipe::EncodeVersion(1, 0, 0)));
     packetVersions.push_back(std::make_pair(ConstructHeader(1, 0, 1), arm::pipe::EncodeVersion(1, 0, 0)));
-    uint32_t numberOfVersions = armnn::numeric_cast<uint32_t>(packetVersions.size());
-    uint32_t packetVersionSize = armnn::numeric_cast<uint32_t>(numberOfVersions * 2 * sizeUint32);
+    uint32_t numberOfVersions = arm::pipe::numeric_cast<uint32_t>(packetVersions.size());
+    uint32_t packetVersionSize = arm::pipe::numeric_cast<uint32_t>(numberOfVersions * 2 * sizeUint32);
 
-    const uint32_t payloadSize = armnn::numeric_cast<uint32_t>(infoSize + hardwareVersionSize +
+    const uint32_t payloadSize = arm::pipe::numeric_cast<uint32_t>(infoSize + hardwareVersionSize +
                                                                softwareVersionSize + processNameSize +
                                                                packetVersionCountSize + packetVersionSize);
 
@@ -113,7 +113,7 @@ void SendCounterPacket::SendStreamMetaDataPacket()
         WriteUint32(writeBuffer, offset, MAX_METADATA_PACKET_LENGTH); // max_data_length
         offset += sizeUint32;
         int pid = armnnUtils::Processes::GetCurrentId();
-        WriteUint32(writeBuffer, offset, armnn::numeric_cast<uint32_t>(pid)); // pid
+        WriteUint32(writeBuffer, offset, arm::pipe::numeric_cast<uint32_t>(pid)); // pid
         offset += sizeUint32;
         uint32_t poolOffset = bodySize;
         WriteUint32(writeBuffer, offset, poolOffset); // offset_info
@@ -236,7 +236,7 @@ bool SendCounterPacket::CreateCategoryRecord(const CategoryPtr& category,
     std::vector<EventRecord> eventRecords(counterCount);
     std::vector<uint32_t> eventRecordOffsets(counterCount, 0);
     size_t eventRecordsSize = 0;
-    uint32_t eventRecordsOffset = armnn::numeric_cast<uint32_t>(
+    uint32_t eventRecordsOffset = arm::pipe::numeric_cast<uint32_t>(
                     (eventRecords.size() + categoryNameBuffer.size()) * uint32_t_size);
     for (size_t counterIndex = 0, eventRecordIndex = 0, eventRecordOffsetIndex = 0;
          counterIndex < counterCount;
@@ -257,12 +257,12 @@ bool SendCounterPacket::CreateCategoryRecord(const CategoryPtr& category,
 
         // Add the event record offset to the event pointer table offset field
         eventRecordOffsets[eventRecordOffsetIndex] = eventRecordsOffset;
-        eventRecordsOffset += armnn::numeric_cast<uint32_t>(eventRecord.size() * uint32_t_size);
+        eventRecordsOffset += arm::pipe::numeric_cast<uint32_t>(eventRecord.size() * uint32_t_size);
     }
 
     // Category record word 3:
     // 0:31 [32] name_offset (offset from the beginning of the category data pool to the name field)
-    const uint32_t categoryRecordWord3 = armnn::numeric_cast<uint32_t>(
+    const uint32_t categoryRecordWord3 = arm::pipe::numeric_cast<uint32_t>(
             (3u + eventRecordOffsets.size()) * uint32_t_size);
 
     // Calculate the size in words of the category record
@@ -496,7 +496,7 @@ bool SendCounterPacket::CreateEventRecord(const CounterPtr& counter,
     // The size of the description buffer in bytes
     const uint32_t eventRecordWord7 = includeUnits ?
                                 eventRecordWord6 +
-                                armnn::numeric_cast<uint32_t>(counterDescriptionBuffer.size()
+                                arm::pipe::numeric_cast<uint32_t>(counterDescriptionBuffer.size()
                                 * uint32_t_size) :
                                 0;
 
@@ -575,7 +575,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
     size_t deviceIndex = 0;
     size_t deviceRecordOffsetIndex = 0;
 
-    pointerTableOffset = armnn::numeric_cast<uint32_t>(deviceCount * uint32_t_size +
+    pointerTableOffset = arm::pipe::numeric_cast<uint32_t>(deviceCount * uint32_t_size +
                                                        counterSetCount * uint32_t_size +
                                                        categoryCount   * uint32_t_size);
     for (auto it = devices.begin(); it != devices.end(); it++)
@@ -594,7 +594,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
 
         // Add the device record offset to the device records pointer table offset field
         deviceRecordOffsets[deviceRecordOffsetIndex] = pointerTableOffset;
-        pointerTableOffset += armnn::numeric_cast<uint32_t>(deviceRecord.size() * uint32_t_size);
+        pointerTableOffset += arm::pipe::numeric_cast<uint32_t>(deviceRecord.size() * uint32_t_size);
 
         deviceIndex++;
         deviceRecordOffsetIndex++;
@@ -612,7 +612,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
     size_t counterSetIndex = 0;
     size_t counterSetRecordOffsetIndex = 0;
 
-    pointerTableOffset -= armnn::numeric_cast<uint32_t>(deviceCount * uint32_t_size);
+    pointerTableOffset -= arm::pipe::numeric_cast<uint32_t>(deviceCount * uint32_t_size);
     for (auto it = counterSets.begin(); it != counterSets.end(); it++)
     {
         const CounterSetPtr& counterSet = it->second;
@@ -629,7 +629,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
 
         // Add the counter set record offset to the counter set records pointer table offset field
         counterSetRecordOffsets[counterSetRecordOffsetIndex] = pointerTableOffset;
-        pointerTableOffset += armnn::numeric_cast<uint32_t>(counterSetRecord.size() * uint32_t_size);
+        pointerTableOffset += arm::pipe::numeric_cast<uint32_t>(counterSetRecord.size() * uint32_t_size);
 
         counterSetIndex++;
         counterSetRecordOffsetIndex++;
@@ -647,7 +647,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
     size_t categoryIndex = 0;
     size_t categoryRecordOffsetIndex = 0;
 
-    pointerTableOffset -= armnn::numeric_cast<uint32_t>(counterSetCount * uint32_t_size);
+    pointerTableOffset -= arm::pipe::numeric_cast<uint32_t>(counterSetCount * uint32_t_size);
     for (auto it = categories.begin(); it != categories.end(); it++)
     {
         const CategoryPtr& category = *it;
@@ -664,7 +664,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
 
         // Add the category record offset to the category records pointer table offset field
         categoryRecordOffsets[categoryRecordOffsetIndex] = pointerTableOffset;
-        pointerTableOffset += armnn::numeric_cast<uint32_t>(categoryRecord.size() * uint32_t_size);
+        pointerTableOffset += arm::pipe::numeric_cast<uint32_t>(categoryRecord.size() * uint32_t_size);
 
         categoryIndex++;
         categoryRecordOffsetIndex++;
@@ -702,7 +702,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
 
     // Packet header word 1:
     // 0:31 [32] data_length: length of data, in bytes
-    uint32_t packetHeaderWord1 = armnn::numeric_cast<uint32_t>(
+    uint32_t packetHeaderWord1 = arm::pipe::numeric_cast<uint32_t>(
             counterDirectoryPacketDataLength * uint32_t_size);
 
     // Create the packet header
@@ -734,7 +734,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
 
     // Body header word 3:
     // 0:31 [32] counter_set_pointer_table_offset: offset to the counter_set_pointer_table
-    const uint32_t bodyHeaderWord3 = armnn::numeric_cast<uint32_t>(deviceRecordOffsets.size() *
+    const uint32_t bodyHeaderWord3 = arm::pipe::numeric_cast<uint32_t>(deviceRecordOffsets.size() *
                                                                    uint32_t_size +       // The size of the
                                                                    bodyHeaderSizeBytes); // device records pointer table
 
@@ -746,7 +746,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
     // Body header word 3:
     // 0:31 [32] categories_pointer_table_offset: offset to the categories_pointer_table
     const uint32_t bodyHeaderWord5 =
-                   armnn::numeric_cast<uint32_t>(
+                   arm::pipe::numeric_cast<uint32_t>(
                        deviceRecordOffsets.size() * uint32_t_size +     // The size of the device records
                        counterSetRecordOffsets.size() * uint32_t_size   // pointer table, plus the size of
                        +  bodyHeaderSizeBytes);                         // the counter set pointer table
@@ -801,7 +801,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
     ARMNN_NO_CONVERSION_WARN_END
 
     // Calculate the total size in bytes of the counter directory packet
-    uint32_t totalSize = armnn::numeric_cast<uint32_t>(counterDirectoryPacketSize * uint32_t_size);
+    uint32_t totalSize = arm::pipe::numeric_cast<uint32_t>(counterDirectoryPacketSize * uint32_t_size);
 
     // Reserve space in the buffer for the packet
     uint32_t reserved = 0;
@@ -821,7 +821,7 @@ void SendCounterPacket::SendCounterDirectoryPacket(const ICounterDirectory& coun
     for (uint32_t counterDirectoryPacketWord : counterDirectoryPacket)
     {
         WriteUint32(writeBuffer, offset, counterDirectoryPacketWord);
-        offset += armnn::numeric_cast<uint32_t>(uint32_t_size);
+        offset += arm::pipe::numeric_cast<uint32_t>(uint32_t_size);
     }
 
     m_BufferManager.Commit(writeBuffer, totalSize);
@@ -837,7 +837,8 @@ void SendCounterPacket::SendPeriodicCounterCapturePacket(uint64_t timestamp, con
     uint32_t packetClass = 0;
     uint32_t packetType = 0;
     uint32_t headerSize = 2 * uint32_t_size;
-    uint32_t bodySize = uint64_t_size + armnn::numeric_cast<uint32_t>(values.size()) * (uint16_t_size + uint32_t_size);
+    uint32_t bodySize = uint64_t_size + arm::pipe::numeric_cast<uint32_t>(
+        values.size()) * (uint16_t_size + uint32_t_size);
     uint32_t totalSize = headerSize + bodySize;
     uint32_t offset = 0;
     uint32_t reserved = 0;
@@ -886,7 +887,7 @@ void SendCounterPacket::SendPeriodicCounterSelectionPacket(uint32_t capturePerio
     uint32_t packetFamily = 0;
     uint32_t packetId = 4;
     uint32_t headerSize = 2 * uint32_t_size;
-    uint32_t bodySize = uint32_t_size + armnn::numeric_cast<uint32_t>(selectedCounterIds.size()) * uint16_t_size;
+    uint32_t bodySize = uint32_t_size + arm::pipe::numeric_cast<uint32_t>(selectedCounterIds.size()) * uint16_t_size;
     uint32_t totalSize = headerSize + bodySize;
     uint32_t offset = 0;
     uint32_t reserved = 0;
diff --git a/src/profiling/SendThread.cpp b/src/profiling/SendThread.cpp
index e932eba3e9..c09a656cd2 100644
--- a/src/profiling/SendThread.cpp
+++ b/src/profiling/SendThread.cpp
@@ -7,7 +7,7 @@
 #include "ProfilingUtils.hpp"
 
 #include <armnn/Conversion.hpp>
-#include <armnn/utility/NumericCast.hpp>
+#include <common/include/NumericCast.hpp>
 
 #include <common/include/ProfilingException.hpp>
 
@@ -233,7 +233,7 @@ void SendThread::FlushBuffer(IProfilingConnection& profilingConnection, bool not
         if (profilingConnection.IsOpen())
         {
             // Write a packet to the profiling connection. Silently ignore any write error and continue
-            profilingConnection.WritePacket(readBuffer, armnn::numeric_cast<uint32_t>(readBufferSize));
+            profilingConnection.WritePacket(readBuffer, arm::pipe::numeric_cast<uint32_t>(readBufferSize));
 
             // Set the flag that indicates whether at least a packet has been sent
             packetsSent = true;
diff --git a/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp b/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
index fb8c97265b..f1f1d2410f 100644
--- a/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
+++ b/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
@@ -4,10 +4,14 @@
 //
 
 #include "../ProfilingConnectionDumpToFileDecorator.hpp"
-#include <armnnUtils/Filesystem.hpp>
+
 #include <Runtime.hpp>
+
+#include <armnnUtils/Filesystem.hpp>
+
 #include <armnn/utility/IgnoreUnused.hpp>
-#include <armnn/utility/NumericCast.hpp>
+
+#include <common/include/NumericCast.hpp>
 
 #include <fstream>
 #include <sstream>
@@ -20,7 +24,7 @@ namespace
 {
 
 const std::vector<char> g_Data       = { 'd', 'u', 'm', 'm', 'y' };
-const uint32_t          g_DataLength = armnn::numeric_cast<uint32_t>(g_Data.size());
+const uint32_t          g_DataLength = arm::pipe::numeric_cast<uint32_t>(g_Data.size());
 const unsigned char*    g_DataPtr    = reinterpret_cast<const unsigned char*>(g_Data.data());
 
 class DummyProfilingConnection : public IProfilingConnection
diff --git a/src/profiling/test/ProfilingMocks.hpp b/src/profiling/test/ProfilingMocks.hpp
index b9ba9315ee..1985a3a3b8 100644
--- a/src/profiling/test/ProfilingMocks.hpp
+++ b/src/profiling/test/ProfilingMocks.hpp
@@ -17,8 +17,8 @@
 #include <armnn/Conversion.hpp>
 #include <armnn/utility/Assert.hpp>
 #include <armnn/utility/IgnoreUnused.hpp>
-#include <armnn/utility/NumericCast.hpp>
 
+#include <common/include/NumericCast.hpp>
 #include <common/include/ProfilingException.hpp>
 #include <common/include/ProfilingGuidGenerator.hpp>
 
@@ -571,10 +571,10 @@ public:
     }
 
     // Getters for counts
-    uint16_t GetCategoryCount()   const override { return armnn::numeric_cast<uint16_t>(m_Categories.size());  }
-    uint16_t GetDeviceCount()     const override { return armnn::numeric_cast<uint16_t>(m_Devices.size());     }
-    uint16_t GetCounterSetCount() const override { return armnn::numeric_cast<uint16_t>(m_CounterSets.size()); }
-    uint16_t GetCounterCount()    const override { return armnn::numeric_cast<uint16_t>(m_Counters.size());    }
+    uint16_t GetCategoryCount()   const override { return arm::pipe::numeric_cast<uint16_t>(m_Categories.size());  }
+    uint16_t GetDeviceCount()     const override { return arm::pipe::numeric_cast<uint16_t>(m_Devices.size());     }
+    uint16_t GetCounterSetCount() const override { return arm::pipe::numeric_cast<uint16_t>(m_CounterSets.size()); }
+    uint16_t GetCounterCount()    const override { return arm::pipe::numeric_cast<uint16_t>(m_Counters.size());    }
 
     // Getters for collections
     const Categories&  GetCategories()  const override { return m_Categories;  }
diff --git a/src/profiling/test/ProfilingTestUtils.cpp b/src/profiling/test/ProfilingTestUtils.cpp
index 0d8988c17a..ca322868fc 100644
--- a/src/profiling/test/ProfilingTestUtils.cpp
+++ b/src/profiling/test/ProfilingTestUtils.cpp
@@ -11,13 +11,13 @@
 #include <armnn/Descriptors.hpp>
 #include <armnn/profiling/ArmNNProfiling.hpp>
 #include <armnn/utility/Assert.hpp>
-#include <armnn/utility/NumericCast.hpp>
 
 #include <Processes.hpp>
 #include <ProfilingService.hpp>
 #include <armnnUtils/Threads.hpp>
 
 #include <common/include/LabelsAndEventClasses.hpp>
+#include <common/include/NumericCast.hpp>
 
 #include <TestUtils.hpp>
 
@@ -27,10 +27,10 @@ uint32_t GetStreamMetaDataPacketSize()
 {
     uint32_t sizeUint32 = sizeof(uint32_t);
     uint32_t payloadSize = 0;
-    payloadSize += armnn::numeric_cast<uint32_t>(GetSoftwareInfo().size()) + 1;
-    payloadSize += armnn::numeric_cast<uint32_t>(GetHardwareVersion().size()) + 1;
-    payloadSize += armnn::numeric_cast<uint32_t>(GetSoftwareVersion().size()) + 1;
-    payloadSize += armnn::numeric_cast<uint32_t>(GetProcessName().size()) + 1;
+    payloadSize += arm::pipe::numeric_cast<uint32_t>(GetSoftwareInfo().size()) + 1;
+    payloadSize += arm::pipe::numeric_cast<uint32_t>(GetHardwareVersion().size()) + 1;
+    payloadSize += arm::pipe::numeric_cast<uint32_t>(GetSoftwareVersion().size()) + 1;
+    payloadSize += arm::pipe::numeric_cast<uint32_t>(GetProcessName().size()) + 1;
 
     // Add packetVersionEntries
     payloadSize += 13 * 2 * sizeUint32;
@@ -112,7 +112,7 @@ ProfilingGuid VerifyTimelineLabelBinaryPacketData(Optional<ProfilingGuid> guid,
     // Utils
     unsigned int uint32_t_size = sizeof(uint32_t);
     unsigned int uint64_t_size = sizeof(uint64_t);
-    unsigned int label_size    = armnn::numeric_cast<unsigned int>(label.size());
+    unsigned int label_size    = arm::pipe::numeric_cast<unsigned int>(label.size());
 
     // Check the decl id
     uint32_t eventClassDeclId = ReadUint32(readableData, offset);
diff --git a/src/profiling/test/ProfilingTests.cpp b/src/profiling/test/ProfilingTests.cpp
index 0389377fe5..26130ef403 100644
--- a/src/profiling/test/ProfilingTests.cpp
+++ b/src/profiling/test/ProfilingTests.cpp
@@ -3,15 +3,10 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include <ArmNNProfilingServiceInitialiser.hpp>
-
 #include "ProfilingTests.hpp"
 #include "ProfilingTestUtils.hpp"
 
-#include <backends/BackendProfiling.hpp>
-#include <common/include/EncodeVersion.hpp>
-#include <common/include/PacketVersionResolver.hpp>
-#include <common/include/SwTrace.hpp>
+#include <ArmNNProfilingServiceInitialiser.hpp>
 #include <CommandHandler.hpp>
 #include <ConnectionAcknowledgedCommandHandler.hpp>
 #include <CounterDirectory.hpp>
@@ -20,8 +15,6 @@
 #include <ICounterValues.hpp>
 #include <PeriodicCounterCapture.hpp>
 #include <PeriodicCounterSelectionCommandHandler.hpp>
-#include <armnn/profiling/ArmNNProfiling.hpp>
-#include <armnn/profiling/ProfilingOptions.hpp>
 #include <ProfilingStateMachine.hpp>
 #include <ProfilingUtils.hpp>
 #include <RegisterBackendCounters.hpp>
@@ -33,15 +26,23 @@
 #include <SendTimelinePacket.hpp>
 
 #include <armnn/Conversion.hpp>
-
 #include <armnn/Utils.hpp>
+
+#include <armnn/profiling/ArmNNProfiling.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
+
 #include <armnn/utility/IgnoreUnused.hpp>
-#include <armnn/utility/NumericCast.hpp>
+
+#include <backends/BackendProfiling.hpp>
 
 #include <common/include/CommandHandlerKey.hpp>
 #include <common/include/CommandHandlerRegistry.hpp>
-#include <common/include/SocketConnectionException.hpp>
+#include <common/include/EncodeVersion.hpp>
+#include <common/include/NumericCast.hpp>
 #include <common/include/Packet.hpp>
+#include <common/include/PacketVersionResolver.hpp>
+#include <common/include/SocketConnectionException.hpp>
+#include <common/include/SwTrace.hpp>
 
 #include <doctest/doctest.h>
 
@@ -1808,8 +1809,8 @@ TEST_CASE("CounterSelectionCommandHandlerParseData")
     SendCounterPacket sendCounterPacket(mockBuffer);
     SendThread sendThread(profilingStateMachine, mockBuffer, sendCounterPacket);
 
-    uint32_t sizeOfUint32 = armnn::numeric_cast<uint32_t>(sizeof(uint32_t));
-    uint32_t sizeOfUint16 = armnn::numeric_cast<uint32_t>(sizeof(uint16_t));
+    uint32_t sizeOfUint32 = arm::pipe::numeric_cast<uint32_t>(sizeof(uint32_t));
+    uint32_t sizeOfUint16 = arm::pipe::numeric_cast<uint32_t>(sizeof(uint16_t));
 
     // Data with period and counters
     uint32_t period1     = arm::pipe::LOWEST_CAPTURE_PERIOD;
@@ -2045,8 +2046,8 @@ TEST_CASE("CheckConnectionAcknowledged")
     const uint32_t connectionPacketId = 0x10000;
     const uint32_t version            = 1;
 
-    uint32_t sizeOfUint32 = armnn::numeric_cast<uint32_t>(sizeof(uint32_t));
-    uint32_t sizeOfUint16 = armnn::numeric_cast<uint32_t>(sizeof(uint16_t));
+    uint32_t sizeOfUint32 = arm::pipe::numeric_cast<uint32_t>(sizeof(uint32_t));
+    uint32_t sizeOfUint16 = arm::pipe::numeric_cast<uint32_t>(sizeof(uint16_t));
 
     // Data with period and counters
     uint32_t period1     = 10;
@@ -2470,7 +2471,7 @@ TEST_CASE("RequestCounterDirectoryCommandHandlerTest1")
     CHECK(header1Word1 == 24);                       // data length
 
     uint32_t bodyHeader1Word0   = ReadUint32(readBuffer1, 8);
-    uint16_t deviceRecordCount = armnn::numeric_cast<uint16_t>(bodyHeader1Word0 >> 16);
+    uint16_t deviceRecordCount = arm::pipe::numeric_cast<uint16_t>(bodyHeader1Word0 >> 16);
     CHECK(deviceRecordCount == 0); // device_records_count
 
     auto readBuffer2 = mockBuffer2.GetReadableBuffer();
@@ -2537,9 +2538,9 @@ TEST_CASE("RequestCounterDirectoryCommandHandlerTest2")
     const uint32_t bodyHeader1Word3      = ReadUint32(readBuffer1, 20);
     const uint32_t bodyHeader1Word4      = ReadUint32(readBuffer1, 24);
     const uint32_t bodyHeader1Word5      = ReadUint32(readBuffer1, 28);
-    const uint16_t deviceRecordCount     = armnn::numeric_cast<uint16_t>(bodyHeader1Word0 >> 16);
-    const uint16_t counterSetRecordCount = armnn::numeric_cast<uint16_t>(bodyHeader1Word2 >> 16);
-    const uint16_t categoryRecordCount   = armnn::numeric_cast<uint16_t>(bodyHeader1Word4 >> 16);
+    const uint16_t deviceRecordCount     = arm::pipe::numeric_cast<uint16_t>(bodyHeader1Word0 >> 16);
+    const uint16_t counterSetRecordCount = arm::pipe::numeric_cast<uint16_t>(bodyHeader1Word2 >> 16);
+    const uint16_t categoryRecordCount   = arm::pipe::numeric_cast<uint16_t>(bodyHeader1Word4 >> 16);
     CHECK(deviceRecordCount == 1);                      // device_records_count
     CHECK(bodyHeader1Word1 == 0 + bodyHeaderSizeBytes);      // device_records_pointer_table_offset
     CHECK(counterSetRecordCount == 1);                  // counter_set_count
diff --git a/src/profiling/test/RequestCountersPacketHandler.cpp b/src/profiling/test/RequestCountersPacketHandler.cpp
index fb3eee8f20..b688b2d0c3 100644
--- a/src/profiling/test/RequestCountersPacketHandler.cpp
+++ b/src/profiling/test/RequestCountersPacketHandler.cpp
@@ -7,8 +7,7 @@
 
 #include "DirectoryCaptureCommandHandler.hpp"
 
-#include <armnn/utility/NumericCast.hpp>
-
+#include <common/include/NumericCast.hpp>
 #include <common/include/PacketVersionResolver.hpp>
 #include <common/include/ProfilingException.hpp>
 
@@ -55,7 +54,7 @@ void RequestCountersPacketHandler::SendCounterSelectionPacket()
     uint32_t uint32_t_size = sizeof(uint32_t);
 
     uint32_t offset   = 0;
-    uint32_t bodySize = uint32_t_size + armnn::numeric_cast<uint32_t>(m_IdList.size()) * uint16_t_size;
+    uint32_t bodySize = uint32_t_size + arm::pipe::numeric_cast<uint32_t>(m_IdList.size()) * uint16_t_size;
 
     auto uniqueData     = std::make_unique<unsigned char[]>(bodySize);
     auto data = reinterpret_cast<unsigned char*>(uniqueData.get());
@@ -77,4 +76,4 @@ void RequestCountersPacketHandler::SendCounterSelectionPacket()
 
 } // namespace pipe
 
-} // namespace arm
\ No newline at end of file
+} // namespace arm
diff --git a/src/profiling/test/SendCounterPacketTests.cpp b/src/profiling/test/SendCounterPacketTests.cpp
index cfcd64b98f..17931cc79b 100644
--- a/src/profiling/test/SendCounterPacketTests.cpp
+++ b/src/profiling/test/SendCounterPacketTests.cpp
@@ -18,6 +18,7 @@
 #include <armnn/Utils.hpp>
 
 #include <common/include/Constants.hpp>
+#include <common/include/NumericCast.hpp>
 #include <common/include/ProfilingException.hpp>
 
 #include <armnn/utility/Assert.hpp>
@@ -289,7 +290,7 @@ TEST_CASE("SendPeriodicCounterCapturePacketTest")
 
 TEST_CASE("SendStreamMetaDataPacketTest")
 {
-    uint32_t sizeUint32 = armnn::numeric_cast<uint32_t>(sizeof(uint32_t));
+    uint32_t sizeUint32 = arm::pipe::numeric_cast<uint32_t>(sizeof(uint32_t));
 
     // Error no space left in buffer
     MockBufferManager mockBuffer1(10);
@@ -300,10 +301,10 @@ TEST_CASE("SendStreamMetaDataPacketTest")
 
     std::string processName = GetProcessName().substr(0, 60);
 
-    uint32_t infoSize =            armnn::numeric_cast<uint32_t>(GetSoftwareInfo().size()) + 1;
-    uint32_t hardwareVersionSize = armnn::numeric_cast<uint32_t>(GetHardwareVersion().size()) + 1;
-    uint32_t softwareVersionSize = armnn::numeric_cast<uint32_t>(GetSoftwareVersion().size()) + 1;
-    uint32_t processNameSize =     armnn::numeric_cast<uint32_t>(processName.size()) + 1;
+    uint32_t infoSize =            arm::pipe::numeric_cast<uint32_t>(GetSoftwareInfo().size()) + 1;
+    uint32_t hardwareVersionSize = arm::pipe::numeric_cast<uint32_t>(GetHardwareVersion().size()) + 1;
+    uint32_t softwareVersionSize = arm::pipe::numeric_cast<uint32_t>(GetSoftwareVersion().size()) + 1;
+    uint32_t processNameSize =     arm::pipe::numeric_cast<uint32_t>(processName.size()) + 1;
 
     // Supported Packets
     // Packet Encoding version 1.0.0
@@ -350,7 +351,7 @@ TEST_CASE("SendStreamMetaDataPacketTest")
     CHECK(((headerWord0 >> 26) & 0x3F) == 0); // packet family
     CHECK(((headerWord0 >> 16) & 0x3FF) == 0); // packet id
 
-    uint32_t totalLength = armnn::numeric_cast<uint32_t>(2 * sizeUint32 +
+    uint32_t totalLength = arm::pipe::numeric_cast<uint32_t>(2 * sizeUint32 +
                                                          10 * sizeUint32 + infoSize +
                                                          hardwareVersionSize + softwareVersionSize +
                                                          processNameSize + sizeUint32 +
@@ -366,7 +367,7 @@ TEST_CASE("SendStreamMetaDataPacketTest")
     CHECK(ReadUint32(readBuffer2, offset) == MAX_METADATA_PACKET_LENGTH); // max_data_len
     offset += sizeUint32;
     int pid = armnnUtils::Processes::GetCurrentId();
-    CHECK(ReadUint32(readBuffer2, offset) == armnn::numeric_cast<uint32_t>(pid));
+    CHECK(ReadUint32(readBuffer2, offset) == arm::pipe::numeric_cast<uint32_t>(pid));
     offset += sizeUint32;
     uint32_t poolOffset = 10 * sizeUint32;
     CHECK(ReadUint32(readBuffer2, offset) == poolOffset); // offset_info
@@ -942,7 +943,7 @@ TEST_CASE("CreateCategoryRecordTest")
     ARMNN_ASSERT(counter1);
     ARMNN_ASSERT(counter2);
     ARMNN_ASSERT(counter3);
-    uint16_t categoryEventCount = armnn::numeric_cast<uint16_t>(counters.size());
+    uint16_t categoryEventCount = arm::pipe::numeric_cast<uint16_t>(counters.size());
 
     // Create a category record
     SendCounterPacket::CategoryRecord categoryRecord;
diff --git a/src/profiling/test/SendCounterPacketTests.hpp b/src/profiling/test/SendCounterPacketTests.hpp
index bae08b231e..cfd03f86c7 100644
--- a/src/profiling/test/SendCounterPacketTests.hpp
+++ b/src/profiling/test/SendCounterPacketTests.hpp
@@ -14,7 +14,6 @@
 #include <armnn/Conversion.hpp>
 #include <armnn/utility/Assert.hpp>
 #include <armnn/utility/IgnoreUnused.hpp>
-#include <armnn/utility/NumericCast.hpp>
 
 
 #include <atomic>
diff --git a/src/profiling/test/TimelinePacketTests.cpp b/src/profiling/test/TimelinePacketTests.cpp
index de791c1da0..f1a038555c 100644
--- a/src/profiling/test/TimelinePacketTests.cpp
+++ b/src/profiling/test/TimelinePacketTests.cpp
@@ -3,11 +3,11 @@
 // SPDX-License-Identifier: MIT
 //
 
-#include <armnnUtils/Threads.hpp>
 #include <ProfilingUtils.hpp>
 
-#include <armnn/utility/NumericCast.hpp>
+#include <armnnUtils/Threads.hpp>
 
+#include <common/include/NumericCast.hpp>
 #include <common/include/SwTrace.hpp>
 
 #include <doctest/doctest.h>
@@ -56,7 +56,7 @@ TEST_CASE("TimelineLabelPacketTestBufferExhaustionFixedValue")
     TimelinePacketStatus result = WriteTimelineLabelBinaryPacket(profilingGuid,
                                                                  label,
                                                                  buffer.data(),
-                                                                 armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                                 arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                                  numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::BufferExhaustion);
     CHECK(numberOfBytesWritten == 0);
@@ -72,7 +72,7 @@ TEST_CASE("TimelineLabelPacketTestInvalidLabel")
     TimelinePacketStatus result = WriteTimelineLabelBinaryPacket(profilingGuid,
                                                                  label,
                                                                  buffer.data(),
-                                                                 armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                                 arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                                  numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Error);
     CHECK(numberOfBytesWritten == 0);
@@ -88,7 +88,7 @@ TEST_CASE("TimelineLabelPacketTestSingleConstructionOfData")
     TimelinePacketStatus result = WriteTimelineLabelBinaryPacket(profilingGuid,
                                                                  label,
                                                                  buffer.data(),
-                                                                 armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                                 arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                                  numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);
     CHECK(numberOfBytesWritten == 28);
@@ -179,7 +179,7 @@ TEST_CASE("TimelineRelationshipPacketSmallBufferSizeTest")
                                                              tailGuid,
                                                              attributeGuid,
                                                              buffer.data(),
-                                                             armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                             arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                              numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::BufferExhaustion);
     CHECK(numberOfBytesWritten == 0);
@@ -202,7 +202,7 @@ TEST_CASE("TimelineRelationshipPacketInvalidRelationTest")
                                                       tailGuid,
                                                       attributeGuid,
                                                       buffer.data(),
-                                                      armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                      arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                       numberOfBytesWritten),
                     arm::pipe::InvalidArgumentException);
 
@@ -226,7 +226,7 @@ TEST_CASE("TimelineRelationshipPacketTestDataConstruction")
                                                              tailGuid,
                                                              attributeGuid,
                                                              buffer.data(),
-                                                             armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                             arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                              numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);
     CHECK(numberOfBytesWritten == 40);
@@ -283,7 +283,7 @@ TEST_CASE("TimelineRelationshipPacketExecutionLinkTestDataConstruction")
                                                              tailGuid,
                                                              attributeGuid,
                                                              buffer.data(),
-                                                             armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                             arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                              numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);
     CHECK(numberOfBytesWritten == 40);
@@ -339,7 +339,7 @@ TEST_CASE("TimelineRelationshipPacketDataLinkTestDataConstruction")
                                                              tailGuid,
                                                              attributeGuid,
                                                              buffer.data(),
-                                                             armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                             arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                              numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);
     CHECK(numberOfBytesWritten == 40);
@@ -395,7 +395,7 @@ TEST_CASE("TimelineRelationshipPacketLabelLinkTestDataConstruction")
                                                              tailGuid,
                                                              attributeGuid,
                                                              buffer.data(),
-                                                             armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                             arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                              numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);
     CHECK(numberOfBytesWritten == 40);
@@ -461,7 +461,8 @@ TEST_CASE("TimelineMessageDirectoryPacketTestFullConstruction")
     std::vector<unsigned char> buffer(512, 0);
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result = WriteTimelineMessageDirectoryPackage(buffer.data(),
-                                                                       armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                                       arm::pipe::numeric_cast<unsigned int>(
+                                                                           buffer.size()),
                                                                        numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);
 
@@ -528,7 +529,7 @@ TEST_CASE("TimelineMessageDirectoryPacketTestFullConstruction")
     // Check the ui_name
     std::vector<uint32_t> swTraceString;
     StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
-    offset += (armnn::numeric_cast<unsigned int>(swTraceString.size()) - 1) * uint32_t_size;
+    offset += (arm::pipe::numeric_cast<unsigned int>(swTraceString.size()) - 1) * uint32_t_size;
     uint32_t swTraceUINameLength = ReadUint32(buffer.data(), offset);
     CHECK(swTraceUINameLength == 14); // ui_name length including the null-terminator
 
@@ -540,7 +541,7 @@ TEST_CASE("TimelineMessageDirectoryPacketTestFullConstruction")
 
     // Check arg_types
     StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
-    offset += (armnn::numeric_cast<unsigned int>(swTraceString.size()) - 1) * uint32_t_size;
+    offset += (arm::pipe::numeric_cast<unsigned int>(swTraceString.size()) - 1) * uint32_t_size;
     uint32_t swTraceArgTypesLength = ReadUint32(buffer.data(), offset);
     CHECK(swTraceArgTypesLength == 3); // arg_types length including the null-terminator
 
@@ -552,7 +553,7 @@ TEST_CASE("TimelineMessageDirectoryPacketTestFullConstruction")
 
     // Check arg_names
     StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
-    offset += (armnn::numeric_cast<unsigned int>(swTraceString.size()) - 1) * uint32_t_size;
+    offset += (arm::pipe::numeric_cast<unsigned int>(swTraceString.size()) - 1) * uint32_t_size;
     uint32_t swTraceArgNamesLength = ReadUint32(buffer.data(), offset);
     CHECK(swTraceArgNamesLength == 11); // arg_names length including the null-terminator
 
@@ -564,7 +565,7 @@ TEST_CASE("TimelineMessageDirectoryPacketTestFullConstruction")
 
     // Check second message decl_id
     StringToSwTraceString<SwTraceCharPolicy>(label, swTraceString);
-    offset += (armnn::numeric_cast<unsigned int>(swTraceString.size()) - 1) * uint32_t_size;
+    offset += (arm::pipe::numeric_cast<unsigned int>(swTraceString.size()) - 1) * uint32_t_size;
     readDeclId = ReadUint32(buffer.data(), offset);
     CHECK(readDeclId == 1);
 
@@ -614,7 +615,7 @@ TEST_CASE("TimelineEntityPacketTestBufferExhaustedWithFixedBufferSize")
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
                                                             buffer.data(),
-                                                            armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                            arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                             numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::BufferExhaustion);
     CHECK(numberOfBytesWritten == 0);
@@ -628,7 +629,7 @@ TEST_CASE("TimelineEntityPacketTestFullConstructionOfData")
     unsigned int numberOfBytesWritten = 789u;
     TimelinePacketStatus result = WriteTimelineEntityBinary(profilingGuid,
                                                             buffer.data(),
-                                                            armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                            arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                             numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);
     CHECK(numberOfBytesWritten == 12);
@@ -686,7 +687,7 @@ TEST_CASE("TimelineEventClassTestBufferExhaustionFixedValue")
     TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
                                                                 profilingNameGuid,
                                                                 buffer.data(),
-                                                                armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                                arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                                 numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::BufferExhaustion);
     CHECK(numberOfBytesWritten == 0);
@@ -702,7 +703,7 @@ TEST_CASE("TimelineEventClassTestFullConstructionOfData")
     TimelinePacketStatus result = WriteTimelineEventClassBinary(profilingGuid,
                                                                 profilingNameGuid,
                                                                 buffer.data(),
-                                                                armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                                arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                                 numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);
     CHECK(numberOfBytesWritten == 20);
@@ -771,7 +772,7 @@ TEST_CASE("TimelineEventPacketTestBufferExhaustionFixedValue")
                                                            threadId,
                                                            profilingGuid,
                                                            buffer.data(),
-                                                           armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                           arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                            numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::BufferExhaustion);
     CHECK(numberOfBytesWritten == 0);
@@ -789,7 +790,7 @@ TEST_CASE("TimelineEventPacketTestFullConstructionOfData")
                                                            threadId,
                                                            profilingGuid,
                                                            buffer.data(),
-                                                           armnn::numeric_cast<unsigned int>(buffer.size()),
+                                                           arm::pipe::numeric_cast<unsigned int>(buffer.size()),
                                                            numberOfBytesWritten);
     CHECK(result == TimelinePacketStatus::Ok);