Fixing ambiguous method name in BackendHelper.

!android-nn-driver:10035

* Two of the 4 HasCapability methods in BackendHelper were checking the
  value of the capability not just the existence of the capability.

Signed-off-by: Colm Donelan <colm.donelan@arm.com>
Change-Id: I63bc1671dfb088a947de70a21c86d2502f92f008

6 files changed, 39 insertions, 18 deletions

diff --git a/include/armnn/BackendHelper.hpp b/include/armnn/BackendHelper.hpp
index b550f9f68e..59cbbfced3 100644
--- a/include/armnn/BackendHelper.hpp
+++ b/include/armnn/BackendHelper.hpp
@@ -466,11 +466,19 @@ bool HasCapability(const std::string& name,const BackendCapabilities& capabiliti
 bool HasCapability(const std::string& name, const armnn::BackendId& backend);
 
 /// Convenience function to check if a given capability matches a  capability in a BackendCapabilities struct
+ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use HasMatchingCapability instead.", "24.05")
 bool HasCapability(const BackendOptions::BackendOption& capability, const BackendCapabilities& capabilities);
 
 /// Convenience function to check if a given capability matches a  capability in a backend
+ARMNN_DEPRECATED_MSG_REMOVAL_DATE("Use HasMatchingCapability instead.", "24.05")
 bool HasCapability(const BackendOptions::BackendOption& backendOption, const armnn::BackendId& backend);
 
+/// Convenience function to check if a given capability matches a  capability in a BackendCapabilities struct
+bool HasMatchingCapability(const BackendOptions::BackendOption& capability, const BackendCapabilities& capabilities);
+
+/// Convenience function to check if a given capability matches a  capability in a backend
+bool HasMatchingCapability(const BackendOptions::BackendOption& backendOption, const armnn::BackendId& backend);
+
 /// Returns a BackendCapability if the backend lists the capability
 /// The BackendCapability must then be inspected to check whether or not that BackendCapability is supported
 /// Otherwise returns an EmptyOptional if the BackendCapability is unlisted
diff --git a/src/armnn/BackendHelper.cpp b/src/armnn/BackendHelper.cpp
index 0a55a08087..f025193006 100644
--- a/src/armnn/BackendHelper.cpp
+++ b/src/armnn/BackendHelper.cpp
@@ -74,6 +74,16 @@ bool HasCapability(const std::string& name, const armnn::BackendId& backend)
 
 bool HasCapability(const BackendOptions::BackendOption& capability, const BackendCapabilities& capabilities)
 {
+    return HasMatchingCapability(capability, capabilities);
+}
+
+bool HasCapability(const BackendOptions::BackendOption& backendOption, const armnn::BackendId& backend)
+{
+    return HasMatchingCapability(backendOption, backend);
+}
+
+bool HasMatchingCapability(const BackendOptions::BackendOption& capability, const BackendCapabilities& capabilities)
+{
     for (size_t i=0; i < capabilities.GetOptionCount(); i++)
     {
         const auto& backendCapability = capabilities.GetOption(i);
@@ -104,7 +114,7 @@ bool HasCapability(const BackendOptions::BackendOption& capability, const Backen
     return false;
 }
 
-bool HasCapability(const BackendOptions::BackendOption& backendOption, const armnn::BackendId& backend)
+bool HasMatchingCapability(const BackendOptions::BackendOption& backendOption, const armnn::BackendId& backend)
 {
     auto const& backendRegistry = armnn::BackendRegistryInstance();
     if (backendRegistry.IsBackendRegistered(backend))
@@ -112,7 +122,7 @@ bool HasCapability(const BackendOptions::BackendOption& backendOption, const arm
         auto factoryFunc = backendRegistry.GetFactory(backend);
         auto backendObject = factoryFunc();
         auto capabilities = backendObject->GetCapabilities();
-        return HasCapability(backendOption, capabilities);
+        return HasMatchingCapability(backendOption, capabilities);
     }
     return false;
 }
diff --git a/src/armnn/LoadedNetwork.cpp b/src/armnn/LoadedNetwork.cpp
index 3d84054b69..7150261ddd 100644
--- a/src/armnn/LoadedNetwork.cpp
+++ b/src/armnn/LoadedNetwork.cpp
@@ -255,14 +255,15 @@ LoadedNetwork::LoadedNetwork(std::unique_ptr<IOptimizedNetwork> net,
             // If we're doing async execution verify that the backend supports it and ExternallyManagedMemory.
             if (networkProperties.m_AsyncEnabled)
             {
-                if (!HasCapability(BackendOptions::BackendOption{"AsyncExecution", true}, backend->GetCapabilities()))
+                if (!HasMatchingCapability(BackendOptions::BackendOption{"AsyncExecution", true},
+                                                                         backend->GetCapabilities()))
                 {
                     std::string er = backend->GetId();
                     er += " does not support AsyncExecution";
                     throw BackendCapabilityException(er);
                 }
-                if (!HasCapability(BackendOptions::BackendOption{"ExternallyManagedMemory", true},
-                backend->GetCapabilities()))
+                if (!HasMatchingCapability(BackendOptions::BackendOption{"ExternallyManagedMemory", true},
+                                                                         backend->GetCapabilities()))
                 {
                     std::string er = backend->GetId();
                     er += " does not support ExternallyManagedMemory\n";
@@ -1508,7 +1509,8 @@ std::vector<ImportedInputId> LoadedNetwork::ImportInputs(const InputTensors& inp
             }
 
             auto& backend = m_Backends.at(layer->GetBackendId());
-            if (!HasCapability(BackendOptions::BackendOption{"PreImportIOTensors", true}, backend->GetCapabilities()))
+            if (!HasMatchingCapability(BackendOptions::BackendOption{"PreImportIOTensors", true},
+                                                                     backend->GetCapabilities()))
             {
                 std::string er = backend->GetId();
                 er += " does not have PreImportIOTensors capability";
@@ -1641,7 +1643,8 @@ std::vector<ImportedOutputId> LoadedNetwork::ImportOutputs(const OutputTensors&
         }
 
         auto& backend = m_Backends.at(layer->GetBackendId());
-        if (!HasCapability(BackendOptions::BackendOption{"PreImportIOTensors", true}, backend->GetCapabilities()))
+        if (!HasMatchingCapability(BackendOptions::BackendOption{"PreImportIOTensors", true},
+                                                                 backend->GetCapabilities()))
         {
             std::string er = backend->GetId();
             er += " does not have PreImportIOTensors capability";
diff --git a/src/armnn/Runtime.cpp b/src/armnn/Runtime.cpp
index f71fad1f35..b0fc55010d 100644
--- a/src/armnn/Runtime.cpp
+++ b/src/armnn/Runtime.cpp
@@ -371,7 +371,7 @@ RuntimeImpl::RuntimeImpl(const IRuntime::CreationOptions& options)
                 // check if backend supports ProtectedMode
                 using BackendCapability = BackendOptions::BackendOption;
                 BackendCapability protectedContentCapability {"ProtectedContentAllocation", true};
-                if (!HasCapability(protectedContentCapability, id))
+                if (!HasMatchingCapability(protectedContentCapability, id))
                 {
                     // Protected Content Allocation is not supported by the backend
                     // backend should not be registered
@@ -480,7 +480,7 @@ RuntimeImpl::RuntimeImpl(const IRuntime::CreationOptions& options)
                         using BackendCapability = BackendOptions::BackendOption;
                         auto strategyType = GetMemBlockStrategyTypeName(strategy->GetMemBlockStrategyType());
                         BackendCapability memOptimizeStrategyCapability {strategyType, true};
-                        if (HasCapability(memOptimizeStrategyCapability, id))
+                        if (HasMatchingCapability(memOptimizeStrategyCapability, id))
                         {
                             BackendRegistryInstance().RegisterMemoryOptimizerStrategy(id, strategy);
 
diff --git a/src/armnn/test/OptimizerTests.cpp b/src/armnn/test/OptimizerTests.cpp
index f83900404b..de077c19f0 100644
--- a/src/armnn/test/OptimizerTests.cpp
+++ b/src/armnn/test/OptimizerTests.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright © 2017,2022 Arm Ltd and Contributors. All rights reserved.
+// Copyright © 2017,2022-2023 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 
@@ -724,7 +724,7 @@ TEST_CASE("BackendCapabilityTest")
     armnn::BackendOptions::BackendOption nonConstWeights{"NonConstWeights", true};
 
     // MockBackend does not support the NonConstWeights capability
-    CHECK(!armnn::HasCapability(nonConstWeights, backendId));
+    CHECK(!armnn::HasMatchingCapability(nonConstWeights, backendId));
     CHECK(!armnn::HasCapability("NonConstWeights", backendId));
 
     // MockBackend does not support the AsyncExecution capability
diff --git a/src/backends/backendsCommon/test/CompatibilityTests.cpp b/src/backends/backendsCommon/test/CompatibilityTests.cpp
index a0e5a1e402..2be99498bb 100644
--- a/src/backends/backendsCommon/test/CompatibilityTests.cpp
+++ b/src/backends/backendsCommon/test/CompatibilityTests.cpp
@@ -139,8 +139,8 @@ void CapabilityTestHelper(BackendCapabilities &capabilities,
     {
         CHECK_MESSAGE(armnn::HasCapability(pair.first, capabilities),
                         pair.first << " capability was not been found");
-        CHECK_MESSAGE(armnn::HasCapability(BackendOptions::BackendOption{pair.first, pair.second}, capabilities),
-                        pair.first << " capability set incorrectly");
+        CHECK_MESSAGE(armnn::HasMatchingCapability(BackendOptions::BackendOption{pair.first, pair.second},
+                                                   capabilities), pair.first << " capability set incorrectly");
     }
 }
 #endif
@@ -153,20 +153,20 @@ TEST_CASE("Ref_Backends_Unknown_Capability_Test")
     auto refCapabilities = refBackend->GetCapabilities();
 
     armnn::BackendOptions::BackendOption AsyncExecutionFalse{"AsyncExecution", false};
-    CHECK(!armnn::HasCapability(AsyncExecutionFalse, refCapabilities));
+    CHECK(!armnn::HasMatchingCapability(AsyncExecutionFalse, refCapabilities));
 
     armnn::BackendOptions::BackendOption AsyncExecutionInt{"AsyncExecution", 50};
-    CHECK(!armnn::HasCapability(AsyncExecutionFalse, refCapabilities));
+    CHECK(!armnn::HasMatchingCapability(AsyncExecutionFalse, refCapabilities));
 
     armnn::BackendOptions::BackendOption AsyncExecutionFloat{"AsyncExecution", 0.0f};
-    CHECK(!armnn::HasCapability(AsyncExecutionFloat, refCapabilities));
+    CHECK(!armnn::HasMatchingCapability(AsyncExecutionFloat, refCapabilities));
 
     armnn::BackendOptions::BackendOption AsyncExecutionString{"AsyncExecution", "true"};
-    CHECK(!armnn::HasCapability(AsyncExecutionString, refCapabilities));
+    CHECK(!armnn::HasMatchingCapability(AsyncExecutionString, refCapabilities));
 
     CHECK(!armnn::HasCapability("Telekinesis", refCapabilities));
     armnn::BackendOptions::BackendOption unknownCapability{"Telekinesis", true};
-    CHECK(!armnn::HasCapability(unknownCapability, refCapabilities));
+    CHECK(!armnn::HasMatchingCapability(unknownCapability, refCapabilities));
 }
 
 TEST_CASE ("Ref_Backends_Capability_Test")