diff --git a/profiling/client/src/BufferManager.cpp b/profiling/client/src/BufferManager.cpp
index 42e3200..592d374 100644
--- a/profiling/client/src/BufferManager.cpp
+++ b/profiling/client/src/BufferManager.cpp
@@ -24,19 +24,25 @@
 IPacketBufferPtr BufferManager::Reserve(unsigned int requestedSize, unsigned int& reservedSize)
 {
     reservedSize = 0;
+#if !defined(ARMNN_DISABLE_THREADS)
     std::unique_lock<std::mutex> availableListLock(m_AvailableMutex, std::defer_lock);
+#endif
     if (requestedSize > m_MaxBufferSize)
     {
         return nullptr;
     }
+#if !defined(ARMNN_DISABLE_THREADS)
     availableListLock.lock();
+#endif
     if (m_AvailableList.empty())
     {
         if (m_CurrentNumberOfBuffers < m_MaxNumberOfBuffers)
         {
             // create a temporary overflow/surge buffer and hand it back
             m_CurrentNumberOfBuffers++;
+#if !defined(ARMNN_DISABLE_THREADS)
             availableListLock.unlock();
+#endif
             IPacketBufferPtr buffer = std::make_unique<PacketBuffer>(m_MaxBufferSize);
             reservedSize = requestedSize;
             return buffer;
@@ -44,25 +50,34 @@
         else
         {
             // we have totally busted the limit. call a halt to new memory allocations.
+#if !defined(ARMNN_DISABLE_THREADS)
             availableListLock.unlock();
+#endif
             return nullptr;
         }
     }
     IPacketBufferPtr buffer = std::move(m_AvailableList.back());
     m_AvailableList.pop_back();
+#if !defined(ARMNN_DISABLE_THREADS)
     availableListLock.unlock();
+#endif
     reservedSize = requestedSize;
     return buffer;
 }
 
 void BufferManager::Commit(IPacketBufferPtr& packetBuffer, unsigned int size, bool notifyConsumer)
 {
+#if !defined(ARMNN_DISABLE_THREADS)
     std::unique_lock<std::mutex> readableListLock(m_ReadableMutex, std::defer_lock);
+#endif
     packetBuffer->Commit(size);
+#if !defined(ARMNN_DISABLE_THREADS)
     readableListLock.lock();
+#endif
     m_ReadableList.push(std::move(packetBuffer));
+#if !defined(ARMNN_DISABLE_THREADS)
     readableListLock.unlock();
-
+#endif
     if (notifyConsumer)
     {
         FlushReadList();
@@ -82,9 +97,13 @@
 
 void BufferManager::Release(IPacketBufferPtr& packetBuffer)
 {
+#if !defined(ARMNN_DISABLE_THREADS)
     std::unique_lock<std::mutex> availableListLock(m_AvailableMutex, std::defer_lock);
+#endif
     packetBuffer->Release();
+#if !defined(ARMNN_DISABLE_THREADS)
     availableListLock.lock();
+#endif
     if (m_AvailableList.size() <= m_NumberOfBuffers)
     {
         m_AvailableList.push_back(std::move(packetBuffer));
@@ -98,14 +117,18 @@
             --m_CurrentNumberOfBuffers;
         }
     }
+#if !defined(ARMNN_DISABLE_THREADS)
     availableListLock.unlock();
+#endif
 }
 
 void BufferManager::Reset()
 {
     //This method should only be called once all threads have been joined
+#if !defined(ARMNN_DISABLE_THREADS)
     std::lock_guard<std::mutex> readableListLock(m_ReadableMutex);
     std::lock_guard<std::mutex> availableListLock(m_AvailableMutex);
+#endif
 
     m_AvailableList.clear();
     std::queue<IPacketBufferPtr>().swap(m_ReadableList);
@@ -115,12 +138,16 @@
 
 IPacketBufferPtr BufferManager::GetReadableBuffer()
 {
+#if !defined(ARMNN_DISABLE_THREADS)
     std::unique_lock<std::mutex> readableListLock(m_ReadableMutex);
+#endif
     if (!m_ReadableList.empty())
     {
         IPacketBufferPtr buffer = std::move(m_ReadableList.front());
         m_ReadableList.pop();
+#if !defined(ARMNN_DISABLE_THREADS)
         readableListLock.unlock();
+#endif
         return buffer;
     }
     return nullptr;
@@ -128,9 +155,13 @@
 
 void BufferManager::MarkRead(IPacketBufferPtr& packetBuffer)
 {
+#if !defined(ARMNN_DISABLE_THREADS)
     std::unique_lock<std::mutex> availableListLock(m_AvailableMutex, std::defer_lock);
+#endif
     packetBuffer->MarkRead();
+#if !defined(ARMNN_DISABLE_THREADS)
     availableListLock.lock();
+#endif
     if (m_AvailableList.size() <= m_NumberOfBuffers)
     {
         m_AvailableList.push_back(std::move(packetBuffer));
@@ -144,7 +175,9 @@
             --m_CurrentNumberOfBuffers;
         }
     }
+#if !defined(ARMNN_DISABLE_THREADS)
     availableListLock.unlock();
+#endif
 }
 
 void BufferManager::SetConsumer(IConsumer* consumer)
diff --git a/profiling/client/src/BufferManager.hpp b/profiling/client/src/BufferManager.hpp
index 0ab3e0e..548edec 100644
--- a/profiling/client/src/BufferManager.hpp
+++ b/profiling/client/src/BufferManager.hpp
@@ -8,8 +8,10 @@
 #include "IBufferManager.hpp"
 #include "IConsumer.hpp"
 
-#include <condition_variable>
+#if !defined(ARMNN_DISABLE_THREADS)
 #include <mutex>
+#endif
+
 #include <vector>
 #include <queue>
 
@@ -61,11 +63,13 @@
     // List of readable packet buffers
     std::queue<IPacketBufferPtr> m_ReadableList;
 
+#if !defined(ARMNN_DISABLE_THREADS)
     // Mutex for available packet buffer list
     std::mutex m_AvailableMutex;
 
     // Mutex for readable packet buffer list
     std::mutex m_ReadableMutex;
+#endif
 
     // Consumer thread to notify packet is ready to read
     IConsumer* m_Consumer = nullptr;
diff --git a/profiling/client/src/CommandHandler.cpp b/profiling/client/src/CommandHandler.cpp
index 6ba49c2..b5a7551 100644
--- a/profiling/client/src/CommandHandler.cpp
+++ b/profiling/client/src/CommandHandler.cpp
@@ -8,6 +8,10 @@
 
 #include <common/include/Logging.hpp>
 
+#if defined(ARMNN_DISABLE_THREADS)
+#include <common/include/IgnoreUnused.hpp>
+#endif
+
 namespace arm
 {
 
@@ -21,24 +25,32 @@
         return;
     }
 
+#if !defined(ARMNN_DISABLE_THREADS)
     if (m_CommandThread.joinable())
     {
         m_CommandThread.join();
     }
+#endif
 
     m_IsRunning.store(true);
     m_KeepRunning.store(true);
+#if !defined(ARMNN_DISABLE_THREADS)
     m_CommandThread = std::thread(&CommandHandler::HandleCommands, this, std::ref(profilingConnection));
+#else
+    IgnoreUnused(profilingConnection);
+#endif
 }
 
 void CommandHandler::Stop()
 {
     m_KeepRunning.store(false);
 
+#if !defined(ARMNN_DISABLE_THREADS)
     if (m_CommandThread.joinable())
     {
         m_CommandThread.join();
     }
+#endif
 }
 
 void CommandHandler::HandleCommands(IProfilingConnection& profilingConnection)
diff --git a/profiling/client/src/CommandHandler.hpp b/profiling/client/src/CommandHandler.hpp
index b097f9e..bc0461f 100644
--- a/profiling/client/src/CommandHandler.hpp
+++ b/profiling/client/src/CommandHandler.hpp
@@ -11,7 +11,9 @@
 #include <common/include/CommandHandlerRegistry.hpp>
 
 #include <atomic>
+#if !defined(ARMNN_DISABLE_THREADS)
 #include <thread>
+#endif
 
 namespace arm
 {
@@ -30,7 +32,9 @@
           m_StopAfterTimeout(stopAfterTimeout),
           m_IsRunning(false),
           m_KeepRunning(false),
+#if !defined(ARMNN_DISABLE_THREADS)
           m_CommandThread(),
+#endif
           m_CommandHandlerRegistry(commandHandlerRegistry),
           m_PacketVersionResolver(packetVersionResolver)
     {}
@@ -38,7 +42,6 @@
 
     void SetTimeout(uint32_t timeout) { m_Timeout.store(timeout); }
     void SetStopAfterTimeout(bool stopAfterTimeout) { m_StopAfterTimeout.store(stopAfterTimeout); }
-
     void Start(IProfilingConnection& profilingConnection);
     void Stop();
     bool IsRunning() const { return m_IsRunning.load(); }
@@ -50,7 +53,9 @@
     std::atomic<bool>     m_StopAfterTimeout;
     std::atomic<bool>     m_IsRunning;
     std::atomic<bool>     m_KeepRunning;
+#if !defined(ARMNN_DISABLE_THREADS)
     std::thread           m_CommandThread;
+#endif
 
     arm::pipe::CommandHandlerRegistry& m_CommandHandlerRegistry;
     arm::pipe::PacketVersionResolver&  m_PacketVersionResolver;
diff --git a/profiling/client/src/FileOnlyProfilingConnection.cpp b/profiling/client/src/FileOnlyProfilingConnection.cpp
index bee2c62..01ea3a2 100644
--- a/profiling/client/src/FileOnlyProfilingConnection.cpp
+++ b/profiling/client/src/FileOnlyProfilingConnection.cpp
@@ -11,7 +11,10 @@
 
 #include <algorithm>
 #include <iostream>
-#include <thread>
+
+#if defined(ARMNN_DISABLE_THREADS)
+#include <common/include/IgnoreUnused.hpp>
+#endif
 
 namespace arm
 {
@@ -97,12 +100,14 @@
     }
     // dispose of the processing thread
     m_KeepRunning.store(false);
+#if !defined(ARMNN_DISABLE_THREADS)
     if (m_LocalHandlersThread.joinable())
     {
         // make sure the thread wakes up and sees it has to stop
         m_ConditionPacketReadable.notify_one();
         m_LocalHandlersThread.join();
     }
+#endif
 }
 
 bool FileOnlyProfilingConnection::WritePacket(const unsigned char* buffer, uint32_t length)
@@ -116,14 +121,19 @@
 void FileOnlyProfilingConnection::ReturnPacket(arm::pipe::Packet& packet)
 {
     {
+#if !defined(ARMNN_DISABLE_THREADS)
         std::lock_guard<std::mutex> lck(m_PacketAvailableMutex);
+#endif
         m_PacketQueue.push(std::move(packet));
     }
+#if !defined(ARMNN_DISABLE_THREADS)
     m_ConditionPacketAvailable.notify_one();
+#endif
 }
 
 arm::pipe::Packet FileOnlyProfilingConnection::ReadPacket(uint32_t timeout)
 {
+#if !defined(ARMNN_DISABLE_THREADS)
     std::unique_lock<std::mutex> lck(m_PacketAvailableMutex);
 
     // Here we are using m_PacketQueue.empty() as a predicate variable
@@ -135,6 +145,9 @@
         arm::pipe::Packet empty;
         return empty;
     }
+#else
+    IgnoreUnused(timeout);
+#endif
 
     arm::pipe::Packet returnedPacket = std::move(m_PacketQueue.front());
     m_PacketQueue.pop();
@@ -188,13 +201,17 @@
         return;
     }
     // make sure if there was one running before it is joined
+#if !defined(ARMNN_DISABLE_THREADS)
     if (m_LocalHandlersThread.joinable())
     {
         m_LocalHandlersThread.join();
     }
+#endif
     m_IsRunning.store(true);
     m_KeepRunning.store(true);
+#if !defined(ARMNN_DISABLE_THREADS)
     m_LocalHandlersThread = std::thread(&FileOnlyProfilingConnection::ServiceLocalHandlers, this);
+#endif
 }
 
 void FileOnlyProfilingConnection::ForwardPacketToHandlers(arm::pipe::Packet& packet)
