IVGCVSW-5208 Wrap SampleDynamicBackend in own namespace

 * to prevent name clashes with armnn

Signed-off-by: Jan Eilers <jan.eilers@arm.com>
Change-Id: I10b394d47e58cec45bacd489938ee048b7c9776e

13 files changed, 173 insertions, 159 deletions

diff --git a/src/dynamic/sample/SampleDynamicAdditionWorkload.cpp b/src/dynamic/sample/SampleDynamicAdditionWorkload.cpp
index 0fa57a7e07..4879b99105 100644
--- a/src/dynamic/sample/SampleDynamicAdditionWorkload.cpp
+++ b/src/dynamic/sample/SampleDynamicAdditionWorkload.cpp
@@ -8,10 +8,10 @@
 #include "SampleDynamicAdditionWorkload.hpp"
 #include "SampleTensorHandle.hpp"
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
-inline const TensorInfo& GetTensorInfo(const ITensorHandle* tensorHandle)
+inline const armnn::TensorInfo& GetTensorInfo(const armnn::ITensorHandle* tensorHandle)
 {
     // We know that reference workloads use RefTensorHandles for inputs and outputs
     const SampleTensorHandle* sampleTensorHandle =
@@ -19,26 +19,26 @@ inline const TensorInfo& GetTensorInfo(const ITensorHandle* tensorHandle)
     return sampleTensorHandle->GetTensorInfo();
 }
 
-const float* GetInputTensorData(unsigned int idx, const AdditionQueueDescriptor& data)
+const float* GetInputTensorData(unsigned int idx, const armnn::AdditionQueueDescriptor& data)
 {
-    const ITensorHandle* tensorHandle = data.m_Inputs[idx];
+    const armnn::ITensorHandle* tensorHandle = data.m_Inputs[idx];
     return reinterpret_cast<const float*>(tensorHandle->Map());
 }
 
-float* GetOutputTensorData(unsigned int idx, const AdditionQueueDescriptor& data)
+float* GetOutputTensorData(unsigned int idx, const armnn::AdditionQueueDescriptor& data)
 {
-    ITensorHandle* tensorHandle = data.m_Outputs[idx];
+    armnn::ITensorHandle* tensorHandle = data.m_Outputs[idx];
     return reinterpret_cast<float*>(tensorHandle->Map());
 }
 
-SampleDynamicAdditionWorkload::SampleDynamicAdditionWorkload(const AdditionQueueDescriptor& descriptor,
-                                                             const WorkloadInfo& info)
+SampleDynamicAdditionWorkload::SampleDynamicAdditionWorkload(const armnn::AdditionQueueDescriptor& descriptor,
+                                                             const armnn::WorkloadInfo& info)
     : BaseWorkload(descriptor, info)
 {}
 
 void SampleDynamicAdditionWorkload::Execute() const
 {
-    const TensorInfo& info = GetTensorInfo(m_Data.m_Inputs[0]);
+    const armnn::TensorInfo& info = GetTensorInfo(m_Data.m_Inputs[0]);
     unsigned int num = info.GetNumElements();
 
     const float* inputData0 = GetInputTensorData(0, m_Data);
@@ -51,4 +51,4 @@ void SampleDynamicAdditionWorkload::Execute() const
     }
 }
 
-} // namespace armnn
+} // namespace sdb // sample dynamic backend
diff --git a/src/dynamic/sample/SampleDynamicAdditionWorkload.hpp b/src/dynamic/sample/SampleDynamicAdditionWorkload.hpp
index 8362588c39..f425ab6c6b 100644
--- a/src/dynamic/sample/SampleDynamicAdditionWorkload.hpp
+++ b/src/dynamic/sample/SampleDynamicAdditionWorkload.hpp
@@ -7,15 +7,15 @@
 #include <backendsCommon/Workload.hpp>
 #include <backendsCommon/WorkloadData.hpp>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
-class SampleDynamicAdditionWorkload : public BaseWorkload<AdditionQueueDescriptor>
+class SampleDynamicAdditionWorkload : public armnn::BaseWorkload<armnn::AdditionQueueDescriptor>
 {
 public:
-    SampleDynamicAdditionWorkload(const AdditionQueueDescriptor& descriptor, const WorkloadInfo& info);
+    SampleDynamicAdditionWorkload(const armnn::AdditionQueueDescriptor& descriptor, const armnn::WorkloadInfo& info);
 
     void Execute() const override;
 };
 
