IVGCVSW-6708 Break Profiling Dependence on IRuntime ExternalProfilingOptions

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

29 files changed, 217 insertions, 94 deletions

diff --git a/Android.mk b/Android.mk
index b7aec59119..688a188546 100644
--- a/Android.mk
+++ b/Android.mk
@@ -157,6 +157,7 @@ LOCAL_SRC_FILES := \
         src/armnnUtils/VerificationHelpers.cpp \
         src/armnnUtils/Filesystem.cpp \
         src/armnnUtils/Processes.cpp \
+        src/armnnUtils/ProfilingOptionsConverter.cpp \
         src/armnnUtils/Threads.cpp \
         src/armnnUtils/Transpose.cpp \
         src/armnn/layers/ActivationLayer.cpp \
@@ -266,7 +267,7 @@ LOCAL_SRC_FILES := \
 
 LOCAL_STATIC_LIBRARIES := \
         libflatbuffers-framework \
-        arm_compute_library 
+        arm_compute_library
 
 LOCAL_SHARED_LIBRARIES := \
         liblog
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3ba5985efd..9e115719cf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,6 +106,8 @@ list(APPEND armnnUtils_sources
     src/armnnUtils/ParserPrototxtFixture.hpp
     src/armnnUtils/Processes.hpp
     src/armnnUtils/Processes.cpp
+    src/armnnUtils/ProfilingOptionsConverter.hpp
+    src/armnnUtils/ProfilingOptionsConverter.cpp
     src/armnnUtils/PrototxtConversions.hpp
     src/armnnUtils/PrototxtConversions.cpp
     src/armnnUtils/TensorIOUtils.hpp
@@ -178,6 +180,7 @@ list(APPEND armnn_sources
     include/armnn/Utils.hpp
     include/armnn/Version.hpp
     include/armnn/profiling/ISendTimelinePacket.hpp
+    include/armnn/profiling/ProfilingOptions.hpp
     include/armnn/utility/Assert.hpp
     include/armnn/utility/IgnoreUnused.hpp
     include/armnn/utility/NumericCast.hpp
diff --git a/delegate/include/DelegateOptions.hpp b/delegate/include/DelegateOptions.hpp
index 5bc2e59070..5aa7939e4b 100644
--- a/delegate/include/DelegateOptions.hpp
+++ b/delegate/include/DelegateOptions.hpp
@@ -8,6 +8,7 @@
 #include <armnn/ArmNN.hpp>
 #include <armnn/Logging.hpp>
 #include <armnn/Optional.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
 
 #include <set>
 #include <string>
@@ -229,10 +230,10 @@ public:
     const armnn::ProfilingDetailsMethod& GetInternalProfilingDetail() const { return m_InternalProfilingDetail; }
 
     void SetExternalProfilingParams(
-        const armnn::IRuntime::CreationOptions::ExternalProfilingOptions& externalProfilingParams)
+        const armnn::profiling::ProfilingOptions& externalProfilingParams)
         { m_ProfilingOptions = externalProfilingParams; }
 
-    const armnn::IRuntime::CreationOptions::ExternalProfilingOptions& GetExternalProfilingParams() const
+    const armnn::profiling::ProfilingOptions& GetExternalProfilingParams() const
         { return m_ProfilingOptions; }
 
     void SetSerializeToDot(const std::string& serializeToDotFile) { m_SerializeToDot = serializeToDotFile; }
@@ -264,7 +265,7 @@ private:
     armnn::OptimizerOptions m_OptimizerOptions;
 
     /// External profiling options.
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions m_ProfilingOptions;
+    armnn::profiling::ProfilingOptions m_ProfilingOptions;
 
     /// Internal profiling options.
     /// Indicates whether internal profiling is enabled or not.
diff --git a/delegate/src/DelegateOptions.cpp b/delegate/src/DelegateOptions.cpp
index d477d9839d..5cfddadf99 100644
--- a/delegate/src/DelegateOptions.cpp
+++ b/delegate/src/DelegateOptions.cpp
@@ -59,7 +59,7 @@ DelegateOptions::DelegateOptions(char const* const* options_keys,
     armnn::OptimizerOptions optimizerOptions;
     bool internalProfilingState = false;
     armnn::ProfilingDetailsMethod internalProfilingDetail = armnn::ProfilingDetailsMethod::DetailsWithEvents;
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions extProfilingParams;
+    armnn::profiling::ProfilingOptions extProfilingParams;
     for (size_t i = 0; i < num_options; ++i)
     {
         // Process backends
diff --git a/include/armnn/profiling/ProfilingOptions.hpp b/include/armnn/profiling/ProfilingOptions.hpp
new file mode 100644
index 0000000000..50cd50e5c3
--- /dev/null
+++ b/include/armnn/profiling/ProfilingOptions.hpp
@@ -0,0 +1,53 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/profiling/ILocalPacketHandler.hpp>
+
+#include <string>
+#include <vector>
+
+namespace arm
+{
+namespace pipe
+{
+/// The lowest performance data capture interval we support is 10 miliseconds.
+constexpr unsigned int LOWEST_CAPTURE_PERIOD = 10000u;
+} // namespace pipe
+} // namespace arm
+
+namespace armnn
+{
+
+namespace profiling
+{
+
+struct ProfilingOptions {
+    ProfilingOptions()
+    : m_EnableProfiling(false), m_TimelineEnabled(false), m_OutgoingCaptureFile(""),
+      m_IncomingCaptureFile(""), m_FileOnly(false), m_CapturePeriod(arm::pipe::LOWEST_CAPTURE_PERIOD),
+      m_FileFormat("binary"), m_LocalPacketHandlers() {}
+
+    /// Indicates whether external profiling is enabled or not.
+    bool m_EnableProfiling;
+    /// Indicates whether external timeline profiling is enabled or not.
+    bool m_TimelineEnabled;
+    /// Path to a file in which outgoing timeline profiling messages will be stored.
+    std::string m_OutgoingCaptureFile;
+    /// Path to a file in which incoming timeline profiling messages will be stored.
+    std::string m_IncomingCaptureFile;
+    /// Enable profiling output to file only.
+    bool m_FileOnly;
+    /// The duration at which captured profiling messages will be flushed.
+    uint32_t m_CapturePeriod;
+    /// The format of the file used for outputting profiling data.
+    std::string m_FileFormat;
+    std::vector <armnn::profiling::ILocalPacketHandlerSharedPtr> m_LocalPacketHandlers;
+};
+
+} // namespace profiling
+
+} // namespace armnn
diff --git a/src/armnn/Runtime.cpp b/src/armnn/Runtime.cpp
index 1abe0f394b..4b9d0aeabb 100644
--- a/src/armnn/Runtime.cpp
+++ b/src/armnn/Runtime.cpp
@@ -14,6 +14,7 @@
 #include <backendsCommon/DynamicBackendUtils.hpp>
 #include <backendsCommon/memoryOptimizerStrategyLibrary/MemoryOptimizerStrategyLibrary.hpp>
 #include <armnn/utility/PolymorphicDowncast.hpp>
+#include <ProfilingOptionsConverter.hpp>
 
 #include <common/include/LabelsAndEventClasses.hpp>
 
@@ -474,7 +475,7 @@ RuntimeImpl::RuntimeImpl(const IRuntime::CreationOptions& options)
 
             unique_ptr<armnn::profiling::IBackendProfiling> profilingIface =
                 std::make_unique<armnn::profiling::BackendProfiling>(armnn::profiling::BackendProfiling(
-                    options, m_ProfilingService, id));
+                    ConvertExternalProfilingOptions(options.m_ProfilingOptions), m_ProfilingService, id));
 
             // Backends may also provide a profiling context. Ask for it now.
             auto profilingContext = backend->CreateBackendProfilingContext(options, profilingIface);
@@ -493,7 +494,7 @@ RuntimeImpl::RuntimeImpl(const IRuntime::CreationOptions& options)
 
     BackendRegistryInstance().SetProfilingService(m_ProfilingService);
     // pass configuration info to the profiling service
-    m_ProfilingService.ConfigureProfilingService(options.m_ProfilingOptions);
+    m_ProfilingService.ConfigureProfilingService(ConvertExternalProfilingOptions(options.m_ProfilingOptions));
     if (options.m_ProfilingOptions.m_EnableProfiling)
     {
         // try to wait for the profiling service to initialise
diff --git a/src/armnn/test/RuntimeTests.cpp b/src/armnn/test/RuntimeTests.cpp
index 045007b5c9..e175c12b57 100644
--- a/src/armnn/test/RuntimeTests.cpp
+++ b/src/armnn/test/RuntimeTests.cpp
@@ -6,10 +6,12 @@
 #include <armnn/Descriptors.hpp>
 #include <armnn/IRuntime.hpp>
 #include <armnn/INetwork.hpp>
+#include <ProfilingOptionsConverter.hpp>
 #include <Processes.hpp>
 #include <Runtime.hpp>
 #include <armnn/TypesUtils.hpp>
 
+
 #include <common/include/LabelsAndEventClasses.hpp>
 #include <test/ProfilingTestUtils.hpp>
 
@@ -644,7 +646,8 @@ TEST_CASE("ProfilingEnableCpuRef")
     options.m_ProfilingOptions.m_TimelineEnabled = true;
 
     armnn::RuntimeImpl runtime(options);
-    GetProfilingService(&runtime).ResetExternalProfilingOptions(options.m_ProfilingOptions, false);
+    GetProfilingService(&runtime).ResetExternalProfilingOptions(
+        ConvertExternalProfilingOptions(options.m_ProfilingOptions), false);
 
     profiling::ProfilingServiceRuntimeHelper profilingServiceHelper(GetProfilingService(&runtime));
     profilingServiceHelper.ForceTransitionToState(ProfilingState::NotConnected);
diff --git a/src/armnnUtils/ProfilingOptionsConverter.cpp b/src/armnnUtils/ProfilingOptionsConverter.cpp
new file mode 100644
index 0000000000..6d5b35134a
--- /dev/null
+++ b/src/armnnUtils/ProfilingOptionsConverter.cpp
@@ -0,0 +1,30 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ProfilingOptionsConverter.hpp"
+
+#include <algorithm>
+#include <iterator>
+
+namespace armnn
+{
+
+profiling::ProfilingOptions ConvertExternalProfilingOptions(
+    const IRuntime::CreationOptions::ExternalProfilingOptions& options)
+{
+    profiling::ProfilingOptions convertedOptions;
+    convertedOptions.m_EnableProfiling =     options.m_EnableProfiling;
+    convertedOptions.m_TimelineEnabled =     options.m_TimelineEnabled;
+    convertedOptions.m_OutgoingCaptureFile = options.m_OutgoingCaptureFile;
+    convertedOptions.m_IncomingCaptureFile = options.m_IncomingCaptureFile;
+    convertedOptions.m_FileOnly =            options.m_FileOnly;
+    convertedOptions.m_CapturePeriod =       options.m_CapturePeriod;
+    convertedOptions.m_FileFormat =          options.m_FileFormat;
+    std::copy(options.m_LocalPacketHandlers.begin(), options.m_LocalPacketHandlers.end(),
+        std::back_inserter(convertedOptions.m_LocalPacketHandlers));
+    return convertedOptions;
+}
+
+} // namespace armnn
diff --git a/src/armnnUtils/ProfilingOptionsConverter.hpp b/src/armnnUtils/ProfilingOptionsConverter.hpp
new file mode 100644
index 0000000000..02be849816
--- /dev/null
+++ b/src/armnnUtils/ProfilingOptionsConverter.hpp
@@ -0,0 +1,17 @@
+//
+// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/IRuntime.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
+
+namespace armnn
+{
+
+profiling::ProfilingOptions ConvertExternalProfilingOptions(
+    const IRuntime::CreationOptions::ExternalProfilingOptions& options);
+
+} // namespace armnn
diff --git a/src/backends/backendsCommon/test/BackendProfilingTests.cpp b/src/backends/backendsCommon/test/BackendProfilingTests.cpp
index b40964c89a..9769b4f7a1 100644
--- a/src/backends/backendsCommon/test/BackendProfilingTests.cpp
+++ b/src/backends/backendsCommon/test/BackendProfilingTests.cpp
@@ -10,6 +10,7 @@
 #include "MockBackendId.hpp"
 #include "PeriodicCounterCapture.hpp"
 #include "PeriodicCounterSelectionCommandHandler.hpp"
+#include "ProfilingOptionsConverter.hpp"
 #include "ProfilingStateMachine.hpp"
 #include "ProfilingUtils.hpp"
 #include "RequestCounterDirectoryCommandHandler.hpp"
@@ -20,6 +21,7 @@
 #include <armnn/BackendId.hpp>
 #include <armnn/Logging.hpp>
 #include <armnn/profiling/ISendTimelinePacket.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
 
 #include <doctest/doctest.h>
 #include <vector>
@@ -140,7 +142,8 @@ TEST_CASE("BackendProfilingCounterRegisterMockBackendTest")
     CHECK(counterMap.GetGlobalId(4, mockId) == 9 + shiftedId);
     CHECK(counterMap.GetGlobalId(5, mockId) == 10 + shiftedId);
     options.m_ProfilingOptions.m_EnableProfiling = false;
-    GetProfilingService(&runtime).ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+    GetProfilingService(&runtime).ResetExternalProfilingOptions(
+        ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
 }
 
 TEST_CASE("TestBackendCounters")
@@ -155,8 +158,8 @@ TEST_CASE("TestBackendCounters")
     const armnn::BackendId cpuAccId(armnn::Compute::CpuAcc);
     const armnn::BackendId gpuAccId(armnn::Compute::GpuAcc);
 
-    armnn::IRuntime::CreationOptions options;
-    options.m_ProfilingOptions.m_EnableProfiling = true;
+    ProfilingOptions options;
+    options.m_EnableProfiling = true;
 
     armnn::profiling::ProfilingService profilingService;
 
@@ -403,8 +406,8 @@ TEST_CASE("TestBackendCounterLogging")
     const armnn::BackendId cpuAccId(armnn::Compute::CpuAcc);
     const armnn::BackendId gpuAccId(armnn::Compute::GpuAcc);
 
-    armnn::IRuntime::CreationOptions options;
-    options.m_ProfilingOptions.m_EnableProfiling = true;
+    ProfilingOptions options;
+    options.m_EnableProfiling = true;
 
     armnn::profiling::ProfilingService profilingService;
 
@@ -459,7 +462,8 @@ TEST_CASE("BackendProfilingContextGetSendTimelinePacket")
     armnn::IRuntime::CreationOptions options;
     options.m_ProfilingOptions.m_EnableProfiling = true;
     armnn::profiling::ProfilingService profilingService;
-    profilingService.ConfigureProfilingService(options.m_ProfilingOptions, true);
+    profilingService.ConfigureProfilingService(
+        ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
 
     armnn::MockBackendInitialiser initialiser;
     // Create a runtime. During this the mock backend will be registered and context returned.
@@ -483,7 +487,8 @@ TEST_CASE("BackendProfilingContextGetSendTimelinePacket")
 
     // Reset the profiling servie after the test.
     options.m_ProfilingOptions.m_EnableProfiling = false;
-    profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+    profilingService.ResetExternalProfilingOptions(
+        ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
 }
 
 TEST_CASE("GetProfilingGuidGenerator")
diff --git a/src/profiling/FileOnlyProfilingConnection.hpp b/src/profiling/FileOnlyProfilingConnection.hpp
index 9ad2c94e07..6204f913f4 100644
--- a/src/profiling/FileOnlyProfilingConnection.hpp
+++ b/src/profiling/FileOnlyProfilingConnection.hpp
@@ -50,7 +50,7 @@ private:
 class FileOnlyProfilingConnection : public IProfilingConnection, public IInternalProfilingConnection
 {
 public:
-    explicit FileOnlyProfilingConnection(const IRuntime::CreationOptions::ExternalProfilingOptions& options)
+    explicit FileOnlyProfilingConnection(const ProfilingOptions& options)
         : m_Options(options)
         , m_Endianness(TargetEndianness::LeWire)    // Set a sensible default.
                                                     // StreamMetaDataProcessor will set a real value.
@@ -103,7 +103,7 @@ private:
     void ForwardPacketToHandlers(arm::pipe::Packet& packet);
     void ServiceLocalHandlers();
 
-    IRuntime::CreationOptions::ExternalProfilingOptions m_Options;
+    ProfilingOptions m_Options;
     std::queue<arm::pipe::Packet> m_PacketQueue;
     TargetEndianness m_Endianness;
 
@@ -130,4 +130,4 @@ private:
 
 }    // namespace profiling
 
-}    // namespace armnn
\ No newline at end of file
+}    // namespace armnn
diff --git a/src/profiling/IProfilingConnectionFactory.hpp b/src/profiling/IProfilingConnectionFactory.hpp
index c2bbc70d8b..9b0eda0334 100644
--- a/src/profiling/IProfilingConnectionFactory.hpp
+++ b/src/profiling/IProfilingConnectionFactory.hpp
@@ -7,7 +7,7 @@
 
 #include "IProfilingConnection.hpp"
 
-#include <armnn/IRuntime.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
 
 #include <memory>
 
@@ -20,12 +20,12 @@ namespace profiling
 class IProfilingConnectionFactory
 {
 public:
-    using ExternalProfilingOptions = IRuntime::CreationOptions::ExternalProfilingOptions;
+    using ExternalProfilingOptions = ProfilingOptions;
     using IProfilingConnectionPtr = std::unique_ptr<IProfilingConnection>;
 
     virtual ~IProfilingConnectionFactory() {}
 
-    virtual IProfilingConnectionPtr GetProfilingConnection(const ExternalProfilingOptions& options) const = 0;
+    virtual IProfilingConnectionPtr GetProfilingConnection(const ProfilingOptions& options) const = 0;
 };
 
 } // namespace profiling