@@ -208,14 +225,18 @@
         return;
     }
     {
+#if !defined(ARMNN_DISABLE_THREADS)
         std::unique_lock<std::mutex> readableListLock(m_ReadableMutex);
+#endif
         if (!m_KeepRunning.load())
         {
             return;
         }
         m_ReadableList.push(std::move(packet));
     }
+#if !defined(ARMNN_DISABLE_THREADS)
     m_ConditionPacketReadable.notify_one();
+#endif
 }
 
 void FileOnlyProfilingConnection::ServiceLocalHandlers()
@@ -225,17 +246,23 @@
         arm::pipe::Packet returnedPacket;
         bool readPacket = false;
         {   // only lock while we are taking the packet off the incoming list
+#if !defined(ARMNN_DISABLE_THREADS)
             std::unique_lock<std::mutex> lck(m_ReadableMutex);
+#endif
             if (m_Timeout < 0)
             {
+#if !defined(ARMNN_DISABLE_THREADS)
                 m_ConditionPacketReadable.wait(lck,
                                                [&] { return !m_ReadableList.empty(); });
+#endif
             }
             else
             {
+#if !defined(ARMNN_DISABLE_THREADS)
                 m_ConditionPacketReadable.wait_for(lck,
                                                    std::chrono::milliseconds(std::max(m_Timeout, 1000)),
                                                    [&] { return !m_ReadableList.empty(); });
+#endif
             }
             if (m_KeepRunning.load())
             {
diff --git a/profiling/client/src/FileOnlyProfilingConnection.hpp b/profiling/client/src/FileOnlyProfilingConnection.hpp
index c7e60f5..9ecbd6c 100644
--- a/profiling/client/src/FileOnlyProfilingConnection.hpp
+++ b/profiling/client/src/FileOnlyProfilingConnection.hpp
@@ -17,12 +17,15 @@
 #include <server/include/timelineDecoder/DirectoryCaptureCommandHandler.hpp>
 
 #include <atomic>
-#include <condition_variable>
 #include <fstream>
 #include <map>
-#include <mutex>
 #include <queue>
+
+#if !defined(ARMNN_DISABLE_THREADS)
+#include <condition_variable>
+#include <mutex>
 #include <thread>
+#endif
 
 namespace arm
 {
@@ -111,8 +114,10 @@
     std::queue<arm::pipe::Packet> m_PacketQueue;
     TargetEndianness m_Endianness;
 
+#if !defined(ARMNN_DISABLE_THREADS)
     std::mutex m_PacketAvailableMutex;
     std::condition_variable m_ConditionPacketAvailable;
+#endif
 
     std::vector<ILocalPacketHandlerSharedPtr> m_PacketHandlers;
     std::map<uint32_t, std::vector<ILocalPacketHandlerSharedPtr>> m_IndexedHandlers;
@@ -121,11 +126,13 @@
     // List of readable packets for the local packet handlers
     std::queue<arm::pipe::Packet> m_ReadableList;
     // Mutex and condition variable for the readable packet list
+#if !defined(ARMNN_DISABLE_THREADS)
     std::mutex m_ReadableMutex;
     std::condition_variable m_ConditionPacketReadable;
     // thread that takes items from the readable list and dispatches them
     // to the handlers.
     std::thread m_LocalHandlersThread;
+#endif
     // atomic booleans that control the operation of the local handlers thread
     std::atomic<bool> m_IsRunning;
     std::atomic<bool> m_KeepRunning;
diff --git a/profiling/client/src/PeriodicCounterCapture.cpp b/profiling/client/src/PeriodicCounterCapture.cpp
index 490173c..25d1a17 100644
--- a/profiling/client/src/PeriodicCounterCapture.cpp
+++ b/profiling/client/src/PeriodicCounterCapture.cpp
@@ -31,7 +31,9 @@
     m_KeepRunning.store(true);
 
     // Start the new capture thread.
+#if !defined(ARMNN_DISABLE_THREADS)
     m_PeriodCaptureThread = std::thread(&PeriodicCounterCapture::Capture, this, std::ref(m_ReadCounterValues));
+#endif
 }
 
 void PeriodicCounterCapture::Stop()
@@ -39,12 +41,14 @@
     // Signal the capture thread to stop
     m_KeepRunning.store(false);
 
+#if !defined(ARMNN_DISABLE_THREADS)
     // Check that the capture thread is running
     if (m_PeriodCaptureThread.joinable())
     {
         // Wait for the capture thread to complete operations
         m_PeriodCaptureThread.join();
     }
+#endif
 
     // Mark the capture thread as not running
     m_IsRunning = false;
@@ -85,7 +89,9 @@
         if (capturePeriod == 0)
         {
             // No data capture, wait the indicated capture period (milliseconds), if it is not zero
+#if !defined(ARMNN_DISABLE_THREADS)
             std::this_thread::sleep_for(std::chrono::milliseconds(50u));
+#endif
             continue;
         }
 
@@ -129,7 +135,9 @@
         });
 
         // Wait the indicated capture period (microseconds)
