Fix armnn_external_delegate option parsing

 * Fixed the mechanism in armnn_delegate.cpp which creates the runtime
   options by moving it to DelegateOptions. BackendOptions are used in
   the runtime options as well as in the optimizer options but need
   to be processed separately.
 * Added runtime options to DelegateOptions to make it easier to differ
   between backend options of the runtime and the optimization
 * Updated armnn_external_delegate to use runtime options
 * Added explanations to OptimizerOptions

Signed-off-by: Jan Eilers <jan.eilers@arm.com>
Change-Id: I34235474147def261821e4576dd41a83ad492258
diff --git a/delegate/src/DelegateOptions.cpp b/delegate/src/DelegateOptions.cpp
index d4d906a..c19697d 100644
--- a/delegate/src/DelegateOptions.cpp
+++ b/delegate/src/DelegateOptions.cpp
@@ -11,15 +11,17 @@
 DelegateOptions::DelegateOptions(armnn::Compute computeDevice,
                                  const std::vector<armnn::BackendOptions>& backendOptions,
                                  const armnn::Optional<armnn::LogSeverity> logSeverityLevel)
-    : m_Backends({computeDevice}), m_BackendOptions(backendOptions), m_LoggingSeverity(logSeverityLevel)
+    : m_Backends({computeDevice}), m_RuntimeOptions(), m_LoggingSeverity(logSeverityLevel)
 {
+    m_RuntimeOptions.m_BackendOptions = backendOptions;
 }
 
 DelegateOptions::DelegateOptions(const std::vector<armnn::BackendId>& backends,
                                  const std::vector<armnn::BackendOptions>& backendOptions,
                                  const armnn::Optional<armnn::LogSeverity> logSeverityLevel)
-    : m_Backends(backends), m_BackendOptions(backendOptions), m_LoggingSeverity(logSeverityLevel)
+    : m_Backends(backends), m_RuntimeOptions(), m_LoggingSeverity(logSeverityLevel)
 {
+    m_RuntimeOptions.m_BackendOptions = backendOptions;
 }
 
 DelegateOptions::DelegateOptions(armnn::Compute computeDevice,
@@ -27,7 +29,7 @@
                                  const armnn::Optional<armnn::LogSeverity>& logSeverityLevel,
                                  const armnn::Optional<armnn::DebugCallbackFunction>& func)
     : m_Backends({computeDevice}),
-      m_BackendOptions({}),
+      m_RuntimeOptions(),
       m_OptimizerOptions(optimizerOptions),
       m_LoggingSeverity(logSeverityLevel),
       m_DebugCallbackFunc(func)
@@ -39,7 +41,7 @@
                                  const armnn::Optional<armnn::LogSeverity>& logSeverityLevel,
                                  const armnn::Optional<armnn::DebugCallbackFunction>& func)
     : m_Backends(backends),
-      m_BackendOptions({}),
+      m_RuntimeOptions(),
       m_OptimizerOptions(optimizerOptions),
       m_LoggingSeverity(logSeverityLevel),
       m_DebugCallbackFunc(func)
diff --git a/delegate/src/armnn_delegate.cpp b/delegate/src/armnn_delegate.cpp
index ae25430..966d17c 100644
--- a/delegate/src/armnn_delegate.cpp
+++ b/delegate/src/armnn_delegate.cpp
@@ -137,21 +137,7 @@
     }
 
     // Create ArmNN Runtime