-} // namespace armnn
+} // namespace sdb
diff --git a/src/dynamic/sample/SampleDynamicBackend.cpp b/src/dynamic/sample/SampleDynamicBackend.cpp
index 7a3475b8d4..ce4d2dfc99 100644
--- a/src/dynamic/sample/SampleDynamicBackend.cpp
+++ b/src/dynamic/sample/SampleDynamicBackend.cpp
@@ -12,24 +12,24 @@
 #include <armnn/backends/IBackendInternal.hpp>
 #include <armnn/backends/OptimizationViews.hpp>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
 constexpr const char * SampleDynamicBackendId() { return "SampleDynamic"; }
 
-class SampleDynamicBackend : public IBackendInternal
+class SampleDynamicBackend : public armnn::IBackendInternal
 {
 public:
     SampleDynamicBackend()  = default;
     ~SampleDynamicBackend() = default;
 
-    static const BackendId& GetIdStatic()
+    static const armnn::BackendId& GetIdStatic()
     {
-        static const BackendId s_Id{SampleDynamicBackendId()};
+        static const armnn::BackendId s_Id{SampleDynamicBackendId()};
         return s_Id;
     }
 
-    const BackendId& GetId() const override { return GetIdStatic(); }
+    const armnn::BackendId& GetId() const override { return GetIdStatic(); }
 
     IBackendInternal::IMemoryManagerUniquePtr CreateMemoryManager() const override
     {
@@ -40,11 +40,11 @@ public:
         const IMemoryManagerSharedPtr& memoryManager) const override
     {
         return std::make_unique<SampleDynamicWorkloadFactory>(
-                PolymorphicPointerDowncast<SampleMemoryManager>(memoryManager));
+                armnn::PolymorphicPointerDowncast<SampleMemoryManager>(memoryManager));
     }
 
     IBackendInternal::IWorkloadFactoryPtr CreateWorkloadFactory(
-        class TensorHandleFactoryRegistry& tensorHandleFactoryRegistry) const override
+        class armnn::TensorHandleFactoryRegistry& tensorHandleFactoryRegistry) const override
     {
         auto memoryManager = std::make_shared<SampleMemoryManager>();
 
@@ -52,11 +52,11 @@ public:
         tensorHandleFactoryRegistry.RegisterFactory(std::make_unique<SampleDynamicTensorHandleFactory>(memoryManager));
 
         return std::make_unique<SampleDynamicWorkloadFactory>(
-            PolymorphicPointerDowncast<SampleMemoryManager>(memoryManager));
+                armnn::PolymorphicPointerDowncast<SampleMemoryManager>(memoryManager));
     }
 
     IBackendInternal::IBackendProfilingContextPtr CreateBackendProfilingContext(
-        const IRuntime::CreationOptions&, IBackendProfilingPtr&) override
+        const armnn::IRuntime::CreationOptions&, IBackendProfilingPtr&) override
     {
         return IBackendProfilingContextPtr{};
     }
@@ -67,26 +67,26 @@ public:
         return layerSupport;
     }
 
-    std::vector<ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences() const override
+    std::vector<armnn::ITensorHandleFactory::FactoryId> GetHandleFactoryPreferences() const override
     {
-        return std::vector<ITensorHandleFactory::FactoryId> { SampleDynamicTensorHandleFactory::GetIdStatic() };
+        return std::vector<armnn::ITensorHandleFactory::FactoryId> { SampleDynamicTensorHandleFactory::GetIdStatic() };
     }
 
-    IBackendInternal::IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const override
+    IBackendInternal::IBackendContextPtr CreateBackendContext(const armnn::IRuntime::CreationOptions&) const override
     {
         return IBackendContextPtr{};
     }
 
-    OptimizationViews OptimizeSubgraphView(const SubgraphView& subgraph) const override
+    armnn::OptimizationViews OptimizeSubgraphView(const armnn::SubgraphView& subgraph) const override
     {
-        OptimizationViews optimizationViews;
+        armnn::OptimizationViews optimizationViews;
 
-        optimizationViews.AddUntouchedSubgraph(SubgraphView(subgraph));
+        optimizationViews.AddUntouchedSubgraph(armnn::SubgraphView(subgraph));
 
         return optimizationViews;
     }
 
-    void RegisterTensorHandleFactories(class TensorHandleFactoryRegistry& registry) override
+    void RegisterTensorHandleFactories(class armnn::TensorHandleFactoryRegistry& registry) override
     {
         auto memoryManager = std::make_shared<SampleMemoryManager>();
 
@@ -96,11 +96,11 @@ public:
 
 };
 
-} // namespace armnn
+} // namespace sdb
 
 const char* GetBackendId()
 {
-    return armnn::SampleDynamicBackend::GetIdStatic().Get().c_str();
+    return sdb::SampleDynamicBackend::GetIdStatic().Get().c_str();
 }
 
 void GetVersion(uint32_t* outMajor, uint32_t* outMinor)