+#if !defined(ARMNN_DISABLE_THREADS)
         std::this_thread::sleep_for(std::chrono::microseconds(capturePeriod));
+#endif
     }
     while (m_KeepRunning.load());
 }
diff --git a/profiling/client/src/PeriodicCounterCapture.hpp b/profiling/client/src/PeriodicCounterCapture.hpp
index 8808417..35ceb0c 100644
--- a/profiling/client/src/PeriodicCounterCapture.hpp
+++ b/profiling/client/src/PeriodicCounterCapture.hpp
@@ -17,8 +17,11 @@
 #include <common/include/Packet.hpp>
 
 #include <atomic>
+
+#if !defined(ARMNN_DISABLE_THREADS)
 #include <mutex>
 #include <thread>
+#endif
 
 namespace arm
 {
@@ -34,7 +37,7 @@
                            IReadCounterValues& readCounterValue,
                            const ICounterMappings& counterIdMap,
                            const std::unordered_map<std::string,
-                               std::shared_ptr<IBackendProfilingContext>>& backendProfilingContexts)
+                           std::shared_ptr<IBackendProfilingContext>>& backendProfilingContexts)
             : m_CaptureDataHolder(data)
             , m_IsRunning(false)
             , m_KeepRunning(false)
@@ -58,7 +61,9 @@
     const Holder&             m_CaptureDataHolder;
     bool                      m_IsRunning;
     std::atomic<bool>         m_KeepRunning;