-    armnn::IRuntime::CreationOptions runtimeOptions;
-    runtimeOptions.m_DynamicBackendsPath = m_Options.GetDynamicBackendsPath();
-    runtimeOptions.m_EnableGpuProfiling = m_Options.GetGpuProfilingState();
-    runtimeOptions.m_ProfilingOptions = m_Options.GetExternalProfilingParams();
-
-    auto backendOptions = m_Options.GetBackendOptions();
-    if (!backendOptions.empty())
-    {
-        runtimeOptions.m_BackendOptions = backendOptions;
-    }
-    else if (!m_Options.GetOptimizerOptions().m_ModelOptions.empty())
-    {
-        runtimeOptions.m_BackendOptions = m_Options.GetOptimizerOptions().m_ModelOptions;
-    }
-    m_Runtime = armnn::IRuntime::Create(runtimeOptions);
+    m_Runtime = armnn::IRuntime::Create(options.GetRuntimeOptions());
 
     std::vector<armnn::BackendId> backends;
     if (m_Runtime)
diff --git a/delegate/src/armnn_external_delegate.cpp b/delegate/src/armnn_external_delegate.cpp
index 4f583e8..5919a6c 100644
--- a/delegate/src/armnn_external_delegate.cpp
+++ b/delegate/src/armnn_external_delegate.cpp
@@ -171,6 +171,8 @@
     {
         // (Initializes with CpuRef backend)
         armnnDelegate::DelegateOptions options = armnnDelegate::TfLiteArmnnDelegateOptionsDefault();
+
+        armnn::IRuntime::CreationOptions runtimeOptions;
         armnn::OptimizerOptions optimizerOptions;
         bool internalProfilingState = false;
         armnn::ProfilingDetailsMethod internalProfilingDetail = armnn::ProfilingDetailsMethod::DetailsWithEvents;
@@ -194,7 +196,7 @@
             // Process dynamic-backends-path
             else if (std::string(options_keys[i]) == std::string("dynamic-backends-path"))
             {
-                options.SetDynamicBackendsPath(std::string(options_values[i]));
+                runtimeOptions.m_DynamicBackendsPath = std::string(options_values[i]);
             }
             // Process logging level
             else if (std::string(options_keys[i]) == std::string("logging-severity"))
@@ -205,26 +207,26 @@
             else if (std::string(options_keys[i]) == std::string("gpu-tuning-level"))
             {
                 armnn::BackendOptions option("GpuAcc", {{"TuningLevel", atoi(options_values[i])}});
-                options.AddBackendOption(option);
+                runtimeOptions.m_BackendOptions.push_back(option);
             }
             else if (std::string(options_keys[i]) == std::string("gpu-mlgo-tuning-file"))
             {
                 armnn::BackendOptions option("GpuAcc", {{"MLGOTuningFilePath", std::string(options_values[i])}});
-                options.AddBackendOption(option);
+                optimizerOptions.m_ModelOptions.push_back(option);
             }
             else if (std::string(options_keys[i]) == std::string("gpu-tuning-file"))
             {
                 armnn::BackendOptions option("GpuAcc", {{"TuningFile", std::string(options_values[i])}});
-                options.AddBackendOption(option);
+                runtimeOptions.m_BackendOptions.push_back(option);
             }
             else if (std::string(options_keys[i]) == std::string("gpu-enable-profiling"))
             {
-                options.SetGpuProfilingState(*options_values[i] != '0');
+                runtimeOptions.m_EnableGpuProfiling = (*options_values[i] != '0');
             }
             else if (std::string(options_keys[i]) == std::string("gpu-kernel-profiling-enabled"))
             {
                 armnn::BackendOptions option("GpuAcc", {{"KernelProfilingEnabled", (*options_values[i] != '0')}});
-                options.AddBackendOption(option);
+                runtimeOptions.m_BackendOptions.push_back(option);
             }
             else if (std::string(options_keys[i]) == std::string("save-cached-network"))
             {
@@ -340,6 +342,8 @@
                 throw armnn::Exception("Unknown option for the ArmNN Delegate given: " + std::string(options_keys[i]));
             }
         }
+
+        options.SetRuntimeOptions(runtimeOptions);
         options.SetOptimizerOptions(optimizerOptions);
         options.SetInternalProfilingParams(internalProfilingState, internalProfilingDetail);
         options.SetExternalProfilingParams(extProfilingParams);