@@ -118,7 +118,7 @@ void GetVersion(uint32_t* outMajor, uint32_t* outMinor)
 
 void* BackendFactory()
 {
-    return new armnn::SampleDynamicBackend();
+    return new sdb::SampleDynamicBackend();
 }
 
 
diff --git a/src/dynamic/sample/SampleDynamicLayerSupport.cpp b/src/dynamic/sample/SampleDynamicLayerSupport.cpp
index 031d39cbae..cbd221f52b 100644
--- a/src/dynamic/sample/SampleDynamicLayerSupport.cpp
+++ b/src/dynamic/sample/SampleDynamicLayerSupport.cpp
@@ -9,25 +9,25 @@
 #include <LayerSupportCommon.hpp>
 #include <armnn/Types.hpp>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
-bool SampleDynamicLayerSupport::IsInputSupported(const TensorInfo& input,
-                                                 Optional<std::string&> reasonIfUnsupported) const
+bool SampleDynamicLayerSupport::IsInputSupported(const armnn::TensorInfo& input,
+                                                 armnn::Optional<std::string&> reasonIfUnsupported) const
 {
     return true;
 }
 
-bool SampleDynamicLayerSupport::IsOutputSupported(const TensorInfo& output,
-                                                  Optional<std::string&> reasonIfUnsupported) const
+bool SampleDynamicLayerSupport::IsOutputSupported(const armnn::TensorInfo& output,
+                                                  armnn::Optional<std::string&> reasonIfUnsupported) const
 {
     return true;
 }
 
-bool SampleDynamicLayerSupport::IsAdditionSupported(const TensorInfo& input0,
-                                                    const TensorInfo& input1,
-                                                    const TensorInfo& output,
-                                                    Optional<std::string&> reasonIfUnsupported) const
+bool SampleDynamicLayerSupport::IsAdditionSupported(const armnn::TensorInfo& input0,
+                                                    const armnn::TensorInfo& input1,
+                                                    const armnn::TensorInfo& output,
+                                                    armnn::Optional<std::string&> reasonIfUnsupported) const
 {
 
     if (input0.GetDataType() != armnn::DataType::Float32)
@@ -48,4 +48,4 @@ bool SampleDynamicLayerSupport::IsAdditionSupported(const TensorInfo& input0,
     return true;
 }
 
-} // namespace armnn
+} // namespace sdb
diff --git a/src/dynamic/sample/SampleDynamicLayerSupport.hpp b/src/dynamic/sample/SampleDynamicLayerSupport.hpp
index f6aa0cb91f..a38207304f 100644
--- a/src/dynamic/sample/SampleDynamicLayerSupport.hpp
+++ b/src/dynamic/sample/SampleDynamicLayerSupport.hpp
@@ -7,22 +7,22 @@
 
 #include <backendsCommon/LayerSupportBase.hpp>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
-class SampleDynamicLayerSupport : public LayerSupportBase
+class SampleDynamicLayerSupport : public armnn::LayerSupportBase
 {
 public:
-    bool IsAdditionSupported(const TensorInfo& input0,
-                             const TensorInfo& input1,
-                             const TensorInfo& output,
-                             Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+    bool IsAdditionSupported(const armnn::TensorInfo& input0,
+                             const armnn::TensorInfo& input1,
+                             const armnn::TensorInfo& output,
+                             armnn::Optional<std::string&> reasonIfUnsupported = armnn::EmptyOptional()) const override;
 
-    bool IsInputSupported(const TensorInfo& input,
-                          Optional<std::string&> reasonIfUnsupported) const override;
+    bool IsInputSupported(const armnn::TensorInfo& input,
+                          armnn::Optional<std::string&> reasonIfUnsupported) const override;
 
-    bool IsOutputSupported(const TensorInfo& output,
-                           Optional<std::string&> reasonIfUnsupported) const override;
+    bool IsOutputSupported(const armnn::TensorInfo& output,
+                           armnn::Optional<std::string&> reasonIfUnsupported) const override;
 };
 
-} // namespace armnn
+} // namespace sdb
diff --git a/src/dynamic/sample/SampleDynamicTensorHandleFactory.cpp b/src/dynamic/sample/SampleDynamicTensorHandleFactory.cpp
index 0852bed720..d625595478 100644
--- a/src/dynamic/sample/SampleDynamicTensorHandleFactory.cpp
+++ b/src/dynamic/sample/SampleDynamicTensorHandleFactory.cpp
@@ -8,10 +8,10 @@
 
 #include <armnn/utility/IgnoreUnused.hpp>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