+#if !defined(ARMNN_DISABLE_THREADS)
     std::thread               m_PeriodCaptureThread;
+#endif
     IReadCounterValues&       m_ReadCounterValues;
     ISendCounterPacket&       m_SendCounterPacket;
     const ICounterMappings&   m_CounterIdMap;
diff --git a/profiling/client/src/ProfilingService.cpp b/profiling/client/src/ProfilingService.cpp
index 3a5c74b..b8e0348 100644
--- a/profiling/client/src/ProfilingService.cpp
+++ b/profiling/client/src/ProfilingService.cpp
@@ -10,6 +10,11 @@
 #include <common/include/ProfilingGuid.hpp>
 #include <common/include/SocketConnectionException.hpp>
 
+#if defined(ARMNN_BUILD_BARE_METAL)
+#include <common/include/IgnoreUnused.hpp>
+#endif
+
+
 #include <fmt/format.h>
 
 namespace arm
@@ -33,6 +38,9 @@
         // Reset the profiling service
         Reset();
     }
+#else
+    IgnoreUnused(options);
+    IgnoreUnused(resetProfilingService);
 #endif // ARMNN_BUILD_BARE_METAL
 }
 
@@ -94,6 +102,10 @@
                 return m_StateMachine.GetCurrentState();
         }
     }
