IVGCVSW-2066: Add IMemoryManager and integrate into the backends framework

Change-Id: I93223c8678165cbc3d39f461c36bb8610dc81c05

13 files changed, 123 insertions, 278 deletions

diff --git a/src/backends/neon/CMakeLists.txt b/src/backends/neon/CMakeLists.txt
index badad2f8a4..be318e9854 100644
--- a/src/backends/neon/CMakeLists.txt
+++ b/src/backends/neon/CMakeLists.txt
@@ -30,8 +30,6 @@ else()
         NeonBackendId.hpp
         NeonLayerSupport.cpp
         NeonLayerSupport.hpp
-        NeonWorkloadFactory.cpp
-        NeonWorkloadFactory.hpp
     )
 endif()
 
diff --git a/src/backends/neon/NeonBackend.cpp b/src/backends/neon/NeonBackend.cpp
index 4d57eda877..cde29983bd 100644
--- a/src/backends/neon/NeonBackend.cpp
+++ b/src/backends/neon/NeonBackend.cpp
@@ -8,11 +8,18 @@
 #include "NeonWorkloadFactory.hpp"
 #include "NeonLayerSupport.hpp"
 
-#include <backendsCommon/IBackendContext.hpp>
+#include <aclCommon/BaseMemoryManager.hpp>
+
 #include <backendsCommon/BackendRegistry.hpp>
+#include <backendsCommon/IBackendContext.hpp>
+#include <backendsCommon/IMemoryManager.hpp>
+
 #include <Optimizer.hpp>
 
+#include <arm_compute/runtime/Allocator.h>
+
 #include <boost/cast.hpp>
+#include <boost/polymorphic_pointer_cast.hpp>
 
 namespace armnn
 {
@@ -38,9 +45,17 @@ const BackendId& NeonBackend::GetIdStatic()
     return s_Id;
 }
 
-IBackendInternal::IWorkloadFactoryPtr NeonBackend::CreateWorkloadFactory() const
+IBackendInternal::IMemoryManagerUniquePtr NeonBackend::CreateMemoryManager() const
+{
+    return std::make_unique<NeonMemoryManager>(std::make_unique<arm_compute::Allocator>(),
+                                               BaseMemoryManager::MemoryAffinity::Offset);
+}
+
+IBackendInternal::IWorkloadFactoryPtr NeonBackend::CreateWorkloadFactory(
+    const IBackendInternal::IMemoryManagerSharedPtr& memoryManager) const
 {
-    return std::make_unique<NeonWorkloadFactory>();
+    return std::make_unique<NeonWorkloadFactory>(
+        boost::polymorphic_pointer_downcast<NeonMemoryManager>(memoryManager));
 }
 
 IBackendInternal::IBackendContextPtr NeonBackend::CreateBackendContext(const IRuntime::CreationOptions&) const
diff --git a/src/backends/neon/NeonBackend.hpp b/src/backends/neon/NeonBackend.hpp
index d83710d22c..127a5a4b62 100644
--- a/src/backends/neon/NeonBackend.hpp
+++ b/src/backends/neon/NeonBackend.hpp
@@ -18,8 +18,13 @@ public:
     static const BackendId& GetIdStatic();
     const BackendId& GetId() const override { return GetIdStatic(); }
 
-    IWorkloadFactoryPtr CreateWorkloadFactory() const override;
+    IBackendInternal::IMemoryManagerUniquePtr CreateMemoryManager() const override;
+
+    IWorkloadFactoryPtr CreateWorkloadFactory(
+        const IBackendInternal::IMemoryManagerSharedPtr& memoryManager = nullptr) const override;
+
     IBackendInternal::IBackendContextPtr CreateBackendContext(const IRuntime::CreationOptions&) const override;
+
     IBackendInternal::Optimizations GetOptimizations() const override;
     IBackendInternal::ILayerSupportSharedPtr GetLayerSupport() const override;
 };
diff --git a/src/backends/neon/NeonWorkloadFactory.cpp b/src/backends/neon/NeonWorkloadFactory.cpp
index f0d916b63b..65844476e4 100644
--- a/src/backends/neon/NeonWorkloadFactory.cpp
+++ b/src/backends/neon/NeonWorkloadFactory.cpp
@@ -2,24 +2,23 @@
 // Copyright © 2017 Arm Ltd. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