-using FactoryId = ITensorHandleFactory::FactoryId;
+using FactoryId = armnn::ITensorHandleFactory::FactoryId;
 
 const FactoryId& SampleDynamicTensorHandleFactory::GetIdStatic()
 {
@@ -19,29 +19,32 @@ const FactoryId& SampleDynamicTensorHandleFactory::GetIdStatic()
     return s_Id;
 }
 
-std::unique_ptr<ITensorHandle>
-SampleDynamicTensorHandleFactory::CreateSubTensorHandle(ITensorHandle& parent,
-                                                        TensorShape const& subTensorShape,
+std::unique_ptr<armnn::ITensorHandle>
+SampleDynamicTensorHandleFactory::CreateSubTensorHandle(armnn::ITensorHandle& parent,
+                                                        armnn::TensorShape const& subTensorShape,
                                                         unsigned int const* subTensorOrigin) const
 {
     IgnoreUnused(parent, subTensorShape, subTensorOrigin);
     return nullptr;
 }
 
-std::unique_ptr<ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo) const
+std::unique_ptr<armnn::ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHandle(
+        const armnn::TensorInfo& tensorInfo) const
 {
     return std::make_unique<SampleTensorHandle>(tensorInfo, m_MemoryManager);
 }
 
-std::unique_ptr<ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                                                    DataLayout dataLayout) const
+std::unique_ptr<armnn::ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHandle(
+        const armnn::TensorInfo& tensorInfo,
+        armnn::DataLayout dataLayout) const
 {
     IgnoreUnused(dataLayout);
     return std::make_unique<SampleTensorHandle>(tensorInfo, m_MemoryManager);
 }
 
-std::unique_ptr<ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                                                    const bool IsMemoryManaged) const
+std::unique_ptr<armnn::ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHandle(
+        const armnn::TensorInfo& tensorInfo,
+        const bool IsMemoryManaged) const
 {
     if (IsMemoryManaged)
     {
@@ -53,9 +56,10 @@ std::unique_ptr<ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHan
     }
 }
 
-std::unique_ptr<ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                                                    DataLayout dataLayout,
-                                                                                    const bool IsMemoryManaged) const
+std::unique_ptr<armnn::ITensorHandle> SampleDynamicTensorHandleFactory::CreateTensorHandle(
+        const armnn::TensorInfo& tensorInfo,
+        armnn::DataLayout dataLayout,
+        const bool IsMemoryManaged) const
 {
     IgnoreUnused(dataLayout);
     if (IsMemoryManaged)
@@ -78,14 +82,14 @@ bool SampleDynamicTensorHandleFactory::SupportsSubTensors() const
     return false;
 }
 
-MemorySourceFlags SampleDynamicTensorHandleFactory::GetExportFlags() const
+armnn::MemorySourceFlags SampleDynamicTensorHandleFactory::GetExportFlags() const
 {
     return m_ExportFlags;
 }
 
-MemorySourceFlags SampleDynamicTensorHandleFactory::GetImportFlags() const
+armnn::MemorySourceFlags SampleDynamicTensorHandleFactory::GetImportFlags() const
 {
     return m_ImportFlags;
 }
 
-} // namespace armnn
\ No newline at end of file
+} // namespace sdb
\ No newline at end of file
diff --git a/src/dynamic/sample/SampleDynamicTensorHandleFactory.hpp b/src/dynamic/sample/SampleDynamicTensorHandleFactory.hpp
index 5f5e880b88..790eee1b2c 100644
--- a/src/dynamic/sample/SampleDynamicTensorHandleFactory.hpp
+++ b/src/dynamic/sample/SampleDynamicTensorHandleFactory.hpp
@@ -9,36 +9,36 @@
 
 #include <armnn/backends/ITensorHandleFactory.hpp>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
 constexpr const char * SampleDynamicTensorHandleFactoryId() { return "Arm/SampleDynamic/TensorHandleFactory"; }
 