diff --git a/src/profiling/PeriodicCounterSelectionCommandHandler.cpp b/src/profiling/PeriodicCounterSelectionCommandHandler.cpp
index cb14ec0a1a..f94cb31f62 100644
--- a/src/profiling/PeriodicCounterSelectionCommandHandler.cpp
+++ b/src/profiling/PeriodicCounterSelectionCommandHandler.cpp
@@ -6,7 +6,7 @@
 #include "PeriodicCounterSelectionCommandHandler.hpp"
 #include "ProfilingUtils.hpp"
 
-#include <armnn/Types.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
 #include <armnn/utility/NumericCast.hpp>
 
 #include <fmt/format.h>
@@ -86,9 +86,9 @@ void PeriodicCounterSelectionCommandHandler::operator()(const arm::pipe::Packet&
         // Get the capture data
         uint32_t capturePeriod = captureData.GetCapturePeriod();
         // Validate that the capture period is within the acceptable range.
-        if (capturePeriod > 0  && capturePeriod < LOWEST_CAPTURE_PERIOD)
+        if (capturePeriod > 0  && capturePeriod < arm::pipe::LOWEST_CAPTURE_PERIOD)
         {
-            capturePeriod = LOWEST_CAPTURE_PERIOD;
+            capturePeriod = arm::pipe::LOWEST_CAPTURE_PERIOD;
         }
         const std::vector<uint16_t>& counterIds = captureData.GetCounterIds();
 
diff --git a/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp b/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
index 9ac7cc03e4..f00d7fa965 100644
--- a/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
+++ b/src/profiling/ProfilingConnectionDumpToFileDecorator.cpp
@@ -18,7 +18,7 @@ namespace profiling
 
 ProfilingConnectionDumpToFileDecorator::ProfilingConnectionDumpToFileDecorator(
     std::unique_ptr<IProfilingConnection> connection,
-    const IRuntime::CreationOptions::ExternalProfilingOptions& options,
+    const ProfilingOptions& options,
     bool ignoreFailures)
       : m_Connection(std::move(connection))
       , m_Options(options)
diff --git a/src/profiling/ProfilingConnectionDumpToFileDecorator.hpp b/src/profiling/ProfilingConnectionDumpToFileDecorator.hpp
index f1b9324d2b..bf79adc603 100644
--- a/src/profiling/ProfilingConnectionDumpToFileDecorator.hpp
+++ b/src/profiling/ProfilingConnectionDumpToFileDecorator.hpp
@@ -27,7 +27,7 @@ class ProfilingConnectionDumpToFileDecorator : public IProfilingConnection
 public:
 
     ProfilingConnectionDumpToFileDecorator(std::unique_ptr<IProfilingConnection> connection,
-                                           const IRuntime::CreationOptions::ExternalProfilingOptions& options,
+                                           const ProfilingOptions& options,
                                            bool ignoreFailures = false);
 
     ~ProfilingConnectionDumpToFileDecorator();
@@ -51,11 +51,11 @@ private:
 
     void Fail(const std::string& errorMessage);
 
-    std::unique_ptr<IProfilingConnection>               m_Connection;
-    IRuntime::CreationOptions::ExternalProfilingOptions m_Options;
-    std::ofstream                                       m_IncomingDumpFileStream;
-    std::ofstream                                       m_OutgoingDumpFileStream;
-    bool                                                m_IgnoreFileErrors;
+    std::unique_ptr<IProfilingConnection> m_Connection;
+    ProfilingOptions                      m_Options;
+    std::ofstream                         m_IncomingDumpFileStream;
+    std::ofstream                         m_OutgoingDumpFileStream;
+    bool                                  m_IgnoreFileErrors;
 };
 
 } // namespace profiling