+#else
+    IgnoreUnused(options);
+    IgnoreUnused(resetProfilingService);
+    return ProfilingState::Uninitialised;
 #endif // ARMNN_BUILD_BARE_METAL
 }
 
@@ -212,6 +224,9 @@
     // Register the backend counters
     m_MaxGlobalCounterId = profilingContext->RegisterCounters(m_MaxGlobalCounterId);
     m_BackendProfilingContexts.emplace(backendId, std::move(profilingContext));
+#else
+    IgnoreUnused(backendId);
+    IgnoreUnused(profilingContext);
 #endif // ARMNN_BUILD_BARE_METAL
 }
 const ICounterDirectory& ProfilingService::GetCounterDirectory() const
@@ -348,6 +363,8 @@
     // Register the new counter to the counter index for quick access
     std::atomic<uint32_t>* counterValuePtr = &(m_CounterValues.back());
     m_CounterIndex.at(counterUid) = counterValuePtr;
+#else
+    IgnoreUnused(counterUid);
 #endif // ARMNN_BUILD_BARE_METAL
 }
 
@@ -404,6 +421,8 @@
     {
         throw arm::pipe::InvalidArgumentException(fmt::format("Counter UID {} is not registered", counterUid));
     }
+#else
+    IgnoreUnused(counterUid);
 #endif // ARMNN_BUILD_BARE_METAL
 }
 