-class SampleDynamicTensorHandleFactory : public ITensorHandleFactory
+class SampleDynamicTensorHandleFactory : public armnn::ITensorHandleFactory
 {
 
 public:
     SampleDynamicTensorHandleFactory(std::shared_ptr<SampleMemoryManager> mgr)
     : m_MemoryManager(mgr),
-      m_ImportFlags(static_cast<MemorySourceFlags>(MemorySource::Malloc)),
-      m_ExportFlags(static_cast<MemorySourceFlags>(MemorySource::Malloc))
+      m_ImportFlags(static_cast<armnn::MemorySourceFlags>(armnn::MemorySource::Malloc)),
+      m_ExportFlags(static_cast<armnn::MemorySourceFlags>(armnn::MemorySource::Malloc))
     {}
 
-    std::unique_ptr<ITensorHandle> CreateSubTensorHandle(ITensorHandle& parent,
-                                                         TensorShape const& subTensorShape,
-                                                         unsigned int const* subTensorOrigin) const override;
+    std::unique_ptr<armnn::ITensorHandle> CreateSubTensorHandle(armnn::ITensorHandle& parent,
+                                                                armnn::TensorShape const& subTensorShape,
+                                                                unsigned int const* subTensorOrigin) const override;
 
-    std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo) const override;
+    std::unique_ptr<armnn::ITensorHandle> CreateTensorHandle(const armnn::TensorInfo& tensorInfo) const override;
 
-    std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                      DataLayout dataLayout) const override;
+    std::unique_ptr<armnn::ITensorHandle> CreateTensorHandle(const armnn::TensorInfo& tensorInfo,
+                                                             armnn::DataLayout dataLayout) const override;
 
-    std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                      const bool IsMemoryManaged) const override;
+    std::unique_ptr<armnn::ITensorHandle> CreateTensorHandle(const armnn::TensorInfo& tensorInfo,
+                                                             const bool IsMemoryManaged) const override;
 
-    std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                      DataLayout dataLayout,
-                                                      const bool IsMemoryManaged) const override;
+    std::unique_ptr<armnn::ITensorHandle> CreateTensorHandle(const armnn::TensorInfo& tensorInfo,
+                                                             armnn::DataLayout dataLayout,
+                                                             const bool IsMemoryManaged) const override;
 
     static const FactoryId& GetIdStatic();
 
@@ -46,15 +46,15 @@ public:
 
     bool SupportsSubTensors() const override;
 
-    MemorySourceFlags GetExportFlags() const override;
+    armnn::MemorySourceFlags GetExportFlags() const override;
 
-    MemorySourceFlags GetImportFlags() const override;
+    armnn::MemorySourceFlags GetImportFlags() const override;
 
 private:
     mutable std::shared_ptr<SampleMemoryManager> m_MemoryManager;
-    MemorySourceFlags m_ImportFlags;
-    MemorySourceFlags m_ExportFlags;
+    armnn::MemorySourceFlags m_ImportFlags;
+    armnn::MemorySourceFlags m_ExportFlags;
 };
 
-} // namespace armnn
+} // namespace sdb
 
diff --git a/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp b/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp
index 0fb5504f41..ac324946d2 100644
--- a/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp
+++ b/src/dynamic/sample/SampleDynamicWorkloadFactory.cpp
@@ -11,12 +11,12 @@
 #include "SampleDynamicWorkloadFactory.hpp"
 #include "SampleTensorHandle.hpp"
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
 namespace
 {
-static const BackendId s_Id{  GetBackendId() };
+static const armnn::BackendId s_Id{  GetBackendId() };
 }
 
 SampleDynamicWorkloadFactory::SampleDynamicWorkloadFactory(const std::shared_ptr<SampleMemoryManager>& memoryManager)
@@ -29,47 +29,52 @@ SampleDynamicWorkloadFactory::SampleDynamicWorkloadFactory()
 {
 }
 
-const BackendId& SampleDynamicWorkloadFactory::GetBackendId() const
+const armnn::BackendId& SampleDynamicWorkloadFactory::GetBackendId() const
 {
     return s_Id;
 }
 
-bool SampleDynamicWorkloadFactory::IsLayerSupported(const IConnectableLayer& layer,
-                                                    Optional<DataType> dataType,
+bool SampleDynamicWorkloadFactory::IsLayerSupported(const armnn::IConnectableLayer& layer,
+                                                    armnn::Optional<armnn::DataType> dataType,
                                                     std::string& outReasonIfUnsupported)
 {
     return IWorkloadFactory::IsLayerSupported(s_Id, layer, dataType, outReasonIfUnsupported);
 }
 
-std::unique_ptr<ITensorHandle> SampleDynamicWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                                                const bool isMemoryManaged) const
+std::unique_ptr<armnn::ITensorHandle> SampleDynamicWorkloadFactory::CreateTensorHandle(
+        const armnn::TensorInfo& tensorInfo,
+        const bool isMemoryManaged) const
 {
-    return std::make_unique<ScopedCpuTensorHandle>(tensorInfo);
+    return std::make_unique<armnn::ScopedCpuTensorHandle>(tensorInfo);
 }
 