diff --git a/src/profiling/ProfilingConnectionFactory.cpp b/src/profiling/ProfilingConnectionFactory.cpp
index b5af5a7efa..fe42de493b 100644
--- a/src/profiling/ProfilingConnectionFactory.cpp
+++ b/src/profiling/ProfilingConnectionFactory.cpp
@@ -16,7 +16,7 @@ namespace profiling
 {
 
 std::unique_ptr<IProfilingConnection> ProfilingConnectionFactory::GetProfilingConnection(
-    const IRuntime::CreationOptions::ExternalProfilingOptions& options) const
+    const ProfilingOptions& options) const
 {
     // Before proceed to create the IProfilingConnection, check if the file format is supported
     if (!(options.m_FileFormat == "binary"))
diff --git a/src/profiling/ProfilingConnectionFactory.hpp b/src/profiling/ProfilingConnectionFactory.hpp
index fa8b32f703..f767ed07c2 100644
--- a/src/profiling/ProfilingConnectionFactory.hpp
+++ b/src/profiling/ProfilingConnectionFactory.hpp
@@ -19,7 +19,7 @@ public:
     ProfilingConnectionFactory()  = default;
     ~ProfilingConnectionFactory() = default;
 
-    IProfilingConnectionPtr GetProfilingConnection(const ExternalProfilingOptions& options) const override;
+    IProfilingConnectionPtr GetProfilingConnection(const ProfilingOptions& options) const override;
 };
 
 }    // namespace profiling