-#include "NeonWorkloadFactory.hpp"
+
 #include "NeonBackendId.hpp"
-#include <armnn/Utils.hpp>
-#include <backendsCommon/CpuTensorHandle.hpp>
+#include "NeonTensorHandle.hpp"
+#include "NeonWorkloadFactory.hpp"
+
 #include <Layer.hpp>
 
-#ifdef ARMCOMPUTENEON_ENABLED
-#include <arm_compute/runtime/Allocator.h>
+#include <armnn/Utils.hpp>
 
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <backendsCommon/MakeWorkloadHelper.hpp>
 #include <backendsCommon/MemCopyWorkload.hpp>
-#include "NeonTensorHandle.hpp"
-#include "workloads/NeonWorkloadUtils.hpp"
-#include "workloads/NeonWorkloads.hpp"
-
-#endif
 
-#include <backendsCommon/MakeWorkloadHelper.hpp>
+#include <neon/workloads/NeonWorkloadUtils.hpp>
+#include <neon/workloads/NeonWorkloads.hpp>
 
+#include <boost/core/ignore_unused.hpp>
 #include <boost/polymorphic_cast.hpp>
 
 namespace armnn
@@ -42,10 +41,8 @@ const BackendId& NeonWorkloadFactory::GetBackendId() const
     return s_Id;
 }
 
-#ifdef ARMCOMPUTENEON_ENABLED
-
-NeonWorkloadFactory::NeonWorkloadFactory()
-    : m_MemoryManager(std::make_unique<arm_compute::Allocator>(), BaseMemoryManager::MemoryAffinity::Offset)
+NeonWorkloadFactory::NeonWorkloadFactory(const std::shared_ptr<NeonMemoryManager>& memoryManager)
+    : m_MemoryManager(memoryManager)
 {
 }
 
@@ -71,7 +68,7 @@ std::unique_ptr<ITensorHandle> NeonWorkloadFactory::CreateSubTensorHandle(ITenso
 std::unique_ptr<ITensorHandle> NeonWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo) const
 {
     auto tensorHandle = std::make_unique<NeonTensorHandle>(tensorInfo);
-    tensorHandle->SetMemoryGroup(m_MemoryManager.GetInterLayerMemoryGroup());
+    tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
 
     return tensorHandle;
 }
@@ -80,7 +77,7 @@ std::unique_ptr<ITensorHandle> NeonWorkloadFactory::CreateTensorHandle(const Ten
                                                                        DataLayout dataLayout) const
 {
     auto tensorHandle = std::make_unique<NeonTensorHandle>(tensorInfo, dataLayout);
-    tensorHandle->SetMemoryGroup(m_MemoryManager.GetInterLayerMemoryGroup());
+    tensorHandle->SetMemoryGroup(m_MemoryManager->GetInterLayerMemoryGroup());
 
     return tensorHandle;
 }