-std::unique_ptr<ITensorHandle> SampleDynamicWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                                                DataLayout dataLayout,
-                                                                                const bool isMemoryManaged) const
+std::unique_ptr<armnn::ITensorHandle> SampleDynamicWorkloadFactory::CreateTensorHandle(
+        const armnn::TensorInfo& tensorInfo,
+        armnn::DataLayout dataLayout,
+        const bool isMemoryManaged) const
 {
-    return std::make_unique<ScopedCpuTensorHandle>(tensorInfo);
+    return std::make_unique<armnn::ScopedCpuTensorHandle>(tensorInfo);
 }
 
-std::unique_ptr<IWorkload> SampleDynamicWorkloadFactory::CreateAddition(const AdditionQueueDescriptor& descriptor,
-                                                                        const WorkloadInfo& info) const
+std::unique_ptr<armnn::IWorkload> SampleDynamicWorkloadFactory::CreateAddition(
+        const armnn::AdditionQueueDescriptor& descriptor,
+        const armnn::WorkloadInfo& info) const
 {
     return std::make_unique<SampleDynamicAdditionWorkload>(descriptor, info);
 }
 
-std::unique_ptr<IWorkload> SampleDynamicWorkloadFactory::CreateInput(const InputQueueDescriptor& descriptor,
-                                                                     const WorkloadInfo& info) const
+std::unique_ptr<armnn::IWorkload> SampleDynamicWorkloadFactory::CreateInput(
+        const armnn::InputQueueDescriptor& descriptor,
+        const armnn::WorkloadInfo& info) const
 {
-    return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
+    return std::make_unique<armnn::CopyMemGenericWorkload>(descriptor, info);
 }
 
-std::unique_ptr<IWorkload> SampleDynamicWorkloadFactory::CreateOutput(const OutputQueueDescriptor& descriptor,
-                                                                      const WorkloadInfo& info) const
+std::unique_ptr<armnn::IWorkload> SampleDynamicWorkloadFactory::CreateOutput(
+        const armnn::OutputQueueDescriptor& descriptor,
+        const armnn::WorkloadInfo& info) const
 {
-    return std::make_unique<CopyMemGenericWorkload>(descriptor, info);
+    return std::make_unique<armnn::CopyMemGenericWorkload>(descriptor, info);
 }
 
-} // namespace armnn
+} // namespace sdb
diff --git a/src/dynamic/sample/SampleDynamicWorkloadFactory.hpp b/src/dynamic/sample/SampleDynamicWorkloadFactory.hpp
index a80aa83215..4a2b657f5d 100644
--- a/src/dynamic/sample/SampleDynamicWorkloadFactory.hpp
+++ b/src/dynamic/sample/SampleDynamicWorkloadFactory.hpp
@@ -9,11 +9,11 @@
 #include <armnn/Optional.hpp>
 #include <backendsCommon/WorkloadFactory.hpp>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
 // Sample Dynamic workload factory.
-class SampleDynamicWorkloadFactory : public IWorkloadFactory
+class SampleDynamicWorkloadFactory : public armnn::IWorkloadFactory
 {
 public:
     explicit SampleDynamicWorkloadFactory(const std::shared_ptr<SampleMemoryManager>& memoryManager);
@@ -21,45 +21,49 @@ public:
 
     ~SampleDynamicWorkloadFactory() {}
 
-    const BackendId& GetBackendId() const override;
+    const armnn::BackendId& GetBackendId() const override;
 
-    static bool IsLayerSupported(const IConnectableLayer& layer,
-                                 Optional<DataType> dataType,
+    static bool IsLayerSupported(const armnn::IConnectableLayer& layer,
+                                 armnn::Optional<armnn::DataType> dataType,
                                  std::string& outReasonIfUnsupported);
 
     bool SupportsSubTensors() const override { return false; }
 
     ARMNN_DEPRECATED_MSG("Use ITensorHandleFactory::CreateSubTensorHandle instead")
-    std::unique_ptr<ITensorHandle> CreateSubTensorHandle(ITensorHandle& parent,
-                                                         TensorShape const& subTensorShape,
-                                                         unsigned int const* subTensorOrigin) const override
+    std::unique_ptr<armnn::ITensorHandle> CreateSubTensorHandle(
+            armnn::ITensorHandle& parent,
+            armnn::TensorShape const& subTensorShape,
+            unsigned int const* subTensorOrigin) const override
     {
         IgnoreUnused(parent, subTensorShape, subTensorOrigin);
         return nullptr;
     }
 
     ARMNN_DEPRECATED_MSG("Use ITensorHandleFactory::CreateTensorHandle instead")
-    std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                      const bool IsMemoryManaged = true) const override;
+    std::unique_ptr<armnn::ITensorHandle> CreateTensorHandle(
+            const armnn::TensorInfo& tensorInfo,
+            const bool IsMemoryManaged = true) const override;
 
     ARMNN_DEPRECATED_MSG("Use ITensorHandleFactory::CreateTensorHandle instead")
-    std::unique_ptr<ITensorHandle> CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                      DataLayout dataLayout,
-                                                      const bool IsMemoryManaged = true) const override;
+    std::unique_ptr<armnn::ITensorHandle> CreateTensorHandle(
+            const armnn::TensorInfo& tensorInfo,
+            armnn::DataLayout dataLayout,
+            const bool IsMemoryManaged = true) const override;
 