@@ -454,7 +473,8 @@
         ss << "Timed out waiting on profiling service activation for " << elapsed.count() << " ms";
         ARM_PIPE_LOG(warning) << ss.str();
     }
-    return;
+#else
+    IgnoreUnused(timeout);
 #endif // ARMNN_BUILD_BARE_METAL
 }
 
diff --git a/profiling/client/src/ProfilingService.hpp b/profiling/client/src/ProfilingService.hpp
index b84b39d..588bcd2 100644
--- a/profiling/client/src/ProfilingService.hpp
+++ b/profiling/client/src/ProfilingService.hpp
@@ -261,8 +261,10 @@
     uint16_t                    m_MaxGlobalCounterId;
 
     // Signalling to let external actors know when service is active or not
+#if !defined(ARMNN_DISABLE_THREADS)
     std::mutex m_ServiceActiveMutex;
     std::condition_variable m_ServiceActiveConditionVariable;
+#endif
     bool m_ServiceActive;
 
     IInitialiseProfilingService& m_Initialiser;
diff --git a/profiling/client/src/ProfilingUtils.cpp b/profiling/client/src/ProfilingUtils.cpp
index 2963a98..4426d41 100644
--- a/profiling/client/src/ProfilingUtils.cpp
+++ b/profiling/client/src/ProfilingUtils.cpp
@@ -13,6 +13,7 @@
 
 #include <armnn/Version.hpp>
 
+#include <chrono>
 #include <fstream>
 #include <iostream>
 #include <limits>
@@ -593,11 +594,7 @@
 
 uint64_t GetTimestamp()
 {
-#if USE_CLOCK_MONOTONIC_RAW
-    using clock = armnn::MonotonicClockRaw;
-#else
     using clock = std::chrono::steady_clock;
-#endif
 
     // Take a timestamp
     auto timestamp = std::chrono::duration_cast<std::chrono::nanoseconds>(clock::now().time_since_epoch());
diff --git a/profiling/client/src/SendThread.cpp b/profiling/client/src/SendThread.cpp
index 7fb8e65..9a13dae 100644
--- a/profiling/client/src/SendThread.cpp
+++ b/profiling/client/src/SendThread.cpp
@@ -9,6 +9,10 @@
 #include <common/include/NumericCast.hpp>
 #include <common/include/ProfilingException.hpp>
 
+#if defined(ARMNN_DISABLE_THREADS)
+#include <common/include/IgnoreUnused.hpp>
+#endif
+
 #include <cstring>
 
 namespace arm
@@ -36,11 +40,15 @@
 {
     // We need to wait for the send thread to release its mutex
     {
+#if !defined(ARMNN_DISABLE_THREADS)
         std::lock_guard<std::mutex> lck(m_WaitMutex);
+#endif
         m_ReadyToRead = true;
     }
     // Signal the send thread that there's something to read in the buffer
+#if !defined(ARMNN_DISABLE_THREADS)
     m_WaitCondition.notify_one();
+#endif
 }
 
 void SendThread::Start(IProfilingConnection& profilingConnection)
@@ -52,10 +60,12 @@
         return;
     }
 
+#if !defined(ARMNN_DISABLE_THREADS)
     if (m_SendThread.joinable())
     {
         m_SendThread.join();
     }
+#endif
 
     // Mark the send thread as running
     m_IsRunning.store(true);
@@ -70,7 +80,11 @@
     m_PacketSent = false;
 
     // Start the send thread
+#if !defined(ARMNN_DISABLE_THREADS)
     m_SendThread = std::thread(&SendThread::Send, this, std::ref(profilingConnection));
+#else
+    IgnoreUnused(profilingConnection);
+#endif
 }
 
 void SendThread::Stop(bool rethrowSendThreadExceptions)
@@ -79,6 +93,7 @@
     m_KeepRunning.store(false);
 
     // Check that the send thread is running