diff --git a/src/profiling/ProfilingService.cpp b/src/profiling/ProfilingService.cpp
index fe407e478a..c7ebee2ccf 100644
--- a/src/profiling/ProfilingService.cpp
+++ b/src/profiling/ProfilingService.cpp
@@ -38,7 +38,7 @@ void ProfilingService::ResetGuidGenerator()
     m_GuidGenerator.Reset();
 }
 
-void ProfilingService::ResetExternalProfilingOptions(const ExternalProfilingOptions& options,
+void ProfilingService::ResetExternalProfilingOptions(const armnn::profiling::ProfilingOptions& options,
                                                      bool resetProfilingService)
 {
     // Update the profiling options
@@ -60,7 +60,7 @@ bool ProfilingService::IsProfilingEnabled() const
 }
 
 ProfilingState ProfilingService::ConfigureProfilingService(
-        const ExternalProfilingOptions& options,
+        const armnn::profiling::ProfilingOptions& options,
         bool resetProfilingService)
 {
     ResetExternalProfilingOptions(options, resetProfilingService);
diff --git a/src/profiling/ProfilingService.hpp b/src/profiling/ProfilingService.hpp
index c705a49313..af480f3c5e 100644
--- a/src/profiling/ProfilingService.hpp
+++ b/src/profiling/ProfilingService.hpp
@@ -15,6 +15,7 @@
 #include "ICounterRegistry.hpp"
 #include "ICounterValues.hpp"
 #include <armnn/profiling/ILocalPacketHandler.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
 #include "IProfilingService.hpp"
 #include "IReportStructure.hpp"
 #include "PeriodicCounterCapture.hpp"
@@ -50,7 +51,6 @@ static const uint16_t MAX_ARMNN_COUNTER     = INFERENCES_RUN;
 class ProfilingService : public IReadWriteCounterValues, public IProfilingService, public INotifyBackends
 {
 public:
-    using ExternalProfilingOptions = IRuntime::CreationOptions::ExternalProfilingOptions;
     using IProfilingConnectionFactoryPtr = std::unique_ptr<IProfilingConnectionFactory>;
     using IProfilingConnectionPtr = std::unique_ptr<IProfilingConnection>;
     using CounterIndices = std::vector<std::atomic<uint32_t>*>;
@@ -149,8 +149,9 @@ public:
     ~ProfilingService();
 
     // Resets the profiling options, optionally clears the profiling service entirely
-    void ResetExternalProfilingOptions(const ExternalProfilingOptions& options, bool resetProfilingService = false);
-    ProfilingState ConfigureProfilingService(const ExternalProfilingOptions& options,
+    void ResetExternalProfilingOptions(const armnn::profiling::ProfilingOptions& options,
+                                       bool resetProfilingService = false);
+    ProfilingState ConfigureProfilingService(const armnn::profiling::ProfilingOptions& options,
                                              bool resetProfilingService = false);
 
 
@@ -239,7 +240,7 @@ private:
     void CheckCounterUid(uint16_t counterUid) const;
 
     // Profiling service components
-    ExternalProfilingOptions           m_Options;
+    ProfilingOptions                   m_Options;
     std::atomic<bool>                  m_TimelineReporting;
     CounterDirectory                   m_CounterDirectory;
     CounterIdMap                       m_CounterIdMap;
diff --git a/src/profiling/backends/BackendProfiling.hpp b/src/profiling/backends/BackendProfiling.hpp
index 71d0af16ff..5bf4655dd9 100644
--- a/src/profiling/backends/BackendProfiling.hpp
+++ b/src/profiling/backends/BackendProfiling.hpp
@@ -17,7 +17,7 @@ namespace profiling
 class BackendProfiling : public IBackendProfiling
 {
 public:
-    BackendProfiling(const IRuntime::CreationOptions& options,
+    BackendProfiling(const ProfilingOptions& options,
                      ProfilingService& profilingService,
                      const BackendId& backendId)
             : m_Options(options),
@@ -43,9 +43,9 @@ public:
     bool IsProfilingEnabled() const override;
 
 private:
-    IRuntime::CreationOptions m_Options;
+    ProfilingOptions m_Options;
     ProfilingService& m_ProfilingService;
     BackendId m_BackendId;
 };
 }    // namespace profiling
-}    // namespace armnn
\ No newline at end of file
+}    // namespace armnn
diff --git a/src/profiling/test/FileOnlyProfilingDecoratorTests.cpp b/src/profiling/test/FileOnlyProfilingDecoratorTests.cpp
index a96de66ecd..03767c0a2a 100644
--- a/src/profiling/test/FileOnlyProfilingDecoratorTests.cpp
+++ b/src/profiling/test/FileOnlyProfilingDecoratorTests.cpp
@@ -6,6 +6,7 @@
 #include <armnnUtils/Filesystem.hpp>
 #include <ProfilingService.hpp>
 #include "ProfilingTestUtils.hpp"
+#include "ProfilingOptionsConverter.hpp"
 #include "PrintPacketHeaderHandler.hpp"
 #include <Runtime.hpp>
 #include "TestTimelinePacketHandler.hpp"
@@ -233,7 +234,8 @@ TEST_CASE("DumpOutgoingValidFileEndToEnd")
 
         // In order to flush the files we need to gracefully close the profiling service.
         options.m_ProfilingOptions.m_EnableProfiling = false;
-        GetProfilingService(&runtime).ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+        GetProfilingService(&runtime).ResetExternalProfilingOptions(
+            ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
 
         // The output file size should be greater than 0.
         CHECK(fs::file_size(tempPath) > 0);
diff --git a/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp b/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
index 2da3f2d729..a851e940b4 100644
--- a/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
+++ b/src/profiling/test/ProfilingConnectionDumpToFileDecoratorTests.cpp
@@ -78,7 +78,7 @@ TEST_SUITE("ProfilingConnectionDumpToFileDecoratorTests")
 {
 TEST_CASE("DumpIncomingInvalidFile")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_IncomingCaptureFile = "/";
     options.m_OutgoingCaptureFile =  "";
     ProfilingConnectionDumpToFileDecorator decorator(std::make_unique<DummyProfilingConnection>(), options, false);
@@ -87,7 +87,7 @@ TEST_CASE("DumpIncomingInvalidFile")
 
 TEST_CASE("DumpIncomingInvalidFileIgnoreErrors")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_IncomingCaptureFile = "/";
     options.m_OutgoingCaptureFile =  "";
     ProfilingConnectionDumpToFileDecorator decorator(std::make_unique<DummyProfilingConnection>(), options, true);
@@ -98,7 +98,7 @@ TEST_CASE("DumpIncomingValidFile")
 {
     fs::path fileName = armnnUtils::Filesystem::NamedTempFile("Armnn-DumpIncomingValidFileTest-TempFile");
 
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_IncomingCaptureFile = fileName.string();
     options.m_OutgoingCaptureFile =  "";
 
@@ -122,7 +122,7 @@ TEST_CASE("DumpIncomingValidFile")
 
 TEST_CASE("DumpOutgoingInvalidFile")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_IncomingCaptureFile = "";
     options.m_OutgoingCaptureFile = "/";
     ProfilingConnectionDumpToFileDecorator decorator(std::make_unique<DummyProfilingConnection>(), options, false);
@@ -131,7 +131,7 @@ TEST_CASE("DumpOutgoingInvalidFile")
 
 TEST_CASE("DumpOutgoingInvalidFileIgnoreErrors")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_IncomingCaptureFile = "";
     options.m_OutgoingCaptureFile = "/";
 
@@ -146,7 +146,7 @@ TEST_CASE("DumpOutgoingValidFile")
 {
     fs::path fileName = armnnUtils::Filesystem::NamedTempFile("Armnn-DumpOutgoingValidFileTest-TempFile");
 
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_IncomingCaptureFile = "";
     options.m_OutgoingCaptureFile = fileName.string();
 
diff --git a/src/profiling/test/ProfilingMocks.hpp b/src/profiling/test/ProfilingMocks.hpp
index e0acfbdd32..491f057599 100644
--- a/src/profiling/test/ProfilingMocks.hpp
+++ b/src/profiling/test/ProfilingMocks.hpp
@@ -163,7 +163,7 @@ private:
 class MockProfilingConnectionFactory : public IProfilingConnectionFactory
 {
 public:
-    IProfilingConnectionPtr GetProfilingConnection(const ExternalProfilingOptions& options) const override
+    IProfilingConnectionPtr GetProfilingConnection(const ProfilingOptions& options) const override
     {
         IgnoreUnused(options);
         return std::make_unique<MockProfilingConnection>();
diff --git a/src/profiling/test/ProfilingTestUtils.cpp b/src/profiling/test/ProfilingTestUtils.cpp
index 51f27d4387..a03a3ba28a 100644
--- a/src/profiling/test/ProfilingTestUtils.cpp
+++ b/src/profiling/test/ProfilingTestUtils.cpp
@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "ProfilingOptionsConverter.hpp"
 #include "ProfilingTestUtils.hpp"
 #include "ProfilingUtils.hpp"
 
@@ -369,7 +370,8 @@ void VerifyPostOptimisationStructureTestImpl(armnn::BackendId backendId)
     options.m_ProfilingOptions.m_EnableProfiling = true;
     options.m_ProfilingOptions.m_TimelineEnabled = true;
     armnn::RuntimeImpl runtime(options);
-    GetProfilingService(&runtime).ResetExternalProfilingOptions(options.m_ProfilingOptions, false);
+    GetProfilingService(&runtime).ResetExternalProfilingOptions(
+        ConvertExternalProfilingOptions(options.m_ProfilingOptions), false);
 
     profiling::ProfilingServiceRuntimeHelper profilingServiceHelper(GetProfilingService(&runtime));
     profilingServiceHelper.ForceTransitionToState(ProfilingState::NotConnected);
diff --git a/src/profiling/test/ProfilingTests.cpp b/src/profiling/test/ProfilingTests.cpp
index 5e9a5e7e8d..12a0105563 100644
--- a/src/profiling/test/ProfilingTests.cpp
+++ b/src/profiling/test/ProfilingTests.cpp
@@ -18,6 +18,7 @@
 #include <ICounterValues.hpp>
 #include <PeriodicCounterCapture.hpp>
 #include <PeriodicCounterSelectionCommandHandler.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
 #include <ProfilingStateMachine.hpp>
 #include <ProfilingUtils.hpp>
 #include <RegisterBackendCounters.hpp>
@@ -29,7 +30,6 @@
 #include <SendTimelinePacket.hpp>
 
 #include <armnn/Conversion.hpp>
-#include <armnn/Types.hpp>
 
 #include <armnn/Utils.hpp>
 #include <armnn/utility/IgnoreUnused.hpp>
@@ -656,7 +656,7 @@ TEST_CASE("CaptureDataMethods")
 
 TEST_CASE("CheckProfilingServiceDisabled")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
     CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
@@ -666,7 +666,7 @@ TEST_CASE("CheckProfilingServiceDisabled")
 
 TEST_CASE("CheckProfilingServiceCounterDirectory")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
 
@@ -689,7 +689,7 @@ TEST_CASE("CheckProfilingServiceCounterDirectory")
 
 TEST_CASE("CheckProfilingServiceCounterValues")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -1800,7 +1800,7 @@ TEST_CASE("CounterSelectionCommandHandlerParseData")
     uint32_t sizeOfUint16 = armnn::numeric_cast<uint32_t>(sizeof(uint16_t));
 
     // Data with period and counters
-    uint32_t period1     = armnn::LOWEST_CAPTURE_PERIOD;
+    uint32_t period1     = arm::pipe::LOWEST_CAPTURE_PERIOD;
     uint32_t dataLength1 = 8;
     uint32_t offset      = 0;
 
@@ -1848,7 +1848,7 @@ TEST_CASE("CounterSelectionCommandHandlerParseData")
     CHECK(((headerWord0 >> 26) & 0x3F) == 0);             // packet family
     CHECK(((headerWord0 >> 16) & 0x3FF) == 4);            // packet id
     CHECK(headerWord1 == 8);                              // data length
-    CHECK(period ==  armnn::LOWEST_CAPTURE_PERIOD);       // capture period
+    CHECK(period ==  arm::pipe::LOWEST_CAPTURE_PERIOD);   // capture period
 
     uint16_t counterId = 0;
     offset += sizeOfUint32;
@@ -1875,7 +1875,7 @@ TEST_CASE("CounterSelectionCommandHandlerParseData")
     const std::vector<uint16_t> counterIdsB = holder.GetCaptureData().GetCounterIds();
 
     // Value should have been pulled up from 9000 to LOWEST_CAPTURE_PERIOD.
-    CHECK(holder.GetCaptureData().GetCapturePeriod() ==  armnn::LOWEST_CAPTURE_PERIOD);
+    CHECK(holder.GetCaptureData().GetCapturePeriod() ==  arm::pipe::LOWEST_CAPTURE_PERIOD);
     CHECK(counterIdsB.size() == 0);
 
     readBuffer = mockBuffer.GetReadableBuffer();
@@ -1888,10 +1888,10 @@ TEST_CASE("CounterSelectionCommandHandlerParseData")
     offset += sizeOfUint32;
     period = ReadUint32(readBuffer, offset);
 
-    CHECK(((headerWord0 >> 26) & 0x3F) == 0);         // packet family
-    CHECK(((headerWord0 >> 16) & 0x3FF) == 4);        // packet id
-    CHECK(headerWord1 == 4);                          // data length
-    CHECK(period == armnn::LOWEST_CAPTURE_PERIOD);    // capture period
+    CHECK(((headerWord0 >> 26) & 0x3F) == 0);          // packet family
+    CHECK(((headerWord0 >> 16) & 0x3FF) == 4);         // packet id
+    CHECK(headerWord1 == 4);                           // data length
+    CHECK(period == arm::pipe::LOWEST_CAPTURE_PERIOD); // capture period
 }
 
 TEST_CASE("CheckTimelineActivationAndDeactivation")
@@ -2549,7 +2549,7 @@ TEST_CASE("CheckProfilingServiceGoodConnectionAcknowledgedPacket")
     unsigned int streamMetadataPacketsize = GetStreamMetaDataPacketSize();
 
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -2609,7 +2609,7 @@ TEST_CASE("CheckProfilingServiceGoodConnectionAcknowledgedPacket")
 TEST_CASE("CheckProfilingServiceGoodRequestCounterDirectoryPacket")
 {
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -2667,7 +2667,7 @@ TEST_CASE("CheckProfilingServiceGoodRequestCounterDirectoryPacket")
 TEST_CASE("CheckProfilingServiceBadPeriodicCounterSelectionPacketInvalidCounterUid")
 {
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -2746,7 +2746,7 @@ TEST_CASE("CheckProfilingServiceBadPeriodicCounterSelectionPacketInvalidCounterU
 TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketNoCounters")
 {
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -2811,7 +2811,7 @@ TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketNoCounters")
 TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketSingleCounter")
 {
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -2888,7 +2888,7 @@ TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketSingleCounter"
 TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketMultipleCounters")
 {
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -2967,7 +2967,7 @@ TEST_CASE("CheckProfilingServiceGoodPeriodicCounterSelectionPacketMultipleCounte
 TEST_CASE("CheckProfilingServiceDisconnect")
 {
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -3025,7 +3025,7 @@ TEST_CASE("CheckProfilingServiceDisconnect")
 TEST_CASE("CheckProfilingServiceGoodPerJobCounterSelectionPacket")
 {
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -3092,7 +3092,7 @@ TEST_CASE("CheckProfilingServiceGoodPerJobCounterSelectionPacket")
 
 TEST_CASE("CheckConfigureProfilingServiceOn")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
@@ -3106,7 +3106,7 @@ TEST_CASE("CheckConfigureProfilingServiceOn")
 
 TEST_CASE("CheckConfigureProfilingServiceOff")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     armnn::profiling::ProfilingService profilingService;
     CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
     profilingService.ConfigureProfilingService(options);
@@ -3121,7 +3121,7 @@ TEST_CASE("CheckProfilingServiceEnabled")
 {
     // Locally reduce log level to "Warning", as this test needs to parse a warning message from the standard output
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -3152,7 +3152,7 @@ TEST_CASE("CheckProfilingServiceEnabledRuntime")
 {
     // Locally reduce log level to "Warning", as this test needs to parse a warning message from the standard output
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
     CHECK(profilingService.GetCurrentState() == ProfilingState::Uninitialised);
@@ -3194,7 +3194,7 @@ TEST_CASE("CheckProfilingServiceBadConnectionAcknowledgedPacket")
     StreamRedirector streamRedirector(std::cout, ss.rdbuf());
 
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -3256,7 +3256,7 @@ TEST_CASE("CheckProfilingServiceBadRequestCounterDirectoryPacket")
     StreamRedirector streamRedirector(std::cout, ss.rdbuf());
 
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -3320,7 +3320,7 @@ TEST_CASE("CheckProfilingServiceBadPeriodicCounterSelectionPacket")
     StreamRedirector streamRedirector(std::cout, ss.rdbuf());
 
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -3421,7 +3421,7 @@ TEST_CASE("CheckRegisterBackendCounters")
     armnn::BackendId cpuRefId(armnn::Compute::CpuRef);
 
     // Reset the profiling service to the uninitialized state
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling          = true;
     ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
@@ -3468,12 +3468,12 @@ TEST_CASE("CheckRegisterBackendCounters")
 
 TEST_CASE("CheckCounterStatusQuery")
 {
-    armnn::IRuntime::CreationOptions options;
-    options.m_ProfilingOptions.m_EnableProfiling = true;
+    ProfilingOptions options;
+    options.m_EnableProfiling = true;
 
     // Reset the profiling service to the uninitialized state
     ProfilingService profilingService;
-    profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+    profilingService.ResetExternalProfilingOptions(options, true);
 
     const armnn::BackendId cpuRefId(armnn::Compute::CpuRef);
     const armnn::BackendId cpuAccId(armnn::Compute::CpuAcc);
@@ -3599,18 +3599,18 @@ TEST_CASE("CheckCounterStatusQuery")
     CHECK_EQ(inactiveCpuRefCounter.m_Enabled, false);
 
     // Reset the profiling service to stop any running thread
-    options.m_ProfilingOptions.m_EnableProfiling = false;
-    profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+    options.m_EnableProfiling = false;
+    profilingService.ResetExternalProfilingOptions(options, true);
 }
 
 TEST_CASE("CheckRegisterCounters")
 {
-    armnn::IRuntime::CreationOptions options;
-    options.m_ProfilingOptions.m_EnableProfiling = true;
+    ProfilingOptions options;
+    options.m_EnableProfiling = true;
     MockBufferManager mockBuffer(1024);
 
     CaptureData captureData;
-    MockProfilingService mockProfilingService(mockBuffer, options.m_ProfilingOptions.m_EnableProfiling, captureData);
+    MockProfilingService mockProfilingService(mockBuffer, options.m_EnableProfiling, captureData);
     armnn::BackendId cpuRefId(armnn::Compute::CpuRef);
 
     mockProfilingService.RegisterMapping(6, 0, cpuRefId);
@@ -3667,7 +3667,7 @@ TEST_CASE("CheckFileFormat") {
     LogLevelSwapper logLevelSwapper(armnn::LogSeverity::Warning);
 
     // Create profiling options.
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling = true;
     // Check the default value set to binary
     CHECK(options.m_FileFormat == "binary");
diff --git a/src/profiling/test/RequestCountersPacketHandler.hpp b/src/profiling/test/RequestCountersPacketHandler.hpp
index b5e48626a7..82bd313b85 100644
--- a/src/profiling/test/RequestCountersPacketHandler.hpp
+++ b/src/profiling/test/RequestCountersPacketHandler.hpp
@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include <armnn/Types.hpp>
 #include <armnn/profiling/ILocalPacketHandler.hpp>
+#include <armnn/profiling/ProfilingOptions.hpp>
 #include "ProfilingUtils.hpp"
 
 #include <common/include/Packet.hpp>
@@ -20,7 +20,7 @@ namespace profiling
 class RequestCountersPacketHandler : public ILocalPacketHandler
 {
 public:
-    explicit RequestCountersPacketHandler(uint32_t capturePeriod = LOWEST_CAPTURE_PERIOD) :
+    explicit RequestCountersPacketHandler(uint32_t capturePeriod = arm::pipe::LOWEST_CAPTURE_PERIOD) :
         m_CapturePeriod(capturePeriod),
         m_Connection(nullptr),
         m_CounterDirectoryMessageHeader(ConstructHeader(0, 2)) {}
@@ -45,4 +45,4 @@ private:
 
 } // namespace profiling
 
-} // namespace armnn
\ No newline at end of file
+} // namespace armnn
diff --git a/src/profiling/test/SendTimelinePacketTests.cpp b/src/profiling/test/SendTimelinePacketTests.cpp
index 02c92af465..a2076b87c5 100644
--- a/src/profiling/test/SendTimelinePacketTests.cpp
+++ b/src/profiling/test/SendTimelinePacketTests.cpp
@@ -7,6 +7,7 @@
 
 #include <BufferManager.hpp>
 #include <ProfilingService.hpp>
+#include "ProfilingOptionsConverter.hpp"
 #include <ProfilingUtils.hpp>
 #include <SendTimelinePacket.hpp>
 #include <armnnUtils/Threads.hpp>
@@ -430,7 +431,8 @@ TEST_CASE("GetGuidsFromProfilingService")
     armnn::RuntimeImpl runtime(options);
     armnn::profiling::ProfilingService profilingService(runtime);
 
-    profilingService.ResetExternalProfilingOptions(options.m_ProfilingOptions, true);
+    profilingService.ResetExternalProfilingOptions(
+        ConvertExternalProfilingOptions(options.m_ProfilingOptions), true);
     ProfilingStaticGuid staticGuid = profilingService.GetStaticId("dummy");
     std::hash<std::string> hasher;
     uint64_t hash = static_cast<uint64_t>(hasher("dummy"));
@@ -446,7 +448,7 @@ TEST_CASE("GetGuidsFromProfilingService")
 
 TEST_CASE("GetTimelinePackerWriterFromProfilingService")
 {
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    ProfilingOptions options;
     options.m_EnableProfiling = true;
     armnn::profiling::ProfilingService profilingService;
     profilingService.ResetExternalProfilingOptions(options, true);
diff --git a/tests/ExecuteNetwork/ExecuteNetwork.cpp b/tests/ExecuteNetwork/ExecuteNetwork.cpp
index abcda40d1d..1f19584c68 100644
--- a/tests/ExecuteNetwork/ExecuteNetwork.cpp
+++ b/tests/ExecuteNetwork/ExecuteNetwork.cpp
@@ -11,6 +11,7 @@
 #include <armnn/Logging.hpp>
 #include <armnnUtils/Filesystem.hpp>
 #include <armnnUtils/TContainer.hpp>
+#include <ProfilingOptionsConverter.hpp>
 #include <InferenceTest.hpp>
 
 #if defined(ARMNN_SERIALIZER)
@@ -90,7 +91,8 @@ int TfLiteDelegateMainImpl(const ExecuteNetworkParams& params, const armnn::IRun
         // Create the Armnn Delegate
         // Populate a DelegateOptions from the ExecuteNetworkParams.
         armnnDelegate::DelegateOptions delegateOptions = params.ToDelegateOptions();
-        delegateOptions.SetExternalProfilingParams(runtimeOptions.m_ProfilingOptions);
+        delegateOptions.SetExternalProfilingParams(
+            ConvertExternalProfilingOptions(runtimeOptions.m_ProfilingOptions));
 
         std::unique_ptr<TfLiteDelegate, decltype(&armnnDelegate::TfLiteArmnnDelegateDelete)>
                 theArmnnDelegate(armnnDelegate::TfLiteArmnnDelegateCreate(delegateOptions),
diff --git a/tests/profiling/gatordmock/tests/GatordMockTests.cpp b/tests/profiling/gatordmock/tests/GatordMockTests.cpp
index 388de368dd..f76b2939cd 100644
--- a/tests/profiling/gatordmock/tests/GatordMockTests.cpp
+++ b/tests/profiling/gatordmock/tests/GatordMockTests.cpp
@@ -250,7 +250,7 @@ TEST_CASE("GatorDMockEndToEnd")
     arm::pipe::ConnectionHandler connectionHandler(udsNamespace, false);
 
     // Enable the profiling service.
-    armnn::IRuntime::CreationOptions::ExternalProfilingOptions options;
+    armnn::profiling::ProfilingOptions options;
     options.m_EnableProfiling = true;
     options.m_TimelineEnabled = true;