-    std::unique_ptr<IWorkload> CreateAddition(const AdditionQueueDescriptor& descriptor,
-                                              const WorkloadInfo& info) const override;
+    std::unique_ptr<armnn::IWorkload> CreateAddition(
+            const armnn::AdditionQueueDescriptor& descriptor,
+            const armnn::WorkloadInfo& info) const override;
 
 
-    std::unique_ptr<IWorkload> CreateInput(const InputQueueDescriptor& descriptor,
-                                           const WorkloadInfo& info) const override;
+    std::unique_ptr<armnn::IWorkload> CreateInput(const armnn::InputQueueDescriptor& descriptor,
+                                                  const armnn::WorkloadInfo& info) const override;
 
-    std::unique_ptr<IWorkload> CreateOutput(const OutputQueueDescriptor& descriptor,
-                                            const WorkloadInfo& info) const override;
+    std::unique_ptr<armnn::IWorkload> CreateOutput(const armnn::OutputQueueDescriptor& descriptor,
+                                                   const armnn::WorkloadInfo& info) const override;
 
 private:
     mutable std::shared_ptr<SampleMemoryManager> m_MemoryManager;
 
 };
 
-} // namespace armnn
+} // namespace sdb
diff --git a/src/dynamic/sample/SampleMemoryManager.cpp b/src/dynamic/sample/SampleMemoryManager.cpp
index 30a7548b02..52ada22eb5 100644
--- a/src/dynamic/sample/SampleMemoryManager.cpp
+++ b/src/dynamic/sample/SampleMemoryManager.cpp
@@ -7,7 +7,7 @@
 
 #include <algorithm>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
 SampleMemoryManager::SampleMemoryManager()
@@ -92,4 +92,4 @@ void SampleMemoryManager::Pool::Release()
     m_Pointer = nullptr;
 }
 
-}
+} // namespace sdb
diff --git a/src/dynamic/sample/SampleMemoryManager.hpp b/src/dynamic/sample/SampleMemoryManager.hpp
index 0993bc1e2b..9e5271e32d 100644
--- a/src/dynamic/sample/SampleMemoryManager.hpp
+++ b/src/dynamic/sample/SampleMemoryManager.hpp
@@ -9,11 +9,11 @@
 #include <forward_list>
 #include <vector>
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
 // An implementation of IMemoryManager to be used with SampleTensorHandle
-class SampleMemoryManager : public IMemoryManager
+class SampleMemoryManager : public armnn::IMemoryManager
 {
 public:
     SampleMemoryManager();
@@ -56,4 +56,4 @@ private:
     std::vector<Pool*> m_FreePools;
 };
 
-}
+} // namespace sdb
diff --git a/src/dynamic/sample/SampleTensorHandle.cpp b/src/dynamic/sample/SampleTensorHandle.cpp
index fb4eddcb55..c00861871c 100644
--- a/src/dynamic/sample/SampleTensorHandle.cpp
+++ b/src/dynamic/sample/SampleTensorHandle.cpp
@@ -5,23 +5,23 @@
 
 #include "SampleTensorHandle.hpp"
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
-SampleTensorHandle::SampleTensorHandle(const TensorInfo &tensorInfo,
+SampleTensorHandle::SampleTensorHandle(const armnn::TensorInfo &tensorInfo,
                                        std::shared_ptr<SampleMemoryManager> &memoryManager)
     : m_TensorInfo(tensorInfo),
       m_MemoryManager(memoryManager),
       m_Pool(nullptr),
       m_UnmanagedMemory(nullptr),
-      m_ImportFlags(static_cast<MemorySourceFlags>(MemorySource::Undefined)),
+      m_ImportFlags(static_cast<armnn::MemorySourceFlags>(armnn::MemorySource::Undefined)),
       m_Imported(false)
 {
 
 }
 
-SampleTensorHandle::SampleTensorHandle(const TensorInfo& tensorInfo,
-                                       MemorySourceFlags importFlags)
+SampleTensorHandle::SampleTensorHandle(const armnn::TensorInfo& tensorInfo,
+                                       armnn::MemorySourceFlags importFlags)
     : m_TensorInfo(tensorInfo),
       m_MemoryManager(nullptr),
       m_Pool(nullptr),
@@ -65,8 +65,9 @@ void SampleTensorHandle::Allocate()
     }
     else
     {
-        throw InvalidArgumentException("SampleTensorHandle::Allocate Trying to allocate a SampleTensorHandle"
-                                       "that already has allocated memory.");
+        throw armnn::InvalidArgumentException("SampleTensorHandle::Allocate Trying to allocate a "
+                                              "SampleTensorHandle that already has allocated "
+                                              "memory.");
     }
 }
 