+#if !defined(ARMNN_DISABLE_THREADS)
     if (m_SendThread.joinable())
     {
         // Kick the send thread out of the wait condition
@@ -86,6 +101,7 @@
         // Wait for the send thread to complete operations
         m_SendThread.join();
     }
+#endif
 
     // Check if the send thread exception has to be rethrown
     if (!rethrowSendThreadExceptions)
@@ -147,17 +163,19 @@
 
             // Wait condition lock scope - Begin
             {
+#if !defined(ARMNN_DISABLE_THREADS)
                 std::unique_lock<std::mutex> lock(m_WaitMutex);
 
                 bool timeout = m_WaitCondition.wait_for(lock,
                                                         std::chrono::milliseconds(std::max(m_Timeout, 1000)),
                                                         [&]{ return m_ReadyToRead; });
                 // If we get notified we need to flush the buffer again
-                if(timeout)
+                if (timeout)
                 {
                     // Otherwise if we just timed out don't flush the buffer
                     continue;
                 }
+#endif
                 //reset condition variable predicate for next use
                 m_ReadyToRead = false;
             }
@@ -167,20 +185,25 @@
         default:
             // Wait condition lock scope - Begin
             {
+#if !defined(ARMNN_DISABLE_THREADS)
                 std::unique_lock<std::mutex> lock(m_WaitMutex);
-
+#endif
                 // Normal working state for the send thread
                 // Check if the send thread is required to enforce a timeout wait policy
                 if (m_Timeout < 0)
                 {
                     // Wait indefinitely until notified that something to read has become available in the buffer
+#if !defined(ARMNN_DISABLE_THREADS)
                     m_WaitCondition.wait(lock, [&] { return m_ReadyToRead; });
+#endif
                 }
                 else
                 {
                     // Wait until the thread is notified of something to read from the buffer,
                     // or check anyway after the specified number of milliseconds
+#if !defined(ARMNN_DISABLE_THREADS)
                     m_WaitCondition.wait_for(lock, std::chrono::milliseconds(m_Timeout), [&] { return m_ReadyToRead; });
+#endif
                 }
 
                 //reset condition variable predicate for next use
@@ -246,25 +269,33 @@
     {
         // Wait for the parent thread to release its mutex if necessary
         {
+#if !defined(ARMNN_DISABLE_THREADS)
             std::lock_guard<std::mutex> lck(m_PacketSentWaitMutex);
+#endif
             m_PacketSent = true;
         }
         // Notify to any watcher that something has been sent
+#if !defined(ARMNN_DISABLE_THREADS)
         m_PacketSentWaitCondition.notify_one();
+#endif
     }
 }
 
 bool SendThread::WaitForPacketSent(uint32_t timeout = 1000)
 {
+#if !defined(ARMNN_DISABLE_THREADS)
     std::unique_lock<std::mutex> lock(m_PacketSentWaitMutex);
     // Blocks until notified that at least a packet has been sent or until timeout expires.
     bool timedOut = m_PacketSentWaitCondition.wait_for(lock,
                                                        std::chrono::milliseconds(timeout),
                                                        [&] { return m_PacketSent; });
-
     m_PacketSent = false;
 
     return timedOut;
+#else
+    IgnoreUnused(timeout);
+    return false;
+#endif
 }
 
 } // namespace pipe
diff --git a/profiling/client/src/SendThread.hpp b/profiling/client/src/SendThread.hpp
index b96a6d5..f462ae0 100644
--- a/profiling/client/src/SendThread.hpp
+++ b/profiling/client/src/SendThread.hpp
@@ -17,9 +17,11 @@
 #include <common/include/ICounterDirectory.hpp>
 
 #include <atomic>
+#if !defined(ARMNN_DISABLE_THREADS)
 #include <condition_variable>
 #include <mutex>
 #include <thread>
+#endif
 #include <type_traits>
 
 namespace arm
@@ -57,9 +59,11 @@
     IBufferManager& m_BufferManager;
     ISendCounterPacket& m_SendCounterPacket;
     int m_Timeout;
+#if !defined(ARMNN_DISABLE_THREADS)
     std::mutex m_WaitMutex;
     std::condition_variable m_WaitCondition;
     std::thread m_SendThread;
+#endif
     std::atomic<bool> m_IsRunning;
     std::atomic<bool> m_KeepRunning;
     // m_ReadyToRead will be protected by m_WaitMutex