@@ -107,7 +104,7 @@ std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSoftmax(const SoftmaxQueue
                                                               const WorkloadInfo&           info) const
 {
     return MakeWorkloadHelper<NeonSoftmaxFloatWorkload, NeonSoftmaxUint8Workload>(descriptor, info,
-        m_MemoryManager.GetIntraLayerManager());
+        m_MemoryManager->GetIntraLayerManager());
 }
 
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSplitter(const SplitterQueueDescriptor& descriptor,
@@ -126,7 +123,7 @@ std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateFullyConnected(
     const FullyConnectedQueueDescriptor& descriptor, const WorkloadInfo& info) const
 {
     return MakeWorkloadHelper<NeonFullyConnectedWorkload, NeonFullyConnectedWorkload>(descriptor, info,
-        m_MemoryManager.GetIntraLayerManager());
+        m_MemoryManager->GetIntraLayerManager());
 }
 
 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreatePermute(const PermuteQueueDescriptor& descriptor,
@@ -145,7 +142,7 @@ std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateConvolution2d(
     const Convolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
 {
     return std::make_unique<NeonConvolution2dWorkload>(descriptor, info,
-                                                       m_MemoryManager.GetIntraLayerManager());
+                                                       m_MemoryManager->GetIntraLayerManager());
 }
 
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateDepthwiseConvolution2d(
@@ -158,7 +155,7 @@ std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateNormalization(
     const NormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
 {
     return MakeWorkloadHelper<NeonNormalizationFloatWorkload, NullWorkload>(descriptor, info,
-        m_MemoryManager.GetIntraLayerManager());
+        m_MemoryManager->GetIntraLayerManager());
 }
 
 std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreateAddition(const AdditionQueueDescriptor& descriptor,
@@ -220,7 +217,7 @@ std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateL2Normalization(const L2No
     const WorkloadInfo& info) const
 {
     return MakeWorkloadHelper<NeonL2NormalizationFloatWorkload, NullWorkload>(descriptor, info,
-        m_MemoryManager.GetIntraLayerManager());
+        m_MemoryManager->GetIntraLayerManager());
 }
 
 std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConstant(const ConstantQueueDescriptor& descriptor,
@@ -287,232 +284,12 @@ std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateBatchToSpaceNd(const Batch
 
 void NeonWorkloadFactory::Release()
 {
-    m_MemoryManager.Release();
+    m_MemoryManager->Release();
 }
 
 void NeonWorkloadFactory::Acquire()
 {
-    m_MemoryManager.Acquire();
-}
-
-#else // Compiled without ArmCompute libs
-
-NeonWorkloadFactory::NeonWorkloadFactory()
-{
-}
-
-std::unique_ptr<ITensorHandle> NeonWorkloadFactory::CreateSubTensorHandle(ITensorHandle& parent,
-    TensorShape const& subTensorShape,
-    unsigned int const* subTensorOrigin) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<ITensorHandle> NeonWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<ITensorHandle> NeonWorkloadFactory::CreateTensorHandle(const TensorInfo& tensorInfo,
-                                                                       DataLayout dataLayout) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateInput(const InputQueueDescriptor& descriptor,
-                                                            const WorkloadInfo&        info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateOutput(const OutputQueueDescriptor& descriptor,
-                                                             const WorkloadInfo&        info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateActivation(const ActivationQueueDescriptor& descriptor,
-                                                                 const WorkloadInfo&              info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSoftmax(const SoftmaxQueueDescriptor& descriptor,
-                                                              const WorkloadInfo&           info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSplitter(const SplitterQueueDescriptor& descriptor,
-                                                               const WorkloadInfo&            info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateMerger(const MergerQueueDescriptor& descriptor,
-                                                             const WorkloadInfo&          info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFullyConnected(const FullyConnectedQueueDescriptor& descriptor,
-                                                                     const WorkloadInfo&                  info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<armnn::IWorkload> NeonWorkloadFactory::CreatePermute(const PermuteQueueDescriptor& descriptor,
-                                                                     const WorkloadInfo&           info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreatePooling2d(const Pooling2dQueueDescriptor& descriptor,
-                                                                const WorkloadInfo&           info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConvolution2d(const Convolution2dQueueDescriptor& descriptor,
-                                                                    const WorkloadInfo&               info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateDepthwiseConvolution2d(
-    const DepthwiseConvolution2dQueueDescriptor& descriptor, const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateNormalization(const NormalizationQueueDescriptor& descriptor,
-                                                                    const WorkloadInfo&                 info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateAddition(const AdditionQueueDescriptor& descriptor,
-                                                               const WorkloadInfo&            info) const
-{
-    return nullptr;
+    m_MemoryManager->Acquire();
 }
 
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateBatchNormalization(const BatchNormalizationQueueDescriptor& data,
-                                                                         const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateMultiplication(const MultiplicationQueueDescriptor& data,
-                                                                     const WorkloadInfo&                  info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateMemCopy(const MemCopyQueueDescriptor& descriptor,
-                                                              const WorkloadInfo&        info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateResizeBilinear(const ResizeBilinearQueueDescriptor& descriptor,
-                                                                     const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFakeQuantization(
-        const FakeQuantizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateL2Normalization(const L2NormalizationQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConstant(const ConstantQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateReshape(const ReshapeQueueDescriptor& descriptor,
-    const WorkloadInfo&           info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFloor(const FloorQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateLstm(const LstmQueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConvertFp16ToFp32(
-    const ConvertFp16ToFp32QueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateConvertFp32ToFp16(
-    const ConvertFp32ToFp16QueueDescriptor& descriptor,
-    const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateDivision(const DivisionQueueDescriptor& data,
-                                                               const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateSubtraction(const SubtractionQueueDescriptor& data,
-                                                                  const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateMean(const MeanQueueDescriptor& descriptor,
-                                                           const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreatePad(const PadQueueDescriptor& descriptor,
-                                                          const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateBatchToSpaceNd(const BatchToSpaceNdQueueDescriptor& descriptor,
-                                                                     const WorkloadInfo& info) const
-{
-    return nullptr;
-}
-
-void NeonWorkloadFactory::Release()
-{}
-
-void NeonWorkloadFactory::Acquire()
-{}
-
-#endif
-
-} //namespace armnn
+} // namespace armnn
diff --git a/src/backends/neon/NeonWorkloadFactory.hpp b/src/backends/neon/NeonWorkloadFactory.hpp
index 98f323afdf..d5444f5828 100644
--- a/src/backends/neon/NeonWorkloadFactory.hpp
+++ b/src/backends/neon/NeonWorkloadFactory.hpp
@@ -11,7 +11,6 @@
 
 #include <boost/core/ignore_unused.hpp>
 
-
 namespace armnn
 {
 
@@ -19,7 +18,7 @@ namespace armnn
 class NeonWorkloadFactory : public IWorkloadFactory
 {
 public:
-    NeonWorkloadFactory();
+    NeonWorkloadFactory(const std::shared_ptr<NeonMemoryManager>& memoryManager);
 
     const BackendId& GetBackendId() const override;
 
@@ -136,9 +135,7 @@ public:
     virtual void Acquire() override;
 
 private:
-#ifdef ARMCOMPUTENEON_ENABLED
-    mutable NeonMemoryManager m_MemoryManager;
-#endif
+    mutable std::shared_ptr<NeonMemoryManager> m_MemoryManager;
 };
 
-} //namespace armnn
+} // namespace armnn
diff --git a/src/backends/neon/test/CMakeLists.txt b/src/backends/neon/test/CMakeLists.txt
index a1ac1e0049..19512f98eb 100644
--- a/src/backends/neon/test/CMakeLists.txt
+++ b/src/backends/neon/test/CMakeLists.txt
@@ -13,6 +13,7 @@ list(APPEND armnnNeonBackendUnitTests_sources
     NeonOptimizedNetworkTests.cpp
     NeonRuntimeTests.cpp
     NeonTimerTest.cpp
+    NeonWorkloadFactoryHelper.hpp
 )
 
 add_library(armnnNeonBackendUnitTests OBJECT ${armnnNeonBackendUnitTests_sources})
diff --git a/src/backends/neon/test/NeonCreateWorkloadTests.cpp b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
index 5cd305c8ac..07953bf86f 100644
--- a/src/backends/neon/test/NeonCreateWorkloadTests.cpp
+++ b/src/backends/neon/test/NeonCreateWorkloadTests.cpp
@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "NeonWorkloadFactoryHelper.hpp"
+
 #include <backendsCommon/MemCopyWorkload.hpp>
 
 #include <aclCommon/test/CreateWorkloadClNeon.hpp>
@@ -56,7 +58,7 @@ template <typename armnn::DataType DataType>
 static void NeonCreateActivationWorkloadTest()
 {
     Graph graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto workload = CreateActivationWorkloadTest<NeonActivationWorkload, DataType>(factory, graph);
 
     // Checks that inputs/outputs are as we expect them (see definition of CreateActivationWorkloadTest).
@@ -86,7 +88,7 @@ template <typename WorkloadType,
 static void NeonCreateArithmethicWorkloadTest()
 {
     Graph graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto workload = CreateArithmeticWorkloadTest<WorkloadType, DescriptorType, LayerType, DataType>(factory, graph);
 
     DescriptorType queueDescriptor = workload->GetData();
@@ -156,7 +158,7 @@ template <typename BatchNormalizationWorkloadType, typename armnn::DataType Data
 static void NeonCreateBatchNormalizationWorkloadTest(DataLayout dataLayout)
 {
     Graph                graph;
-    NeonWorkloadFactory  factory;
+    NeonWorkloadFactory  factory = NeonWorkloadFactoryHelper::GetFactory();
     auto workload = CreateBatchNormalizationWorkloadTest<BatchNormalizationWorkloadType, DataType>
                     (factory, graph, dataLayout);
 
@@ -198,7 +200,7 @@ template <typename armnn::DataType DataType>
 static void NeonCreateConvolution2dWorkloadTest(DataLayout dataLayout = DataLayout::NCHW)
 {
     Graph                graph;
-    NeonWorkloadFactory  factory;
+    NeonWorkloadFactory  factory = NeonWorkloadFactoryHelper::GetFactory();
     auto                 workload = CreateConvolution2dWorkloadTest<NeonConvolution2dWorkload,
                                     DataType>(factory, graph, dataLayout);
 
@@ -239,7 +241,7 @@ template <typename armnn::DataType DataType>
 static void NeonCreateDepthWiseConvolutionWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
 
     auto workload = CreateDepthwiseConvolution2dWorkloadTest<NeonDepthwiseConvolutionWorkload,
                                                              DataType>(factory, graph, dataLayout);
@@ -276,7 +278,7 @@ template <typename FullyConnectedWorkloadType, typename armnn::DataType DataType
 static void NeonCreateFullyConnectedWorkloadTest()
 {
     Graph               graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto                workload = CreateFullyConnectedWorkloadTest<FullyConnectedWorkloadType,
                                    DataType>(factory, graph);
 
@@ -304,7 +306,7 @@ template <typename NormalizationWorkloadType, typename armnn::DataType DataType>
 static void NeonCreateNormalizationWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto workload = CreateNormalizationWorkloadTest<NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
 
     // Checks that outputs and inputs are as we expect them (see definition of CreateNormalizationWorkloadTest).
@@ -346,7 +348,7 @@ template <typename armnn::DataType DataType>
 static void NeonCreatePooling2dWorkloadTest(DataLayout dataLayout = DataLayout::NCHW)
 {
     Graph               graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto                workload = CreatePooling2dWorkloadTest<NeonPooling2dWorkload, DataType>
                                    (factory, graph, dataLayout);
 
@@ -392,7 +394,7 @@ template <typename armnn::DataType DataType>
 static void NeonCreateReshapeWorkloadTest()
 {
     Graph               graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto                workload = CreateReshapeWorkloadTest<NeonReshapeWorkload, DataType>(factory, graph);
 
     // Checks that outputs and inputs are as we expect them (see definition of CreateReshapeWorkloadTest).
@@ -424,7 +426,7 @@ template <typename SoftmaxWorkloadType, typename armnn::DataType DataType>
 static void NeonCreateSoftmaxWorkloadTest()
 {
     Graph               graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto workload = CreateSoftmaxWorkloadTest<SoftmaxWorkloadType, DataType>(factory, graph);
 
     // Checks that outputs and inputs are as we expect them (see definition of CreateSoftmaxWorkloadTest).
@@ -450,7 +452,7 @@ BOOST_AUTO_TEST_CASE(CreateSoftmaxFloatWorkload)
 BOOST_AUTO_TEST_CASE(CreateSplitterWorkload)
 {
     Graph graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto workload = CreateSplitterWorkloadTest<NeonSplitterWorkload, DataType::Float32>(factory, graph);
 
     // Checks that outputs are as we expect them (see definition of CreateSplitterWorkloadTest).
@@ -477,7 +479,7 @@ BOOST_AUTO_TEST_CASE(CreateSplitterMerger)
     // of the merger.
 
     Graph graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
 
     auto workloads =
         CreateSplitterMergerWorkloadTest<NeonSplitterWorkload, NeonMergerWorkload,
@@ -508,7 +510,7 @@ BOOST_AUTO_TEST_CASE(CreateSingleOutputMultipleInputs)
     // We created a splitter with two outputs. That each of those outputs is used by two different activation layers
 
     Graph graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     std::unique_ptr<NeonSplitterWorkload> wlSplitter;
     std::unique_ptr<NeonActivationWorkload> wlActiv0_0;
     std::unique_ptr<NeonActivationWorkload> wlActiv0_1;
@@ -542,7 +544,7 @@ BOOST_AUTO_TEST_CASE(CreateSingleOutputMultipleInputs)
 
 BOOST_AUTO_TEST_CASE(CreateMemCopyWorkloadsNeon)
 {
-    NeonWorkloadFactory    factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     CreateMemCopyWorkloads<INeonTensorHandle>(factory);
 }
 
@@ -550,7 +552,7 @@ template <typename L2NormalizationWorkloadType, typename armnn::DataType DataTyp
 static void NeonCreateL2NormalizationWorkloadTest(DataLayout dataLayout)
 {
     Graph graph;
-    NeonWorkloadFactory factory;
+    NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     auto workload =
             CreateL2NormalizationWorkloadTest<L2NormalizationWorkloadType, DataType>(factory, graph, dataLayout);
 
diff --git a/src/backends/neon/test/NeonLayerSupportTests.cpp b/src/backends/neon/test/NeonLayerSupportTests.cpp
index 893f11ebf3..56955432b6 100644
--- a/src/backends/neon/test/NeonLayerSupportTests.cpp
+++ b/src/backends/neon/test/NeonLayerSupportTests.cpp
@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "NeonWorkloadFactoryHelper.hpp"
+
 #include <layers/ConvertFp16ToFp32Layer.hpp>
 #include <layers/ConvertFp32ToFp16Layer.hpp>
 #include <test/TensorHelpers.hpp>
@@ -20,19 +22,19 @@ BOOST_AUTO_TEST_SUITE(NeonLayerSupport)
 
 BOOST_AUTO_TEST_CASE(IsLayerSupportedFloat16Neon)
 {
-    armnn::NeonWorkloadFactory factory;
+    armnn::NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     IsLayerSupportedTests<armnn::NeonWorkloadFactory, armnn::DataType::Float16>(&factory);
 }
 
 BOOST_AUTO_TEST_CASE(IsLayerSupportedFloat32Neon)
 {
-    armnn::NeonWorkloadFactory factory;
+    armnn::NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     IsLayerSupportedTests<armnn::NeonWorkloadFactory, armnn::DataType::Float32>(&factory);
 }
 
 BOOST_AUTO_TEST_CASE(IsLayerSupportedUint8Neon)
 {
-    armnn::NeonWorkloadFactory factory;
+    armnn::NeonWorkloadFactory factory = NeonWorkloadFactoryHelper::GetFactory();
     IsLayerSupportedTests<armnn::NeonWorkloadFactory, armnn::DataType::QuantisedAsymm8>(&factory);
 }
 
diff --git a/src/backends/neon/test/NeonLayerTests.cpp b/src/backends/neon/test/NeonLayerTests.cpp
index 4a1c5f9836..48ef667323 100644
--- a/src/backends/neon/test/NeonLayerTests.cpp
+++ b/src/backends/neon/test/NeonLayerTests.cpp
@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "NeonWorkloadFactoryHelper.hpp"
+
 #include <test/TensorHelpers.hpp>
 #include <test/UnitTests.hpp>
 
diff --git a/src/backends/neon/test/NeonMemCopyTests.cpp b/src/backends/neon/test/NeonMemCopyTests.cpp
index a37a07e869..f6699a61ba 100644
--- a/src/backends/neon/test/NeonMemCopyTests.cpp
+++ b/src/backends/neon/test/NeonMemCopyTests.cpp
@@ -3,9 +3,14 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "NeonWorkloadFactoryHelper.hpp"
+
+#include <aclCommon/test/MemCopyTestImpl.hpp>
+
 #include <neon/NeonWorkloadFactory.hpp>
+
 #include <reference/RefWorkloadFactory.hpp>
-#include <aclCommon/test/MemCopyTestImpl.hpp>
+#include <reference/test/RefWorkloadFactoryHelper.hpp>
 
 #include <boost/test/unit_test.hpp>
 
diff --git a/src/backends/neon/test/NeonOptimizedNetworkTests.cpp b/src/backends/neon/test/NeonOptimizedNetworkTests.cpp
index 3bf1eb8caa..b6f479804a 100644
--- a/src/backends/neon/test/NeonOptimizedNetworkTests.cpp
+++ b/src/backends/neon/test/NeonOptimizedNetworkTests.cpp
@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "NeonWorkloadFactoryHelper.hpp"
+
 #include <armnn/ArmNN.hpp>
 #include <Graph.hpp>
 #include <Network.hpp>
@@ -31,7 +33,7 @@ BOOST_AUTO_TEST_CASE(OptimizeValidateCpuAccDeviceSupportLayerNoFallback)
     armnn::IOptimizedNetworkPtr optNet = armnn::Optimize(*net, backends, runtime->GetDeviceSpec());
     BOOST_CHECK(optNet);
     // validate workloads
-    armnn::NeonWorkloadFactory fact;
+    armnn::NeonWorkloadFactory fact = NeonWorkloadFactoryHelper::GetFactory();
     for (auto&& layer : static_cast<armnn::OptimizedNetwork*>(optNet.get())->GetGraph())
     {
         BOOST_CHECK(layer->GetBackendId() == armnn::Compute::CpuAcc);
diff --git a/src/backends/neon/test/NeonTimerTest.cpp b/src/backends/neon/test/NeonTimerTest.cpp
index 11b319a5ff..a2bf4a95e5 100644
--- a/src/backends/neon/test/NeonTimerTest.cpp
+++ b/src/backends/neon/test/NeonTimerTest.cpp
@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: MIT
 //
 
+#include "NeonWorkloadFactoryHelper.hpp"
+
 #include <armnn/ArmNN.hpp>
 
 #include <test/TensorHelpers.hpp>
@@ -35,7 +37,7 @@ BOOST_AUTO_TEST_CASE(NeonTimerGetName)
 
 BOOST_AUTO_TEST_CASE(NeonTimerMeasure)
 {
-    NeonWorkloadFactory workloadFactory;
+    NeonWorkloadFactory workloadFactory = NeonWorkloadFactoryHelper::GetFactory();
 
     unsigned int inputWidth = 4000u;
     unsigned int inputHeight = 5000u;
diff --git a/src/backends/neon/test/NeonWorkloadFactoryHelper.hpp b/src/backends/neon/test/NeonWorkloadFactoryHelper.hpp
new file mode 100644
index 0000000000..bcf9c57a16
--- /dev/null
+++ b/src/backends/neon/test/NeonWorkloadFactoryHelper.hpp
@@ -0,0 +1,37 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <backendsCommon/IBackendInternal.hpp>
+#include <backendsCommon/IMemoryManager.hpp>
+#include <backendsCommon/test/WorkloadFactoryHelper.hpp>
+
+#include <neon/NeonWorkloadFactory.hpp>
+
+#include <arm_compute/runtime/Allocator.h>
+
+#include <boost/polymorphic_pointer_cast.hpp>
+
+namespace
+{
+
+template<>
+struct WorkloadFactoryHelper<armnn::NeonWorkloadFactory>
+{
+    static armnn::NeonWorkloadFactory GetFactory()
+    {
+        armnn::IBackendInternal::IMemoryManagerSharedPtr memoryManager =
+            std::make_shared<armnn::NeonMemoryManager>(std::make_unique<arm_compute::Allocator>(),
+                                                       armnn::BaseMemoryManager::MemoryAffinity::Offset);
+
+        return armnn::NeonWorkloadFactory(
+            boost::polymorphic_pointer_downcast<armnn::NeonMemoryManager>(memoryManager));
+    }
+};
+
+using NeonWorkloadFactoryHelper = WorkloadFactoryHelper<armnn::NeonWorkloadFactory>;
+
+} // anonymous namespace