@@ -87,12 +88,12 @@ void* SampleTensorHandle::GetPointer() const
     }
 }
 
-bool SampleTensorHandle::Import(void* memory, MemorySource source)
+bool SampleTensorHandle::Import(void* memory, armnn::MemorySource source)
 {
 
-    if (m_ImportFlags & static_cast<MemorySourceFlags>(source))
+    if (m_ImportFlags & static_cast<armnn::MemorySourceFlags>(source))
     {
-        if (source == MemorySource::Malloc)
+        if (source == armnn::MemorySource::Malloc)
         {
             // Check memory alignment
             constexpr uintptr_t alignment = sizeof(size_t);
@@ -147,4 +148,4 @@ void SampleTensorHandle::CopyInFrom(const void* src)
     memcpy(dest, src, m_TensorInfo.GetNumBytes());
 }
 
-}
+} // namespace sdb
diff --git a/src/dynamic/sample/SampleTensorHandle.hpp b/src/dynamic/sample/SampleTensorHandle.hpp
index 2a44ed6ada..9ddccedce2 100644
--- a/src/dynamic/sample/SampleTensorHandle.hpp
+++ b/src/dynamic/sample/SampleTensorHandle.hpp
@@ -8,16 +8,16 @@
 
 #include "SampleMemoryManager.hpp"
 
-namespace armnn
+namespace sdb // sample dynamic backend
 {
 
 // An implementation of ITensorHandle with simple "bump the pointer" memory-management behaviour
-class SampleTensorHandle : public ITensorHandle
+class SampleTensorHandle : public armnn::ITensorHandle
 {
 public:
-    SampleTensorHandle(const TensorInfo& tensorInfo, std::shared_ptr<SampleMemoryManager> &memoryManager);
+    SampleTensorHandle(const armnn::TensorInfo& tensorInfo, std::shared_ptr<SampleMemoryManager> &memoryManager);
 
-    SampleTensorHandle(const TensorInfo& tensorInfo, MemorySourceFlags importFlags);
+    SampleTensorHandle(const armnn::TensorInfo& tensorInfo, armnn::MemorySourceFlags importFlags);
 
     ~SampleTensorHandle();
 
@@ -36,27 +36,27 @@ public:
     virtual void Unmap() const override
     {}
 
-    TensorShape GetStrides() const override
+    armnn::TensorShape GetStrides() const override
     {
         return GetUnpaddedTensorStrides(m_TensorInfo);
     }
 
-    TensorShape GetShape() const override
+    armnn::TensorShape GetShape() const override
     {
         return m_TensorInfo.GetShape();
     }
 
-    const TensorInfo& GetTensorInfo() const
+    const armnn::TensorInfo& GetTensorInfo() const
     {
         return m_TensorInfo;
     }
 
-    virtual MemorySourceFlags GetImportFlags() const override
+    virtual armnn::MemorySourceFlags GetImportFlags() const override
     {
         return m_ImportFlags;
     }
 
-    virtual bool Import(void* memory, MemorySource source) override;
+    virtual bool Import(void* memory, armnn::MemorySource source) override;
 
 private:
     // Only used for testing
@@ -68,13 +68,13 @@ private:
     SampleTensorHandle(const SampleTensorHandle& other) = delete; // noncopyable
     SampleTensorHandle& operator=(const SampleTensorHandle& other) = delete; //noncopyable
 
-    TensorInfo m_TensorInfo;
+    armnn::TensorInfo m_TensorInfo;
 
     std::shared_ptr<SampleMemoryManager> m_MemoryManager;
     SampleMemoryManager::Pool* m_Pool;
     mutable void *m_UnmanagedMemory;
-    MemorySourceFlags m_ImportFlags;
+    armnn::MemorySourceFlags m_ImportFlags;
     bool m_Imported;
 };
 
-}
+} // namespace sdb