@@ -67,9 +71,10 @@
     // m_PacketSent will be protected by m_PacketSentWaitMutex
     bool m_PacketSent;
     std::exception_ptr m_SendThreadException;
+#if !defined(ARMNN_DISABLE_THREADS)
     std::mutex m_PacketSentWaitMutex;
     std::condition_variable m_PacketSentWaitCondition;
-
+#endif
 };
 
 } // namespace pipe
diff --git a/profiling/client/src/SocketProfilingConnection.cpp b/profiling/client/src/SocketProfilingConnection.cpp
index a211567..b924f8d 100644
--- a/profiling/client/src/SocketProfilingConnection.cpp
+++ b/profiling/client/src/SocketProfilingConnection.cpp
@@ -20,6 +20,7 @@
 
 SocketProfilingConnection::SocketProfilingConnection()
 {
+#if !defined(ARMNN_DISABLE_SOCKETS)
     arm::pipe::Initialize();
     memset(m_Socket, 0, sizeof(m_Socket));
     // Note: we're using Linux specific SOCK_CLOEXEC flag.
@@ -59,15 +60,21 @@
             m_Socket[0].fd,
             errno);
     }
+#endif
 }
 
 bool SocketProfilingConnection::IsOpen() const
 {
+#if !defined(ARMNN_DISABLE_SOCKETS)
     return m_Socket[0].fd > 0;
+#else
+    return false;
+#endif
 }
 
 void SocketProfilingConnection::Close()
 {
+#if !defined(ARMNN_DISABLE_SOCKETS)
     if (arm::pipe::Close(m_Socket[0].fd) != 0)
     {
         throw arm::pipe::SocketConnectionException(
@@ -77,6 +84,7 @@
     }
 
     memset(m_Socket, 0, sizeof(m_Socket));
+#endif
 }
 
 bool SocketProfilingConnection::WritePacket(const unsigned char* buffer, uint32_t length)
@@ -85,12 +93,16 @@
     {
         return false;
     }
-
+#if !defined(ARMNN_DISABLE_SOCKETS)
     return arm::pipe::Write(m_Socket[0].fd, buffer, length) != -1;
+#else
+    return false;
+#endif
 }
 
 arm::pipe::Packet SocketProfilingConnection::ReadPacket(uint32_t timeout)
 {
+#if !defined(ARMNN_DISABLE_SOCKETS)
     // Is there currently at least a header worth of data waiting to be read?
     int bytes_available = 0;
     arm::pipe::Ioctl(m_Socket[0].fd, FIONREAD, &bytes_available);
@@ -156,10 +168,16 @@
 
         return ReceivePacket();
     }
+#else
+    IgnoreUnused(timeout);
+    throw arm::pipe::TimeoutException(
+        "SocketProfilingConnection: Cannot use ReadPacket function with sockets disabled");
+#endif
 }
 
 arm::pipe::Packet SocketProfilingConnection::ReceivePacket()
 {
+#if !defined(ARMNN_DISABLE_SOCKETS)
     char header[8] = {};
     long receiveResult = arm::pipe::Read(m_Socket[0].fd, &header, sizeof(header));
     // We expect 8 as the result here. 0 means EOF, socket is closed. -1 means there been some other kind of error.
@@ -219,6 +237,10 @@
     }
 
     return arm::pipe::Packet(metadataIdentifier, dataLength, packetData);
+#else
+    throw arm::pipe::TimeoutException(
+        "SocketProfilingConnection: Cannot use ReceivePacket function with sockets disabled");
+#endif
 }
 
 } // namespace pipe
diff --git a/profiling/client/src/SocketProfilingConnection.hpp b/profiling/client/src/SocketProfilingConnection.hpp
index 52616c9..db6b512 100644
--- a/profiling/client/src/SocketProfilingConnection.hpp
+++ b/profiling/client/src/SocketProfilingConnection.hpp
@@ -35,7 +35,9 @@
     // MACOSX does not support abstract UDS
     const char* m_GatorNamespace = "/tmp/gatord_namespace";
 #endif
+#if !defined(ARMNN_DISABLE_SOCKETS)
     arm::pipe::PollFd m_Socket[1]{};
+#endif
 };
 
 } // namespace pipe